toolfreebie

Posted on May 28 • Originally published at toolfreebie.com

Bolt.new: Free AI App Builder That Codes, Runs, and Deploys in Your Browser

#ai #automation

What Is Bolt.new?

Bolt.new is a free, browser-based AI app builder from StackBlitz. You type a prompt — “build me a Next.js todo app with Supabase auth” — and Bolt scaffolds the project, writes the code, runs npm install, boots a dev server, and shows you the live preview, all inside a browser tab. When you like what you see, one click deploys it to Netlify with a real URL.

The trick is that none of the build happens on a remote sandbox. The Node.js runtime, the package manager, the dev server, and the file system all live inside your browser, courtesy of StackBlitz WebContainers. When the AI agent edits a file, the change is immediate — there is no round trip to a Docker container in the cloud, no cold start, no queue. That single architectural choice is what makes Bolt feel a generation ahead of older AI coding tools that wrap a remote VM in a chat UI.

In Eric Simons’ interview on the Latent Space podcast, the StackBlitz CEO described Bolt.new’s growth as “the fastest software product I have ever seen go from zero to viral” — the product crossed $8M ARR within two months of launch in late 2024, before adding any salespeople. By 2026 it has settled into one of the three most-used AI app builders alongside Lovable and v0 by Vercel.

This guide is the honest 2026 take on Bolt.new’s free tier: what 1 million tokens per month actually buys, where Bolt beats the alternatives, where it falls down, and how to combine it with free AI APIs and self-hosted clones to get more out of it without paying for Pro.

The WebContainer Trick: Why “AI Code in Browser” Actually Works

Most AI coding products fall into one of two camps. The first runs in your local editor — Cursor, Cline, GitHub Copilot, Aider — and assumes you have Node.js, Python, Docker, and the rest of your toolchain already set up. The second runs on a remote sandbox: Replit Agent, GitHub Codespaces, Gitpod. They give you a VM in the cloud and pipe a terminal back to your browser.

Bolt.new is the only widely-used product in a third camp. The Linux runtime, the package manager, the file system, the HTTP server — all of it is compiled to WebAssembly and runs inside a single browser tab. There is no VM to rent and no laptop to set up. The first time you open Bolt.new on a fresh Chromebook, you can prompt “build me a SvelteKit blog with markdown posts” and have a running app in 60 seconds.

Three concrete consequences of this:

Cold start is zero. The dev server is ready the moment your AI agent finishes writing files — no container provisioning, no docker pull, no waiting room.
Compute cost is your laptop, not their cloud. StackBlitz pays nothing per running project, which is a big part of why a $25/month Pro plan can include 10M tokens of Claude usage. Their marginal cost is the AI tokens, not the hosting.
You can fork and remix instantly. Sharing a Bolt.new URL is the same as sharing source — anyone who opens it has a fully running clone in their browser within a few seconds. There is no “deploy this to a sandbox” intermediate step.

The only thing WebContainers cannot do is run native binaries that aren’t compiled for WASM. That rules out Docker-in-Docker, native Postgres, Python data science with NumPy/Pandas (some Python does work via Pyodide, but it is slower and more limited), and anything that calls into a system library beyond the Node ecosystem. For 90% of modern web app prototyping — React, Next.js, Vue, Svelte, Astro, Remix, Vite, Tailwind, TypeScript — none of that matters. For ML pipelines or anything with a heavy native dependency, Bolt is not the right tool.

Free Tier: What 1M Tokens Per Month Actually Buys

Per the Bolt pricing page, the 2026 free tier gives you:

1,000,000 tokens per month — the soft cap on AI usage
300,000 tokens per day — the hard daily cap; you cannot burn the whole month in one sitting
No rollover — unused free-tier tokens reset every day; only paid tokens roll over (up to one extra month)
Bolt branding on deployed sites
Public projects only — the free tier cannot make a project private

