AWS Lambda Pricing 2026: Requests, GB-Seconds, Hidden Costs

AWS Lambda costs $0.20 per million requests plus $0.0000166667 per GB-second of compute on x86 in US East (N. Virginia), or $0.0000133334 per GB-second on Arm, after a monthly free tier of 1 million requests and 400,000 GB-seconds. A small API often pays under $1 a month; the API Gateway and log bills in front of it frequently cost more than Lambda itself.

Every rate here comes from the AWS Lambda pricing page and the AWS Price List API for us-east-1 (publication dated 16 October 2026), read on 19 October 2026, with supporting rates from the API Gateway pricing page and CloudWatch pricing page. Other regions charge different rates, so treat the dollar figures as us-east-1 prices.

Toolradar data: 45 of the 54 serverless tools tracked on Toolradar, the software directory we run, offer a free tier (83%), as of October 18, 2026. AWS Lambda is one of them, with a free allowance that its pricing page states per month rather than as a one-off credit.

Our view: Lambda's per-call price is rarely the problem. The bill grows through memory settings nobody revisits, through x86 functions that could run on Arm, and through the services wired around each function.

AWS Lambda pricing at a glance

Charge	x86 price	Arm price	Free each month
Requests	$0.20 per million	$0.20 per million	1 million requests
Compute, first tier	$0.0000166667 per GB-s (first 6 billion GB-s)	$0.0000133334 per GB-s (first 7.5 billion GB-s)	400,000 GB-s
Compute, second tier	$0.000015 per GB-s (next 9 billion)	$0.0000120001 per GB-s (next 11.25 billion)
Compute, third tier	$0.0000133334 per GB-s (over 15 billion)	$0.0000106667 per GB-s (over 18.75 billion)
Ephemeral storage above 512 MB	$0.0000000309 per GB-s	$0.0000000309 per GB-s	512 MB per function
Provisioned Concurrency	$0.0000041667 per GB-s	$0.0000033334 per GB-s	Free tier does not apply
Response streaming	$0.008 per GB	$0.008 per GB	100 GB, plus the first 6 MB of each response

Rates are US East (N. Virginia), in USD, from AWS's Lambda pricing page and Price List API in October 2026. Compute tiers apply to the total monthly duration of all functions on the same architecture, in the same region, across the account (or the whole AWS Organization with consolidated billing), so most teams never leave the first tier.

How does Lambda bill a GB-second?

A GB-second is one second of runtime at 1 GB of allocated memory. Lambda multiplies the memory you configure, anywhere from 128 MB to 10,240 MB in 1 MB steps, by the duration of each invocation, rounded up to the nearest millisecond. A function set to 512 MB that runs for 200 ms uses 0.1 GB-seconds per call.

Two consequences matter for your bill. First, memory is billed whether the code uses it or not, so a function configured at 1 GB that peaks at 300 MB pays for the full gigabyte on every call. Second, CPU scales with memory, so cutting memory can lengthen duration and leave the bill unchanged. Measure duration at two or three memory sizes before trimming.

Duration also covers initialization code declared outside the handler and, with extensions, the time the last extension takes to shut down. A heavy cold start is billed time.

What does the free tier cover?

The free tier includes 1 million requests and 400,000 GB-seconds per month, according to the Lambda pricing page. How far 400,000 GB-seconds stretches depends on memory: 3.2 million seconds of runtime at 128 MB, 800,000 seconds at 512 MB, or 400,000 seconds at 1 GB.

For a hobby API or a cron job, that is usually the whole bill. The catch is that the free tier does not apply to functions with Provisioned Concurrency enabled, and it covers Lambda only: API Gateway, CloudWatch Logs and data transfer have their own allowances or none.

What do three real workloads cost?

The three scenarios below are our arithmetic on the us-east-1 list prices, after the monthly free tier, with no Savings Plan. They count Lambda requests and compute only; the next section prices what usually sits in front.

Workload	Monthly requests	Avg duration	Memory	Lambda bill, x86	Lambda bill, Arm
Side project API	3 million	120 ms	512 MB	$0.40	$0.40
SaaS backend	30 million	200 ms	1,024 MB	$99.13	$80.47
High-volume webhook handler	100 million	50 ms	256 MB	$33.97	$31.13

Side project. 3 million calls at 120 ms and 512 MB use 180,000 GB-seconds, inside the free allowance. Only the 2 million requests past the free million are billed, at $0.40. Architecture makes no difference here.

