Skip to content

Serverless Functions Pricing Compared (2026)

TL;DR

As of November 9, 2026, an API serving 10 million requests a month (100 ms per request, 7 ms of it CPU) costs about $3.47 on AWS Lambda, $5.80 on Cloudflare Workers Paid and $20 on Vercel Pro, on our arithmetic. At 100 million requests Workers is cheapest at $45.40 because it bills CPU time, not waiting time, while Lambda reaches $96.47 before API Gateway.

Per-request, CPU-time and memory rates on six function platforms and two always-on hosts, priced for one API at 10 million and 100 million requests a month.

Updated

Some links on this page are affiliate links: if you sign up through one, Toolradar may earn a commission. Commissions never change our ranking or what we write. How we make money

Publications that cover the tools tracked here
  • TechCrunch
  • Bloomberg
  • The Information
  • Fortune
  • The Verge
53 Serverless tools tracked
Toolradar comparison of AWS Lambda, Cloudflare Workers, Vercel, Netlify and Cloud Run function costs

Serverless price comparisons disagree because the platforms do not bill the same thing. AWS Lambda charges for every millisecond your function is alive, multiplied by its memory. Cloudflare Workers charges only for the milliseconds the CPU is working. Vercel splits the bill into active CPU and provisioned memory, Netlify converts everything into credits, and Cloud Run charges per vCPU-second and GiB-second. The same API can look cheapest or most expensive depending on which unit dominates.

So this guide prices one workload everywhere. Picture a JSON API that receives 10 million requests a month. Each request lasts 100 ms of wall-clock time, but only 7 ms of that is CPU work; the rest is waiting on a database. That ratio is typical of an I/O-bound API, and it is exactly where wall-clock billing and CPU billing split apart.

Toolradar data: our serverless category lists 53 tools. 85% of them offer a free or freemium plan and 15% are paid only, which matches a market where almost every platform lets you start free and charges once traffic is real.

Methodology: six function platforms and three always-on hosts are compared on the list prices each vendor publishes, as of November 9, 2026, in US dollars and for US regions. Monthly totals are our arithmetic for the fixed workload above, before bandwidth, logs, databases and tax. For a broader ranking that is not built around price, see our best serverless platforms roundup.

Top Picks

Selected by pricing the same I/O-bound API on each platform's published per-request, CPU and memory rates, then ranking on the monthly bill at 10 and 100 million requests. How we rate

AWS Lambda logo

AWS's function service, billed per request and per GB-second of memory multiplied by run time.

Starting price

$0.20 per 1M requests + GB-seconds

4.6 (1,148 reviews)

Best for

Low and moderate traffic inside AWS, where the monthly free tier covers most of the bill.

Serverless Functions Pricing Compared (2026): AWS Lambda vs Cloudflare Workers vs Vercel vs Netlify vs Cloud Run for a 10M-Request API compared: starting price, rating and best use, as of November 2026. Each rating is the average of the review sites listed on that tool's card, weighted by the logarithm of their review counts.
Tool Starting price Rating Best for
Cloudflare Workers Visit Cloudflare Workers website $5/mo minimum; Free: 100,000 req/day 4.6 from 6 reviews Best for: I/O-bound APIs above about 20 million requests a month, and anything with heavy egress.
AWS Lambda Visit AWS Lambda website $0.20 per 1M requests + GB-seconds 4.6 1,148 reviews Best for: Low and moderate traffic inside AWS, where the monthly free tier covers most of the bill.
Google Cloud Run functions Visit Google Cloud Run functions website $0.40 per 1M requests + vCPU-seconds 4.4 81 reviews Best for: Teams on Google Cloud that want containers, per-instance concurrency and no monthly minimum.
Vercel Functions Visit Vercel Functions website Pro $20/mo, usage credit included n/a Best for: Next.js and frontend teams already paying for Vercel Pro who want functions next to the app.
Deno Deploy Visit Deno Deploy website Free; Pro $20/mo with 5M requests 3.6 115 reviews Best for: TypeScript teams with steady traffic under 5 million requests a month.
Netlify Functions Visit Netlify Functions website Free 300 credits; Pro $20/mo 4.5 76 reviews Best for: Sites already on Netlify that run a few functions alongside the frontend.
Azure Functions Visit Azure Functions website Free grant; check rates on Azure's site 4.4 214 reviews Best for: Teams on Azure that want functions billed inside their existing Microsoft agreement.
Railway Visit Railway website Hobby $5/mo minimum, usage included 3.4 56 reviews Best for: Developers who want one small always-on server instead of per-request billing.
Render Visit Render website Starter instance $7/mo 4.6 87 reviews Best for: Small APIs with predictable traffic that prefer a fixed instance price.
1
Cloudflare Workers logo
Top Pick

