Bolt.new turns a prompt into a running full-stack app inside your browser, using StackBlitz's WebContainers to execute Node.js locally rather than on a server. Pricing is token-metered: free gives 1M tokens a month capped at 300K a day, Pro is $25 for 10M, Teams $30 per member. The number that matters isn't the plan — it's that tokens are consumed by every attempt, so a vague prompt that produces the wrong screen costs the same as one that works. Your bill tracks your iteration count, not your output.
Reviewed by EdGrows·Updated Aug 18, 2026Affiliate link — we may earn a commission
This analysis is based on documentation, public user reports, and vendor materials — not yet on our own hands-on testing. How we rate
Bolt.new does the thing the demos show. Describe an app, wait a couple of minutes, get a running full-stack project with a file tree you can edit and a preview you can click. A Next.js app with auth and a database, live, before your coffee cools.
The part the demos skip is how it bills.
Bolt charges by token, and tokens are consumed by attempts rather than results. The model reads your project context, writes code, and that costs the same whether you keep the output or immediately say "no, not like that."
Which produces the defining fact about this product: two people on the same $25 plan can have wildly different months. One writes specific prompts against a tidy project and gets a working MVP. The other iterates vaguely on a sprawling codebase and hits the ceiling in a week. Same plan. Same product. Different discipline.
| Plan | Price | Tokens |
|---|---|---|
| Free | $0 | 1M/month, capped at 300K/day |
| Pro | $25/mo | 10M/month, no daily cap |
| Pro (higher tiers) | up to ~$50/mo | ~26M/month at the $50 step |
| Teams | $30/member/mo | 10M per member, not pooled |
| Enterprise | Custom | SSO, audit logs, SLA, priority support |
Two details that catch people out.
The daily cap is what the free tier is really limited by. 300K a day means the free plan doesn't run out at the end of the month — it runs out at 4pm. That's a deliberately good trial design, because it shows you the shape of your own usage before you commit.
Teams tokens don't pool. Each member gets their own allocation, so a heavy builder can't borrow from a light one. Compare that to the org-wide pooling on GitHub Copilot Business, where one enthusiast can drain the shared balance. Different failure modes; Bolt's is the fairer one.
Paid plans roll unused tokens forward for up to two months, and annual billing knocks off around 28%.
Three things drive token burn, and only one of them is how much app you built.
Project size. Context gets read on every prompt. A 40-file project costs more per instruction than a 5-file one, which means Bolt gets progressively more expensive as your app grows — the opposite of how per-seat tools behave.
Prompt precision. "Make the dashboard better" spends real money finding out what you meant. "Add a date-range filter to the orders table, defaulting to last 30 days" spends less and lands closer.
Iteration count. This is the big one. Every rejected attempt bills. The developers who report Bolt as cheap are usually the ones who think before prompting; the ones who report it as expensive are frequently conversing with it.
None of this is hidden — it's just structurally different from a flat subscription, and the mental model people bring from $20/month tools doesn't transfer.
Bolt V2 shipped in September 2025 with Bolt Cloud — database, auth, file storage, edge functions and hosting built in. That closed the gap that used to send everyone to Supabase on day one, and made "prompt to deployed URL" a single-vendor path.
A Microsoft Azure partnership landed in May 2026, bringing enterprise procurement, M365 integration, and own-tenant deployment. That's not a feature most solo builders will notice, but it's the sort of thing that decides whether a company can buy the tool at all.
The price moved from $20 to $25. Small, but it means older comparison articles — including plenty still ranking — understate the current cost.
The trajectory underneath: $40M ARR by March 2025, 7M+ registered users by December 2025, $105.5M Series B. This is not a project that's about to disappear, which in 2026 is worth stating explicitly.
Long-lived production codebases. The economics invert as the project grows, and you eventually want a real editor, real branches, and a real review process. Export to GitHub and continue in Cursor — that's the standard path, not a failure.
Precise design work. Bolt produces competent, generic interfaces. If the visual detail is the product, you'll be fighting it. v0 is stronger on polished UI components.
Budget certainty. If someone needs to approve a fixed monthly number, token metering is an awkward conversation. Flat-rate tools exist for exactly this reason.
Anything security-critical. Generated auth and data handling look plausible by default. Plausible is not the same as correct, and telling the difference requires the expertise Bolt was supposed to save you.
Against Lovable: Lovable targets the non-technical builder, with Supabase wiring that mostly just happens and a gentler surface overall. Bolt gives you the actual development environment — terminal, file tree, instant execution — because WebContainers runs it in your tab. For validating an idea without touching code, Lovable. For building something you intend to keep and extend yourself, Bolt.
Against v0: v0 generates polished React components and interfaces, and it's better at that than Bolt is. It isn't trying to give you a full-stack app with a backend. Use v0 when the interface is the deliverable, Bolt when the running application is.
Against Replit: Replit is a full cloud IDE with agent capability, collaboration, and hosting, running on remote infrastructure. Bolt runs in your browser and is faster to first result. Replit suits sustained multi-person development; Bolt suits the sprint from idea to prototype.
Against Cursor: Cursor is where Bolt projects tend to go once they get serious — a real editor at $20 flat, working on code you already have. Bolt creates from nothing; Cursor improves what exists. Many builders use exactly that sequence.
Against Bubble: Bubble is visual no-code with a hosted runtime and no code to export. Bolt writes actual framework code you own. If you never want to see a repository, Bubble; if you want the option, Bolt.
| Plan | Monthly | Tokens included | Best for |
|---|---|---|---|
| Free | $0 | 1M/mo, 300K/day cap | Evaluating, small experiments |
| Pro | $25 | 10M | Solo builders, MVPs, client prototypes |
| Pro (upper) | ~$50 | ~26M | Sustained building on larger projects |
| Teams | $30/member | 10M per member | Small teams needing collaboration and admin |
| Enterprise | Custom | Negotiated | SSO, audit logs, SLAs, own-tenant deployment |
Checked August 2026 against Bolt's published pricing and current third-party reporting. Pro rose from $20 to $25 during 2026 and token allowances shift with plan step, so confirm on bolt.new/pricing before budgeting. Token consumption per prompt is not published and varies with project size and model workload — no external calculator can predict your bill accurately.
Burn the free tier deliberately. Build something you actually want, watch the counter, and let the 300K daily cap tell you what kind of user you are. That's a better sizing exercise than any plan comparison.
Keep projects small and prompts specific. Both cut token spend directly, and the second one improves output quality at the same time. This is the rare case where the cheap habit is also the effective one.
Export before it gets expensive. When the project is big enough that each prompt reads a lot of context, the economics favour moving to a flat-rate editor. Push to GitHub and carry on elsewhere — that's the tool working as intended.
Annual billing if you're sure. Around 28% off, but only worth it once you've established that your usage pattern actually fits.
Bolt.new is the fastest route from a sentence to a running full-stack application that exists right now, and WebContainers is a genuinely clever piece of engineering rather than a marketing word — running Node in the browser removes a server round trip that every competitor still pays. The output is real framework code you own and can take anywhere, Bolt Cloud closed the backend gap, and the Azure partnership means enterprises can now buy it through channels they trust.
The honest problem is that the pricing model rewards a skill most people don't know they're being graded on. Token metering means your bill tracks your iteration count, and iteration count tracks how clearly you can specify what you want. The developers who call Bolt cheap and the ones who call it expensive are frequently describing their own prompting rather than the product. Costs also rise as your project grows, which is backwards from how subscription tools feel and catches people mid-build. And generated code still needs review from someone who can distinguish working from plausible — particularly anywhere near auth or data.
There's a fair counterpoint to all of it: metered billing means light users aren't subsidising heavy ones, and the free tier's daily cap is an unusually honest trial. You find out what you'll spend before you spend it, which is more than the flat-rate tools let you do.
For prototypes, MVPs, and client demos, recommend at Pro. For a codebase you'll maintain for a year, use Bolt to start it and something flat-rate to finish it.
Note: Bolt.new does not currently have an affiliate program with AIVario. We earn no commission, and this rating carries no commercial incentive.
Best for: Fast prototypes and MVPs, developers who want the real code and a real terminal, client demos on a deadline, validating an idea before committing engineering time Not ideal for: Long-lived production codebases, pixel-precise design work, teams needing a fixed predictable bill, security-critical applications without expert review Bottom line: Two minutes from prompt to running app, billed by the attempt rather than the result. Write precise prompts and it's cheap; converse with it and it isn't.
Free at $0, Pro at $25 a month, Teams at $30 per member. The free tier includes 1 million tokens monthly with a 300,000 daily cap, Pro raises that to 10 million with the daily cap removed, and higher Pro tiers scale up — around 26 million tokens for $50. Enterprise is custom-quoted. Paid plans include token rollover for up to two months, which softens a light month. Note that Pro moved from $20 to $25 during 2026, so older comparisons understate it.
Every generation attempt, whether or not you keep the result. Tokens are spent when the model reads your project context and writes code, so a rejected screen costs roughly what an accepted one does. Larger projects cost more per prompt because more context gets read each time. This is why two people on identical plans can have completely different experiences — the one who writes specific prompts against a small project gets several times more output per dollar.
Enough to evaluate, not enough to finish. One million tokens a month with a 300,000 daily ceiling covers a small prototype or a serious afternoon of experimentation. The daily cap is the part people hit first — it stops long sessions rather than long months. If you hit it twice and still want to keep going, that's the actual signal to upgrade, and it's a better test than any calculator.
Bolt runs the development environment in your browser; Lovable leans on hosted backend integration. StackBlitz's WebContainers execute Node.js client-side, which is why Bolt gives you a real terminal, real file tree, and instant execution without a server round trip. Lovable is generally smoother for non-technical builders wiring up Supabase. Developers who want to see and edit the actual code tend to prefer Bolt; first-time builders often find Lovable friendlier.
StackBlitz technology that runs a Node.js environment entirely inside the browser tab. Traditional cloud IDEs execute your code on a remote machine and stream results back; WebContainers eliminates that round trip, so installs, builds, and reloads happen locally at local speed. It's also why Bolt has no per-user server cost for the runtime, and why the experience feels closer to a local dev environment than a remote one.
Yes, and you own the code. Bolt V2 added Bolt Cloud with built-in database, auth, file storage, edge functions and hosting, so you can stay inside the platform. You can also export to GitHub and deploy to Netlify, Vercel, or anywhere else that takes a Node project. Nothing about the output is locked to StackBlitz — the generated code is ordinary React, Next.js, Vue, Svelte or Astro.
The foundation does; the details usually need work. Output is real framework code rather than a proprietary abstraction, which means a developer can read, refactor, and extend it. Simple apps often ship close to as-generated. Anything with real business logic, edge cases, or security requirements needs review by someone who can tell good code from plausible code. The honest framing is that Bolt removes the blank-page problem, not the engineering.
It'll get you further than you expect and then stop. You can reach a working prototype without writing code, which is genuinely useful for validating an idea or showing a stakeholder. What you can't do without some technical judgement is debug the thing when it breaks, evaluate whether the auth is safe, or decide which of the AI's three suggested fixes is correct. Bolt makes developers much faster; it doesn't turn non-developers into developers.
Still the fastest issue tracker for engineering teams — and after the plan restructure, the tier with the good features costs $16 instead of $50.
The AI code editor that became the default — now rebuilt around parallel agents in Cursor 3, with its own Composer models.
Terminal-native, model-agnostic, git-obsessed. Cheaper than the vendor CLIs and slightly less accurate — an explicit trade, not a hidden one.