Base44 pricing in 2026: plans, credits, and what an app with Twitter (X) data really costs

By TwitterAPI.io Team•15 min read
Base44 plan ladder with monthly and yearly prices, message and integration credits, next to a flow from a Base44 app through a backend function to api.twitterapi.io
Base44 plans as listed on base44.com/pricing (monthly / yearly billing per month), and where an X data call sits in a Base44 app. The X data is billed by its provider, not in Base44 credits.
TL;DR
  • Five public plans: Free $0, Starter $20, Builder $50, Pro $100, Elite $200, each per month on monthly billing; $16 / $40 / $80 / $160 a month billed yearly (20% off). Enterprise is custom.
  • Two credit pools: message credits build the app (25 to 1,200 a month); integration credits run built-in services in the live app (100 to 50,000 a month).
  • No rollover by default: paid credits reset on your subscription day each month and unused ones expire; Free gets 5 message credits a day, 25 a month.
  • What X says: across 755 X posts about Base44 and money (collected in 2026), 13.8% carry a cost complaint and 2.8% call it good value; 22.9% mention Wix, the owner since June 2025.
  • Compared most with Lovable: 16.2% of those posts also name Lovable, ahead of Claude (10.5%) and Replit (9.8%).
  • X data is a separate, small bill: call /twitter/tweet/advanced_search from a Base44 backend function with your own key; $0.15 per 1,000 tweets vs $0.005 per post read on the official X API card.

Base44 is a no-code AI app builder: you describe an app in plain language and it generates the frontend, backend, database, auth and hosting. Wix announced it had acquired Base44 on June 18, 2025 (an initial payment of about $80 million plus milestone payments, as reported at the time), and the pricing page footer now reads "Wix.com Ltd." The pricing itself is simple to read and easy to misjudge, because every plan meters two different credits and the cost per message depends on how much work the AI has to do.

This page answers the price question first, from the vendor's own pricing page and credit docs fetched this year, then adds two things the usual pricing roundups do not have: a study of 755 X posts about Base44 pricing and credits plus 180 posts from the official @Base44 account, and a worked example of wiring live X data into a Base44 app with the full X data bill next to the Base44 bill.

Base44 money posts on X with a cost complaint vs praise

13.8% of 755 X posts about Base44 pricing and credits carry a cost complaint, against 2.8% calling it good value (collected in 2026); 22.9% are about Wix, and 16.2% also name Lovable.

01 — Section

Base44 pricing at a glance: Free, Starter, Builder, Pro, Elite

The public plans on base44.com/pricing are shown in US dollars per month, with a Yearly / Monthly toggle. Yearly is the default view and is labeled "SAVE 20%"; the FAQ explains that the discount applies to the monthly price times twelve, charged once a year.

PlanMonthly billing, per monthYearly billingMessage credits / moIntegration credits / mo
Free$0$025 (max 5 a day)100
Starter$20$16 / mo ($192 a year)1002,000
Builder$50$40 / mo ($480 a year)25010,000
Pro$100$80 / mo ($960 a year)50020,000
Elite$200$160 / mo ($1,920 a year)1,20050,000
Enterprisecustomcustomcustomcustom

What each tier adds. Free gives every core feature (AI building, backend and database, auth, analytics) for up to 5 apps. Starter lifts the app limit to unlimited and adds in-app code edits and a custom domain. Builder, marked "Popular", adds AI model selection and GitHub integration. Pro adds early access to beta features. Elite adds premium support and the largest credit pools. Enterprise adds custom credits, a dedicated architect, SSO, advanced security controls and an account team.

Yearly-only extras. On the yearly toggle, paid plans list a free domain for one year, and Builder and up list 25 credits to share with a friend. Those two lines disappear when you switch the toggle to Monthly, so they are part of the yearly deal rather than the plan itself.

Payment and changes. Base44 takes Visa, Mastercard, American Express and Discover; Enterprise can pay by invoice or ACH. You can upgrade, downgrade or cancel at any time, changes apply at the next billing cycle, and the FAQ says apps stay live. Education and nonprofit pricing is handled case by case, and founders can apply to Base44 for Startups for a free annual license and credits.

02 — Section

Message vs integration credits: what you spend, and when they reset

Base44's credits documentation (docs.base44.com/Account-and-billing/Credits) splits usage into two pools, and the split is the most important thing to understand before choosing a plan.