Cloudflare Workers

Functions that run on Cloudflare's network and bill CPU milliseconds, not the time spent waiting on I/O.

Starting price
$5/mo minimum; Free: 100,000 req/day
Free plan
Yes
Rating
4.6 from 6 reviews

Best for: I/O-bound APIs above about 20 million requests a month, and anything with heavy egress.

  • Pro: The Paid plan includes 10 million requests and 30 million CPU milliseconds every month.
  • Pro: Waiting on a database or upstream API costs nothing, because duration is not billed.
  • Pro: No charges for egress or bandwidth, and requests to static assets are free.
  • Con: The monthly minimum applies even to a Worker that serves a few thousand requests.
  • Con: The Free plan caps each call at 10 ms of CPU, too little for heavier handlers.
Great value

The zero-egress-fee model on R2 is a genuine differentiator against AWS S3.

Watch out

CPU time is the real billing dimension, not requests. The included 30M CPU-ms sounds generous, but a single image-processing Worker using 50ms CPU per request exhausts it after just 600K requests/month, well under the 10M request allowance

Used Cloudflare Workers? Rate it
2
AWS Lambda logo

AWS Lambda

AWS's function service, billed per request and per GB-second of memory multiplied by run time.

  • 4.6 on G2 (1,052 reviews)
  • 4.6 on Capterra (96 reviews)
Starting price
$0.20 per 1M requests + GB-seconds
Free plan
Yes
Rating
4.6 (1,148 reviews)

Best for: Low and moderate traffic inside AWS, where the monthly free tier covers most of the bill.

  • Pro: The free tier of 1 million requests and 400,000 GB-seconds renews every month.
  • Pro: Arm functions cost $0.0000133334 per GB-second, about 20% below the x86 rate.
  • Pro: Memory is adjustable from 128 MB to 10,240 MB in 1 MB steps, so lean functions stay cheap.
  • Con: Duration is billed while the function waits on I/O, so slow upstream calls cost money.
  • Con: An HTTP API in front of it through API Gateway is billed separately, from $1.00 per million calls.
Good value

Lambda pioneered serverless compute and remains the default choice in the AWS ecosystem.

Watch out

Duration billing rounds up to the nearest millisecond, but memory billing is per-GB-second at allocated memory (not used memory). Allocating 1 GB but using 200 MB still bills for 1 GB, right-sizing memory is critical

Used AWS Lambda? Rate it
3
Google Cloud Run functions logo

Google Cloud Run functions

Google's container and function platform, billed per vCPU-second, GiB-second and request.

  • 4.4 on G2 (81 reviews)
Starting price
$0.40 per 1M requests + vCPU-seconds
Free plan
Yes
Rating
4.4 (81 reviews)

Best for: Teams on Google Cloud that want containers, per-instance concurrency and no monthly minimum.

  • Pro: The free tier gives 2 million requests, 180,000 vCPU-seconds and 360,000 GiB-seconds a month.
  • Pro: One instance can serve many requests at once, so a busy API pays for overlapping time once.
  • Pro: Instance-based billing drops the request fee and lowers CPU to $0.000018 per vCPU-second.
  • Con: Billable time rounds up to the nearest 100 ms, which hurts very short requests.
  • Con: At one request per instance, the CPU line alone reaches $19.68 for our 10 million request API.
Great value

Google Cloud Functions (now Cloud Run functions) pricing is generous: the monthly free tier covers 2 million requests, 180,000 vCPU-seconds and 360,000 GiB-seconds.

Watch out

Cloud Build and Artifact Registry charges for deploying functions past their free tiers