SaaS backend. 30 million calls at 200 ms and 1 GB use 6 million GB-seconds. After the free 400,000, compute costs $93.33 on x86 or $74.67 on Arm, and 29 million billable requests add $5.80. Moving to Arm saves $18.66 a month, about 20%, which is the whole case for testing Graviton builds of your dependencies.

Webhook handler. 100 million short calls at 256 MB use 1.25 million GB-seconds, so compute is only $11.33 on Arm after the free tier ($14.17 on x86), while requests cost $19.80. At this shape the request fee is the larger line, and memory tuning barely moves the total.

Hidden costs: what sits around a Lambda function

For many web workloads, Lambda's own charge ends up as the smallest line on the invoice, and four neighboring services explain most of the surprises.

API Gateway. HTTP APIs cost $1.00 per million requests for the first 300 million a month, and REST APIs cost $3.50 per million for the first 333 million, per AWS's API Gateway pricing page. For the webhook handler above, 100 million calls through an HTTP API add $100 a month, more than three times the Lambda bill.

CloudWatch Logs. Every invocation writes to CloudWatch Logs by default. The CloudWatch pricing page includes 5 GB of logs per month and its examples bill standard ingestion at $0.50 per GB. If each of those 100 million invocations writes 1 KB of logs, that is about 100 GB a month, or $47.50 of ingestion after the free 5 GB, before storage. Lower log levels in production pay for themselves.

Data transfer and VPC. Data moving in or out of a function from outside its region is billed at EC2 data transfer rates, and functions attached to a VPC or using VPC peering incur the charges listed on the EC2 pricing page. Transfers within the same region to S3, DynamoDB, SQS, SNS, Kinesis, ECR, EFS and SES are free.

The services the function calls. A function that reads S3 pays S3 request and storage charges; one that writes to DynamoDB pays DynamoDB. AWS lists these as additional charges on the Lambda pricing page, and they often exceed compute.

Add-ons that change the bill

Provisioned Concurrency keeps environments warm and bills $0.0000041667 per GB-second on x86 for as long as it is enabled, rounded up to five minutes, plus a lower duration rate of $0.0000097222 per GB-second when those environments run. Ten warm 1 GB environments held all month (730 hours) cost $109.50 before a single request. Use it for latency-sensitive endpoints with predictable peaks, and schedule it off overnight.

SnapStart caches a snapshot of the initialized function and restores it on cold start. It bills $0.0000015046 per GB-second of cache and $0.0001397998 per GB restored. It suits Java and other slow-starting runtimes where cold starts hurt more than the small cache fee.

Durable functions add per-operation billing for multi-step workflows: $0.000008 per durable operation ($8 per million), $0.25 per GB of data written and $0.15 per GB-month of retained state, per the Price List API. Waits on on-demand functions do not incur duration charges while suspended, which makes long human-in-the-loop steps cheap on compute.

Lambda@Edge runs at CloudFront locations and costs $0.60 per million requests, three times the regional rate, plus $0.00000625125 per 128 MB-second of compute, metered per millisecond.

Lambda Web Functions, MicroVMs and Managed Instances

AWS now prices Lambda in three shapes. Event Functions are the classic model priced above. Web Functions bill requests, active CPU time and memory, and one environment can serve concurrent requests; on Graviton the Price List API shows $0.30 per million requests, $0.0000276944 per vCPU-second and $0.0000036667 per GB-second of memory. MicroVMs bill per second of baseline vCPU and memory, $0.0000326557 per vCPU-second and $0.0000043235 per GB-second on x86, plus snapshot reads, writes and storage.

Lambda Managed Instances run functions on EC2 instances in your VPC. You pay the standard Lambda request fee, the EC2 instance price, and a management fee of 15% of the on-demand instance price, with no per-request duration charge. EC2 Savings Plans and Reserved Instances apply to the instance portion, so steady, high-volume workloads can come in below on-demand Lambda.

If you track cloud bills across providers, the Devshot brief covers price changes like these as they land.

Dupple data: the Devshot newsletter goes to 30,000+ developers and opens at 32%, according to our audience file updated November 1, 2026.

Is Lambda cheaper than Cloudflare Workers?