Message credits are spent when you prompt the AI to plan, change or fix the app. There is no fixed price per message; the docs give rough ranges and say the real figure is calculated after the message runs. Manual visual edits in the editor (dragging elements, changing layouts, editing text) use no credits.

Scope of the promptTypical message credits (Base44 docs)
Simple visual or text changeabout 0.5
Improving a small featureabout 1
Adding a complex module (entities, flows, logic)about 2
Large-scale or app-wide changeabout 3 to 4

Integration credits are spent by the running app when it uses Base44's built-in services. The docs list SendEmail at about 1 credit per email (about 2 from a custom domain), GenerateImage at about 1 per image, GenerateVideo at about 5 per second of video, invokeLLM on the Automatic model at about 1 per call, in-app agent messages from about 3 credits each on Automatic and several times more on larger models, workflows at about 1 credit per 10 steps, and backend functions at about 1 credit per 100 invocations. The docs also state that integration credits are not used when you call an external service with your own API key.

Credits per dollar. On monthly billing every plan from Starter to Pro buys 5 message credits per dollar ($0.20 each); yearly billing makes that 6.25 per dollar ($0.16 each). Elite is the only tier with a better ratio: 6 per dollar monthly and 7.5 yearly (about $0.17 and $0.13 each). Integration credits scale faster than price: 100 per dollar on Starter, 200 on Builder and Pro, 250 on Elite (monthly billing).

At the docs' own estimates, Starter's 100 message credits are roughly 100 small feature changes or about 25 to 33 app-wide rewrites a month, and Builder's 250 are two and a half times that. That is the real sizing question: how many prompts you send, not how many apps you own.

Reset date. Paid message and integration credits reset once a month on the day you subscribed (subscribe on the 5th, reset on the 5th). The docs say credits you have not used expire at the reset. On Free, your personal workspace gets up to 5 message credits a day and 25 a month; the daily allowance resets at midnight in the owner's time zone, and other workspaces on Free get no free message credits.

Running out. When you hit the limit, actions that use credits pause until the next reset. Your app stays up, but AI building (message credits) or built-in services (integration credits) stop until then, unless you upgrade from the billing dashboard.

Upgrading mid-cycle. An upgrade gives the new plan's extra credits right away. Moving from a monthly plan to a higher monthly plan charges the full price difference, and your unused credits carry over for one more cycle (up to one month of credits) before expiring. Any upgrade that involves a yearly plan is prorated, and unused credits expire at the next reset as usual.

No top-up store on the pricing page. The pricing page lists no credit packs; the documented paths to more credits are a higher plan, Enterprise custom credits, or a coupon code redeemed on the usage page. Base44 gift cards are no longer sold, according to the same docs page.

Workspace-wide pool. Credits are shared across every app in a workspace, and owners on plans with member limits can cap how many credits each member uses. The usage page breaks spend down by app, member, source (workflows, backend functions, agents) and branch.

03 — Section

Base44 vs Lovable vs Replit vs Bolt pricing, as each vendor shows it

Every AI app builder meters something different, so a straight price comparison only goes so far. These are the entry paid plans as each vendor's own pricing page or docs showed them when we checked this year.

BuilderEntry paid planWhat the plan metersUnused allowance
Base44Starter $20 / mo ($16 yearly)100 message + 2,000 integration creditsexpires at monthly reset
LovablePro $25 / mo, 100 credits ($250 a year)credits, plus 5 daily build creditsmonthly credits valid two months
ReplitCore $20 / mo ($18 yearly)$20 toward more powerful modelsnot stated on the page
BoltPro $25 / mofrom 10M tokens a monthrolls over (up to two months)

Base44's distinctive line item is the second pool. Lovable, Replit and Bolt price the building work; Base44 also prices what the live app does with its built-in email, image, LLM and agent services. If your app sends a lot of email or runs in-app agents, compare integration credits, not just the headline price.

Rollover is where Base44 is strict. Bolt says unused tokens roll over to the next month and Lovable's monthly credits stay valid for two months; Base44's docs say unused credits expire at each reset. A public Base44 feature request to roll unused credits over exists, but it is a request, not a policy.