Used Google Cloud Run functions? Rate it
4
Vercel Functions logo

Vercel Functions

Fluid compute functions on Vercel, billed by active CPU, provisioned memory and invocations.

Starting price
Pro $20/mo, usage credit included
Free plan
Yes

Best for: Next.js and frontend teams already paying for Vercel Pro who want functions next to the app.

  • Pro: Active CPU billing pauses while code waits on I/O, at $0.128 per hour in Washington D.C.
  • Pro: The Pro plan's included usage credit absorbed our whole 10 million request scenario.
  • Pro: One instance handles several requests at once, which shrinks the memory line.
  • Con: Pro invocations cost $0.60 per million, three times Lambda's request price.
  • Con: Functions start at 2 GB of memory; Hobby is fixed at that size and is non-commercial.
Good value

Vercel's pricing is fair, offering a generous free Hobby tier for basic deployments.

Watch out

Enterprise add-ons can increase Pro costs.

Used Vercel Functions? Rate it
5
Deno Deploy logo

Deno Deploy

Deno's hosting platform for JavaScript and TypeScript apps, billed on requests, active CPU and memory time.

Starting price
Free; Pro $20/mo with 5M requests
Free plan
Yes
Rating
3.6 (115 reviews)

Best for: TypeScript teams with steady traffic under 5 million requests a month.

  • Pro: Pro includes 5 million requests, 50 hours of active CPU and 750 GiB-hours of memory.
  • Pro: CPU is billed only while code runs, not while it waits on the network.
  • Pro: Idle apps shut down after about 20 to 30 seconds, so a quiet app stops paying for memory.
  • Con: Requests beyond the included 5 million cost $2 per million, the highest overage here.
  • Con: Memory is billed at 768 MB for every second the app stays loaded, busy or idle.
Good value

Deno Deploy's free tier includes 1M requests, 20 GiB egress and 10 hours of Active CPU per month.

Watch out

Request overages at $2/million

Used Deno Deploy? Rate it
6
Netlify Functions logo

Netlify Functions

Serverless functions on Netlify, billed in credits for compute GB-hours and web requests.

  • 4.5 on G2 (76 reviews)
Starting price
Free 300 credits; Pro $20/mo
Free plan
Yes
Rating
4.5 (76 reviews)

Best for: Sites already on Netlify that run a few functions alongside the frontend.

  • Pro: Credit plans no longer charge per seat, so a team pays one plan fee.
  • Pro: Pro credit tiers above 3,000 a month roll unused credits over one billing cycle.
  • Pro: Edge functions use web request credits only, with no compute charge.
  • Con: Every request costs 2 credits per 10,000, so traffic alone used 2,000 credits in our scenario.
  • Con: Functions default to 1 GB of memory, and only Pro or Enterprise can change it.
Good value

Functions compute uses 10 credits per GB-hour, so cost depends on usage rather than invocation counts.

Watch out

Functions compute consumes credits (10 credits per GB-hour) shared with bandwidth, requests and deploys

Used Netlify Functions? Rate it
7
Azure Functions logo

Azure Functions

Microsoft's function service with Flex Consumption, Consumption and Premium hosting plans.

  • 4.4 on G2 (214 reviews)
Starting price
Free grant; check rates on Azure's site
Free plan
No
Rating
4.4 (214 reviews)

Best for: Teams on Azure that want functions billed inside their existing Microsoft agreement.

  • Pro: The Consumption plan's free grant covers 1 million executions and 400,000 GB-seconds a month.
  • Pro: Flex Consumption bills only while instances execute, with no minimum instance count.
  • Pro: Premium plans remove cold starts and add VNET access, billed per core-second.
  • Con: Check the current per-execution and GB-second rates on Azure's site before you budget.
  • Con: Each function app creates a storage account that is billed outside the free grant.
Good value

Azure Functions offers a very generous Free Tier with 1M executions and 400,000 GB-seconds, making it highly accessible for small projects.

Watch out

Storage for function code/logs

Used Azure Functions? Rate it
8
Railway logo

Railway

Container hosting billed per second of memory and CPU, an always-on alternative to functions.

Starting price
Hobby $5/mo minimum, usage included
Free plan
Yes
Rating
3.4 (56 reviews)

