Inside RapidNative's Credit System: The Token Math Behind Every Prompt

Most AI app builders charge you in "credits" and hope you never do the math. You pick a plan, a mysterious counter ticks down, and one day the app tells you to top up. What did that last prompt actually cost? Nobody's telling.

RapidNative's AI app builder credits work differently. They're metered against the real tokens your prompt consumes, split across four separate balance buckets, refunded when a paid build fails, and shared across your whole team. This post opens the hood — bucket by bucket, formula by formula — so you can predict exactly what a month of building will cost before you commit a dollar.

Photo by Christopher Gower on Unsplash

What "pay for what you build" actually means

Here's the short version, in 45 words: RapidNative meters AI generations by the number of input and output tokens the underlying model processes. Every team gets a shared credit balance. Simple prompts spend fractions of a credit; big multi-file rewrites spend more. When you finish, only the tokens you used are billed.

That's the tagline. Underneath is a real system with rules — the kind you want to understand before you scale up.

The credit landscape in 2026, briefly

Metered AI billing is now the norm for AI app builders. Roughly two-thirds of the AI-native tools on the market run a base subscription plus a metered credit pool, and it's common for a busy month to cost two to five times the sticker price. The industry has settled on "credits" as the unit because a raw token count would be meaningless to most users and unstable to price against (LLM providers change token costs constantly).

The trap is that most vendors treat credits as a black box. One "credit" at Lovable, Emergent, or Bolt is not the same as one credit at RapidNative — and even inside a single vendor, one credit spent on a small edit is not the same as one credit spent on a large file rewrite. Without a public formula, you can't budget.

RapidNative's formula is public, so the rest of this post is straightforward: here's what we charge, when we charge it, and where the money goes.

The four buckets

Every RapidNative team has a single credit account with four balances inside it. Think of them as compartments in a wallet — each with different rules about when it fills up, when it empties, and whether it expires.

The reason for four buckets is priority — the system needs to know which balance to draw from when a prompt costs 1.2 credits and you have 0.5 subscription credits left plus 100 top-up credits sitting in your wallet. The deduction order is deterministic:

• Paying users: subscription credits first → then non-expiring paid credits (if top-ups are enabled for your plan)
• Free users: non-expiring free credits first → then the monthly free allowance

This ordering means your monthly quota always burns down before your never-expiring top-ups get touched, which is what you want. If you pay $50 for a top-up, you don't want it silently drained while your subscription allowance sits unused and then expires at renewal.

Every debit, credit, expiry, and adjustment is logged in a separate audit table, tagged with the bucket it hit, so admin support can reconstruct any team's history down to the millisecond.

What one prompt actually costs

Here's the formula RapidNative uses to convert an AI generation into credits:

credits = (input_tokens / 1,000,000)  × 20
        + (output_tokens / 1,000,000) × 80
        + (cached_input / 1,000,000)  × 2

Twenty credits per million input tokens. Eighty per million output tokens. Two per million for cached input (context the model has already seen from earlier in the same conversation, which the provider charges us less for).

Let's translate that into normal numbers.

• A short edit — "make the button blue" — might process 5,000 input tokens and 2,000 output tokens. Cost: (5000/1M × 20) + (2000/1M × 80) = 0.1 + 0.16 = ~0.26 credits.
• A medium generation — a new screen with a form and validation — might be 30,000 input / 15,000 output. Cost: ~1.8 credits.
• A big rewrite — a multi-file refactor with heavy context — might be 100,000 input / 40,000 output. Cost: ~5.2 credits.

These aren't marketing numbers. They're the arithmetic. The token counts are returned by the LLM provider (Anthropic, OpenAI, DeepSeek, depending on the model routing) and multiplied by the credit rate at settlement time.

Photo by Rob Hampson on Unsplash — the kind of interface you're building

Fractional billing matters

Two of those examples cost less than one credit. Every AI builder that rounds to whole credits per prompt is systematically overcharging its users on small edits — which are the majority of edits inside a session. RapidNative bills in fractions all the way down (with a small minimum-to-start floor to prevent an incoming prompt with zero balance from slipping through), so a session of tiny tweaks costs what tiny tweaks cost.

What isn't charged

Not every AI action costs credits.

• "Fix with AI" retries on a broken generation are free. If our first attempt produced code that didn't compile and the system automatically retries, you're not double-billed.
• Auto-restart after a stream disconnect is free — the model may need to redo work, but that's our infrastructure's problem, not yours.
• Truncated responses (where the model gets cut off mid-stream) are flagged in the message metadata so the UI doesn't show them as a charged generation.

The general principle: if the system had to intervene to make your generation succeed, you don't pay for the extra tries.

APK builds: the other place credits get spent

There's one non-token action that costs credits: building an installable APK for Android testing. This is a fixed 10 credits per build, charged up front, and it's a paid-plan-only feature.

Why fixed and not metered? APK builds don't run through an LLM — they run through a build service that spins up an Android compile job. The cost to us is a flat compute cost per build, so we pass it through as a flat cost per build.

And critically: if the build fails, the 10 credits are refunded to your subscription bucket automatically, logged in the audit table with the reason. If our build service isn't reachable at all, the request is rejected before you're charged. Learn more about exporting and publishing your app.

Plan tiers, without the marketing fog

Here's what each plan gives you and how the effective per-credit cost breaks down.

A few things fall out of that table that most vendor pricing pages hide from you:

• Annual billing is much cheaper per credit on some tiers than others. Starter annual gives 450 credits — barely a bulk discount over monthly. Ultra annual gives 6,050 credits — a significant reduction per credit. If you're a heavy user, annual on the top tiers is where the value density is.
• Free is genuinely usable. 20 credits/month, capped at 5/day, is enough to build and iterate on a real prototype without ever entering a credit card. The daily cap prevents burst abuse but lets casual builders keep coming back.
• Team size scales with plan. The higher the tier, the bigger the collaboration surface. Credits are pooled across the whole team, which is the important detail most people miss — see the next section.