For the Lovable side in full (every Pro and Business credit tier, top-ups, Cloud costs), see our Lovable pricing breakdown linked below. Replit Pro was listed at $100 a month ($90 yearly) with $100 of credits, and Bolt Teams at $30 per member a month.

04 — Section

What X says about Base44 pricing and credits

We pulled 883 recent X posts matching Base44 plus a money word (credits, pricing, plan, subscription, cost, pay and similar), kept the 755 posted since the @Base44 account was created in September 2024 that actually contain a pricing term, and tagged them with transparent keyword rules. They come from 520 distinct authors; 97.9% are in English, 26.2% are replies, and 33.6% tag @Base44 directly.

ThemeShare of postsPostsMedian likesMedian views
Wix stock ($WIX cashtag)12.3%9351,255
Wix acquisition story11.7%885.0714
Backend / integration credits10.7%817995
Free / daily credits10.5%796428
Bugs and fix loops6.2%478777
"Expensive" (any sense)6.1%464.5510
Worth it / good value2.8%217899
Credits ran out / burned1.6%125.5208

Money talk about Base44 is mostly about the company, not the bill. The largest single theme is Wix: 22.9% of the posts mention Wix, split between $WIX stock commentary (12.3%) and retellings of the solo-founder-to-acquisition story (11.7%). For a buyer reading X to decide on a plan, roughly a fifth of the search results are noise.

Complaints are real but small. 13.8% of posts carry a cost complaint of some kind (the word expensive, burned credits, fix loops, refunds), against 2.8% that call Base44 worth it or good value, about 5.0 to 1. Posts saying credits ran out are only 1.6% (12 posts), and refund or cancel talk 0.9%. Read the expensive row with care: the keyword also fires on builders pitching Base44 as a way to replace expensive tools.

Free credits and the second pool get attention. Free and daily credits are 10.5% of posts, and backend or integration credits 10.7%; the integration-credit posts have the highest median views of the product themes (995), a sign that the two-pool model is what people need explained.

Volume is rising. 78.4% of the on-topic posts are from 2026, and the most recent partial quarter already has 134 posts, against 69 in the same quarter of 2025.

Bar chart of themes in 755 X posts about Base44 and money: Wix stock posts 12.3%, Wix acquisition story 11.7%, backend or integration credits 10.7%, free or daily credits 10.5%
Share of 755 on-topic X posts about Base44 and money per theme, keyword rules in analyze.py; a post can carry several themes. Collected in 2026.
05 — Section

Which builders Base44 gets compared with on X

26.2% of the posts name at least one other builder or coding tool. Lovable is the default comparison by a wide margin.

Tool named alongside Base44Share of postsPosts
Lovable16.2%122
Claude10.5%79
Replit9.8%74
Cursor8.1%61
Bolt6.5%49
v03.7%28
Windsurf2.3%17
Emergent1.3%10

Lovable first, then the coding agents. Lovable appears in 16.2% of posts, Claude (mostly Claude Code) in 10.5%, Replit in 9.8% and Cursor in 8.1%. Bolt (6.5%) and v0 (3.7%) trail. The pattern matches the buying question: people choose between Base44 and Lovable as no-code builders, and between a builder and a coding agent once the app gets serious.

If you are weighing that second step, our Claude Code pricing page and the Cursor vs Claude Code comparison cover the agent side of the bill.

Bar chart: share of Base44 money posts that also name another tool; Lovable 16.2%, Claude 10.5%, Replit 9.8%, Cursor 8.1%, Bolt 6.5%
Share of 755 on-topic X posts about Base44 and money that also name another builder or coding tool. Collected in 2026.
06 — Section

What the official @Base44 account posts about plans and credits

The official account (@Base44, created in 2024) had 39,571 followers when we collected. Its 180 most recent posts span 194 days, about 0.93 posts a day.

@Base44 timeline metricValue
Posts in sample180
Mention credits, pricing, plans or free18.3% (33)
Free promotions (free, no credits, giveaway)6.1% (11)
Mention agents or Superagents15.0% (27)
Mention Wix0.6% (1)
Median likes / views per post43 / 4,339

Pricing posts outperform the average. About one post in five (18.3%) touches credits, plans or free offers, and those posts get a median of 54 likes against 43 for the account overall. The official feed almost never mentions Wix (1 post), while Wix is the biggest money topic in the public conversation.