Best for: Developers who want one small always-on server instead of per-request billing.

  • Pro: No per-request fee, so traffic growth only costs the CPU it uses.
  • Pro: Hobby's included usage nearly covers a small API holding 0.5 GB, on our arithmetic.
  • Pro: Memory is $0.00000386 per GB-second and CPU $0.00000772 per vCPU-second.
  • Con: Memory is billed for every second the service runs, idle nights included.
  • Con: Egress costs $0.05 per GB, while Workers includes it.
Good value

Railway's pricing is quite generous, especially with the Free and Hobby tiers offering significant resources for $0 and $5 respectively.

Watch out

Overage fees for exceeding included credits

Used Railway? Rate it
9
Render logo

Render

Managed hosting for web services, workers and databases, billed per instance per month.

Starting price
Starter instance $7/mo
Free plan
Yes
Rating
4.6 (87 reviews)

Best for: Small APIs with predictable traffic that prefer a fixed instance price.

  • Pro: A Starter web service with 512 MB and 0.5 CPU has one flat monthly price, so the bill never spikes with traffic.
  • Pro: The Hobby workspace has no platform fee, only compute.
  • Pro: Instances step up to 2 GB and 1 CPU at $25 a month when traffic grows.
  • Con: A flat instance does not scale to zero, so idle months cost the same.
  • Con: Team features need the Pro workspace at $25 a month plus compute.
Good value

Render Hobby has no workspace fee.

Watch out

Compute, databases, storage and bandwidth are charged separately where applicable.

Used Render? Rate it

Other Serverless tools worth considering

More published tools from our Serverless category, ordered by our category ranking. They are not part of the editorial picks above.

What a serverless function bill is made of

A serverless function runs your code on demand and bills for usage instead of for a server that sits idle. Every platform here charges some mix of four meters, and the mix decides which workload is cheap:

Table
Meter What it counts Who uses it
Requests or invocations Each call that reaches your function Lambda, Workers, Vercel, Cloud Run, Deno Deploy, Netlify (as web requests)
Wall-clock compute Memory multiplied by the full run time, waiting included Lambda (GB-seconds), Netlify (GB-hours), Cloud Run request-based billing
CPU time only Milliseconds the processor is actually busy Cloudflare Workers, Vercel active CPU, Deno Deploy active CPU
Provisioned memory Memory held while an instance is alive Vercel, Deno Deploy

Wall-clock billing charges you for waiting. A function that spends 93 ms of every 100 ms waiting on a database pays for all 100 ms on Lambda and Netlify, but only for 7 ms of CPU on Workers. CPU-heavy work such as image resizing flips the comparison, because CPU time and wall time become nearly the same.

The function price is also not the whole bill. An HTTP endpoint in front of Lambda usually means Amazon API Gateway, and data leaving the provider is billed under separate network rates on most clouds.

How much does a 10-million-request API cost per month?

The scenario: 10 million requests a month, 100 ms wall-clock and 7 ms of CPU per request. Memory is 512 MB where the platform lets you pick it (Lambda, Cloud Run), and the smallest or default size elsewhere: 2 GB on Vercel, 1 GB on Netlify, 768 MB on Deno Deploy. Rates as of November 9, 2026; totals are our arithmetic.

Table
Platform How the bill is built 10M requests 100M requests
AWS Lambda, Arm GB-seconds plus requests, after the free tier $3.13 $81.13
AWS Lambda, x86 Same meters at the x86 rate $3.47 $96.47
Cloudflare Workers Paid Monthly minimum, then requests and CPU ms $5.80 $45.40
Vercel Pro Invocations, active CPU and provisioned memory, minus the included credit $20 $143.78
Cloud Run, request-based, 1 vCPU vCPU-seconds, GiB-seconds and requests, after the free tier $23.23 $286.48
Deno Deploy Pro Plan fee plus requests over 5 million $30 $224.44
Netlify Pro Credits for compute and web requests, plus recharges $40 $320