For the full comparison, see RapidNative pricing.

Credits are team-scoped, not per-user

If you're on the Pro plan with 10 team members, you don't each get 15 credits. Your team gets a shared pool of 150 credits per month, and any member's generations draw from that pool. Same on Max, Ultra, and Starter.

This is a deliberate design choice, and it matters for two reasons.

One: it matches how real teams work. A PM writes a spec, an engineer generates the initial screens, a designer edits the UI later in the week. All three of them are contributing to the same product. Splitting the credit pool per-person would force artificial rationing — you'd have engineers running out of credits mid-sprint while the designer's untouched allocation sat frozen.

Two: it makes billing predictable at the org level. Finance sees one line item per team, one Stripe invoice, one credit balance to reason about. Not ten.

The tradeoff: one member can theoretically drain the pool for the month. Owners have visibility into usage and can top up at any time; on the higher tiers, top-ups are frictionless.

Photo by Annie Spratt on Unsplash — credits pool across the whole team

Top-ups: when subscription credits aren't enough

Sometimes you burn through your allowance mid-cycle and can't wait for the reset. Top-ups solve that.

• Top-ups are purchased through a Stripe Checkout session initiated from the app.
• The default tiers are 40 credits for $20, and 100 credits for $35 (bulk buyers get a discount on the per-credit rate).
• Top-up credits land in the non-expiring paid bucket and never expire. Not at the end of your billing cycle, not at renewal, not ever.
• They're only consumed after your subscription credits are drained, so buying top-ups can never cause you to "lose" your monthly allowance.
• Purchases are idempotent against Stripe payment IDs — if the webhook retries (which happens routinely for reliability), the credits are only granted once.

Top-ups are available on Pro, Max, Ultra, and annual Starter plans. The Free plan and monthly Starter don't have top-ups — a deliberate choice to keep the entry price predictable at the low end.

What happens when you run out

The system fails hard, not soft, and that's on purpose.

• If you don't have enough credits to start a generation, the request is rejected with an "insufficient credits" error before any AI work happens. You don't get a partial response.
• Free users hit both a daily cap (5 credits/day) and a monthly cap (20/month). Blowing the daily cap doesn't touch the monthly bucket; you just wait until midnight.
• Billing-overdue teams (a subscription that failed to renew) are hard-blocked from all AI actions with a distinct error, so you know it's a payment issue and not a credit issue.
• The Fix with AI retry on a stuck generation bypasses the credit gate — you're never locked out of recovering from a failed prompt just because you're low on credits.

The reason for hard-blocking rather than degrading gracefully: silent degradation is worse than a clear error. If we quietly used a cheaper model when you're low on credits, your generation quality would drop and you wouldn't know why. Hard errors tell you exactly what to do (top up, upgrade, or wait for the cycle to reset).

How it compares to the rest of the market

A few reference points from the current AI app builder pricing landscape:

• Emergent: 10 free credits/month, $20 for 100 credits, $200 for 750.
• Lovable: $25/month starter tier for 100 credits.
• Power Automate AI Builder: $500/unit/month for 1M credits (enterprise-tier metering).

The catch across all three is opacity: none of them publish the per-token math. You pay per "credit," but what generates a credit is left vague. Some vendors count every message as one credit regardless of size; others meter tokens but round up aggressively. Without the formula, you can't tell whether the same session on two platforms would cost $5 or $50.

RapidNative's approach — publishing the token-to-credit rate and refunding failures — is the transparency version of the same model. You can plug your expected token consumption into a spreadsheet and predict your monthly bill within a few percent.

FAQ: the questions we get

How do AI credits work in RapidNative?

Each team has a shared credit balance. When you send a prompt, the AI processes it and returns a token count; that token count is converted into credits at a fixed rate (20 per million input tokens, 80 per million output, 2 per million cached input) and deducted from your balance. Failed builds are refunded. Free retries don't cost credits.

Do RapidNative credits roll over?

Subscription credits do not roll over — they reset at each billing cycle. Top-up credits and bonus credits never expire and carry over indefinitely, so any credits you actively pay for or are gifted stay in your wallet permanently.

What happens if I run out of credits mid-project?

Your existing generated code stays intact and downloadable. What stops is new AI generation. You can either top up (frictionless via in-app Stripe Checkout on eligible plans), upgrade your plan, or wait for the next billing cycle to reset your subscription bucket. Your project isn't deleted or gated.

Are RapidNative credits per-user or per-team?

Per-team. Every team member draws from the same shared pool. This matches how teams actually build together and keeps billing simple at the org level.

Does RapidNative refund failed generations?

Yes, for paid actions: if an APK build fails, the 10 credits are automatically refunded. Token-based generations get free retries via "Fix with AI" when the first attempt doesn't compile. Truncated streams are flagged and not billed as a completed generation.

What this means for how you should think about the cost

If you've been comparing AI app builders by their sticker price, you've been reading the wrong number. The number that matters is credits per unit of work you actually do — a new screen, an edit, an export.

For most builders, that number is unknowable in advance. For RapidNative, you can start building on the Free plan, watch how many credits your first few real prompts consume, and extrapolate. If your first 10 prompts averaged 0.8 credits, you know a month of similar work is roughly 24 credits. Starter covers it comfortably; Pro is overkill; Free might even do the job for lightweight iteration.

That's what pay-for-what-you-build actually means: you can predict the bill.

Want to see it in practice? Check out our guides on turning a sketch into an app, or converting a PRD into a working prototype — both work on the free tier with the 20 credits you get on signup.