Vercel is the deployment platform built by the Next.js team, and nothing gets you from a Git push to a global edge deployment faster. The pricing needs reading carefully: Pro is $20 per developer seat, and on top of that Vercel meters roughly eight separate dimensions — bandwidth, edge requests, function invocations, Active CPU, provisioned memory, image optimisation, ISR operations and builds. Each Pro team gets $20 of monthly credit against those. The line item that surprises people is edge requests, because a single page view on a modern app can generate 25 to 40 of them.
Reviewed by EdGrows·Updated Aug 18, 2026Affiliate link — we may earn a commission
Vercel Pro is $20 per developer seat. That's the part you can forecast.
Behind it run roughly eight metered dimensions:
| Meter | Included on Pro | Rate after |
|---|---|---|
| Fast Data Transfer | 1 TB | ~$0.15/GB (US) |
| Edge Requests | 10M | $2 per million |
| Fast Origin Transfer | none | ~$0.06/GB |
| Function Invocations | 1M | $0.60 per million |
| Active CPU | none on Pro | ~$0.128/CPU-hour |
| Provisioned Memory | none on Pro | ~$0.0106/GB-hour |
| Image Optimisation | varies | metered |
| ISR reads/writes + builds | varies | metered |
Each Pro team gets $20 of monthly usage credit that absorbs overages across all of them.
Most competitors meter two to four dimensions and bundle the rest into a seat fee. Vercel exposes eight. That gives precise alignment between what you use and what you pay — and makes the bill genuinely hard to predict before you've run a month of real traffic.
This is the line item that produces the horror stories, and it's worth understanding precisely.
Edge requests count every CDN hit. Not page views — every asset. Your HTML document, every JavaScript chunk, every CSS file, every font, every image. A single page view on a modern Next.js app typically generates 25 to 40 edge requests.
Run the arithmetic on a moderately successful site: 250,000 monthly visitors, eight page views each, 35 assets per page. That's around 70 million edge requests, 60 million of them overage, at $2 per million.
Nothing about that traffic is exotic. And a budget written as "bandwidth plus functions" — which is how most people mentally model hosting — has no line for it at all.
The other common path to a shock is simpler: a traffic spike hitting $0.15/GB past the included terabyte, turning a $20 plan into several hundred dollars without any DDoS or unusual event.
Vercel provides the fix, and it takes two minutes: every team can set an on-demand usage budget, with email, web and SMS notifications as the limit approaches, and the platform can stop usage before the budget is exceeded.
Configure it before your first production deploy, not after your first invoice. Nearly every published bill-shock account involves a team that never turned it on.
Amid the metering complexity, Vercel shipped the most interesting billing idea in hosting.
Traditional serverless bills wall-clock time: a function that spends 100ms computing and 400ms waiting on a database pays for all 500ms. Fluid compute with Active CPU billing charges only for the milliseconds your code actually executes — I/O wait is free — and a single instance can serve multiple concurrent requests.
For the workloads that dominate modern apps — LLM calls, API aggregation, database queries — Vercel cites savings up to 90%, and it was the first Active CPU model from a major platform.
The corollary matters for architecture: CPU-bound work is now the expensive kind. Image processing, video transcoding and heavy computation consume real Active CPU, and are worth moving to dedicated infrastructure rather than running in a function.
Not hosting. Hosting is a commodity.
Next.js on day one. Every new framework feature works immediately, because the same company builds both. No waiting for a platform to catch up, no adapter, no workarounds.
Preview deployments per pull request. A working URL for every PR, automatically. It sounds small and it changes how review works — designers and stakeholders click a link instead of pulling a branch.
Zero configuration. Connect a Git repo, get a global edge deployment with HTTPS. The gap between that and configuring the same thing yourself is measured in days.
For a team shipping a Next.js product, that developer experience is worth real money. The question is only whether the metered bill stays proportionate to it.
Predictable budgets. Eight meters and a repricing history make forecasting genuinely difficult. Netlify moved the other way in 2026 — one credit pool, no seat fees.
High-bandwidth or media-heavy sites. Video, large images and big asset payloads meet the transfer and edge-request meters hard. Cloudflare-style pricing suits them better.
CPU-bound workloads. Image and video processing burn Active CPU. Run them elsewhere and let Vercel serve the result.
Commercial use on Hobby. The free plan is personal and non-commercial. A revenue-generating project needs Pro, licence terms aside from limits.
Against Netlify: Netlify removed per-seat pricing from Pro in April 2026 — $20 flat with unlimited team members and one credit pool covering deploys, bandwidth, compute and requests. Vercel charges per seat and meters eight dimensions. For a five-person team on moderate traffic, Netlify is usually cheaper and far easier to forecast. Vercel wins on Next.js integration, which for Next.js teams is frequently the whole argument.
Against Cloudflare Pages: unbeatable on bandwidth economics and global reach, weaker on framework-specific developer experience. If your bill is dominated by transfer, that's the comparison to run.
Against Supabase: Supabase isn't a competitor — it's what most Vercel projects use for the database and auth Vercel doesn't provide. The two are the default modern stack.
Against Bolt.new: Bolt generates apps and deploys them; Vercel hosts what you build. Bolt projects frequently land on Vercel, which is complementary rather than competitive.
Against v0: v0 is Vercel's own AI UI generator, billed separately with its own token pricing rather than bundled into a hosting plan.
| Plan | Cost | What it covers |
|---|---|---|
| Hobby | Free | Personal, non-commercial; monthly allowances for CPU, memory, invocations |
| Pro | $20/seat/mo | $20 usage credit per team, free viewer seats, spend management, no deploy queues |
| Enterprise | Custom | SLAs, dedicated support, custom terms |
| Usage (all plans) | Metered | Eight dimensions: transfer, edge requests, origin transfer, invocations, Active CPU, memory, image optimisation, ISR/builds |
| AI products | Separate | v0 tokens, AI Gateway, Sandbox, Agent SKU at $0.25/M tokens plus model cost |
Checked August 2026 against Vercel's published pricing and current third-party analysis. Rates cited are US-region and vary by region — São Paulo, for example, carries substantially higher CPU and memory rates. Vercel has repriced its infrastructure meters multiple times since 2024, including the shift to Active CPU billing in mid-2025, so confirm current dimensions on vercel.com/pricing rather than relying on any comparison article, including this one.
Turn on spend management first. Before the first production deploy. This is the single highest-value action on this page.
Model edge requests, not just bandwidth. Multiply page views by assets per page. If that number is large, price it before committing.
Move CPU-bound work off-platform. Active CPU billing makes image and video processing expensive by design.
Count seats honestly. $20 per developer adds up, though free viewer seats mean non-developers cost nothing.
I launched Citelity on Vercel smoothly and without any issues at all. Everything is super intuitive from the start, and you can easily begin on the free hobby plan. Later I will switch to the Pro plan -and that will unlock some real bonuses like faster builds, better performance, and more frequent platform updates. Excellent tool for the money. From me: Vercel just feels built for projects like this — deployments are instant, previews are a game-changer, and the whole experience stays reliable even as things scale. If you’re looking for something that just works without the headaches, this combo is hard to beat.
Vercel remains the best place to deploy a Next.js application, and that isn't a close call. The same company builds the framework and the platform, so new features work on day one, preview deployments arrive per pull request without configuration, and the path from Git push to global edge deployment is as short as it gets. Active CPU billing is a genuine engineering advance — billing only for executing milliseconds rather than wall-clock time, with cited savings up to 90% on I/O-heavy work, and the first such model from a major platform.
The pricing demands attention in a way the $20 headline doesn't suggest. Eight metered dimensions give precise cost alignment and make forecasting hard, particularly since edge requests count every asset and a single page view generates 25 to 40 of them. Several meters — Active CPU, provisioned memory, fast origin transfer — have no included tier on Pro at all. And Vercel has repriced its infrastructure meters repeatedly since 2024, which means a budget built on last year's dimensions may not survive this year's invoice.
None of that is hidden, and the mitigation is one setting: spend management, configured before the first production deploy. The teams that get hurt are consistently the ones who never turned it on.
For Next.js teams who value deployment quality and will manage their meters, recommend at Pro. For anyone who needs a predictable monthly number more than a best-in-class deploy pipeline, Netlify's 2026 model is the easier bill to live with.
Note: Vercel does not currently have an affiliate program with AIVario. We earn no commission, and this rating carries no commercial incentive.
Best for: Next.js teams, projects needing preview deployments per PR, I/O-heavy serverless workloads that benefit from Active CPU billing, teams that will configure spend limits Not ideal for: Fixed-budget projects, high-bandwidth and media-heavy sites, CPU-bound processing workloads, commercial use on the free Hobby tier Bottom line: Unmatched Next.js developer experience billed across eight meters — excellent value if you configure spend management on day one, and a genuinely unpredictable bill if you don't.
Hobby is free for personal, non-commercial use. Pro is $20 per developer seat per month, and each Pro team gets $20 of monthly usage credit that absorbs metered charges. Enterprise is custom. The seat fee is the predictable part — the variable part is usage across roughly eight metered dimensions, which is where real bills are decided. Viewer seats for non-developers are free on Pro.
Fast Data Transfer at around $0.15/GB in US regions after 1 TB included, Edge Requests at $2 per million after 10 million, Fast Origin Transfer at about $0.06/GB with no included tier, function Invocations at $0.60 per million after 1 million, plus Fluid compute's Active CPU at roughly $0.128 per CPU-hour and Provisioned Memory at about $0.0106 per GB-hour, neither with an included tier on Pro. Image optimisation, ISR reads and writes, and build minutes add more. That's eight dimensions where most competitors meter two to four.
Edge requests, usually. They count every CDN hit — your HTML, every JavaScript chunk, every CSS file, font and image — and a single page view on a modern app typically generates 25 to 40 of them. At 250,000 monthly visitors averaging eight page views with 35 assets each, that's around 70 million edge requests, of which 60 million are overage at $2 per million. Budgets built on 'bandwidth plus functions' have no line for this.
Vercel's most interesting pricing idea, introduced with Fluid compute. Traditional serverless bills wall-clock duration, so a function waiting 400ms on a database query pays for those 400ms. Active CPU bills only the milliseconds your code is actually executing — I/O wait is free. Vercel cites savings up to 90% for I/O-heavy workloads like LLM calls and API aggregation. The flip side is that CPU-bound work such as image processing consumes real Active CPU and is worth moving off the platform.
Yes, and you should do it before your first production deploy. Every team can set an on-demand usage budget with email, web and SMS notifications as the limit approaches, and Vercel can stop usage before the budget is exceeded. This is the single most important setting on the platform. The well-documented bill-shock stories almost all involve teams who never configured it and met a traffic spike.
Yes, with one condition that catches people out: Hobby is for personal, non-commercial use. Projects generating revenue need Pro. Within that limit it's genuinely generous — unlimited deployments, automatic HTTPS, custom domains and monthly allowances for Active CPU, memory and invocations. For learning, side projects and portfolios it's excellent. For a client site or a product with a pricing page, it isn't licensed.
They diverged sharply in 2026. Netlify removed per-seat pricing from Pro in April 2026 — one $20 plan, unlimited members, with usage tracked as a single credit pool. Vercel charges $20 per developer seat plus eight-dimension metering. For a five-person team on modest traffic, Netlify is usually cheaper and easier to forecast; for a Next.js app where deployment quality is the priority, Vercel's integration is still unmatched.
Several, billed separately from hosting. v0 is the AI UI generator with its own token pricing, AI Gateway routes model calls, Sandbox provides ephemeral compute for AI-generated code and bills against the same Pro credit pool, and a Vercel Agent SKU meters at $0.25 per million tokens plus pass-through model costs. Worth knowing that these are additional meters rather than bundled features.
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.