At 10 million requests Lambda is cheapest, because the free tier absorbs 400,000 GB-seconds (out of 500,000 used) and 1 million requests. The detail: 100,000 billable GB-seconds at $0.0000166667 come to $1.67, and 9 million requests at $0.20 per million add $1.80. On Workers, the 10 million requests are included and 40 million extra CPU milliseconds cost $0.80 on top of the $5 minimum.

At 100 million requests Workers wins by a wide margin. Lambda bills 4.6 million GB-seconds of mostly waiting time, while Workers bills only 700 million CPU milliseconds. Cloudflare prints this exact 100 million request, 7 ms case on its own pricing page at $45.40.

Three caveats change real bills. The Lambda totals exclude API Gateway: at the $1.00 per million HTTP API rate in AWS's own worked example, 10 million calls add $10, more than the function itself. The Vercel and Cloud Run rows assume each request runs alone on its instance; both platforms let one instance serve several requests at once, which cuts the memory and CPU lines. Netlify's total uses two 1,500-credit recharges at $10 each on top of Pro's 3,000 monthly credits, because 10 million web requests alone consume 2,000 credits.

Key Features to Look For

  • Billing unit (Essential)

    Wall-clock GB-seconds (Lambda, Netlify, Cloud Run request-based) versus CPU time (Workers, Vercel active CPU, Deno Deploy). For I/O-bound APIs this choice moves the bill more than any rate.

  • Free tier that survives production (Essential)

    Lambda's 1 million requests and 400,000 GB-seconds and Cloud Run's 2 million requests renew every month on paid accounts. Vercel Hobby is for non-commercial use only.

  • Plan minimum (Essential)

    Workers Paid carries a monthly minimum per account and Deno Deploy Pro a fixed plan fee, even at low volume. Lambda and Cloud Run have no monthly minimum.

  • Concurrency per instance (Important)

    Vercel fluid compute and Cloud Run let one instance serve several requests at once, so memory is paid once for many overlapping requests. Lambda bills each request's own duration.

  • Egress and gateway costs (Important)

    Workers charges nothing for egress or bandwidth. Lambda bills data leaving its region at EC2 transfer rates, and an API Gateway front door is billed per call.

  • Region pricing (Important)

    Vercel prints different rates per region: $0.128 per active CPU hour in Washington D.C. but $0.184 in Frankfurt. Cloud Run and Lambda also vary by region.

  • Warm capacity options (Nice to have)

    Lambda Provisioned Concurrency costs $0.0000041667 per GB-second and gets no free tier. Cloud Run bills minimum instances at an idle rate.

What to measure before you pick a platform

  1. Measure the ratio of CPU time to wall-clock time per request. Below about 20%, CPU-billed platforms such as Workers usually win at volume.

  2. Count requests that would hit the function versus static assets. Workers serves static assets free and unlimited, so only dynamic calls count.

  3. Price the front door. A Lambda API usually needs API Gateway, which can cost more than the function at moderate traffic.

  4. Check the memory floor. Vercel functions start at 2 GB and Netlify defaults to 1 GB, so a lean function cannot shrink its memory line there.

  5. Decide whether you need a commercial plan. Vercel Hobby is personal and non-commercial, and Netlify Free stops at a hard 300 credit limit.

  6. Estimate egress: Lambda bills data leaving its region at EC2 rates, while Workers includes it.

Evaluation Checklist

  • Export a week of request counts, average duration and memory use from your current host.

  • From traces, split each request's duration into CPU time and time spent waiting on I/O.

  • Run the numbers for this month's traffic and for 10 times that traffic; rankings flip between the two.

  • Add API Gateway, load balancer or CDN charges for platforms that need them in front of the function.

  • Check whether the platform's free tier still applies on your paid account and plan.

  • Set a spend limit or CPU limit per function before launch to cap a runaway bill.

Pricing Overview

Free tiers

Prototypes and low-traffic APIs: Lambda's monthly free tier, Workers Free at 100,000 requests a day, Cloud Run's 2 million requests, Netlify Free and Deno Deploy Free.

$0

Pure pay-per-use

Lambda and Cloud Run: no monthly minimum, requests plus compute time, free tier deducted first every month.

From $0.20 per 1M requests

Entry paid plans

Workers Paid with 10 million requests included and Netlify Personal with 1,000 credits, for side projects that outgrow the free tier.