“How much app is 300,000 tokens?” is the question every new user asks, and the honest answer is: less than you’d expect. Each user prompt sends the entire current file tree, the conversation history, and tool definitions back to Claude. A medium-complexity edit to a 5-file Next.js project — say, “add a search bar to the header that filters the post list” — typically consumes 30,000–60,000 tokens of context. Across the day that gives you 5–10 meaningful prompts.

From an independent 2026 comparison of free AI app builders, the realistic free-tier output is “roughly 3-8 meaningful prompts per day” before you hit the wall. That is enough to scaffold a small project and do a couple of refinements. It is not enough to take a real app from nothing to production in a single sitting.

Two practical workarounds:

Plan offline first. Write a tight design doc — pages, routes, data model, third-party integrations — before opening Bolt. The fewer “wait, also do X” follow-ups you need, the more you get out of 300K tokens. Throwaway prompting destroys the free tier.
Use Bolt.new for scaffold + structure, then export to a real editor. Bolt has a “Download” button that ships you a zip with the full project. Open that in Cline or Aider with a free Gemini or OpenRouter key, and continue iterating without the token budget pressure.

Bolt.new vs Lovable vs v0 vs Replit Agent vs Cursor

Five products are usually in the same conversation in 2026. They look similar from the outside (“AI builds your app from a prompt”) but they make completely different trade-offs. This table summarizes the ones that matter for a developer choosing a default tool.

Feature	Bolt.new	Lovable	v0	Replit Agent	Cursor
Surface	Browser tab (in-browser runtime)	Browser tab (remote sandbox)	Browser tab (UI-only)	Browser tab (remote VM)	Local IDE (forked VS Code)
Free tier	1M tokens/mo, 300K/day	5 messages/day	Generous chat-only tier	Limited Agent trial that expires	2-week Pro trial; limited free
Stack scope	Full-stack web (Node ecosystem)	Full-stack web	UI components only (React/Tailwind)	Full-stack + databases + cron	Anything you have on disk
Default model	Claude Sonnet 4.6	Claude / GPT (managed)	v0-managed	Claude / GPT (managed)	Cursor-managed
Premium model	Opus 4.7 (paid plans)	Yes (paid)	Higher tiers on Vercel Pro	Yes	Yes
One-click deploy	Netlify (built in)	Built-in	Vercel	Replit Deployments	External (your choice)
Database	Connect Supabase	Connect Supabase	Connect Supabase / Neon	Built-in Postgres	Whatever you wire up
GitHub sync	Yes	Yes	Yes	Yes	Native
Open-source clone	bolt.diy	No	No	No	No
Pro pricing	$25/mo (10M tokens)	$25/mo	$20/mo	$25/mo Core	$20/mo

Three takeaways from the table that aren’t obvious to most newcomers:

Replit Agent and Bolt.new are full-stack; v0 is UI-only. If your prompt is “build me a complete app with auth and a database,” v0 is the wrong tool — it is meant to feed React components into an existing codebase, not to ship a finished product. Bolt and Replit both ship something runnable end-to-end.
Bolt’s WebContainer beats Replit’s sandbox for iteration speed. Replit Agent is more capable on long-running backend tasks (it has a real Linux VM), but every time the agent edits a file, you wait for the cloud sandbox to reload. Bolt feels nearly instant because the runtime is local to your browser tab.
Lovable is built for non-developers who want polish over control. If the team using the tool is not technical and the most important thing is that the output looks good without thinking about tailwind.config.js, Lovable is the right pick. If you want to read and edit the code yourself, Bolt is much more developer-friendly.

Five-Minute Quickstart: From Prompt to Deployed App

Here is the shortest path from “nothing” to “deployed Next.js app with a database” using only Bolt’s free tier.

Step 1 — Sign in

Open bolt.new in any Chromium-based browser (Chrome, Edge, Brave, Arc — Firefox works too as of 2026, with slightly slower WebContainer perf). Sign in with GitHub or email. There is no credit card prompt.

Step 2 — Write a tight first prompt

The single biggest free-tier optimization is your first prompt. Vague prompts (“make me a website”) force Bolt to ask follow-ups, each one burning context. A specific prompt produces a working scaffold in one shot.

A prompt that consistently produces a usable starter:

Build a Next.js 14 (App Router) blog with the following:

Pages:
- /            list of posts (title, date, excerpt, tag pill)
- /posts/[slug] full post with markdown rendering
- /admin       password-gated form to create new posts (env var ADMIN_PASSWORD)

Data:
- Posts stored in a single posts.json file in the repo
- Each post has: slug, title, date (ISO), tag, excerpt, body (markdown)

Styling:
- Tailwind CSS, dark mode default, monospace headlines, inline code blocks styled with a card shadow

Tooling:
- TypeScript strict mode
- next.config.js with images.unoptimized = true so it deploys cleanly to Netlify

After scaffolding, add three sample posts so I can see the styling.

Notice that everything is concrete: framework version, routing convention, data shape, styling, deploy target, even sample data. Bolt produces a runnable app in one pass on a prompt this specific and uses about 50K–80K tokens doing it.

Step 3 — Run the preview

The preview pane mounts as soon as npm install finishes, which on a typical broadband connection is 8–15 seconds. There is no “deploy” step yet — you are looking at the dev server running inside your browser.

Step 4 — Connect Supabase (optional)

For a real database instead of posts.json, click “Connect Supabase” in the right sidebar. Bolt will prompt you to create a free Supabase project and inject the credentials into .env.local automatically. Then prompt: “Move posts from posts.json to a Supabase table called posts. Replace the JSON imports with Supabase queries.” Bolt will write the migration, the queries, and update the routes in one pass — typically ~40K tokens.

Step 5 — Deploy

Click “Deploy” → choose Netlify → wait ~20 seconds. You get a real public URL like https://celadon-dingo-12345.netlify.app. Custom domains and removing the Bolt branding are paid features.

Step 6 — Push to GitHub

Click “Push to GitHub”. Bolt creates a public repo with all the code. From there, you can clone it locally and continue with Cline, Aider, or any free CLI agent — no longer paying the Bolt token budget for incremental edits.

The Token Economy: How to Make the Free Tier Last

The single most useful skill for any free-tier Bolt user is reading the token meter and writing prompts that respect it. Five things that meaningfully extend the daily 300K budget:

1. Front-load detail

One specific 2,000-token prompt is much cheaper than five 500-token clarifying prompts, because each follow-up sends the entire conversation history again. The cost grows quadratically with how chatty you are.

2. Pin a tight system prompt

Bolt lets you specify project-level instructions (“Always use TypeScript. Never install new packages without asking. Match the code style of the existing files.”) in the project settings. These are sent once per request and prevent Bolt from re-deciding conventions on every edit, which is a frequent token waster.

3. Edit small files yourself

Bolt’s editor is a real editor. If you need to tweak a literal string, fix a typo, or change a Tailwind class, just type the edit. Don’t burn 20K tokens asking Claude to do it.

4. Use “Discussion mode” for design conversations

Discussion mode lets you talk through architecture changes without editing files. It uses a much smaller context (no file tree, no diff machinery) and is meant for “should I use Server Actions or a tRPC layer?” conversations before you commit to a change.

5. Export and continue locally

The 300K daily cap is the real constraint. Once you hit it, the most productive move is to download the project as a zip, open it in VS Code with Cline + a free OpenRouter or Gemini key, and keep iterating with no token meter. Bolt is a great scaffolder; it doesn’t have to be your only editor.

When Bolt Hits Its Limits

Bolt is not the right tool for every project. Three categories where the WebContainer model breaks down:

Anything with a native binary dependency. Imagemagick, FFmpeg, Postgres-the-binary, Python with NumPy/Pandas/PyTorch, Rust toolchain, system-level audio/video. WebContainers run a Node-shaped runtime; calls into the system C library or other languages mostly don’t work. (Pyodide gives you Python-in-WASM, which Bolt can use for some scripts, but it is slow and missing the data-science package landscape.)
Long-running background workers. A WebContainer lives only as long as the browser tab is open. There is no daemon, no cron, no queue worker. For backends that need to run a Celery/Sidekiq-style worker, deploy elsewhere. Replit Agent, with its real VM, is a better fit if you need persistent background processing.
Large monorepos. Bolt is happiest with one to maybe a dozen workspaces. Pulling a 500-package pnpm monorepo into a browser tab is technically possible and miserable in practice — the file watcher overhead and memory pressure tank the UX. For codebases that size, use Cline or Aider locally.