If you want to track a vendor's pricing announcements like these yourself, the same /twitter/user/last_tweets call used for this study works on any public account.

07 — Section

Build a Base44 app that shows live X data (key stays server-side)

Base44 apps can call outside APIs from backend functions: Deno serverless functions that run server-side, read secrets at runtime and are invoked from the frontend with base44.functions.invoke() (docs.base44.com/developers/backend/resources/backend-functions/overview). That is the right place for an X data call, because the API key never reaches the browser.

Step 1: store the key. Create a key in the TwitterAPI.io dashboard and set it as a Base44 secret with the CLI: base44 secrets set TWITTERAPI_KEY=your_key. Base44's docs note that a function must call secrets.get() inside the handler; a read at module load returns undefined.

Step 2: the function. The function below checks the signed-in user, calls /twitter/tweet/advanced_search on https://api.twitterapi.io with the X-API-Key header, follows has_next_page and next_cursor for a few pages, and returns slim tweet objects (text, url, createdAt, likeCount, viewCount, author.userName). Search results come back in a top-level tweets array.

Step 3: call it from the app. In the frontend, base44.functions.invoke("xSearch", { query }) returns the JSON. You can also prompt Base44's AI to build the UI around that function; the prompt costs message credits, but the X call itself does not.

What it costs in Base44 credits. Because the function calls an external service with your own key, the docs say no integration credits are used for the call itself; the function invocation costs about 1 integration credit per 100 runs. A dashboard that refreshes every 5 minutes runs 8,640 times a month, about 86 integration credits, well inside Starter's 2,000.

