Quick Verdict: Cloudflare Workers vs Vercel
Both platforms publish unit prices. Neither publishes your bill. We computed it at three traffic levels (full math below), and the result splits the decision cleanly: Workers wins on cost at every scale, Vercel wins on Next.js integration and per-request compute.
Pick Cloudflare Workers for APIs, webhooks, and high-volume traffic: $5/month base with 10M requests included, $0.30 per additional million, zero bandwidth charges. Pick Vercel for Next.js applications: every framework feature works with zero config, and Vercel's own SSR benchmarks measured Fluid Compute 1.2-5x faster than Workers. The platforms are not interchangeable; pick based on your primary workload.
Pricing: Exact Unit Prices, Side by Side
Every number below comes from the official pricing pages as of June 2026. The structural difference: Workers charges a flat $5/month per account and meters requests and CPU-milliseconds. Vercel charges $20 per seat and meters five separate dimensions (edge requests, invocations, Active CPU, provisioned memory, data transfer).
| Item | Cloudflare Workers Paid | Vercel Pro |
|---|---|---|
| Base price | $5/month flat (account-wide) | $20/seat/month, includes $20 usage credit |
| Requests included | 10M/month | 10M edge requests + 1M function invocations |
| Request overage | $0.30 per 1M | $2 per 1M edge requests + $0.60 per 1M invocations |
| CPU | 30M CPU-ms included, then $0.02 per 1M CPU-ms | Active CPU $0.128/hr (iad1; up to $0.221/hr in gru1) |
| Memory billing | None (128 MB per isolate, included) | $0.0106/GB-hr provisioned memory (iad1), billed for instance lifetime |
| Bandwidth / egress | $0, no egress charges | 1 TB fast data transfer included, then $0.15/GB |
| Duration charge | None (CPU-time billing only) | None between requests; CPU billing pauses during I/O waits |
| Max execution | CPU time up to 5 min per HTTP request (default 30s); 15 min for cron/queues | 300s default, configurable to 800s (13 min) |
| Logs | 20M log events/month included, then $0.60 per 1M | 1 day of runtime logs, up to 100k rows |
Two billing models worth understanding before the simulation. Workers bills CPU time only: a request that waits 2 seconds on a database but burns 5ms of CPU costs 5 CPU-ms, and wall-clock time is free while the client stays connected. Vercel's Fluid Compute is similar on CPU (billing pauses during I/O waits) but adds a provisioned-memory meter: the instance's GB-hours accrue for its whole lifetime until the last in-flight request completes.
The Monthly Bill at 1M, 10M, and 100M Requests
Assumptions: an API workload averaging 10ms of active CPU per request, one function invocation per request, Vercel functions in iad1 (its cheapest region tier), one Pro seat, and Vercel's $20 monthly usage credit applied. Vercel's provisioned-memory meter is excluded because it depends on instance lifetime and concurrency; it adds to the Vercel column, not the Workers column.
| Traffic | Cloudflare Workers Paid | Vercel Pro (1 seat) |
|---|---|---|
| 1M requests, 100 GB transfer | $5.00 | $20.00 (usage fits inside the $20 credit) |
| 10M requests, 1 TB transfer | $6.40 ($5 + $1.40 CPU overage) | $20.00 ($5.40 invocations + $3.56 CPU, covered by credit) |
| 100M requests, 1 TB transfer (10 KB avg response) | $51.40 ($5 + $27 requests + $19.40 CPU) | ~$275 ($180 edge requests + $59.40 invocations + $35.56 CPU) |
| 100M requests, 10 TB transfer (100 KB avg response) | $51.40 (egress is free) | ~$1,625 (adds ~$1,350 for 9 TB transfer overage) |
The pattern: below 10M requests both bills are flat and small, and Vercel's $20 credit absorbs the usage. Past 10M, three Vercel meters start running at once, and bandwidth dominates everything. The viral "$25k/month to $2k/month" Vercel-to-Cloudflare migration posts are bandwidth stories: at $0.15/GB, each terabyte past the included 1 TB costs about $150 on Vercel and $0 on Workers.
The simulation assumes API-shaped traffic. For an SSR-heavy Next.js app with low traffic and a small team, the comparison is $20/seat with zero ops work vs running the OpenNext adapter yourself. Vercel's seat price buys real things: preview deployments per PR, zero-config ISR, and 1.2-5x faster server rendering per its benchmarks. Cost only decides this comparison at volume.
Free Tier: Workers Free vs Vercel Hobby, Row by Row
| Limit | Workers Free | Vercel Hobby |
|---|---|---|
| Requests | 100,000/day (~3M/month) | 1M edge requests + 1M function invocations/month |
| CPU | 10ms per invocation | 4 Active CPU hours/month |
| Memory | 128 MB per isolate | 360 GB-hrs provisioned memory/month |
| Bandwidth | No egress charges; static assets free and unlimited | 100 GB fast data transfer/month |
| Max duration | No wall-clock limit while the client stays connected | 300s per function |
| Commercial use | Allowed | Not allowed (non-commercial, personal use only per fair use guidelines) |
| Script/app limits | 3 MB gzipped per Worker, 100 Workers per account | 200 projects, 100 deployments/day |
| Extras | 50 subrequests per invocation, 64 env vars | 1 GB Blob storage, 5,000 image transformations, 50k analytics events |
The two limits that decide it: Workers Free allows roughly 3x the monthly request volume and permits commercial products. Vercel Hobby is explicitly non-commercial, so a side project that starts charging money needs Pro at $20/seat. Workers Free's 10ms CPU cap is the constraint in the other direction: enough for API routing and light transforms, not enough for server rendering a heavy page.
Cold Starts: V8 Isolates vs Lambdas
Workers runs your code in V8 isolates, the sandboxing primitive inside Chrome. There is no container or VM to boot. Cloudflare states an isolate starts roughly 100x faster than a Node process on a VM and uses an order of magnitude less memory at startup; it publishes no millisecond figure. Community benchmarks (the r/nextjs thread that ranks in Google's Perspectives for this query) measured isolate cold starts around 0-5ms vs 200-500ms for Node lambdas.
Vercel's answer is Fluid Compute, the default for new projects since April 23, 2025. It attacks cold starts three ways: bytecode caching (compiled bytecode stored after first execution, Node.js 20+ in production), function pre-warming on production deployments, and instance reuse via in-function concurrency so multiple requests share a warm instance. The result is that active production functions rarely cold start; infrequently invoked functions still pay the lambda boot cost.
The deployment model differs too. A Worker deploys to every Cloudflare data center; there is no region to choose, and the same code runs wherever the request lands. Vercel functions execute in a region you select (default iad1, with region-dependent compute prices from $0.128/CPU-hr in iad1/pdx1/cle1 up to $0.221 in gru1), with static assets served from its global CDN and AZ-level then cross-region failover on Fluid.
The Cloudflare vs Vercel Benchmark Feud, Scored
If you arrived here from the X drama, the sequence of events:
Round 1. In October 2025, Theo Browne published benchmarks comparing server-side JavaScript execution on Workers vs Vercel (which runs on AWS Lambda). Initial results: Workers up to 3.5x slower on CPU-intensive tasks.
Round 2. Cloudflare investigated publicly ("Unpacking Cloudflare Workers CPU Performance Benchmarks"). Findings: infrastructure tuning problems on their side, library differences between platforms, and a test issue where an unset NODE_ENV left React in dev mode with extra debug checks. After fixes, Workers matched Vercel in every benchmark case except the Next.js one.
Round 3. Vercel published counter-benchmarks: Fluid Compute outperformed Workers by 1.2x to 5x on server rendering. The configs were each platform's typical production setup, which is the caveat that matters: Workers on shared CPU with 128 MB RAM vs Fluid performance functions with 2 vCPU and 4 GB RAM. It measures what each platform allocates per request, not raw runtime speed.
CPU throughput: parity after Cloudflare's fixes, except Next.js SSR. Per-request compute allocation: Vercel (2 vCPU / 4 GB vs shared CPU / 128 MB). Cost per unit of work and global distribution: Workers. If your workload is rendering Next.js pages, Vercel's 1.2-5x result is the relevant number. If it's API logic, the allocation gap mostly doesn't bind and the pricing section above decides it.
Platform Limits That Bite in Production
| Limit | Cloudflare Workers | Vercel |
|---|---|---|
| Memory per execution | 128 MB per isolate (all plans) | Provisioned per function, metered in GB-hrs |
| Bundle size | 3 MB gzipped Free / 10 MB Paid (64 MB uncompressed) | Build machine up to 30 vCPU / 60 GB on Pro |
| CPU time | 10ms Free; Paid default 30s, configurable to 5 min per HTTP request | Billed per Active CPU hour, no separate CPU cap |
| Wall-clock duration | No HTTP limit while client connected; 15 min for cron, queues, DO alarms | 300s default; 800s max on Pro/Enterprise; 300s max on Hobby |
| Subrequests | 50 Free / 10,000 Paid per invocation | No equivalent cap |
| Environment variables | 64 Free / 128 Paid, 5 KB each | No comparable published cap |
| Functions/apps per account | 100 Workers Free / 500 Paid | 200 projects Hobby / unlimited Pro |
The 128 MB isolate memory cap is the Workers limit teams hit first: it rules out in-memory caching of large datasets and heavyweight server rendering. The 10 MB gzipped bundle cap bites next, usually via fat npm dependencies. On Vercel, the limit teams hit first is financial rather than technical: five concurrent usage meters with per-GB bandwidth pricing.
Next.js on Cloudflare Workers: What OpenNext Actually Supports
The @opennextjs/cloudflare adapter reshapes Next.js build output to run on the Workers Node.js runtime. As of June 2026 it supports all Next.js 16 minor versions plus the latest minors of 14 and 15 (Next.js 14 support ends Q1 2026 upstream).
| Next.js feature | Status on Workers |
|---|---|
| SSG / SSR / ISR | Supported |
| Partial Prerendering (PPR) | Supported |
| 'use cache' (composable caching) | Supported |
| App Router + Pages Router | Supported |
| Middleware | Supported, except Node Middleware from Next.js 15.2 (not yet) |
| Image optimization | Supported, requires Cloudflare Images configuration |
| Node.js runtime APIs | Supported (adapter targets the Node runtime, not the constrained Edge runtime) |
| after() post-response work | Supported |
| Turbopack builds | Supported |
The honest summary: the compatibility gap that justified staying on Vercel in 2024 has mostly closed. What remains is operational, not functional. On Vercel, ISR and image optimization are zero-config; on Workers you wire caching to Cloudflare primitives and configure Cloudflare Images yourself. You trade $0.15/GB bandwidth for an adapter you maintain.
When Cloudflare Workers Wins
High-Volume APIs
At 100M requests/month the simulated bill is $51.40 vs ~$275 on Vercel before bandwidth, ~$1,625 after. Flat $0.30/M request pricing, $0.02/M CPU-ms, no per-seat charges, no egress meter.
Bandwidth-Heavy Workloads
Workers charges $0 for egress at any volume; Vercel charges $0.15/GB past 1 TB, about $150 per additional terabyte. File delivery, media APIs, and proxy layers are categorically cheaper on Workers.
Stateful Edge Logic
Durable Objects give globally unique, single-threaded stateful compute: WebSocket coordination, distributed rate limiting, collaborative state. Vercel has no equivalent primitive.
One-Vendor Data Layer
KV, R2, D1, Durable Objects, Queues, and Hyperdrive ship on the same account and bill. Vercel's storage offerings are wrappers around partners (Blob, plus integrations), so you manage a second vendor for any real database.
This is the setup Morph runs: our inference API routes through Cloudflare Workers at the edge in front of GPU backends, because request routing is exactly the lightweight, latency-sensitive, high-volume workload the isolate model prices well. Details on what we serve through it are on the pricing page.
When Vercel Wins
Next.js Applications
ISR, Server Actions, image optimization, and preview deployments per PR, all zero-config from the company that builds Next.js. OpenNext on Workers now covers most features, but you operate the adapter; on Vercel it's a git push.
Server Rendering Throughput
Vercel's benchmarks measured Fluid Compute 1.2-5x faster than Workers on SSR, running 2 vCPU / 4 GB functions against Workers' shared CPU / 128 MB isolates. If your hot path is rendering pages, the allocation gap is the product.
Long-Running and Memory-Hungry Functions
Fluid functions run up to 800s on Pro with provisioned memory well beyond an isolate's 128 MB cap, and CPU billing pauses during I/O waits. AI agent backends that wait on model calls fit this billing model well.
Non-JavaScript Runtimes
Fluid Compute supports Node.js, Python, Edge, Bun, and Rust runtimes. Workers runs JavaScript/TypeScript and WebAssembly; a Python backend means compiling to Wasm or changing platforms.
Vendor Lock-In
Vercel's lock-in is framework-shaped. ISR, on-demand revalidation, and Fluid-specific behavior assume Vercel infrastructure; OpenNext exists to break that coupling and now covers ISR, PPR, and 'use cache' on Workers, but it perpetually trails new Next.js features. Migrating a production Next.js app off Vercel means testing every feature against the adapter matrix above.
Cloudflare's lock-in is storage-shaped. R2 is S3-compatible and D1 is SQLite, so data is portable. Durable Objects are not: the coordination patterns you build on globally unique stateful objects have no portable equivalent anywhere. The mitigation for both platforms is the same: keep business logic in portable code and push platform bindings to the edges.
Frequently Asked Questions
Is Cloudflare Workers cheaper than Vercel?
For API and high-volume traffic, yes, at every scale we simulated. Workers Paid: $5/month including 10M requests and 30M CPU-ms, then $0.30/M requests and $0.02/M CPU-ms, zero egress. Vercel Pro: $20/seat including 10M edge requests and 1M invocations, then $2/M edge requests, $0.60/M invocations, $0.128/hr Active CPU (iad1), and $0.15/GB transfer past 1 TB. At 100M requests/month with 100 KB responses: $51.40 vs roughly $1,625.
Vercel vs Cloudflare: which should I pick for a frontend app?
If the app is Next.js and the team values preview deployments and zero-config ISR, Vercel: its Fluid Compute benchmarked 1.2-5x faster on SSR and every framework feature works without an adapter. If the app is a static or lightly dynamic frontend in front of API-heavy traffic, Workers: static assets are free and unlimited even on the free plan, and dynamic routes price at $0.30/M requests.
Can I run Next.js on Cloudflare Workers?
Yes, via @opennextjs/cloudflare. Supported: SSG, SSR, ISR, PPR, 'use cache', both routers, middleware, after(), and the full Node.js runtime. Caveats: image optimization requires Cloudflare Images configuration, and Node Middleware (Next.js 15.2+) is not yet supported. Versions covered: all Next.js 16 minors, latest minors of 14 and 15.
Does Vercel's free tier allow commercial use?
No. The Hobby plan is restricted to non-commercial, personal use under Vercel's fair use guidelines, and exceeding a usage limit pauses the feature for up to 30 days. Workers Free (100,000 requests/day, 10ms CPU per invocation) carries no commercial-use restriction.
What are Cloudflare Workers cold starts?
Near zero by architecture. V8 isolates skip container and VM boot entirely; Cloudflare says an isolate starts ~100x faster than a Node process, and community benchmarks measured 0-5ms vs 200-500ms for Node lambdas. Vercel's Fluid Compute closes most of its gap with bytecode caching, pre-warming, and instance reuse, but rarely invoked functions still pay a lambda boot.
Who won the October 2025 benchmark fight?
Both, on their home turf. After Cloudflare fixed tuning issues and the NODE_ENV dev-mode test bug, Workers matched Vercel on every CPU benchmark except Next.js. Vercel's SSR counter-benchmarks showed Fluid 1.2-5x faster, comparing 2 vCPU / 4 GB Fluid functions against shared-CPU / 128 MB isolates. Compute allocation per request: Vercel. Cost per unit of work: Workers.
Related Comparisons
Morph Runs on Cloudflare
Morph routes its inference API through Cloudflare Workers: edge request routing in front of GPU backends serving morph-v3-fast at ~10,500 tok/s. The isolate model prices exactly the workload we have, high-volume and latency-sensitive.