$5 to $9 a month

Team platform plans

Vercel Pro, Netlify Pro and Deno Deploy Pro: a plan fee that includes some usage, then metered overage, plus build and team features.

Plan fee plus metered usage

Enterprise and committed use

Negotiated rates and SLAs on every platform; Cloud Run also prints 1-year committed use rates such as $0.00001992 per active vCPU-second.

Custom

Pricing Comparison

Serverless Functions Pricing Compared (2026): AWS Lambda vs Cloudflare Workers vs Vercel vs Netlify vs Cloud Run for a 10M-Request API pricing comparison, as of November 2026
Platform Request price Compute price Free tier 10M-request API, per month

$0.20 per 1M

$0.0000166667/GB-s x86; $0.0000133334/GB-s Arm

1M requests and 400,000 GB-s a month

$3.47 x86, $3.13 Arm, before API Gateway

10M included, then $0.30 per 1M

30M CPU ms included, then $0.02 per 1M CPU ms

Free: 100,000 requests a day, 10 ms CPU per call

$5.80 on the Paid plan

$0.60 per 1M on Pro

$0.128/active CPU hr; $0.0106/GB-hr memory (iad1)

Hobby: 1M invocations, 4 CPU hrs, 360 GB-hrs

Pro plan fee only (usage $14.38 is inside the credit)

Google Cloud Run

$0.40 per 1M (request-based)

$0.000024/vCPU-s; $0.0000025/GiB-s (us-central1)

2M requests, 180,000 vCPU-s, 360,000 GiB-s

$23.23 at one request per instance

5M included on Pro, then $2 per 1M

50 CPU hrs, then $0.10/hr; 750 GiB-hrs, then $0.025

Free: 1M requests, 10 CPU hrs

$30 on Pro

2 credits per 10,000 web requests

10 credits per GB-hour

Free: 300 credits, hard limit

$40 on Pro with two recharges

Check the current price on Azure's site

Check the current price on Azure's site

Flex Consumption: 250,000 executions, 100,000 GB-s

Check the current price on Azure's site

Railway (always-on)

No request fee

$0.00000386/GB-s memory; $0.00000772/vCPU-s

30-day trial with starter credits

About $5.61 on Hobby

Render (always-on)

No request fee

Starter instance $7/mo (512 MB, 0.5 CPU)

Free instance with limitations

One Starter instance, flat

Prices as of November 9, 2026 from AWS Lambda pricing (US East worked examples), Amazon API Gateway pricing, Cloudflare Workers pricing, Vercel Functions pricing, Vercel pricing, Vercel function memory, Netlify pricing, Netlify functions billing, Netlify credits, Cloud Run pricing, Deno Deploy pricing, Azure Functions pricing, Railway pricing and Render pricing. Monthly totals are our arithmetic for 10 million requests at 100 ms wall-clock and 7 ms CPU each, before bandwidth and tax. Railway assumes the service holds 0.5 GB all month and bills only the 7 ms of CPU per request.

Mistakes to Avoid

  • ×

    Comparing request prices only: Workers' $0.30 per million looks dearer than Lambda's request fee until you add Lambda's duration line, which dominates for slow I/O-bound calls.

  • ×

    Pricing Lambda without API Gateway, which can cost more than the function at moderate traffic.

  • ×

    Giving every function 1 GB or more on Lambda when 512 MB would do, which doubles the GB-second line.

  • ×

    Choosing Vercel Hobby or Netlify Free for a commercial API and hitting the non-commercial rule or the hard credit limit.

  • ×

    Ignoring the CPU-to-wall-clock ratio: an image resizer and a database proxy with the same duration cost very different amounts on Workers.

Expert Tips

  • →

    Move Lambda functions to Arm unless a dependency blocks it; the GB-second rate drops by about a fifth.

  • →

    For APIs that mostly wait on databases, Workers' CPU billing is the biggest single lever. Read Cloudflare Workers on Toolradar for the rest of the platform.

  • →

    Set a CPU limit per Worker or a spend limit on Vercel before launch to stop a loop or a bot from running up the bill.

  • →

    Weighing Lambda against Vercel for a Next.js app? Our AWS Lambda vs Vercel Functions page compares them feature by feature, and AWS Lambda pricing breaks down every Lambda meter.

  • →

    If the function talks to Postgres, price the database too: serverless Postgres pricing compared covers the scale-to-zero options. Leaving Vercel altogether? See cheaper Vercel alternatives.

