v0 (Vercel) — Type English, get a working web UI

🧱

Hands-on — 30 seconds

You get a familiar request: "build me a pricing page with 3 plans, a monthly/annual toggle, and the middle plan highlighted." Normally: open Figma, slice the layout, write HTML/CSS, fix the responsive breakpoints — half a day gone. With v0 you type one English sentence describing that page → v0 generates React + Next.js + Tailwind + shadcn/ui, shows a live, working preview right beside it, then gives you a 1-click deploy to Vercel with a URL you can send to the client. Why it matters: a founder or developer can compress what would take "2 devs + 1 designer over a week" down to under an hour for the UI — you shift from typing every line to describing and refining, producing a clickable mockup you can sign off with a client in the same meeting.

"v0 isn't a chat box that draws pictures of a UI.It generates real React/Next.js code, runs it in a real sandbox, and deploys it to real production."

By the end of this chapter you'll be able to

• Sign up & get going on v0.app (nothing to install), and understand how far the free tier of ~$5/month lets you experiment.
• Type a prompt and get a UI: from a single component to a multi-page app with routing, then iterate to refine it.
• Read the token-based pricing table correctly (Mini/Pro/Max) and avoid the "burned through my credits" trap — broken code generations are still billed.
• Deploy in 1 click to Vercel and push code through the Git panel (branch → PR → merge to deploy).
• Know when NOT to use v0 (complex backends, native apps, non-React stacks) and pair v0 with Cursor/Claude for the logic.
• Pick a plan that protects your data (Business+ so your data isn't used for training) and decide whether you can actually pay for it.

This is a tools chapter — you should read it with v0.app open in another tab, typing along. Seeing the UI appear in front of you teaches you far faster than reading alone.

---

01 · What this tool is & when to use it

v0 is an AI tool from Vercel (the company behind Next.js) that turns a natural-language description (in English) into working web code. You type a prompt → v0 generates React + Next.js + Tailwind CSS + the shadcn/ui library (this is the default stack), shows a live preview, then offers a 1-click deploy to Vercel.

The key shift in 2026: v0 is no longer just a "component generator." The overhaul Vercel calls "the new v0" (launched early February 2026 — the official blog post went up Feb 3, 2026; a major update adding the Git panel + a VS Code–style editor landed around Feb 4, 2026) turns it into a genuine full-stack development platform:

• A sandbox runtime that runs real apps — called the Vercel Sandbox, a lightweight VM in an isolated environment (replacing the older in-browser preview). This lets it run server-side features too, not just render static UI.
• A VS Code–style editor right in the browser — view/edit code file by file, see diffs, and tweak by hand without leaving the platform.
• A Git panel — each chat creates a branch, opens a PR into main, and merging triggers a deploy. For the first time, even non-engineers can "ship" through a standard Git workflow.
• Database connections — supports connecting to Snowflake and AWS (documentation on the specific connectors is still thin, so treat this as "connection supported" for now).

Vercel positions this new version to solve the "90% problem" — connecting AI-generated code to existing production infrastructure, not just stopping at a prototype (per VentureBeat/InfoWorld).

The Feb 2026 overhaul adds features but does NOT change pricing

Per aggregated sources (nocode.mba, ICON) as of mid-2026, Vercel confirmed it kept the same pricing after the update — don't assume "new full-stack version = more expensive." Pricing is still the token-based model described in section 02.

Scale (per sources as of mid-2026 — many figures are self-reported by Vercel, so treat them as a "one-sided source"):

• Users: the official post "Introducing the new v0" (Feb 3, 2026) cites "over 4 million people" using v0. A few third-party roundup blogs estimate ~6 million — that number is not in the official announcement, so stick with 4 million (per Vercel, Feb 2026) to be safe.
• Projects created: a third-party estimate (getpanto.ai) puts it at roughly ~9.6 million projects in 2025. (The "100 million apps" figure circulating in a few places is almost certainly a mistake/exaggeration — the official post never states it, so drop it.)
• Revenue: the "$2M ARR in 14 days" milestone is from the 2023 v0 launch, NOT the 2026 overhaul — don't mix up the context. Likewise, "doubling the user base" usually refers to Vercel (the whole company), not v0 specifically.

Don't quote the wrong numbers

The scale figures are often inflated by roundup posts. The most reliable figure right now: "over 4 million users" (Vercel, Feb 3, 2026 post). Before quoting any "millions of apps / millions of dollars" number, check it directly against the official blog post — many numbers online are wrong years or wrong scope (v0 vs Vercel).

👉 Under the hood: how v0 works (a quick look)

Per Vercel's technical post "How we made v0 an effective coding agent" (detailed, reliable), v0 uses the "v0 Composite Model Family" (Vercel doesn't say whose base model it is) running through a multi-step agentic pipeline. Three notable layers:

• (a) Dynamic system prompt — it injects fresh docs via embeddings + keyword matching (instead of doing a web search), so the model always knows the latest APIs/syntax.
• (b) LLM Suspense — it fixes output mid-stream: e.g., the model types a wrong icon name → the system finds the closest icon via vector search in under 100ms.
• (c) Autofixers — fixes errors after the stream finishes, using deterministic fixes plus a small fine-tuned model, running in under 250ms.

Vercel says LLM-generated code is wrong ~10% of the time; this pipeline pushes the success rate up by "double digits" (in their words).

Key features (in a nutshell)

• Text-to-UI / Text-to-App: generate single components (date picker, navbar, pricing card) up to full-page layouts and multi-page apps with routing.
• High-quality code generation: Next.js + Tailwind + shadcn/ui; the code is praised as "clean, maintainable" in most comparisons.
• Agentic workflow: plans and executes multiple steps on its own (multi-file).
• VS Code–style editor + Git panel + full-stack sandbox (as described above).
• Import a GitHub repo + pull environment variables (env vars) from Vercel into the sandbox.
• Figma import: drag a design file in → get code (paid plan and up).
• 1-click deploy to Vercel with a URL.
• v0 API: call v0 from outside (paid plan).
• An iOS app (Vercel has a post "How we built the v0 iOS app").

How it compares to other tools

v0 isn't the only option in the "prompt to app" category. Short positioning: v0 = strongest at frontend/UI + the Vercel ecosystem; for a full-stack "one tool does it all", Lovable has the edge; for the fastest prompt → preview, Bolt; for the most code-level control, Cursor; Claude Artifacts is great for quick prototyping right inside the chat. The table below (characteristics as of mid-2026, subject to change):

Criterion	v0 (Vercel)	Lovable	Bolt.new	Cursor	Claude Artifacts
What it is	AI that generates React/Next.js UI → now with a full-stack sandbox	Full-stack AI web builder (DB + auth + deploy)	Prompt→app, very fast, runs WebContainers (StackBlitz)	AI code editor (IDE)	Preview pane inside Claude's chat
Output stack	Next.js + Tailwind + shadcn (React-first)	React + TS + Tailwind, backend via Supabase	Multi-framework, including React Native	Any stack (you bring your own)	Usually a single React/HTML file
Backend/DB/Auth	Limited (frontend-first; sandbox + DB connectors newly added)	Built in (Supabase) — a strength	Yes (Bolt Cloud since Aug 2025)	Wire it yourself, AI assists	None
Deploy	1-click to Vercel (locks you into Vercel)	1-click	Yes	No built-in deploy	No (lives inside Claude)
Figma import	Yes (paid plan)	—	—	—	—
Best fit for	People who prioritize a polished UI + Vercel deploy	Non-tech folks who want a finished app	Validating an idea in ~30 minutes	Devs who want code control	Quickly trying out a UI idea
Paid entry price	Free; paid plans from ~$20/month	Free; Pro ~$25, Business ~$50/mo	Bolt Pro usually from ~$20/mo (the "~$10" figure is an old/lower tier — check bolt.new/pricing)	Pro ~$20/mo (Teams ~$40/user; 2026 added Pro+ ~$60, Ultra ~$200 tiers)	Bundled with a Claude plan (Pro ~$20/mo)

