RapidNative's Credit System: Pay for What You Build

Last quarter a product manager I know shipped a side project with one of the popular AI coding tools. The build went fine. The bill, less so. Forty-seven dollars across a single weekend, distributed across hundreds of opaque line items — some prompts charged five cents, some charged a dollar twenty, and nothing on the invoice explained why. She wasn't out a lot of money. She was out the ability to budget for next weekend.

That's the failure mode credit-based AI pricing was invented to fix, and it's the reason RapidNative's billing is built around a single unit you can count on your fingers: one credit, one AI generation.

This post is the deep dive on how that actually works inside the product — what a credit buys, what it doesn't, how plans differ, what happens to your unused balance when you upgrade or downgrade, and why a credit-based AI app builder pricing model beats per-token billing for the kind of work people do here.

How RapidNative credits work, in 40 words

A RapidNative credit is a flat-rate token for one AI generation — creating a screen, editing one, or fixing a bug with AI all cost exactly 1 credit. Plans come with a monthly or annual credit allowance, and paid users can buy top-up packs that never expire.

One credit, one generation — and that's the whole rule

There is no token math at the user surface. There is no per-prompt cost modifier. There is no fine-print pricing for "complex" requests versus "simple" ones. Every AI-driven action you take in RapidNative that produces or modifies code costs one credit, and the deduction happens after the generation completes successfully.

The actions that consume a credit are exactly the ones that involve the model writing or rewriting your React Native code:

• Generating a new screen from a prompt, sketch, screenshot, or PRD
• Editing an existing screen ("change the header to a sticky one with a search icon")
• The "Fix with AI" action on a runtime error or warning
• Any other AI-powered code mutation in the editor

The actions that are free — and stay free regardless of plan — are the ones that don't call the model:

• Previewing your app on web or via QR code on a real device
• Restyling screens through the visual controls
• Exporting React Native and Expo source code (on paid plans)
• Creating projects, inviting teammates, organizing files, all the dashboard plumbing

If your generation is truncated or fails on the model's side, paid users aren't charged. The deduction sits behind a successful-completion check in the credit service. That's the kind of detail that doesn't fit on a pricing page but matters the first time it happens to you.

What every RapidNative plan actually includes

There are four plans, and the differences come down to two numbers: credits per period and how many people can collaborate. Everything else — the AI features, the editor, real-time preview, team workspaces — is the same across tiers.

A few things worth pointing out about that table that aren't obvious at a glance.

Annual billing isn't just a 10 percent discount with extra steps. The Pro annual plan is $199 for 1,800 credits — that's about $0.11 per credit. The Pro monthly plan is $49 for 150 credits, which works out to about $0.33 per credit. You're paying roughly a third as much per generation if you commit to the year. The credit bundle lands once on activation rather than refreshing every month, which works well for teams whose build pace is uneven across the quarter.

The team-member numbers matter more than they look. RapidNative credits are scoped to the team, not the individual user, which means a Pro team of ten people draws from a shared pool of 150 monthly credits. That can be a lot — most teams have a small number of people who drive most of the AI generation — but it's worth knowing.

For the full feature breakdown alongside the credit numbers, the pricing page is the source of truth.

The free plan: 20 credits a month, 5 a day

Free is genuinely free, no trial countdown, and it's the plan most new builders use for their first few projects. You get 20 credits per calendar month, capped at 5 per day so a single afternoon of experimentation can't burn your entire month. Both counters reset automatically — daily at midnight UTC, monthly on the first of the month.

There are two practical limits on the free plan worth knowing about up front.

The first is the five-screens-per-project ceiling. You can build a five-screen app on the free plan, polish it, share it, embed it on a portfolio site. You cannot ask the AI to create a sixth screen in the same project until you upgrade or start a new project (which gets its own five-screen quota). The check runs before the model is called, so being blocked at the limit doesn't cost you a credit. Editing, restyling, and bug-fixing on the existing five screens stays unrestricted.