Red Flags to Watch For

  • A Lambda bill where API Gateway is larger than compute, a sign a cheaper front door would pay off.

  • Function memory set far above what the code uses, inflating GB-second or GB-hour charges.

  • Provisioned Concurrency left on around the clock, which gets no free tier.

  • An estimate with no line for egress, logs or the database the function calls.

The Bottom Line

For most I/O-bound APIs past a few million requests a month, Cloudflare Workers is the cheapest function platform because it bills CPU time instead of waiting time and includes egress. Its monthly minimum is the only reason Lambda beats it at 10 million requests, and the gap there is a couple of dollars.

AWS Lambda stays the right call when the rest of your stack is on AWS and traffic is moderate, as long as you budget for API Gateway. Vercel and Netlify are priced for frontend teams that want functions beside the site, not for high-volume APIs, and a fixed instance on Railway or Render can undercut all of them for steady, small traffic. Compare more options in the serverless category and the edge computing category, or price the traffic in front of your API with CDN pricing compared.

Frequently Asked Questions

How much do serverless functions cost per month in 2026?

For an API with 10 million requests a month, 100 ms each and 7 ms of CPU, our arithmetic gives about $3.47 on AWS Lambda (x86), $5.80 on Cloudflare Workers Paid, the flat Pro plan fee on Vercel, $23.23 on Cloud Run at one request per instance and $40 on Netlify Pro, as of November 9, 2026, before bandwidth.

Is AWS Lambda cheaper than Cloudflare Workers?

At low volume, yes: Lambda's free tier absorbs most of a 10 million request bill, and it has no monthly minimum. As traffic grows, Workers wins for I/O-bound code because it bills CPU milliseconds while Lambda bills the whole run time. At 100 million requests our scenario costs $45.40 on Workers and $96.47 on Lambda x86.

Is there a free serverless functions tier?

Several. Lambda gives 1 million requests and 400,000 GB-seconds a month, Cloud Run 2 million requests, Workers Free 100,000 requests a day with 10 ms of CPU per call, and Deno Deploy Free 1 million requests a month. Vercel Hobby includes 1 million invocations but is for non-commercial use, and Netlify Free stops at 300 credits.

How is Vercel function pricing calculated?

Vercel bills Pro functions on three meters: invocations at $0.60 per million, active CPU at $0.128 per hour and provisioned memory at $0.0106 per GB-hour in Washington D.C. CPU billing pauses while code waits on I/O, memory does not. The Pro plan's included usage credit is spent first.

Why does Netlify cost more for a high-traffic API?

Netlify charges credits for every web request (2 credits per 10,000) on top of compute at 10 credits per GB-hour with 1 GB functions by default. Our 10 million request API uses about 4,778 credits, above the 3,000 in Pro, and 100 million requests reach $320 a month with recharges.

Does Lambda pricing include API Gateway?

No. API Gateway is a separate service with its own per-request price. AWS's worked example bills HTTP APIs at $1.00 per million for the first 300 million calls and REST APIs at $3.50 per million, so 10 million HTTP API calls add $10 to a Lambda bill.

When is an always-on server cheaper than serverless functions?

When traffic is steady and small. A Render Starter instance costs $7 a month and Railway's Hobby plan about $5.61 on our arithmetic for this API, with no request fees. Cloud Run's instance-based billing with one always-on 1 vCPU, 512 MiB instance comes to $44.71 a month, flat at any volume one instance can carry.

Cite this page: Toolradar, "Serverless Functions Pricing Compared (2026)", updated November 2026, https://toolradar.com/guides/serverless-functions-pricing-compared

Spotted an outdated price or a wrong fact? Suggest a correction: we check it against the vendor's own page. Work for one of these vendors? Claim your listing to update it yourself.

Related Guides

Ready to Choose?

Compare features, read reviews, and find the right tool.

Some offers on this page may be paid placements or contain affiliate links.