Cloudflare Workers Pricing Decoded: What You Actually Pay For in 2026

Cloudflare's Workers pricing page tells you the headline number: $5/month for 10 million requests. Then your bill arrives at $340 because you used Durable Objects, KV, R2, and D1, each with a separate meter. Here is the honest breakdown of every line item, what it actually costs, and how to estimate your real bill before you commit to anything.

The marketing page is technically true and practically misleading

Workers Paid plan: $5/month base, includes 10 million requests, plus 30 million CPU-milliseconds. Each additional million requests is $0.30. Each additional million CPU-ms is $0.02.

That is true. It is also incomplete. The moment you do anything stateful (caching, databases, file storage, scheduled tasks, websockets, durable workflows), you are using a different product with a different bill. There are six of them and most teams use at least three.

Meter 1: Workers requests + CPU time (the headline number)

This is the part everyone understands. You pay per request and per millisecond of CPU.

• $5/month base, includes 10M requests + 30M CPU-ms
• $0.30 per additional million requests
• $0.02 per additional million CPU-ms
• Wall time is free. Only CPU time is metered. A worker that fetches a slow upstream API for 2 seconds while doing 5ms of CPU work pays for 5ms.

For a typical static-site-with-light-routing worker (this site uses one), 5 to 10 million monthly requests with simple logic costs roughly $5 to $8/month total. For an API gateway pattern with database calls, expect 10 to 50ms CPU per request, which scales costs quickly.

Real numbers from production: a moderately busy API doing 50M requests/month at 15ms CPU each = 750M CPU-ms = (750 - 30) million billable = 720M × $0.02/M = $14.40. Plus request overage = (50 - 10)M × $0.30 = $12. Total: ~$31/month for the worker itself. So far so good.

Meter 2: Workers KV (the cache that bills per read)

KV is Cloudflare's eventually-consistent key-value store. Most teams use it for cache, session storage, or feature flags.

• $0.50 per million reads
• $5.00 per million writes (10x more expensive)
• $5.00 per million list operations
• $0.50 per million deletes
• $0.50 per GB-month storage

The trap: every cache miss in your Worker probably triggers a KV read. If you cache aggressively and have 50M Worker requests with 80% cache hit rate, you have 40M KV reads = $20/month for KV reads alone. Plus storage. Plus writes when you populate the cache.

For our 50M-requests-per-month example with KV used as a cache layer: roughly $25 to $40/month additional for KV.

Meter 3: Durable Objects (the meter most teams underestimate)

Durable Objects are Cloudflare's strongly-consistent, single-instance compute primitive. Used for websockets, real-time collaboration, rate limiting, or any state that needs strict consistency.

• Requests: $0.15 per million
• Duration: $12.50 per million GB-seconds (yes, GB-seconds, like Lambda)
• Storage: $0.20 per GB-month for SQLite-backed objects, $1.00 per GB-month for KV-backed
• Storage operations: $1.00 per million row reads, $1.00 per million row writes (SQLite-backed); KV-backed is more expensive

The pattern that surprises teams: a chat app with 1,000 concurrent rooms, each room a Durable Object with a websocket connection. Each connection idle costs nothing for requests but does cost duration. 1,000 idle DOs at 128 MB each = 128 GB. 128 GB × 86,400 seconds × 30 days = 332M GB-seconds = $4,150/month just for keeping rooms warm.

Mitigation: hibernation. DOs that idle long enough hibernate and stop billing duration. Make sure your code does not keep internal timers that prevent hibernation.

Meter 4: R2 (the S3 alternative with the egress story Cloudflare loves to tell)

R2 is Cloudflare's S3-compatible object storage. The headline feature: zero egress charges. The real billing:

• Storage: $0.015 per GB-month (cheaper than S3 standard)
• Class A operations (writes, lists, deletes): $4.50 per million
• Class B operations (reads, gets, head): $0.36 per million
• Egress: Free. This is the killer feature.

For a typical SaaS storing 1 TB of user uploads with 10M monthly downloads:

• Storage: 1024 GB × $0.015 = $15.36
• Class B ops: 10M × $0.36 / M = $3.60
• Egress: $0 (would be $90 on S3)
• Total: ~$19/month versus ~$110/month for the same workload on S3

