RapidNative's Credit System Explained: Pay for What You Build

Buying AI tooling has become exhausting. One vendor sells "unlimited" plans that quietly throttle the moment you exceed a hidden fair-use line. Another sells tokens that fluctuate per request, so a five-minute session leaves you guessing. A third bundles "messages" that mean different things on Mondays and Fridays. By the time you've decoded the pricing, you've forgotten what you came to build.

We wanted RapidNative's pricing to read like a utility bill, not a riddle. You buy AI app builder credits. One credit produces one AI generation — a screen, a feature, an iteration. When credits run out, you decide whether to wait, top up, or upgrade. Nothing is throttled silently. Nothing rolls dice on cost per request. This post unpacks exactly how that system works under the hood — the buckets, the expiries, the rollover rules, the audit ledger, and why we built it this way instead of charging $30/month for "unlimited" AI.

Photo placeholder — credit balance UI with mobile preview

What does one RapidNative credit actually get you?

One credit equals one successful AI generation. That covers the full range of what RapidNative's AI does in a session: building a new screen from a prompt, modifying a component, parsing a sketch, ingesting a PRD, regenerating a layout, or refactoring code on point-and-edit. The cost does not vary by prompt length, model, or screen complexity. If the AI returns a usable output, exactly one credit comes off your balance.

Failed generations don't deduct. If our pipeline returns an error before producing code, you keep the credit. This matters because some competitors charge for "tokens consumed," which means a failed run still drains your account. We chose the simpler accounting on purpose: builders should pay for outputs, not for our infrastructure's bad day.

A credit at RapidNative is a unit of creative work, not a unit of compute. The prompt-to-React-Native pipeline behind every generation streams from one or more LLMs, runs the output through a browser-based bundler, and renders it live on your device. We absorb the underlying cost variance so you don't have to model it.

The free tier: 20 credits a month, no card required

Every new RapidNative team starts with a free plan. You get 20 credits per month, capped at 5 credits per day, with no credit card on signup. That's enough to build a complete two-or-three screen prototype — onboarding, list, detail — and decide whether the tool fits your workflow.

The daily cap exists for one reason: to keep abuse from poisoning the experience for everyone who's actually building. Free credits don't roll over. They reset on a calendar boundary. If you use 3 credits today, the remaining 2 don't carry to tomorrow's pool, but unused monthly credits also don't bank for the next month. Most free users land somewhere between "evaluating" and "building a weekend prototype," and the limits are sized for that.

If you need more credits but aren't ready to subscribe, two doors open. First, our referral program grants bonus credits to free accounts that don't expire on the calendar boundary. Second, a single-prompt evaluation — "build me a fitness tracker" — typically costs 1 credit and produces a working app you can test on a real device via Expo's QR preview. That's a long way from "downloaded an evaluation copy."

Photo placeholder — credit balance widget

Inside the engine: the four-bucket accounting model

Here's where most "explained" articles stop. We're going to keep going, because the way credits are stored is what makes the system honest.

A team's balance isn't one number. It's four:

Every AI generation deducts from these buckets in a deterministic order. For a paid user, the engine drains subscription_credits first (so you never lose money to expiry while sitting on top-ups), then non_expiring_paid, then bonus credits last. For a free user, the engine first checks rate limits against the daily/monthly cap, then deducts from non_expiring_free if the user has bonus credits to bypass that cap.

Why four buckets and not one? Because credits aren't fungible the way dollars are. A subscription credit you bought in March should expire if you cancel in April — you didn't pay for it forever. A top-up credit you bought as a one-time pack shouldn't expire — you bought it outright. Bonus credits handed out by support shouldn't disappear silently because the calendar flipped. Lumping all four into "credits" hides that nuance and breeds disputes.

Every debit and credit gets logged to a separate transaction table — the same way Stripe logs payments, the same way Plaid logs bank events, the same way any accounting system you'd actually trust does. If a balance ever looks wrong, we can replay the ledger from zero and prove what happened. That's not glamorous engineering, but it's the kind of engineering that means support tickets get answered with facts instead of apologies.

Plans and what each one buys

Here's the honest map of paid plans. All numbers are credit grants; the price is what you pay Stripe.

Two patterns matter here. First, the yearly grant is roughly 12× the monthly grant at ~16% off the monthly price. A monthly Pro subscriber gets 150 credits per cycle and pays $600/year. A yearly Pro subscriber gets 1,800 credits up front and pays $500/year — saving the cost of two months and getting the full annual pool to draw from. If you know you'll be building for at least three months, yearly almost always wins.

Second, plan credits don't stack across renewal cycles. When your billing date hits, the engine resets subscription_credits to your plan's grant — it doesn't add to whatever you had left. This is the same model used by AT&T data plans, Stripe's API call limits, and most usage-based SaaS. We considered rollover, but it creates a perverse incentive: users hoard credits all year and then dump them in month 12, which strands our LLM costs and hurts the people who actually shipped on time. Top-ups exist precisely so heavy months don't punish anyone.

Upgrades and downgrades behave the way you'd hope. Upgrading mid-cycle from Starter to Pro stacks the new grant onto your remaining subscription_credits — you don't lose what you already paid for. Downgrading from Pro to Starter takes effect at the end of the current billing cycle, so you finish the month with the credits you bought before the new plan kicks in.

Top-ups: when one big week shouldn't break your month