🤝 The tool-pairing pattern many people recommend

Don't think you have to pick one. A pattern that comes up again and again in many write-ups: use v0 to generate a beautiful UI → use Claude/Cursor to wire in logic and a backend for the real app. v0 handles the visible part (the interface), and the code-level tools handle the processing (APIs, DB, auth). (Sources: lovable.dev guide, lowcode.agency, hansreinl.de, tooljet, Medium — Anna Arteeva.)

🛑 When NOT to use v0

• You need a complex server-side backend/business logic, an ORM, or custom auth — v0 is fundamentally frontend-first (even with the new sandbox/DB connectors, it still trails Lovable for full-stack).
• Native mobile apps (iOS/Android) / React Native — v0 produces web, not native apps.
• A non-React/Next.js stack (Vue, Svelte, Angular). Note there's a source conflict here: a few posts say v0 supports Vue/Svelte/HTML, but the official positioning and most sources are React/Next.js-first — in practice, treat v0 as leaning toward React/Next.js.
• A team committed to non-Vercel infrastructure (AWS/GCP as the primary host) — the 1-click deploy locks into Vercel; other platforms require a manual export.
• You need deep debugging and maximum code control → Cursor / Claude Code fit better.
• A very small budget with steady, regular use → the ~$5 free tier burns fast.
• A long-term project that needs tight control so data is NOT used for training → avoid Free/Team (neither opts out by default); go straight to Business+ from day one. This is an architecture/compliance decision, not just a security tip.

---

02 · Sign-up / access & pricing

Sign-up & install — nothing to install

v0 runs in the browser at v0.app; there's no software to download. You sign up with a Vercel, GitHub, or email account. There's also an iOS app if you want to tinker on your phone.

1. Open https://v0.app
2. Sign up with Vercel / GitHub / email
3. Go straight to the chat box — type a prompt to generate UI

🔤 Rename: v0.dev → v0.app

Around January 2026, v0 changed its main domain from v0.dev to v0.app. The old v0.dev links still redirect to the new address, so old docs/bookmarks keep working — but get used to v0.app.

Billing model: token-based (an important change)

This is the easiest place to miscalculate cost. Since May 13, 2025 (the "Updated v0 pricing" post), v0 moved from a "fixed message count" model to token-based: it measures input/output tokens and converts them to credits. The goal (per Vercel): better cost predictability at scale, plus more free usage. (Existing users were moved to the new model on their next billing cycle, not mid-cycle.)

A few credit rules to remember:

• Credits reset monthly on your billing date.
• Credits bundled with a personal plan don't accumulate indefinitely. (One source says they carry over and then expire after ~65 days; another says "no roll over" — this part has mildly conflicting sources, so just treat it as "credits have a shelf life" and check your own billing page.)
• Purchased add-on credits expire after one year and can be shared within a team (Team/Enterprise plans).

Pricing table (per v0.app/pricing as of mid-2026)

Prices change fast — re-check before you commit

Every figure below is "per sources as of mid-2026"; estimated numbers are marked with ~. v0 updates pricing/features constantly — always open v0.app/pricing for the actual price before you put your card in.