For everything else — landing pages, internal admin tools, prototypes, indie SaaS MVPs, one-off scripts, design system playgrounds, hackathon submissions — Bolt is genuinely best-in-class.

Bolt.diy: The Open-Source Self-Hosted Alternative

StackBlitz published bolt.diy as the open-source variant of Bolt’s frontend in 2024, and it has a healthy community in 2026. Bolt.diy ships the same chat-and-preview UI but lets you bring your own model and run the whole thing on a free free hosting platform.

The differences that actually matter:

Feature	Bolt.new (hosted)	bolt.diy (self-hosted)
Cost	Free (1M tokens/mo limit)	Free + your own API costs
Model	Claude Sonnet/Opus, managed	Any model — bring your own key
Free model option	No (always burns Bolt tokens)	Yes — pair with Gemini, Groq, Together
WebContainer	Yes (StackBlitz infra)	Yes (open StackBlitz npm package)
One-click deploy	Built-in Netlify	Manual
Setup time	0 minutes	~30 minutes
Privacy	Code goes through Bolt servers	Stays on your machine

The killer use case for bolt.diy: pair it with a free AI provider so you escape the 1M-tokens-per-month ceiling without paying for Bolt Pro. With Gemini‘s free tier (1,500 requests/day) or Groq‘s free tier (14,400 requests/day), you have effectively unlimited usage for personal projects. Quality is below Claude Sonnet 4.6 on the hardest tasks, but for most CRUD and UI work the gap is small.

Quick start with bolt.diy

# clone
git clone https://github.com/stackblitz-labs/bolt.diy
cd bolt.diy

# install
pnpm install

# bring your own key in .env.local
echo "GOOGLE_GENERATIVE_AI_API_KEY=your_gemini_key_here" > .env.local
# or
echo "GROQ_API_KEY=your_groq_key_here" >> .env.local

# run
pnpm run dev
# open http://localhost:5173

That’s it — five commands and you have a Bolt clone running locally with no token meter, no rate limits beyond what your free AI provider imposes.

Frequently Asked Questions

Is Bolt.new really free?

Yes. The free tier gives you 1,000,000 tokens per month with a 300,000 daily cap, no credit card required, and full access to Claude Sonnet 4.6. The only meaningful restrictions are: deployed sites have Bolt branding, all your projects are public, and you cannot remove the daily cap without upgrading. For prototyping and learning, the free tier is genuinely usable. For sustained daily work on a real project, you will hit the cap and want Pro.

Which AI model does Bolt.new use?

The default is Claude Sonnet 4.6 from Anthropic. Paid plans also unlock Claude Opus 4.7 for harder reasoning tasks, and a “Standard” mode for cheap polish edits. The model selection is built into the UI; you don’t pick the provider, only the depth/cost trade-off.

Can I use my own API key with Bolt.new?

Not on the hosted bolt.new — the model is managed and bundled into the token cost. If you want BYOK, use the open-source bolt.diy fork, which lets you plug in any model: Gemini, Groq, OpenRouter, Together AI, even local Ollama.

Does Bolt.new work offline?

The WebContainer runtime works offline once loaded — you can edit files and run code without a network — but the AI agent obviously can’t, since it calls Claude over HTTPS. For a fully offline AI coding workflow, use Cline or Aider with Ollama instead.

Can I deploy a Bolt.new app to Vercel or Cloudflare instead of Netlify?

Yes — push to GitHub, then connect the repo from Vercel or Cloudflare Pages. The one-click deploy inside Bolt only goes to Netlify, but the generated project is a normal Node/Next.js/Vite codebase that works on any modern host.

Does Bolt.new support backends other than Node?

