AWS Lambda Cost Calculator

Lambda is the cheapest compute on AWS per unit of work and one of the most reliably surprising at scale, for a reason that is baked into its pricing: it bills per request and per GB-second, and a function that costs a fraction of a cent to run once costs a real number when it runs ten million times, sits behind an API Gateway that bills per request too, writes a kilobyte of logs on every call, and reaches the internet through a NAT Gateway nobody included in the estimate. The arithmetic is simple; the surprise is in the lines nobody multiplied.

The calculator below does the multiplication for a Lambda function the way AWS bills it: requests, GB-seconds with the permanent free tier and volume tiers applied, x86 or Arm, provisioned concurrency, ephemeral storage, and the two charges most often left out, API Gateway and CloudWatch Logs. The page around it explains the pricing model, works an example, and is honest about what a list-price estimate cannot see, which is where the real bill comes from. Rates are from the official Lambda pricing page for US regions as of October 2026.

How AWS Lambda Pricing Works

Two meters run on every function, and several more run around it.

Two details change estimates more than any other. Memory and duration multiply: doubling memory doubles the GB-second cost even if runtime stays the same, so a function left at 1,024 MB that needs 256 is paying four times what it should on its largest line. And since August 2025 the initialization phase of a cold start is billed as duration, so functions with heavy runtimes and infrequent traffic pay for warm-up time that the visible execution does not show.

A Worked Example

An API handles 10 million requests a month, each running 200 ms at 512 MB on x86, fronted by an HTTP API, writing about a kilobyte of logs per call. The calculator's defaults are this example.

Duration is 10 million times 0.2 seconds times 0.5 GB, 1 million GB-seconds; after the 400,000 free, 600,000 bill at $0.0000166667, about $10. Requests: 9 million billable at $0.20 per million, $1.80. Lambda itself: about $12. The HTTP API adds $10, and 10 GB of logs adds $5. Total: about $27 a month, of which Lambda compute is under half. Switch the function to Arm and the duration line falls to $8; trim memory to 256 MB if the function allows and it halves again. The function is cheap; the surprise, if there is one, is that the gateway and the logs cost more than the compute, which is the normal pattern and the reason the calculator shows the share.

Change the shape and the picture changes fast. The same API at 1 second and 1,024 MB consumes 10 million GB-seconds, about $160 of duration, and a scheduled job that runs 50,000 times a month for 10 minutes at 2 GB consumes 60 million GB-seconds, about $1,000, from a function nobody thought of as expensive because each run is pennies.

What the Calculator Cannot See

A list-price estimate is a floor. The gap between the floor and the invoice comes from things that exist only in a live account.

• Retries. Asynchronous invocations retry twice on failure by default, and every attempt bills requests and duration. A function failing 10 percent of the time costs 20 percent more than its success rate suggests.
• Cold-start initialization. Billed as duration since August 2025. A function with a heavy runtime and bursty traffic pays for warm-up the execution time does not show.
• Concurrency bursts. A spike that fans out to thousands of concurrent executions bills every one; the average invocation count hides the peak.
• The VPC tax. A function in a private subnet that calls an external API needs a NAT Gateway: about $32 a month plus $0.045 per GB, for a function whose own cost may be a tenth of that.
• The other functions. An account rarely has one. The expensive function is usually the one nobody estimated, a scheduled job or an event processor that quietly consumes most of the GB-seconds.

These are the serverless versions of the waste that hides in small per-unit charges across every cloud, and the reason our guide to cloud pricing models treats serverless as a different shape of bill rather than a discount: it charges exactly for what runs, which is a bargain when little runs and a surprise when a lot does.

From Estimate to Real Spend

The button under the calculator result exists because the estimate and the bill are different documents. Opslyft reads Lambda cost from your actual AWS bill and shows it in Explorer by function, team, and feature, in the same view as the API Gateway, CloudWatch Logs, NAT Gateway, and data-transfer charges the same workload incurs, so a serverless feature's real cost is one number rather than five lines on different pages of the invoice, tracked over time with a spike visible before month end. Monitor catches the function whose invocations tripled or whose duration doubled after a deploy, with the change behind it, and routes it to the owning team; Dimension Studio allocates serverless spend to teams and products without every function needing a tag; and Tickets turns the fix, a memory setting, a retry policy, a runtime switched to Arm, into an assigned item with the saving measured. The estimate tells you what the function should cost; connecting the account tells you what it does.

How to Pay Less for Lambda

• Right-size memory to measured usage; it multiplies every GB-second.
• Switch to Arm for 20 percent off duration where the runtime allows.
• Fix failures before scaling; retries bill every attempt.
• Keep provisioned concurrency for latency-sensitive, steady-traffic functions only.
• Set log levels and retention explicitly; logs often cost more than compute.
• Avoid the VPC unless the function needs private resources, and use VPC endpoints over NAT where it does.
• Watch the scheduled and event-driven functions; they are the ones that quietly consume the GB-seconds.

For how Lambda fits the wider AWS bill and the tools for estimating it, see our guides to the AWS Pricing Calculator and understanding AWS pricing across EC2, S3, EBS, and RDS; for the general discipline, our AWS cost optimization guide.