R2 wins decisively for read-heavy workloads. Where it loses: very write-heavy workloads (each write is a Class A operation), or workloads where you need lifecycle policies and tiering that S3 has but R2 does not yet.

Meter 5: D1 (Cloudflare's SQLite-as-a-service)

D1 is a managed SQLite database that runs in the same network as your Workers. Useful for low-traffic relational data without the operational cost of a real database.

• $5/month base (rolled into Workers Paid)
• 5 GB storage included, then $0.75 per GB-month
• 25 million row reads/day included, then $0.001 per 1,000 reads
• 50,000 row writes/day included, then $1.00 per million writes

The good: D1 is free for low-traffic apps. A site with 1M monthly visits and minimal database activity stays within the included tier.

The catch: D1 is single-region. Reads from far-away Workers go over the network. For globally distributed apps, you either accept the latency or you replicate data via separate KV or Durable Objects.

Meter 6: Workers Logs and Workers Analytics (the meters nobody mentions)

If you want detailed observability beyond the free dashboard, Cloudflare bills for it.

• Workers Logs (Logpush): $0.05 per million requests for log delivery to your S3/R2/Datadog endpoint
• Workers Analytics Engine: $0.25 per million data points written, $1.00 per million read queries
• Tail Workers: Standard Worker pricing applied to log-processing workers you build yourself

For most teams these are negligible. For a team that ships every Worker invocation log to Datadog, the Logpush bill can hit $50 to $200/month at high traffic.

Real bills from real production deployments

Three example workloads with actual numbers:

Example 1: A static blog with simple routing

• 5M Workers requests/month
• 2M KV reads (template caching)
• 50 GB R2 storage for images
• Total: ~$7/month

Example 2: An API gateway in front of an existing backend

• 50M Workers requests/month, 15ms avg CPU
• 40M KV reads (auth cache)
• 5M KV writes (session updates)
• Total: ~$80 to $120/month

Example 3: A real-time collaboration app

• 10M Workers requests/month
• 500 active Durable Objects with websocket connections
• 200 GB R2 storage for user uploads
• D1 database for metadata (well within free tier)
• Durable Object duration: ~$200/month (with hibernation working correctly)
• Total: ~$250 to $400/month

How to estimate your bill before committing

1. Count your Workers invocations. Look at server logs from your existing setup. Multiply requests/month by $0.30/M for overage cost.
2. Estimate CPU time per request. Use Cloudflare's preview environment to test with realistic traffic. Workers UI shows CPU time per request.
3. List every stateful primitive you need. KV for cache, R2 for files, DO for sessions, D1 for relational. Each one is a separate meter.
4. Multiply by the unit price. Use the numbers above. Add 30% for the line items you forgot to count.

When Cloudflare Workers actually wins versus alternatives

Workers wins when:

• You need global low-latency for read-heavy workloads. The 300+ point-of-presence network is the moat.
• Your code is pure-ish: HTTP transformations, edge auth, simple API logic, image optimization.
• You can use R2 to avoid egress costs on user-uploaded files.
• You want zero cold start, which Workers genuinely deliver via V8 isolates.

Workers loses when:

• You need long-running compute. The 30-second wall time limit (50ms CPU on free tier) kills batch jobs.
• You need a real database. D1 is fine for prototypes, not for substantial relational workloads. Postgres on RDS is the right answer for most production data.
• You want to use the Node.js ecosystem freely. Workers support a Node.js compatibility layer but it is incomplete.
• Your traffic is regional, not global. Lambda + CloudFront is often cheaper for US-only or EU-only apps.

The bottom line

Cloudflare Workers pricing is genuinely cheap for the workloads that fit it: read-heavy, globally distributed, light compute. It gets expensive when you start using Durable Objects without understanding hibernation, or KV without batching, or R2 with very write-heavy patterns.

The fix is not to avoid Cloudflare. It is to read every meter on the pricing page before you commit, calculate your projected bill against actual production traffic, and re-check the bill every month for the first three months. If the bill is double what you projected, one of the six meters is consuming more than you think, and the diagnostic queries in the Cloudflare dashboard will show you which one.

Related reading: Datadog vs Grafana vs New Relic Cost Comparison, AWS Bill Spike Incident Response, Snowflake Cost Explosion Patterns, CDN Setup Guide, and Cloudflare Error 521 Fix.