Plan	Price	Included credits	Key notes
Free	$0	~$5 credit/month	Limited to ~7 messages/day; includes Visual Design Mode, GitHub sync, deploy to Vercel; up to ~200 projects
Premium (personal)	~$20/month	~$20 credit/month	Being sunset — existing users only; new users CANNOT sign up (confirmed via community.vercel.com). No hard message cap, Figma import, v0 API, buy extra credits
Team	~$30/user/month	~$30/user + ~$2 credit/day when signed in	Collaboration, shared chats/credits, centralized billing, API
Business	~$100/user/month	~$30/user + ~$2 credit/day	Training opt-out by default (your data isn't used to train)
Enterprise	Contact (custom)	Custom	Data never used for training, SAML SSO, RBAC, priority performance, support SLA

The Premium plan is being sunset — pick an alternative

As of mid-2026, the v0.app/pricing page for new users only shows Free / Team / Business / Enterprise — no Premium. An official thread on community.vercel.com ("Why the v0 Personal Premium plan is missing from the pricing page") confirms Premium is being sunset: existing users keep the plan, new users can no longer sign up.

What you should do: if you need a personal plan, the realistic remaining options are Free (limited to ~7 messages/day) or jumping to Team ~$30/user/month. Still, open v0.app/pricing to check the actual status at the time you're reading.

Per-model pricing (per 1 million tokens, per v0.app/pricing): every plan can access all 3 tiers Mini/Pro/Max; plans differ in credits / daily limits / collaboration features.

Model	Input (USD / million tokens)	Output (USD / million tokens)
v0 Mini	1	5
v0 Pro	3	15
v0 Max	5	25
v0 Max Fast	10	50

(There are also cache write/read prices — see the pricing page.)

Is the free tier really free? — Yes, but it burns fast

It's real, but ~$5 credit/month runs out very quickly — a few complex prompts with Pro/Max can use it all up in one session. Good for trying it out, not for steady project work. And a warning from the community: you're still charged for broken code generations too.

Pricing & access (international)

v0 is a global web app — there's no apparent geo-blocking on using it from anywhere. The hard part (as with most US services) is payment.

Card payments — verify with your bank

Per Vercel's billing FAQ: it accepts credit/debit cards only (no gift cards, prepaid, or some virtual cards); you can pay in any currency as long as your card issuer allows conversion and a charge in USD.

So in practice: a Visa/Mastercard with international USD payments enabled generally works; domestic-only cards or virtual cards may be declined. This is inferred from the billing FAQ — check with your bank that international payments are enabled before you sign up.

Note for Vietnam / SEA readers: there's no official source specific to Vietnam, but the same rule applies — a Visa/Mastercard with international payments switched on usually works, while local-only cards often get rejected. Confirm with your bank first.

---

03 · The hands-on workflow — step by step (with real prompts)

Below is the standard work loop from your first prompt to deploy. Open v0.app and follow along.

Step 1 — Create an account at v0.app (Vercel / GitHub / email).

Step 2 — Pick a model based on how hard the task is:

v0 Mini  → simple tasks, cheapest (single component, small edits)
v0 Pro   → balanced (page layout, medium app)
v0 Max   → hardest tasks, highest quality (multi-page app, complex logic)

Step 3 — Write a prompt that clearly states the purpose + structure + data. Here are 3 real prompts (taken from official guides / reputable sources — usable as-is):

A SaaS pricing page with three tiers, monthly/annual toggle, feature comparison
table, and a highlighted "most popular" plan.

A dashboard for a fitness app showing weekly workout summary, progress charts,
and a calendar heatmap.

A multi-step onboarding form with email verification, profile setup, and a
progress indicator.

Step 4 — Iterate. This is the part that costs the most: type follow-ups to refine one step at a time instead of rewriting from scratch.

change the primary color to blue
add dark mode
make it responsive for mobile
give the middle plan a "Most popular" badge and a different background color

Step 5 — Export / Deploy. Three paths:

① Copy the code → paste it into your own project
② Sync to GitHub → v0 creates a branch / opens a PR
③ 1-click deploy to Vercel → get a URL to send the client

03b · The "ship" workflow via the Git panel (2026 version)

This is the new bit that lets even non-engineers ship. Each chat = one branch; you review, then merge; merging deploys:

1. Each chat in v0 automatically creates its own branch
2. Edit/iterate in the sandbox until you're happy
3. Open a PR into main right in the Git panel
4. Merge the PR → v0 deploys the new version to Vercel

03c · Pull existing code & environment into v0

If you already have a repo and want v0 to keep building on it:

① Import your GitHub repo into v0
② Pull env vars (environment variables) from Vercel into the sandbox
③ Let v0 run the real app in the Vercel Sandbox (including the server-side part)

✍️ Prompting tips (per annjose.com & Medium "v0.dev tip 1: start playing")

• Start simple, then build up step by step — don't cram every requirement into one giant prompt.
• Describe components + behavior (filter, sort, urgency) instead of just saying "make it nice." The model can't guess your version of "nice," but it clearly understands "has a filter by status, sorted by newest date."
• Drag in an image / Figma file so v0 sticks to the design instead of inventing its own layout.

---

04 · Pro tips & common pitfalls

Tips that save you money

6 hands-on tips

1. Iterate, don't rewrite. Typing small follow-ups ("change the color", "add dark mode") is cheaper and more precise than deleting and re-describing the whole page.
2. Pick the right model for the task. Small chores go to Mini (in 1 / out 5); save Max (in 5 / out 25) for complex apps — the token-price gap is 5×, so picking wrong burns credits.
3. Describe behavior, not feelings. "filter by status, sort by urgency" > "make it feel pro."
4. Drag in Figma/images once you have a design — v0 sticks to it far more closely than to a verbal description.
5. Let v0 handle the UI, pair Cursor/Claude for the logic — don't force v0 to build a complex backend (see section 01).
6. Watch your credits like a fuel gauge. The ~$5 free tier burns up in one heavy session; open the billing page to see your burn rate before you go wild.

Security & where your data goes

You're sending descriptions (and sometimes code) to a cloud service — you need to know where the data goes before you paste anything sensitive.

• Free and Team: NOT opt-out by default — your data & code may be used to improve the model (yes, even the Team ~$30 plan — this is an easy one to get wrong: paying for Team still means training). Only Business (training opt-out by default) and Enterprise ("data never used for training") are truly safe on the training front. (Premium used to be in the "may be trained on" group too, but it's being sunset — see section 02.)
• Enterprise adds: SAML SSO, RBAC (role-based access control), priority performance, SLA.
• The app runs in the Vercel Sandbox — an isolated environment (a lightweight isolated VM).

Practical recommendation: don't paste secrets / API keys / real customer data into prompts on the Free/Team plans (neither opts out); use env vars via Vercel; for long-term projects that need data-training control, pick Business+ from the start — this is an architecture decision, not just a security tip. (Specifics on compliance certifications like SOC2/GDPR for v0 are thinly sourced — check Vercel's legal/security pages.)

Privacy/GDPR note: if you process personal data, the privacy-by-design choice is the same — go Business+ (training opt-out) or Enterprise (never trained on), keep secrets in env vars, and verify the relevant data-processing terms on Vercel's legal/security pages before handling regulated data.

FAQ & common errors

(Compiled from multiple community.vercel.com threads + trickle.so reviews. Re-check against the changelog/docs since the product changes fast.)

Q: v0 is stuck in an "error loop," reporting errors over and over even though I did everything right. → This is a real complaint ("error loops"), worst during the dips in quality. Try: trim your request, split it into smaller steps, or open a new chat (new branch) instead of trying to rescue a broken session.

Q: Am I billed for broken code generations too? → Yes — being charged anyway for failed generations is a common complaint. So pick the right model (Mini for small tasks) and describe things clearly upfront to reduce the number of failed generations.

Q: A file errors with "Unexpected end of input." → The AI often **opens a .ts/.tsx file with a stray backtick at the top of the file. Delete that stray backtick.

Q: I asked for a tiny change and v0 touched another file, breaking a working feature. → The "unnecessary changes" bug is real; sometimes v0 even writes chat text into the code file, causing compile errors. Ask specifically for "only edit file X, don't touch other files," and use the Git panel/diff to see exactly what changed before you merge.

Q: A server-side error killed my preview and I don't know why. → v0 lacks debugging tools (no full terminal logs); a server-side error kills the preview and is hard to trace. This is a current limitation — when you need deep debugging, pull the code into Cursor/Claude Code.

Q: Calling the v0 API throws a 500. → Likely a context-size limit. Try reducing the input volume.

Q: It's hard to predict my end-of-month bill. → There are 3+ model tiers with different token prices → hard to estimate monthly cost. Track credits often; for steady work, estimate based on the model tier you use most.

Q: The Premium plan (~$20 personal) is gone — what do I pick instead? → Premium is being sunset: existing users keep it, new users can't sign up (confirmed via community.vercel.com). For new users, the remaining options are Free (limited to ~7 messages/day, good for trying it) or Team ~$30/user/month (collaboration + more credits). Note both Free and Team don't opt out of training — if you need data control, you must go Business+.

Q: Is the code v0 generates "production-ready"? → Good for common UI patterns; it struggles with very complex/unique designs; you'll usually still need a dev to refine it before production.

---

05 · Exercises / mini-projects

Do them in order. Each has clear success criteria so you can check yourself.

Exercise 1 — Generate a pricing page & iterate to refine it (basic)

Goal: get comfortable with the prompt → preview → iterate loop and see the default stack code.

1. Go to v0.app, pick the Pro model, and type:

A SaaS pricing page with three tiers, monthly/annual toggle, feature comparison
table, and a highlighted "most popular" plan.

2. Iterate with at least 3 follow-ups:

change the primary color to blue
add dark mode
make it responsive for mobile

Completion criteria

• You have a clickable pricing-page preview, with the monthly/annual toggle working.
• You can see the code is Next.js + Tailwind + shadcn/ui (open the code/diff tab to confirm).
• The three follow-ups changed the UI without rewriting the original prompt.
• (Reflect) You found iterating cheaper and more precise than rewriting from scratch.

Exercise 2 — 1-click deploy & ship via the Git panel (core)

Goal: take the UI from preview to a real URL and go through the branch → PR → deploy flow.

1. From the page in Exercise 1, Deploy to Vercel to get a URL.
2. Type one more follow-up (e.g., add a "Most popular" badge).
3. In the Git panel: open a PR into main → merge → let v0 deploy the new version.

Completion criteria

• You have a Vercel URL you can open on your phone and send to someone else.
• You can see each chat maps to a branch, and merging the PR triggers a deploy.
• (Reflect) Why this workflow lets non-engineers "ship" too.

Exercise 3 — Pair v0 with Cursor/Claude for the logic (advanced)

Goal: experience the "v0 handles the UI, the code-level tool handles the logic" pattern.

1. Generate a dashboard with v0:

A dashboard for a fitness app showing weekly workout summary, progress charts,
and a calendar heatmap.

2. Export/Copy the code (or sync to GitHub) and open it in Cursor or Claude Code.
3. In the code-level tool, wire real data (read from an API/JSON) into the charts in place of the fake data.

Completion criteria

• A polished UI generated by v0, with the data logic wired up by you in Cursor/Claude.
• You understand the boundary: v0 is great at the visible part, the code-level tool is great at the processing.
• (Reflect) When to stop at v0, and when to pull the code out.

---

06 · Real case studies & use cases (from the community)

This section compiles real v0 use cases from 2025–2026 so you can see what it does on real work — and read the numbers correctly.

Read the numbers correctly

Most cases below come from the Zapier post "v0 by Vercel: 4 examples..." and Vercel Community/blog — most are users telling their own story, so treat them as self-reported evidence, not an independent audit. The time/cost/ticket figures are as the people involved recounted them.

① SeekFast — a customer-feedback dashboard. Borets Stamenov (Co-founder/CEO) built a dashboard that pulls Airtable data and auto-generates the UI + filters in under 40 minutes; he says without v0 it would have taken "2 devs + 1 designer over a week." (Source: Zapier.)

② Cirrus Bridge — a "Voice of the Customer" dashboard. Patric Edwards (Founder) describes a workflow tagging feedback by source/urgency → v0 produced a React layout that "felt ready to ship"; a dev customized it further, saving "a few weeks." (Source: Zapier.)

③ Swapped — a KYC onboarding tool. Thomas Franklin (CEO) built a 3-step guide for deposit limits/KYC by country; v0 produced a clickable prototype in 90 minutes, the official version went live 48 hours later; tickets dropped 43% in 5 days; the v0 cost was ~$0 versus "~$1,400" the traditional way. (Source: Zapier.)

④ Octoparse — a scraping-job management dashboard. Kevin Liu (VP Products) built a real-time job-tracking board with Slack/email alerts, going "from idea to deployment in a day, not weeks." (Source: Zapier.)

⑤ AppMakers USA — a multi-app feedback control center. Daniel Haiem (CEO) built a dashboard of cards sorted by feedback volume + filters by type/urgency. (Source: Zapier.)

A personal use case (lighter source)

A website for a CBT therapist: a developer built a site for his girlfriend (a cognitive-behavioral therapist), using v0 for design inspiration, bought a domain + deployed on Vercel, and was online within a few days. (Source: Vercel Community Showcase — a personal use case, lighter than the cases above.)

06b · Use cases drawn from the cases above

• Internal dashboards pulling data from SaaS (Airtable, feedback systems) — generate UI + filters in under an hour.
• Clickable onboarding/KYC prototypes to demo & close quickly, then build the official version.
• Real-time tracking boards with alerts (Slack/email) — "in a day, not weeks."
• Personal landing pages/websites that look good, with a domain bought + deployed on Vercel within a few days.

Patterns that recur in the community

• Start from real data (Airtable/feedback) and let v0 build the UI around it.
• Ship a clickable prototype first, measure the reaction (tickets, client demos), then invest effort in the production build.
• v0 for the visible part, a dev for the rest — almost every case has a "a dev customized it further" step.

---

07 · Summary & official sources

6 takeaways

1. v0 = an AI tool from Vercel that turns an English prompt → working React/Next.js + Tailwind + shadcn/ui code, deployed in 1 click.
2. The 2026 version ("the new v0") adds a full-stack sandbox + VS Code–style editor + Git panel → you can ship via branch/PR, not just build a prototype.
3. Token-based billing (since May 13, 2025): pick the right tier (Mini/Pro/Max) so you don't burn credits; the ~$5 free tier burns fast and broken generations are still billed.
4. Usable anywhere (a global web app); the real barrier is paying with an international USD card — check with your bank.
5. Know the boundaries: v0 is strong at frontend/UI + the Vercel ecosystem; a complex backend / native / non-React stack → pair with Cursor/Claude or pick another tool.
6. Security: Free and Team (even paid Team) may use your data for training; to opt out you must go to Business (opt-out by default) / Enterprise (never trained on).

The product changes very fast — when this material goes stale, use the official links below to update yourself:

Topic	Official link
Product	https://v0.app
Pricing	https://v0.app/pricing
Detailed pricing (docs)	https://v0.app/docs/pricing
Docs + FAQ	https://v0.app/docs · https://v0.app/docs/faqs
Confirmation that Premium is being sunset	https://community.vercel.com/t/why-the-v0-personal-premium-plan-is-missing-from-the-pricing-page/37072
Changelog	https://v0.app/changelog
Token-based pricing change post	https://vercel.com/blog/updated-v0-pricing
"The new v0" intro (2026 overhaul)	https://vercel.com/blog/introducing-the-new-v0
Agent engineering (under the hood)	https://vercel.com/blog/how-we-made-v0-an-effective-coding-agent
Rename v0.dev → v0.app	https://vercel.com/blog/v0-app

The material in this chapter is based on Vercel's official docs/blog + reputable third-party sources (Zapier, VentureBeat, InfoWorld) as of mid-2026. Some facts are self-reported by Vercel (user/app/ARR scale), some are in flux (the Premium plan, credit-expiry rules), and some are inferred (card payment specifics) — flagged inline where relevant. When in doubt, open v0.app/pricing and v0.app/changelog to see the actual status.