Sometimes a sprint hits and you burn through a month's credits in five days. Maybe the founder dropped a 14-screen marketplace spec into the editor. Maybe design moved a sketch from Figma into whiteboard-to-app mode and started iterating on every screen. Without an escape hatch, you're either blocked until renewal or forced into a higher plan you don't actually need year-round.

Top-ups exist for exactly this. Paid subscribers can buy one-off packs of 50, 100, or 200 credits at any time, charged through Stripe. Top-up credits land in the non_expiring_paid bucket — they don't expire when your billing cycle resets. Buy 100 in March, use 30 of them in March, and the remaining 70 are still there in November.

A few rules keep this honest:

• Free-plan users can't buy top-ups. Top-ups are an overflow valve for paid customers, not a backdoor around subscriptions.
• Top-ups don't grant team seats or unlock features. They're pure credit. If you need more team members or higher rate ceilings, that's a plan change.
• Top-ups burn after subscription credits. Your monthly grant always drains first, so you never lose paid-and-permanent credits to subscription expiry.

This three-layered model — base plan + yearly discount + top-ups — was the only structure that survived testing with our heaviest users. The pattern matches what RevenueCat documented about AI pricing in 2026: pure subscriptions break under variable AI costs, pure usage-based pricing terrifies buyers, and the working answer is hybrid.

Photo placeholder — plan tier visualization

What happens when you run out of credits?

A hard block. No surprises, no silent throttling, no "we slowed your model down to a worse one." When your balance hits zero, the next AI generation request returns a clean error and the editor opens an upgrade dialog with three options: top up, change plan, or wait until renewal.

The error code we return is INSUFFICIENT_CREDITS. The editor's Redux store catches it and dispatches a state update to show a modal with current balance, time until reset (for free users), and a one-click route to either Stripe checkout or the customer portal. We deliberately don't degrade the experience — we don't switch you to a smaller model to "stretch" your balance, because that would mean charging you the same price for worse output. That's the kind of move that erodes trust the second a power user notices.

There's one exception. If your subscription is in a past_due state — Stripe couldn't charge your card on renewal — the API returns a 402 Payment Required instead of INSUFFICIENT_CREDITS, and the editor surfaces a billing-settings modal pointing at the Stripe customer portal. This separates "you need to add credits" from "your card needs attention" so you don't waste time troubleshooting the wrong thing.

Why credit-based pricing instead of "unlimited"?

The honest answer: AI generations cost real money to produce, and unlimited plans only work when costs are predictable. They aren't. A tool like Cursor or Bolt.new can spend more money serving one heavy user in a day than that user pays in a month. The math holds at scale only if (a) most users are light, (b) the heavy users tolerate throttling, and (c) the company eats the variance.

We chose the more transparent path. Credits make the relationship symmetric. You see what you spent, we see what we delivered, and nobody is surprised when the bill arrives. According to a 2026 Metronome analysis of 50+ AI pricing models, every AI vendor that started with pure subscriptions has migrated toward hybrid usage-based models within 18 months of launch. We started with the destination instead of the detour.

Credits also solve the team-fairness problem. A 10-person team on a flat-rate plan creates a tragedy-of-the-commons dynamic — one heavy user can starve everyone else, and the tool can't tell whose work matters most. With credits, a Pro team's 150 monthly credits are visible, accountable, and can be supplemented at the team level when a real deadline hits.

People also ask

How much do RapidNative credits cost?

Free accounts get 20 credits per month at $0. Paid plans range from $20/month (50 credits) to $100/month (500 credits), with yearly plans roughly 16% cheaper per credit. Top-up packs of 50, 100, or 200 credits are available to paid subscribers. Every plan gets one credit per AI generation, regardless of prompt complexity.

What does one credit get you in RapidNative?

One credit produces one successful AI generation. That includes building a new screen from text, modifying a component, parsing a sketch into UI, ingesting a PRD, or applying a point-and-edit change. Failed generations do not consume credits.

Do RapidNative credits roll over?

Subscription and free credits do not roll over — they reset at each billing cycle. Top-up credits and bonus credits never expire. This is enforced at the database level by storing them in separate buckets (subscription_credits vs non_expiring_paid vs non_expiring_free), each with its own expiry policy.

What happens when you run out of credits?

Generation requests return an INSUFFICIENT_CREDITS error and the editor opens an upgrade dialog. You can buy a top-up (paid users), upgrade your plan, or wait for renewal. The model and the rest of the editor — preview, code export, project sharing — keep working at full quality.

Can I buy more credits without changing plans?

Yes. Paid subscribers can buy 50-, 100-, or 200-credit top-up packs at any time. Top-up credits land in the permanent bucket and never expire. Free users cannot buy top-ups; they need to subscribe first.

The TL;DR

RapidNative charges one credit per AI generation. Free accounts get 20/month; paid plans range from 50 to 500 credits per cycle. Yearly is meaningfully cheaper per credit. Top-ups handle bursty months without forcing a plan change. Credits live in four buckets internally — free, subscription, top-up, bonus — each with explicit expiry rules and a complete transaction ledger.

This is the pricing model we wished AI tools had when we were buying them ourselves: predictable, auditable, and aligned with what you actually built.

If you want to see what a credit feels like, start a free project — no card required, 20 credits to spend, full editor access. Or look at the full plan comparison on the pricing page before you commit. And if you want more posts like this one — under-the-hood explanations of how RapidNative actually works — the engineering blog is where we keep them.