●MCP — Rork now lets you add and manage your own MCP servers inside Plugins (11/21)●2.5 ROUTE — From 12/1, apps calling gemini-2.5-flash are routed to 3.5 Flash-Lite and billed at its rates (9 days left)●CHANNEL — Users report Android notification channel reads and writes failing in Expo Go●NEW — New: three clues to check before replying to a stuck-on-splash review●EXPORT — Export your projects before you downgrade or cancel a plan●SONNET 4.5 — Apps that call Sonnet 4.5 through the API should switch before it retires on 11/30●MCP — Rork now lets you add and manage your own MCP servers inside Plugins (11/21)●2.5 ROUTE — From 12/1, apps calling gemini-2.5-flash are routed to 3.5 Flash-Lite and billed at its rates (9 days left)●CHANNEL — Users report Android notification channel reads and writes failing in Expo Go●NEW — New: three clues to check before replying to a stuck-on-splash review●EXPORT — Export your projects before you downgrade or cancel a plan●SONNET 4.5 — Apps that call Sonnet 4.5 through the API should switch before it retires on 11/30
Rork Pricing Compared Honestly: Free vs Rork Max (from $20), How Credits Drain, and How to Choose as an Indie Developer
As of November 2026, Rork has two tiers: a design-only Free plan and Rork Max, which starts at $20/month. What actually costs credits, the point where $20 plus top-ups beats the $200 option, a script that paces credits from your renewal date, and break-even DAU from ad revenue, all from Rork's official numbers.
One morning I put my own billing screen next to Rork's official pricing page and they didn't line up. I remembered a ladder of three or so paid tiers. The page showed two things: "Free" and "Rork Max". And Max now started at $20 a month, an order of magnitude below the number in my notes.
If I'd kept calculating from those notes, I might have talked myself into paying for something I didn't need. Pricing goes stale on the day you learn it, and that morning was a small, cold reminder of it.
Here's the short version: as of November 2026, Rork works in two steps: design for free, then build and ship on Rork Max. Which Max option you pick, and how you cover the months where you run short, can change your monthly bill several times over for the same amount of work. Everything below uses Rork's own documentation, and I'll walk through the decision one piece at a time.
The November 2026 pricing on one page
This is drawn from the official Rork pricing and plans page (updated November 11, 2026), trimmed to what matters for an indie developer. Prices change, so please check the same page before you subscribe.
Tier
Monthly (Nov 2026)
Credits / month
What you get
Free
$0
35 in major markets including Japan (max 5/day); 5 elsewhere
Design mode only (screens and look). No building or publishing
Rork Max
$20
100
Build mode, iPhone (SwiftUI), Android (Kotlin + Compose), web, iPad, Apple Watch, Vision Pro, games, iOS widgets, Dev mode
Rork Max
$200
1,000
Same features
Rork Max
$500
2,500
Same features
Rork Max
$900
5,000
Same features
Rork Max
$1,800
10,000
Same features
Rork Pro (accounts created before Aug 4, 2026 only)
$20
100
iPhone, Android, web. No iPad/Watch/Vision Pro, games, or widgets
The one thing I'd want you to take from this table: every Rork Max option has exactly the same features; only the credit amount differs. The docs say so directly: "Every Rork Max option includes the full feature set." Paying $200 doesn't unlock anything $20 doesn't.
Work out the price per credit and something else shows up. The $20 through $500 options all come to $0.20 per credit; the $900 and $1,800 options to $0.18. A top-up credit costs $0.22. In other words, moving up a tier barely lowers your unit price. That fact is what the "$20 plus top-ups" approach later in this piece rests on.
India also has an entry tier, Rork Start (₹649/month, 40 credits, light models only). It isn't available elsewhere.
What the Free plan can and can't do
You can stay on Free indefinitely with no card on file; it isn't a trial that expires. But as of November 2026, Free runs Design mode only.
In Design mode you describe the app and Rork proposes the screens and the look, for iPhone, Android, web, iPad, Apple Watch, or Vision Pro. Turning that design into a working app (Build mode), testing it on a device, and publishing to the App Store or Google Play all require a paid plan.
Free credits have two limits: 35 a month in major markets, and no more than 5 a day. They reset at the start of each calendar month. Because of the daily cap, you can't save them up and spend all 35 in one mid-month burst. I wrote about living with that daily cap separately in Rork's free tier gives you 35 credits a month, but the 5-a-day cap is what you'll hit.
What I try to do on Free is settle every design question there. Which screens exist, how they connect, what gets saved. Anything left undecided turns into rework once you're building, and rework is paid for in credits.
✦
Thank you for reading this far.
Continue Reading
What follows includes implementation code, benchmarks, and practical content we hope you'll find useful. This site runs without ads — server and development costs are supported entirely by members like you. If it's been helpful, we'd be truly grateful for your support.
WHAT YOU'LL LEARN
✦The November 2026 structure: Free runs Design mode only, building and publishing needs Rork Max (from $20 for 100 credits), and how legacy Pro accounts fit in
✦A script that finds the cheapest option-plus-top-up mix for your monthly usage; below roughly 918 credits a month, $20 plus top-ups wins
✦A triage table for balances that drop faster than expected: per-minute simulators, in-app AI billed to the project owner, and renewal dates
Secure payment via Stripe · Cancel anytime
✦
Unlock This Article
Get full access to the rest of this article. Buy once, read anytime. This site is ad-free — your support goes directly toward keeping it running.
Rork used to count one credit per exchange with the AI. That's gone. The official How credits work page puts it as "A message costs what its work costs."
Action
Cost (Nov 2026, official)
Easy to miss
A message to the agent
Depends on the work: model, web searches, builds, generated images, and so on
Big changes cost more than 1. Messages paid from free monthly credits cost at least 1
iOS simulator
0.2 per minute while running
An hour left on is 12 credits, 12% of the $20 option
Android emulator
0.1 per minute while running
6 credits an hour
Rork AI Cloud inside your apps (AI, search, images, voice)
Provider cost, $1 of usage = 5 credits
Your published app's users are billed to the project owner's balance
Collaborators' messages
From the owner's balance
People you invite spend your credits
To see what a single message cost, open the "⋯" menu under the answer. If you stop a message mid-way, you pay only for the work done before you stopped it.
Which credits go first, and which ones survive
It's one balance, but three kinds of credit sit inside it, and they're spent in a fixed order.
Kind
Where it comes from
Resets monthly?
Spend order
Subscription credits
Free monthly credits and your plan's credits
Yes (no carry-over)
1 (free) then 2 (plan)
Reward credits
Referrals, connecting RevenueCat, and similar
No
3
Usage credits
Top-ups ($0.22 each) and old Cloud Credits
No
4
The credits that expire are spent first; the ones you bought last the longest. Until October 30, 2026 there was a separate "Cloud Credits" balance. It was folded into Usage credits at the same value ($1 = 5 credits).
The reset date differs too. Paid plans renew on the monthly anniversary of your first purchase; Free resets on the 1st. If you assume everything refills on the 1st, your end-of-month calls will be off by up to a few weeks.
Start at $20 and cover short months with top-ups
Put three facts together: unit prices are nearly flat, plan credits expire, and bought credits don't. The order of decisions follows from that. While your monthly usage is still unpredictable, staying on the $20 option and topping up in the months you run short usually costs less than moving up a tier.
The crossover is one division. The $180 gap to the $200 option, divided by $0.22 per top-up credit, is about 818 credits. Add the 100 included at $20 and you get roughly 918 credits a month. Below that, $20 plus top-ups wins; if you're consistently above it, the $200 option does.
I turned it into a script so I can drop in each month's number. It runs as-is with Node.js.
#!/usr/bin/env node// plan-vs-topup.mjs — given monthly credit usage, find the cheapest Rork Max option plus top-ups.// Prices are from docs.rork.com/introduction/subscriptions as of November 2026. Update them if Rork changes pricing.// Usage: node plan-vs-topup.mjs <credits used per month> [<credits used per month> ...]const OPTIONS = [ { usd: 20, credits: 100 }, { usd: 200, credits: 1000 }, { usd: 500, credits: 2500 }, { usd: 900, credits: 5000 }, { usd: 1800, credits: 10000 },];const TOPUP_USD = 0.22; // one top-up credit (carries over to next month)const needs = process.argv.slice(2).map(Number);if (needs.length === 0 || needs.some(Number.isNaN)) { console.error("Usage: node plan-vs-topup.mjs <credits used per month> [...]"); process.exit(1);}for (const need of needs) { const rows = OPTIONS.map((o) => { const short = Math.max(need - o.credits, 0); const cost = o.usd + short * TOPUP_USD; return { ...o, short, cost, unused: Math.max(o.credits - need, 0) }; }).sort((a, b) => a.cost - b.cost); const best = rows[0]; const line = best.short > 0 ? `$${best.usd} option + ${best.short} top-up credits` : `$${best.usd} option only (${best.unused} credits expire at renewal)`; console.log(`${String(need).padStart(5)} credits/mo → cheapest $${best.cost.toFixed(2)}: ${line}`);}
At 300 credits a month, $20 plus 200 top-up credits comes to $64. Moving up to the $200 option would have cost $136 more, and 700 credits would have vanished at the renewal date.
One caveat. Top-ups are sold in fixed amounts, from +25 credits ($5.50) to +1,000 credits ($220.00), not one credit at a time as the script assumes. You'll round up a little, but since bought credits carry over, the extra isn't wasted. Auto top-up, if you turn it on, adds $20 each time you run out; it has a monthly cap you can set, and I'd turn the cap on together with it.
A mistake I made, and the line I drew after it
I'll be honest: I once moved up a tier for a heavy build month and then forgot to come back down. The next month I only touched a few strings of copy, and most of the credits were still sitting there when the renewal date came. It wasn't the amount that bothered me so much as realizing I'd been paying without looking.
My rule now is simple: move up a tier on what I've used, never on what I expect to use. I only move to the $200 option after two straight months above the ~918 line. Until then, $20 and top-ups absorb the spikes.
Pace your credits back from the renewal date
Even with top-ups as a safety net, you can't feel mid-month whether you'll make it. About twelve days after my renewal date I run the next script once with three numbers. The trick is to count elapsed days from your own renewal date, not from the 1st.
#!/usr/bin/env node// credit-pace.mjs — turn non-rolling plan credits into a daily allowance until the next renewal.// Paid plans renew on the anniversary of your first purchase; Free resets on the 1st of each month.// Usage: node credit-pace.mjs <credits per month> <days since renewal> <used> [cycle days] [--free]const args = process.argv.slice(2);const isFree = args.includes("--free");const [total, elapsed, used, cycleDays = 30] = args.filter((a) => a !== "--free").map(Number);if ([total, elapsed, used].some(Number.isNaN)) { console.error("Usage: node credit-pace.mjs <credits per month> <days since renewal> <used> [cycle days] [--free]"); process.exit(1);}const remain = total - used;const daysLeft = Math.max(cycleDays - elapsed, 1);const pace = used / Math.max(elapsed, 1); // current spend per dayconst landing = Math.round(pace * cycleDays); // where this pace ends upconst allowance = remain / daysLeft; // per-day amount that uses everythingconsole.log(`Remaining : ${remain} credits / ${daysLeft} days left`);console.log(`Pace : ${pace.toFixed(2)} / day → lands at ${landing} (cap ${total})`);console.log(`Allowance : ${allowance.toFixed(2)} / day (${(allowance * 7).toFixed(1)} / week)`);if (isFree && allowance > 5) { console.log(`Note: Free is capped at 5 credits a day. Anything above 5/day will expire unused.`);}if (landing > total) { console.log(`⚠ You'll run out around day ${Math.floor(total / pace)}. Check for a simulator left running and repeated rewordings first.`);} else if (landing < total * 0.7) { console.log(`△ About ${total - landing} credits will expire unused (plan credits don't carry over).`);} else { console.log(`✔ On pace to use your credits.`);}
On the $20 option (100 credits), twelve days in with 70 already spent:
$ node credit-pace.mjs 100 12 70
Remaining : 30 credits / 18 days left
Pace : 5.83 / day → lands at 175 (cap 100)
Allowance : 1.67 / day (11.7 / week)
⚠ You'll run out around day 17. Check for a simulator left running and repeated rewordings first.
Running out around day 17 is a concrete date, and having one helps you decide calmly between topping up and pushing work to next month. And in my experience, months like this are usually driven by a simulator left on rather than by the prompts. At 12 credits an hour, it keeps draining while you sit and think.
Now the other side: the Free plan, twelve days in, only 6 credits used.
$ node credit-pace.mjs 35 12 6 30 --free
Remaining : 29 credits / 18 days left
Pace : 0.50 / day → lands at 15 (cap 35)
Allowance : 1.61 / day (11.3 / week)
△ About 20 credits will expire unused (plan credits don't carry over).
Twenty credits are on track to expire unused. Free credits are capped at 5 a day, so you can't catch up at the end of the month. If there are screens you want to refine, spread the work across earlier days.
Put more into each request
Even with cost tied to work rather than message count, fewer round trips still help. Splitting one screen into three requests means three rounds of re-reading context, and often three builds.
❌ Three round trips
1. "Make a settings screen"
2. "Add a dark mode toggle"
3. "Save the toggle state"
✅ One request
"Make a settings screen with a dark mode toggle. Save the selected
state on the device and restore it on the next launch. Put a title
at the top and list the settings vertically below it."
I don't have enough measurements to claim the combined request is always cheaper than three. What I can say is that on days I batch requests, the per-message cost in the "⋯" menu is easier to read, and I miss my month-end landing less often.
When your balance drops faster than expected
Most pricing surprises fall into one of these. Start from the symptom.
Symptom
Likely cause
How to check
Fix
No build or publish button on Free
Free runs Design mode only
Your profile shows the Free plan
Finish the design, then move to Rork Max (from $20)
Credits dropped while you weren't asking for anything
iOS simulator (0.2/min) or Android emulator (0.1/min) left running
Settings → Credits → Build history
Press Stop simulator / Stop emulator when done; leaving the project also stops it
Balance keeps falling after you publish
Rork AI Cloud usage inside your app (AI, search, images, voice)
Credits → Rork AI Cloud → Cloud Usage (last 30 days, by model and project)
Set the monthly limit for your apps' AI. When it's reached, only your app's AI stops, and you get an email
Credits didn't refill on the 1st
Paid plans renew on the anniversary of your first purchase
The renewal date on the Subscription credits row
Count elapsed days from that date
The pricing page shows Rork Pro
Account created before August 4, 2026
When you created the account
If you need iPad, Watch, Vision Pro, games, or widgets, consider Max; otherwise Pro is the same price
Subscribed from the iPhone app, but in-app AI isn't paid from plan credits
With App Store / Google Play subscriptions, plan credits pay for building only
Where you subscribed
In-app AI draws on free, reward, and usage credits; keep some top-up credits on hand
Common misunderstandings, corrected
"Rork Max is the $200 premium product." As of November 2026, Rork Max is the only paid plan for new accounts, it starts at $20, and the options differ only in credits ("Every Rork Max option includes the full feature set, from $20/mo"). Comparing on the old "Max = $200" assumption pushes people toward a $200 option they don't need.
"You can ship to the stores on Free." Free is Design mode only: no building, no publishing. The official FAQ says building, testing, and publishing a working app needs Rork Max.
On annual billing: the official pricing documentation as of November 2026 lists monthly options only, and I couldn't find an annual option in what I checked. I'd hold off on any math that assumes an annual discount until you can confirm one on the official page.
How far ad revenue gets you, tier by tier
Whether a tool is expensive is easier to judge once you turn it into the number of users needed to pay for it. I've run ad-supported wallpaper apps for a long time, so I tend to translate any monthly fee into "how many DAU is that?"
Conservative assumptions: 3 ad impressions per daily active user per day, 30 days, and eCPMs of $1, $2, and $5.
#!/usr/bin/env node// breakeven.mjs — translate each Rork Max option's monthly price into the DAU needed to cover it.// Replace eCPM and impressions per DAU with your own AdMob numbers.const OPTIONS = [20, 200, 500]; // Rork Max options as of November 2026 (USD/month)const IMPRESSIONS_PER_DAU = 3; // ad impressions per DAU per day (a modest value)const DAYS = 30;const ECPMS = [1, 2, 5]; // low / typical / goodfor (const ecpm of ECPMS) { const perDau = (IMPRESSIONS_PER_DAU * DAYS * ecpm) / 1000; const cells = OPTIONS.map((usd) => `$${usd}: ${Math.ceil(usd / perDau).toLocaleString("en-US")} DAU`); console.log(`eCPM $${ecpm} ($${perDau.toFixed(3)} per DAU per month) → ${cells.join(" / ")}`);}
$ node breakeven.mjs
eCPM $1 ($0.090 per DAU per month) → $20: 223 DAU / $200: 2,223 DAU / $500: 5,556 DAU
eCPM $2 ($0.180 per DAU per month) → $20: 112 DAU / $200: 1,112 DAU / $500: 2,778 DAU
eCPM $5 ($0.450 per DAU per month) → $20: 45 DAU / $200: 445 DAU / $500: 1,112 DAU
eCPM
Monthly revenue per DAU
Max $20
Max $200
Max $500
$1
$0.090
223 DAU
2,223 DAU
5,556 DAU
$2
$0.180
112 DAU
1,112 DAU
2,778 DAU
$5
$0.450
45 DAU
445 DAU
1,112 DAU
The $20 option needs about 112 DAU at a $2 eCPM, which one steadily used app can reach. The $200 option only makes sense once four-digit DAU is in sight.
The part that's easy to miss is Rork AI Cloud inside your app. Each time a user calls AI, the provider cost ($1 = 5 credits) comes out of your balance. Subtract per-DAU AI cost before you look at break-even. If your app has AI features, check the Cloud Usage numbers at least once a month.
The IMPRESSIONS_PER_DAU value of 3 is deliberately modest. Raising it improves the table, but it also raises churn. Lowering break-even by bumping that constant tends to be an improvement that only exists on paper.
How to compare it with other app builders
People often ask how Rork compares with FlutterFlow or Adalo. Each of them revises pricing often, so please check November 2026 numbers on their own pages (FlutterFlow, Adalo). What I'd compare first is what you're actually paying for.
Tool
How you build
Output
What drives cost up
Rork
Describe it; AI generates it
Swift (iPhone), Kotlin (Android), React (web)
Work per request, simulator minutes, in-app AI usage
FlutterFlow
Visual builder with AI assistance
Flutter
Plan tier and team size (check official page)
Adalo
Mostly drag and drop
Proprietary runtime
Plan tier and number of published apps (check official page)
If I had to put the choice in one sentence: pick a visual builder if you want to place every pixel yourself; pick Rork if you want a working native app fast and plan to refine from there. Rork's cost tracks the work you do rather than a flat fee, so a table of monthly prices alone won't settle the comparison.
Pay for what you need, when you need it
Here's how the numbers above turn into my own sequence.
Settle the design on Free. Decide screens, navigation, and what gets saved in Design mode, a little each day within the 5-credit cap.
Move to the $20 option the day you start building. Not the night before a deadline. If something snags in checkout, you want room to sort it out.
Absorb short months with top-ups. Bought credits carry over, so buying a little extra just moves it to next month.
Consider the $200 option only after two straight months above ~918. Not before.
The next snag: once you ship AI features, you have two things drawing on one balance
Right after you publish on the $20 option, the thing that tends to catch people is in-app AI billing. The credits you spend building and the credits your users spend calling AI come out of the same balance. It's invisible before launch and grows with every new user.
During your launch week, set the monthly limit for your apps' AI and the low-balance email (the default threshold is $5). When the limit is reached, only your app's AI stops; building isn't affected.
A pricing table starts aging the day you read it. So today, open Settings → Credits and find the renewal date on the Subscription credits row. Run credit-pace.mjs once from that date, and next month's tier decision gets much easier.
Thank you for staying with this one. I hope it saves you a little time in front of that pricing page.
Share
Thank You for Reading
Rork Lab is ad-free, supported entirely by members like you. We publish practical guides daily with implementation code, benchmarks, and production-ready patterns. If you've found it useful, we'd love to have you on board.