The second is code export. The free plan is for evaluating the product and prototyping ideas, not shipping to the App Store. Source code export is a Starter-and-up feature. Everything you build remains yours — RapidNative doesn't hold your code hostage — but the download endpoint is gated to paid users.

If 20 credits a month sounds light for serious work, it's because it's not meant to carry serious work. It's meant to get you to the point where you know whether RapidNative fits your workflow before you commit fifteen or twenty dollars to find out.

Top-up credits: for sprint weeks and last-minute builds

The thing nobody tells you about credit-based AI pricing is that even good monthly allowances run out the week before a deadline. RapidNative paid users can buy top-up packs — 50, 100, or 200 credits — through the same Stripe checkout that handles subscriptions.

Top-up credits are different from subscription credits in one important way: they never expire.

This matters because of how the deduction order works internally. When a paid user runs a generation, the system charges subscription credits first, then falls back to top-up credits when the monthly allowance is gone. So if you buy 100 top-up credits in May and only burn through 30 of them, the remaining 70 sit there waiting — through June's renewal, through a plan change to Max, through a pause and resume. They're yours until you spend them.

There's a quiet implication of that design: top-ups effectively let you smooth out usage across uneven months. The team that builds heavily in March and barely touches the editor in April doesn't have to oversubscribe to the Max plan to cover March. They can stay on Pro and buy a top-up when they need the extra runway.

What happens to credits when you change plans

This is the section that pricing pages always skip and that everyone has to learn by emailing support. Worth being explicit about it.

Free → Paid. When you upgrade from the free plan to any paid tier, your subscription credit balance gets set to the new plan's monthly allowance. If you had bonus credits sitting in your account from a referral or onboarding promo, those stay where they are.

Paid → Higher Paid (mid-cycle). Upgrading mid-cycle — Pro to Max, say — stacks credits rather than replacing them. If you were halfway through the month with 80 Pro credits remaining and you upgrade to Max (330 monthly credits), you end up with 80 + 330 = 410 in your subscription bucket. The upgrade reflects the assumption that you weren't going to abandon what you'd already paid for, and that the higher tier should add capacity rather than reset it. You'll be prorated on the dollar side via Stripe.

Paid → Lower Paid. Downgrading — Max to Pro, for example — resets your subscription credit balance to the new tier's allowance at the start of the next billing period. The piece that doesn't change: any top-up credits you've bought remain in your account, untouched. Those persistent credits are exactly the hedge against this scenario.

Paid → Free. Downgrading to the free plan zeros out your subscription credits and your purchased top-ups. The free tier resets to 20. This is the irreversible one — if you cancel a paid plan with a balance of top-up credits still sitting there, those credits go away when the cancellation takes effect. (Practically speaking: spend the top-ups first, or pause-and-resume the plan instead.)

Subscription expiry. If a payment fails and the subscription ends, your subscription credits auto-zero on the next request that hits the balance check. Top-up credits aren't affected.

For the engineers reading: this lives in the credit service module behind a small set of pure functions that calculate the next state given the current one. The four-bucket design — separate balances for free credits, subscription credits, paid top-ups, and free-tier bonus credits — exists specifically so the upgrade and downgrade math stays predictable and auditable. Every credit movement writes a row to a transactions ledger with the bucket, the amount, the balance after, and a human-readable reason. If you ever want to know where a credit went, support can pull the trail.

Why credits, not tokens — and not flat-rate either

There are three honest ways to charge for AI features. Flat-rate subscriptions, per-token billing, and credits. Each one breaks in a different way, and the question is which way you can live with.

Flat-rate subscriptions look fair and feel terrible at the edges. The user who makes one screen a month subsidizes the user who makes a thousand. Eventually the heavy users force the price up, the light users churn, and the product ends up serving neither well. Anyone who's watched a SaaS company quietly add "fair use" language to a previously unlimited plan has seen this movie.

