Cloudflare Workers Pricing Calculator
Estimate your monthly Cloudflare Workers costs instantly. Compare Standard vs. Unbound (Usage) pricing models based on your request volume and execution time.
$7.50
$5.00
19,200
500,000
Standard = Max($5, $5 + (Requests – 10M) * $0.50). Unbound = Max($5, (Requests * $0.15) + (GB-s * $12.50)).
Cost Comparison: Standard vs Unbound
Chart showing monthly cost comparison based on your inputs.
| Metric | Standard Plan | Unbound Plan |
|---|---|---|
| Base Subscription | $5.00 | $5.00 |
| Request Fees | $2.50 | $2.25 |
| Duration Fees | Included | $0.24 |
| Total Monthly | $7.50 | $5.00 |
What is the Cloudflare Workers Pricing Calculator?
The Cloudflare Workers Pricing Calculator is a specialized tool designed for developers, DevOps engineers, and CTOs to estimate the monthly costs of running serverless functions on the Cloudflare network. Unlike generic cloud calculators, this tool focuses specifically on the nuances of Cloudflare’s two primary pricing models: the **Standard** (Bundled) model and the **Unbound** (Usage-based) model.
Serverless computing removes the need for server management, but the pricing structures can be complex. Costs are often determined by the number of requests, the duration of execution, and the memory allocated to the worker script. This calculator helps you determine which plan is most cost-effective for your specific workload, preventing unexpected billing surprises.
Common misconceptions about Cloudflare pricing include assuming the “Free” tier is sufficient for all small commercial projects (it has strict CPU time limits) or that the Unbound plan is always more expensive due to duration charges (it can actually be cheaper for high-volume, low-latency tasks).
Cloudflare Workers Pricing Formula and Mathematical Explanation
Understanding the math behind the costs is crucial for accurate forecasting. Cloudflare Workers pricing is derived from three main components: a base subscription, request volume, and compute duration (measured in GB-seconds).
1. Standard Plan Formula
The Standard plan (formerly Bundled) charges primarily on requests. It includes a generous allowance in the base fee.
- Base Fee: $5.00/month (includes 10 million requests).
- Overage: $0.50 per additional million requests.
- Duration: Included (typically capped at 50ms CPU time per request).
Formula:
Cost = Max($5, $5 + ((Requests_in_Millions - 10) * $0.50))
2. Unbound Plan Formula
The Unbound plan is usage-based, charging for both requests and duration. It is ideal for longer-running tasks.
- Base Fee: $5.00/month (subscription).
- Request Fee: $0.15 per million requests.
- Duration Fee: $12.50 per million GB-seconds.
GB-Seconds Calculation:
GB-Seconds = (Requests * (Duration_ms / 1000) * (Memory_MB / 1024))
Formula:
Cost = Max($5, (Requests_Millions * $0.15) + (GB_Seconds_Millions * $12.50))
| Variable | Meaning | Unit | Typical Range |
|---|---|---|---|
| Requests | Total invocations of the worker | Millions | 0.1M – 1B+ |
| Duration | Time the worker takes to execute | Milliseconds (ms) | 10ms – 30,000ms |
| Memory | RAM allocated to the worker | Megabytes (MB) | 128MB – 4096MB |
| GB-Second | Resource consumption metric | GB * Seconds | Variable |
Practical Examples (Real-World Use Cases)
Example 1: High Traffic, Lightweight API
Imagine a simple API gateway that authenticates users. It receives heavy traffic but executes very quickly.
- Requests: 50 Million / month
- Execution Time: 15ms
- Memory: 128MB
Standard Plan Calculation:
Included: 10M requests.
Overage: 40M * $0.50 = $20.00.
Base: $5.00.
Total: $25.00
Unbound Plan Calculation:
Requests: 50 * $0.15 = $7.50.
GB-Seconds: 50,000,000 * (15/1000) * (128/1024) = 93,750 GB-s.
Duration Cost: (93,750 / 1,000,000) * $12.50 = $1.17.
Total Raw: $8.67.
Total: $8.67 (Base $5 covered by usage or minimum applies).
Interpretation: The Unbound plan is significantly cheaper here because the execution time is short and the per-request rate ($0.15 vs $0.50) is lower.
Example 2: Image Processing Task
A worker that resizes images on the fly. Lower volume, but high CPU time.
- Requests: 2 Million / month
- Execution Time: 200ms
- Memory: 512MB
Standard Plan: Not viable. The 200ms duration likely exceeds the Standard plan’s CPU limits (typically 50ms for the paid plan unless optimized). Assuming strict limits, you must use Unbound.
Unbound Plan Calculation:
Requests: 2 * $0.15 = $0.30.
GB-Seconds: 2,000,000 * (200/1000) * (512/1024) = 200,000 GB-s.
Duration Cost: 0.2M * $12.50 = $2.50.
Total Raw: $2.80.
Total: $5.00 (Minimum monthly subscription applies).
How to Use This Cloudflare Workers Pricing Calculator
- Enter Monthly Requests: Input your expected traffic in millions. If you have 500,000 requests, enter “0.5”.
- Set Execution Time: Input the average time your script runs in milliseconds. Check your existing Cloudflare dashboard > Workers > Metrics if you have one running.
- Select Memory: Choose the memory limit. Standard workers usually run at 128MB. Heavier tasks need more.
- Review Results: The calculator will highlight the cheapest plan.
- Analyze the Chart: Use the chart to visualize the cost gap between Standard and Unbound models.
- Copy Data: Use the “Copy Results” button to save the estimate for your team or reports.
Key Factors That Affect Cloudflare Workers Costs
- Request Volume: The primary driver for Standard plans. Since the first 10 million are included, low-volume projects often pay just the $5 minimum.
- Execution Duration: Critical for Unbound plans. Inefficient code that runs 10ms longer can add up over millions of requests.
- Memory Allocation: Doubling memory (e.g., 128MB to 256MB) doubles your Duration cost in the Unbound model, as you are billed per GB-second.
- CPU Limits: The Standard plan is cheaper per unit of “hassle” for simple tasks but enforces a strict CPU time limit (usually 50ms). If you hit this, you are forced to switch to Unbound.
- Minimum Monthly Spend: Both paid plans have a $5/month floor. If your calculated usage is $2.50, you still pay $5.00.
- Worker KV & Durable Objects: This calculator focuses on the Workers Compute costs. Using storage like KV or Durable Objects incurs additional separate fees ($0.50/GB stored, etc.).
Frequently Asked Questions (FAQ)
Yes, the $5/month Workers Paid subscription allows you to enable usage-based (Unbound) pricing. It generally acts as a minimum spend or includes a bucket of usage depending on the specific billing cycle terms.
Your worker may be terminated mid-execution, returning an error to the user. For tasks exceeding 50ms CPU time, you should switch to the Unbound usage model.
The calculator focuses on Paid plans (Standard vs Unbound). The Free tier offers 100,000 requests per day but has strict limits (10ms CPU time). If your inputs are very low, the calculator shows the minimum $5 paid cost, assuming you need commercial reliability.
It is the duration of your worker in seconds multiplied by the memory allocated in Gigabytes. For example, a 128MB worker running for 1 second consumes 0.125 GB-seconds.
Generally, Cloudflare Workers does not charge for egress data transfer, which is a significant advantage over AWS Lambda or Google Cloud Functions.
Yes, pricing is configured per Service (worker). You can have some workers on Standard logic and others on Unbound logic within the same account.
The Unbound plan charges $0.15/million requests compared to Standard’s $0.50/million. If your execution time is very short, the lower request rate outweighs the added duration cost.
If you subscribe to the Paid plan, you pay $5/month regardless of whether you use 1 request or 10 million.
Related Tools and Internal Resources
Optimize your cloud strategy with our other specialized tools:
- AWS Lambda Cost Calculator – Compare Cloudflare costs against AWS serverless functions.
- Serverless Architecture Guide – Best practices for building scalable edge applications.
- Bandwidth Cost Estimator – Calculate potential savings on data egress fees.
- Edge Computing Trends 2024 – Why moving logic to the edge matters.
- API Latency Tester – Measure the performance impact of your workers.
- Cloud Migration Checklist – Steps to move your legacy app to serverless.