Limited. WebContainers run a Node.js-shaped runtime, so anything that compiles to JavaScript (TypeScript, Elm, ReScript) works fine. Python via Pyodide works for scripts but is too slow for full backends. Go, Rust, Ruby, Java, .NET — not natively. For polyglot stacks, Replit Agent or your local editor is the right tool.

What happens to my projects if I let my Pro subscription lapse?

Projects stay where they are — Bolt does not delete code. You drop back to the free tier limits: 300K tokens/day, public projects only, Bolt branding on deployments. Already-private projects remain accessible to you but cannot be edited or visited by collaborators in the same way.

Is Bolt.new safe for client work?

Free-tier projects are public, so any client code with secrets in it is a problem. Pro lets you make projects private, which is the minimum bar for professional work. For NDA-grade work, the open-source bolt.diy on a self-hosted instance is the only fully-private option.

How does the token meter actually count?

Tokens reflect what Claude charges StackBlitz: input tokens (your prompt + file context + history) plus output tokens (the diff Claude writes back). Per the official Bolt token docs, file context dominates — a request that touches a 1,000-line file costs roughly the same regardless of how short your prompt is. This is why “edit only the relevant files” is a real technique.

Decision Tree: Bolt.new vs Cline vs Aider vs Cursor vs Lovable

If you want a one-line picker for which tool to start with:

You want to go from prompt to deployed app in one browser tab → Bolt.new
You want a polished UI, you’re not a developer, and you’ll pay for it → Lovable
You want UI components to drop into an existing Next.js codebase → v0
You want a real backend with a real database that runs 24/7 → Replit Agent
You want a serious AI agent inside VS Code with your own API key → Cline
You want a terminal-first AI pair programmer that auto-commits → Aider
You want a managed forked-VS-Code experience and don’t mind paying → Cursor
You want autocomplete plus a chat box, nothing more → GitHub Copilot
You want to self-host the whole stack with your own free API key → bolt.diy + Gemini or Groq

Use Bolt.new with OpenClaw

OpenClaw is an AI agent platform for orchestrating multi-step automated workflows. Bolt and OpenClaw cover different parts of the build-and-ship loop, and the seam between them is genuinely useful.

The pattern: use Bolt.new for the human-driven scaffold-and-design phase — describe the app you want, watch it appear, push to GitHub. Then hand the GitHub repo over to an OpenClaw flow for the unattended phase: a nightly job that bumps dependencies, runs the test suite on each push, regenerates the OpenAPI client whenever the schema changes, and files an issue if anything breaks. Bolt builds the v1; OpenClaw maintains it.

A concrete pipeline an OpenClaw agent can own end-to-end without you touching it: every Monday at 7am, pull the latest Bolt-generated codebase, run pnpm audit, attempt to upgrade any package with a known CVE, run the test suite, and on success open a PR titled “weekly security bump.” On failure, open an issue with the failing test names. You wake up to either a green PR ready to merge or a clear bug report.

Final Verdict

Bolt.new is the best-in-class answer to “I have an idea and want a running app in 5 minutes” in 2026. The WebContainer trick is genuinely a generation ahead of products that wrap a remote VM in chat — there is no cold start, no setup, no dependency on what you have installed locally. For prototyping, hackathons, internal admin tools, and turning a spec into a deployed link in front of a stakeholder, nothing else feels as fast.

The free tier’s 300K daily cap is real, though, and the cost of follow-up prompts grows fast. The right way to use Bolt.new on free is: front-load detail in your first prompt, get a runnable scaffold in one pass, push to GitHub, and continue refinements in Cline or Aider against any free AI API. That hybrid workflow — Bolt for the “0 to 1,” a free local CLI agent for the “1 to 10” — is the cheapest serious AI coding stack available right now, and it costs literally zero dollars.

If you want to escape the token ceiling entirely, bolt.diy with Gemini or Groq as the model is the natural next step. You give up the polish of the hosted product but you also give up the $25/month it would otherwise cost to keep building. Open the page, type a prompt, watch your app run in your browser. There is no faster way to find out whether an idea is worth pursuing.

DEV Community