Per-token billing solves the fairness problem and creates a worse one: cognitive overhead. The user has to think about model selection, prompt length, output verbosity, and context window size every time they ask the AI to do something. That overhead has a real cost — there are studies showing per-token pricing reduces experimentation, which is the worst possible outcome for a product whose whole value depends on people iterating quickly. Every "let me try one more thing" gets weighed against a meter that might tick differently this time. Builders self-censor. The product gets worse because the pricing makes thinking expensive.

Credits split the difference. The unit is opaque on the cost side (RapidNative absorbs the variance between cheap text prompts and expensive vision prompts) and transparent on the user side (one generation, one credit, every time). Industry research from Freemius and Dodo Payments tracks credit-based models growing roughly 126 percent year-over-year for AI tools, which lines up with what we see in the conversion data: pricing pages that frame credits as outcomes ("50 screens you can build") rather than inputs ("50 API calls you can make") convert noticeably better.

The honest tradeoff is that credits aren't free for us either. The variance between a cheap text-only generation and a vision-heavy one is real, and RapidNative eats that variance. The bet — and so far it's looked like a good one — is that simplicity at the user surface is worth that price.

If you want the broader context on what a mobile app actually costs to build in 2026, the agency vs AI builder breakdown is the companion piece to this one.

What credits cost in real-world terms

Most useful way to think about RapidNative credit pricing is in terms of finished work, not abstract units. A rough rule of thumb that holds up across most builds:

• A new screen from a prompt or sketch — 1 credit
• Adding a feature to an existing screen ("add a filter button to this list") — 1 credit
• Reworking a layout based on a screenshot reference — 1 credit
• An end-to-end three-to-five screen prototype — typically 8 to 15 credits including refinement
• A polished ten-screen app with iteration and bug fixes — typically 25 to 40 credits

That last number is the one most teams underestimate. Generation is cheap. Iteration is where most of the credits go — the seven rounds of "make the button bigger, no, smaller, no, that color, no the other one" that turn a working app into a shippable one. Budget for iteration and the plan choice gets easier: a solo builder shipping one app a month fits comfortably inside Starter, a team shipping three or four projects a month is squarely in Pro, and a studio using RapidNative as their primary build tool is on Max with occasional top-ups.

Common questions about RapidNative credits

Do RapidNative credits roll over from month to month?

Subscription credits do not roll over. The monthly allowance resets to the plan amount at the start of each billing period. Top-up credits — the ones you buy in 50, 100, or 200 packs — never expire and stay in your account across renewals and plan changes.

Are credits per-user or per-team?

Credits are scoped to the team, not the individual user. Everyone on the team draws from the same balance. The dashboard shows the current balance and the date of the next refresh.

Do I lose top-up credits if I downgrade?

Top-up credits survive downgrades between paid plans (Max → Pro, Pro → Starter). They are forfeited if you downgrade all the way to the free plan or cancel the subscription, because the free tier doesn't carry purchased credits. If you're considering downgrading, the safest play is to spend the top-up balance first.

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

AI generation pauses until the next billing reset, you upgrade the plan, or you purchase a top-up pack. Your existing projects and screens stay fully accessible — you can preview them, share them, and continue editing the parts of them that don't require the model.

Is the free plan good enough for a real prototype?

For a small prototype you can show stakeholders — yes. Twenty credits comfortably builds a five-screen prototype with room for a few rounds of polish. For anything you want to actually ship to the App Store, you'll need the Starter plan or higher to unlock code export.

Start with 20 free credits

The fastest way to understand the credit system is to use it. The free plan gives you 20 credits a month — enough to build, iterate on, and share a small prototype without entering a card. If RapidNative fits your workflow, the Starter plan is $20 a month and gives you full code export plus three team seats. If it doesn't, the free plan stays free.

Start building on the free plan →

For teams comparing plan options, the pricing page lays out feature differences alongside credit allowances. For broader reading on how AI-native tools are reshaping the cost structure of mobile development, the agency vs AI builder analysis is a good next step.

The underlying tech — React Native and Expo — is yours to keep regardless of plan. Whatever RapidNative generates is standard React Native code that runs anywhere React Native runs. The credits buy generations. The code you keep forever.