How Usage Is Metered (and When It Gets Expensive)
You don’t get billed based on how many pages your site has, or how big your repo is. You get billed based on how users interact with your app in production.
Vercel tracks usage across five main resources. Let’s walk through what each one means, how it’s metered, and when it becomes a cost driver.
1. Edge Requests
Every time someone visits your site or loads dynamic content through Vercel’s Edge Network, it counts as an Edge Request.
Free limit:
Hobby: 1M requests/month
Pro: 10M requests/month
Overage rate: $2 per additional 1M requests
Gets expensive when:
You serve lots of traffic from SSR or edge functions
You have high bot or crawler traffic
You forget to cache aggressively
2. Fast Data Transfer
This is bandwidth, how much data you’re serving across the CDN.
Free limit:
Hobby: 100 GB/month
Pro: 1 TB/month
Overage rate: $0.15/GB in default regions
(Regional rates vary slightly. See docs)
Gets expensive when:
You serve media-heavy content (videos, high-res images)
You have low cache hit rates or long TTFBs
A single page view includes lots of external calls or dynamic content
3. Active CPU Time
This is the actual time your serverless function is executing—not just how long the request lasts, but how long the code runs on CPU.
Free limit:
Hobby: 4 hours/month
Pro: 40 hours/month
Overage rate: $5 per additional hour
(Only charged during active execution, not during I/O waits)
Gets expensive when:
You do heavy computation in your functions
You’re processing large datasets or media
You call external APIs synchronously and block compute time
4. Function Invocations
The total number of times your backend logic runs, Edge, Serverless, or Cron.
Free limit:
Hobby: 1M/month
Pro: 10M/month
Overage rate: $0.40 per additional 1M invocations
Gets expensive when:
You overuse background jobs or frequent API polling
You misconfigure revalidation or ISR
You rely on functions instead of static delivery
5. ISR Reads/Writes
Incremental Static Regeneration lets you serve static content that updates over time.
Reads = requests for stale content, triggering a regeneration
Writes = content updates or rebuilds
Overage rate: $0.40 per 1,000 reads or writes
Gets expensive when:
You use ISR as a workaround for CMS updates
You refresh static pages too aggressively
You forget to debounce frequent updates
A Note on Regional Pricing
Overage rates for bandwidth and ISR vary slightly by region, depending on infrastructure costs (e.g., BOM1 vs FRA1). But for most use cases, the difference is small and doesn’t affect base plan limits.
By default, most developers don’t pay attention to these metrics, until their bill spikes.
And because Vercel doesn’t hard-stop deployments at quota limits (except on Hobby), overages can quietly accumulate if you don’t set alerts or caps.
How vercel’s pricing has evolved (and why developers were angry)
Vercel didn’t start with metered CPU seconds and ISR pricing.
Earlier, it was simple: flat-rate plans with generous limits. Most developers didn’t even think about bandwidth or function costs.
That changed over time; as usage patterns, costs, and Vercel’s customer base shifted.
Phase 1: Flat plans, high overages (2022–Early 2023)
The Pro plan used to include 1TB bandwidth and 1,000 CPU hours. Overages were steep, $150 per extra TB of bandwidth, $180 per 1,000 CPU hours.
Back then, you either stayed within generous limits, or paid painfully high prices if traffic spiked.
Community reaction:
“I didn’t realize my bandwidth spiked and I suddenly got a $400 bill.”
Many early-stage teams felt penalized for growth, not rewarded.
Phase 2: Granular usage-based billing (Mid–Late 2023)
Vercel shifted toward granular pricing; metering Edge Requests, ISR events, function calls, and CPU time.
The goal: align pricing more directly with infra usage.
The result: many developers now needed to learn how the billing system worked, fast.
Developer sentiment:
“Hard to predict.”
“Too many moving parts.”
“I just want to know what I’ll pay if I go viral.”
Phase 3: April 2024 Pricing Update “Infra Pricing 2.0”
Vercel’s CEO framed this as a simplification and price cut:
Lowered base rates for bandwidth and compute
Added more granular spend alerts
Gave users more visibility into what’s driving costs
But not everyone saw it as a win. Backlash highlights:
Devs with active workloads saw higher bills due to tighter CPU tracking
Others said “price reduction” was misleading
Phase 4: New Compute Model & v0 Credits (Mid 2025)
Two major shifts:
Fluid Compute: Charges only when CPU is active, not when waiting for I/O.
→ Great for light workloads, but pricier for long-running code.v0 (AI) Pricing: Moved from “free prompt usage” to strict credit-based pricing.
→ Broke the prototyping loop for solo devs and small teams.
This introduced even more metering complexity. And made experimentation feel expensive again.
Enterprise Cliff
All along, a common thread remained:
If you need just one Enterprise feature, SSO, TLS and WAF you still have to commit to a ~$20–25k/year plan. No in-between. No add-ons. Just a pricing cliff.
Community quotes:
“I just want custom domains. Why am I talking to sales?”
“We migrated to Fly.io just to avoid this mess.”
When to Choose Hobby, Pro, or Enterprise
Vercel’s pricing isn’t just about what you pay—it’s about what stage you’re in.
Each tier aligns with a different level of product maturity, infrastructure needs, and risk tolerance.
Let’s break down what makes sense when—based on how you're building, shipping, and scaling.
Hobby
Choose this if:
You’re testing out a new idea
You’re building a portfolio, blog, or marketing site
You want to explore Vercel without commitment
Upsides:
It’s free. No credit card. Instant deployment.
You get basic CI/CD, CDN, and edge rendering.
Downsides:
No overages, when you hit the limit, you hit a wall.
No observability or cold-start prevention.
Your site can slow down if traffic picks up unexpectedly.
Common mistake: Staying too long on Hobby even after usage spikes—then wondering why pages are timing out or not regenerating.
2. Pro
Choose this if:
You’re seeing consistent traffic or user signups
You’re using SSR, ISR, or edge functions
You want visibility into what’s actually running and costing money
What you get:
10x the free quotas (10M requests, 1TB bandwidth, 40h CPU)
Spend management tools to set alerts and hard caps
Better build performance and zero cold-starts
This is where most real products live until they either:
Need compliance (SSO, SLA, etc.), or
Hit quotas and face consistent overage costs.
Warning sign: If your Pro bill regularly hits $200+, it’s time to evaluate if you’re scaling toward Enterprise, or leaking cost somewhere.
Enterprise: For scale, security, and support
Choose this if:
Your product is handling sensitive data, has strict uptime requirements, or multiple teams deploying
You’re managing infrastructure across multiple regions or orgs
You need a support contract, not just email tickets
What changes here:
You’re negotiating a yearly commit
You get SLAs, audit logs, SSO/SCIM, and priority access to support
You can define spend ceilings and deployment rules org-wide
The friction:
There’s no self-serve path here. No $299/mo Business plan in between.
If you're not ready for a multi-thousand-dollar commit, there's a gap.
How to replicate Vercel's pricing with Flexprice
Complete guide to replicate Vercel multi-tier pricing structure with usage-based billing in flexprice.io
Overview
Vercel uses a sophisticated multi-tier pricing model with usage-based scaling across multiple dimensions:
Features | Base Price | Key Features |
|---|---|---|
Hobby | $0/ month | 1M edge requests, 100GB bandwidth, 4 CPU-hrs |
Pro | 20/user/month | 10M Edge Requests, 1TB bandwidth, 16 CPU-hrs |
Enterprise | Custom pricing | Unlimited resources + SLA + compliance + support |
Prerequisites
- ✅ flexprice.io account
- ✅ API key ready
- ✅ Understanding of edge computing and CDN billing
- ✅ Knowledge of serverless functions and deployment platforms
Step 1: Get Your API Key
Log in to your flexprice.io dashboard
Navigate to **Settings** → **API Keys**
Copy your API key
Step 2: Create Core Usage Features
Edge Requests Feature
Fast Data Transfer Feature
Fast Origin Transfer Feature
Functions Active CPU Feature
Functions Provisioned Memory Feature
Function Invocations Feature
ISR Reads Feature
ISR Writes Feature
Image Transformations Feature
Image Cache Reads Feature
Image Cache Writes Feature
Blob Storage Feature
Blob Simple Operations Feature
Blob Advanced Operations Feature
Blob Data Transfer Feature
Edge Config Reads Feature
Edge Config Writes Feature
Web Analytics Events Feature
Speed Insights Data Points Feature
Step 3: Create Hobby Plan (Free Tier)
Step 4: Create Pro Plan
Step 5: Create Enterprise Plan Template
Step 6: Create Add-on Plans
Speed Insights Add-on
Observability Plus Add-on
Step 7: Create Customer
Step 8: Create Pro Subscription
Step 9: Track Usage Events
Edge Requests Usage
Fast Data Transfer Usage
Functions Active CPU Usage
Functions Provisioned Memory Usage
Image Transformations Usage
ISR Operations Usage
Blob Storage Usage
Web Analytics Events Usage
Step 10: Monitor Usage
Check current usage across all features:
Vercel’s Pricing Isn’t Simple, But It’s Predictable If You Know What to Watch
Vercel’s pricing has evolved from generous, flat-tier plans to a usage-based model that mirrors how modern infrastructure scales.
It’s not meant to be confusing, it’s meant to give you flexibility.
But that flexibility comes with responsibility: understanding what you’re consuming, setting limits, and tracking the right metrics.
If you're building something simple and static, Vercel will likely stay free forever.
If you're launching a production-grade app or running dynamic logic at scale, you’ll need to keep an eye on usage, Edge Requests, CPU, bandwidth, ISR, and more.
Once you understand the logic behind the model, you can predict your costs, control your overages, and avoid the classic “How did this happen?” billing moment.
Vercel doesn’t hide what you’re paying for. But you do have to know where to look.
Explore expert tips, industry trends, and best practices for billing, pricing, and scaling revenue.