Other endpoints. Swap the path for /twitter/user/last_tweets (an account's timeline, under data.tweets), /twitter/user/mentions (posts mentioning a handle) or /twitter/user/info (a profile). Reads need no X account. If you build with a coding agent instead of Base44, our hosted MCP server exposes the same data as tools.

typescript
// functions/xSearch/entry.ts  (Base44 backend function, Deno runtime)
import { createClientFromRequest } from "npm:@base44/sdk";
import { secrets } from "base44:runtime";

const BASE = "https://api.twitterapi.io";

export default async function (req: Request): Promise<Response> {
  const base44 = createClientFromRequest(req);
  const user = await base44.auth.me();
  if (!user) return Response.json({ error: "Unauthorized" }, { status: 401 });

  const { query, maxPages = 2 } = await req.json();
  const apiKey = secrets.get("TWITTERAPI_KEY"); // read inside the handler, not at module load

  const tweets: unknown[] = [];
  let cursor = "";
  for (let page = 0; page < Math.min(maxPages, 5); page++) {
    const url = new URL(`${BASE}/twitter/tweet/advanced_search`);
    url.searchParams.set("query", query);
    url.searchParams.set("queryType", "Latest");
    url.searchParams.set("cursor", cursor);
    const res = await fetch(url, { headers: { "X-API-Key": apiKey ?? "" } });
    if (!res.ok) return Response.json({ error: await res.text() }, { status: res.status });
    const body = await res.json();
    for (const tw of body.tweets ?? []) {
      tweets.push({
        text: tw.text,
        url: tw.url,
        createdAt: tw.createdAt,
        likes: tw.likeCount,
        views: tw.viewCount,
        author: tw.author?.userName,
      });
    }
    if (!body.has_next_page) break;
    cursor = body.next_cursor;
  }
  return Response.json({ count: tweets.length, tweets });
}

// In the app (frontend):
// const { data } = await base44.functions.invoke("xSearch", { query: "base44 -filter:retweets", maxPages: 1 });
08 — Section

The X data bill for a Base44 app, next to the Base44 bill

The X data arrives as a separate line item from the X data provider. TwitterAPI.io bills 15 credits per tweet returned, which is $0.15 per 1,000 tweets, with a minimum of 15 credits per request; $1 buys 100,000 credits. A full 20-tweet page costs $0.003, and a search that finds nothing costs the $0.00015 minimum.

The official X API pay-per-usage rate card at docs.x.com/x-api/getting-started/pricing lists $0.005 per post read and $0.010 per user read, capped at 3 million post reads a month before Enterprise. Per 1,000 posts that is $5 against $0.15, about 33 times more.

Base44 X dashboardX data on TwitterAPI.ioOfficial X API (pay-per-usage)Base44 integration credits
3,000 tweets a month shown$0.45$15.00depends on refresh count
30,000 tweets a month shown$4.50$150.00depends on refresh count
Refresh every 5 min, nothing new$1.30 a month (floor)not billed per empty checkabout 86
Refresh every 60 s, nothing new$6.48 a month (floor)not billed per empty checkabout 432

Read the refresh rows as the worst case for the floor: 8,640 checks a month that each found nothing add up to $1.30 at the $0.00015 minimum; checks that return tweets are billed per tweet instead. A dashboard that shows about 3,000 new tweets a month therefore lands under $2 of X data, next to a Base44 Starter plan at $20 a month ($16 yearly).

For scale, the whole X study on this page (883 search results, 180 official-account posts and one profile lookup, 56 requests) cost 15,963 credits, about $0.16.

Paid accounts get 20 requests per second (0.2 before the first payment). New accounts that pass the automatic bot check get up to $1 of free credits (at most 100,000 credits, no card, one per person or network, expiring after 31 days); purchased credits never expire. Monthly subscriptions start at Starter $29 a month; see the pricing page for details.

09 — Section

How we collected this

Question. When people on X talk about Base44 pricing and credits, what do they say, which tools do they compare it with, and what does the official account post about plans?

Sources and query. /twitter/tweet/advanced_search with Latest ordering on (base44 OR @base44) plus money words (credits, credit, pricing, price, plan, subscription, expensive, cost, paid, pay, a dollar sign) excluding retweets, 45 pages; /twitter/user/last_tweets for @Base44, 10 pages; /twitter/user/info for @Base44, 1 request. 56 requests in total, collected in 2026.

Sample. 883 search posts returned; 6 posted before September 2024 were dropped as unrelated uses of the string; 755 contained a pricing term and form the sample, from 520 distinct authors. The official sample is 180 posts.

Method. Each post is tagged by keyword rules published in analyze.py and results.json in our study folder; a post can carry several themes. Shares are of the on-topic sample. Likes and views are medians.

What the sample cannot show. It is the most recent matching posts on X, not a random sample of Base44 users. Keyword rules miss sarcasm and catch unrelated senses of words like expensive. Posts in other languages that never use the English money words are mostly missed. Nothing here measures how many credits real apps spend.

Privacy. Aggregates only. Raw search pages were kept out of the repository because their authors are private individuals; the de-identified rows hold no IDs, URLs, text or handles. Only the official @Base44 organization account is named.

python
"""Reproduce a small version of our Base44 pricing study on X and price it.
pip install requests ; export TWITTERAPI_IO_KEY=...
"""
import os
import re
import statistics
import requests

BASE = "https://api.twitterapi.io"
HEADERS = {"X-API-Key": os.environ["TWITTERAPI_IO_KEY"]}
QUERY = ('(base44 OR @base44) (credits OR credit OR pricing OR price OR plan '
         'OR subscription OR expensive OR cost OR paid OR pay) -filter:retweets')
THEMES = {
    "free or daily credits": r"free credits|daily credits|free plan|free tier",
    "integration credits / backend": r"integration credits?|backend functions?|database|backend",
    "credits ran out": r"ran out|run out|out of credits|used up|no credits left",
    "expensive": r"too expensive|expensive|overpriced|pricey|can'?t afford",
    "good value": r"worth (it|every)|good value|great value|affordable",
    "Wix": r"\bwix\b",
}
RIVALS = {"Lovable": r"\blovable\b", "Replit": r"\breplit\b", "Bolt": r"\bbolt(\.new)?\b", "Cursor": r"\bcursor\b"}


def search(query, pages=5):
    tweets, cursor = [], ""
    for _ in range(pages):
        params = {"query": query, "queryType": "Latest", "cursor": cursor}
        r = requests.get(f"{BASE}/twitter/tweet/advanced_search", headers=HEADERS, params=params, timeout=30)
        r.raise_for_status()
        body = r.json()
        tweets += body.get("tweets", [])
        if not body.get("has_next_page"):
            break
        cursor = body.get("next_cursor", "")
    return tweets


def official_timeline(user="Base44", pages=2):
    posts, cursor = [], ""
    for _ in range(pages):
        params = {"userName": user, "cursor": cursor}
        r = requests.get(f"{BASE}/twitter/user/last_tweets", headers=HEADERS, params=params, timeout=30)
        r.raise_for_status()
        body = r.json()
        data = body.get("data") or {}
        posts += data.get("tweets", [])
        if not body.get("has_next_page"):
            break
        cursor = body.get("next_cursor", "")
    return posts


def main():
    tweets = search(QUERY, pages=5)
    n = len(tweets) or 1
    print(f"{len(tweets)} search posts")
    for name, rx in THEMES.items():
        hits = [t for t in tweets if re.search(rx, t["text"].lower())]
        likes = [t.get("likeCount") or 0 for t in hits]
        med = statistics.median(likes) if likes else 0
        print(f"  {name:32s} {100 * len(hits) / n:5.1f}%  median likes {med}")
    for name, rx in RIVALS.items():
        hits = sum(1 for t in tweets if re.search(rx, t["text"].lower()))
        print(f"  also names {name:22s} {100 * hits / n:5.1f}%")

    posts = official_timeline()
    pricing = [p for p in posts if re.search(r"credit|pric|plan|subscription|free", p["text"].lower())]
    print(f"@Base44: {len(posts)} recent posts, {len(pricing)} about credits, plans or free offers")

    returned = len(tweets) + len(posts)
    print(f"Tweets returned: {returned}  ->  about ${returned * 15 / 100000:.4f} at 15 credits per tweet")
    print(f"Same reads on the official X API pay-per-usage card: ${returned * 0.005:.2f} at $0.005 per post read")


if __name__ == "__main__":
    main()

Researching this?Free starter credits cover end-to-end testing — Google sign-in, no card. Get a key.

10 — Questions

Questions readers ask

How much does Base44 cost per month?

Free is $0. Starter is $20, Builder $50, Pro $100 and Elite $200, each per month on monthly billing, or $16, $40, $80 and $160 a month on yearly billing, which is 20% off and charged once a year. Enterprise is a custom quote.

What is the difference between message credits and integration credits in Base44?

Message credits are spent when you prompt the AI to build, change or fix your app. Integration credits are spent by the live app when it uses Base44's built-in services such as email, image generation, LLM calls, in-app agents, workflows and backend function invocations. Each plan includes a separate monthly amount of each.

How many credits does a Base44 message use?

There is no fixed amount. Base44's docs estimate about 0.5 credits for a simple text or style change, about 1 for a small feature, about 2 for a complex module and about 3 to 4 for an app-wide change. The exact figure is calculated after the message runs and shown under Credits Used. Manual visual edits are free.

Do unused Base44 credits roll over?

Not by default. Paid credits reset monthly on your subscription day and unused credits expire at the reset. The one documented exception is upgrading from a monthly plan to a higher monthly plan, where unused credits carry over for one more cycle.

What happens when I run out of Base44 credits?

Actions that use credits pause until your next reset date; your published app stays live. To continue sooner, upgrade or change your plan from the billing dashboard, and the new plan's extra credits apply right away.

Is Base44 free?

Yes, there is a Free plan with all core features for up to 5 apps, 25 message credits a month (at most 5 a day) and 100 integration credits a month. Paid plans add unlimited apps, code edits, a custom domain and larger credit pools.

Is Base44 cheaper than Lovable?

At the entry level, Base44 Starter is $20 a month ($16 yearly) and Lovable Pro starts at $25 a month for 100 credits ($250 a year). They meter differently: Base44 adds a separate integration credit pool for live-app services, and Lovable's monthly credits stay valid for two months while Base44's expire at each reset.

Can a Base44 app pull Twitter (X) data?

Yes. Put the API call in a Base44 backend function, store the key with base44 secrets set, and call /twitter/tweet/advanced_search or /twitter/user/last_tweets on api.twitterapi.io. Calls to an external service with your own key use no integration credits apart from about 1 credit per 100 function runs; the X data costs $0.15 per 1,000 tweets.

11 — Further reading

Continue

Sources & further reading
More from this series

Writing about something you built with TwitterAPI.io? Our community rewards program pays API credits for honest tutorials, build logs and videos.

Build it

Stop reading. Start building.

Starter credits cover real testing on real data. Google sign-in, no card, no application queue.

Get an API key

Already building with TwitterAPI.io? Publish an honest tutorial or build log about it and earn up to $200 a month in API credits.