It depends on what you count. Cloudflare's Workers pricing page charges $5 a month for Workers Paid, including 10 million requests and 30 million CPU milliseconds, then $0.30 per extra million requests and $0.02 per extra million CPU milliseconds, with no charge for duration. Cloudflare's own example of 100 million requests at 7 ms of CPU each comes to $45.40 a month.

The billing units differ, so this is not like for like. Workers bills CPU time and ignores time spent waiting on the network; Lambda bills wall-clock duration at the configured memory, waiting included. An I/O-heavy function that waits 150 ms on a database and computes for 5 ms is far cheaper on Workers, and the gap widens once API Gateway is added to the Lambda side. A function built around SQS, DynamoDB and S3 triggers, with free in-region transfer to those services, stays on Lambda. Our Cloudflare Workers pricing breakdown has the full rate card.

For hosted platforms that bundle functions with deploys, see Vercel pricing, Netlify pricing and Firebase pricing, and for always-on containers, Fly.io pricing, Render pricing and Railway pricing. The best serverless platforms ranking compares them on fit, and teams leaving Vercel can start with cheaper Vercel alternatives. Cloudflare Workers and Google Cloud Functions also have Toolradar profiles.

How to cut a Lambda bill

1. Move to Arm where your dependencies build for Graviton; the compute rate is 20% lower at every tier.
2. Right-size memory with measured duration at several sizes, since an oversized function pays for idle gigabytes on every call.
3. Choose HTTP APIs over REST APIs in API Gateway when you do not need REST-only features; the per-million rate is less than a third.
4. Lower log volume in production and set retention on log groups, because ingestion is billed per GB.
5. Schedule Provisioned Concurrency to business hours instead of leaving it on around the clock.
6. Look at Managed Instances once a function runs near-constantly, where EC2 pricing with a Savings Plan can undercut per-request billing.

Teams watching the monitoring side of the bill can compare Datadog pricing with CloudWatch before adding a third-party agent.

How we built this page

We read the AWS Lambda pricing page, the AWS Price List API file for Lambda in us-east-1, the API Gateway and CloudWatch pricing pages, and Cloudflare's Workers pricing page on 19 October 2026. Toolradar's serverless statistics supplied the category figure. We did not deploy functions or run load for this page; every workload cost is our arithmetic on list prices, after the monthly free tier and without Savings Plans. We re-check the page when AWS changes a rate or adds a compute type. Louis Corneloup, who founded Toolradar and Dupple, edited it.

FAQ

How much does AWS Lambda cost in 2026?

In US East (N. Virginia), Lambda Event Functions cost $0.20 per million requests plus $0.0000166667 per GB-second on x86 or $0.0000133334 per GB-second on Arm, read on AWS's pricing page in October 2026. The first 1 million requests and 400,000 GB-seconds each month are free.

Is AWS Lambda free?

Partly. Every account gets 1 million requests and 400,000 GB-seconds of compute free each month, which covers many hobby APIs and scheduled jobs. The allowance excludes functions with Provisioned Concurrency, and API Gateway, CloudWatch Logs and data transfer are billed separately.

What is a GB-second in Lambda pricing?

A GB-second is one second of execution at 1 GB of configured memory. Lambda multiplies configured memory by duration, rounded up to the millisecond, so a 512 MB function running 200 ms uses 0.1 GB-seconds per call, whether or not the code uses all of that memory.

Is Lambda on Arm cheaper than x86?

Yes. Arm (Graviton) compute is billed about 20% below x86 in every duration tier, and the request price is identical on both architectures. In our 30-million-request SaaS scenario that cuts the monthly Lambda bill from $99.13 to $80.47.

Why is my Lambda bill higher than the calculator?

Usually because of the services around Lambda. API Gateway HTTP APIs add $1.00 per million requests, CloudWatch Logs ingestion is billed per GB beyond 5 GB a month, and cross-region data transfer, VPC charges and S3 or DynamoDB calls appear on their own lines.

When does Provisioned Concurrency make sense?

When cold starts break a latency target and traffic is predictable. It costs $0.0000041667 per GB-second on x86 for as long as it is enabled, so ten warm 1 GB environments cost $109.50 a month before requests. Scheduling it to peak hours cuts that sharply.

Cite this: Devshot, "AWS Lambda Pricing 2026: Requests, GB-Seconds, Hidden Costs", November 2026.

Devshot is the daily brief on the tools and bills developers deal with. Subscribe at devshot.co.

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