New See exactly what you're overpaying AWS in under 60 seconds. Estimate your AWS savings →

AWS Lambda Pricing (2026): Rates, Free Tier & Cost Examples

AWS Lambda pricing depends on requests, compute usage, and the execution model. Standard Event Functions start at $0.20 per million requests and $0.0000166667 per GB-second on x86. Newer Web Functions charge separately for active CPU time and memory, while Managed Instances use EC2-based pricing. Here’s how to estimate the complete monthly cost.
Picture of Haider Ali
Cloud & FinOps Content Specialist

Haider Ali

Cloud & FinOps Content Specialist
November 19, 2026

·

17 min read
AWS Lambda Pricing (2026): Rates, Free Tier & Cost Examples
In this article
Key takeaways
1
Event Functions: Pay for requests and execution duration, with x86 compute starting at $0.0000166667 per GB-second.
2
Arm is cheaper: Graviton Event Functions start at $0.0000133334 per GB-second, approximately 20% less than x86.
3
Web Functions bill differently: Active CPU and running-environment memory are charged separately, with requests costing $0.30 per million.
4
Total cost matters: Logging, retries, networking, concurrency, and supporting AWS services can increase the final bill.

AWS Lambda Pricing Breakdown

AWS Lambda runs applications without requiring developers to manage servers directly. Its pricing now varies across several compute options.
Compute model How billing works Best suited for
Event Functions Requests + execution duration Event-driven applications
Web Functions Requests + active CPU + memory HTTP and streaming workloads
Managed Instances Requests + EC2 + management fee Steady, high-volume workloads
MicroVMs Running compute + snapshots Isolated execution environments

Event Function Rates

These are the standard first-tier On-Demand rates in US East (N. Virginia).
Component x86 Arm (Graviton)
Requests $0.20/million $0.20/million
Duration $0.0000166667/GB-second $0.0000133334/GB-second
Monthly free requests 1 million 1 million
Monthly free compute 400,000 GB-seconds 400,000 GB-seconds
The free tier is shared across eligible Event Function usage, not independently provided to each function.

Arm’s lower compute rate does not guarantee a 20% lower total bill. Actual savings depend on execution performance, compatibility, request charges, and other services.

Source: AWS Lambda Pricing

How Lambda Billing Works

Traditional Event Functions have two primary billing dimensions.

Request cost:
Billable requests ÷ 1,000,000 × $0.20
Duration cost:
Invocations × Memory (GB) × Duration (seconds) × GB-second rate
For example, a function using 1 GB of memory for 500 milliseconds consumes 0.5 GB-seconds per invocation.

At the x86 rate:
0.5 × $0.0000166667 = $0.00000833
That is the compute cost of one invocation before free-tier allowances.

AWS measures execution duration in milliseconds. Memory allocation also determines available CPU capacity, so increasing memory can sometimes reduce execution time.

For continuously running applications, compare serverless costs with AWS EC2 pricing.

AWS Lambda Free Tier

Eligible Event Functions receive the following monthly allowances:
Resource Free allowance
Requests 1 million
Duration 400,000 GB-seconds
For example, 400,000 GB-seconds supports approximately 800,000 seconds at 512 MB or 400,000 seconds at 1 GB.

These allowances do not eliminate charges from API Gateway, CloudWatch Logs, networking, or other connected services.

Provisioned Concurrency capacity and execution have separate billing rules. Check AWS’s current free-tier eligibility when estimating these configurations.

AWS Lambda Pricing Examples

The following examples use x86 Event Functions in US East (N. Virginia), the standard free tier, and no other eligible Lambda usage consuming the allowances.

Example 1: Small API

A small application processes 3 million requests monthly.
Metric Value
Requests 3 million
Memory 512 MB
Average duration 200 ms
Compute usage 300,000 GB-seconds
Compute charges $0.00
Request charges $0.40
Monthly total $0.40
The compute usage falls below the 400,000 GB-second free allowance. Only 2 million requests remain billable.

Example 2: Production API

A production API handles 10 million monthly requests with 512 MB of memory and 200 ms average duration.
Component Calculation Cost
Compute usage 10M × 0.5 GB × 0.2 seconds = 1M GB-seconds Usage only
Billable compute 1M − 400,000 free GB-seconds = 600,000 GB-seconds $10.00
Billable requests 10M − 1M free requests = 9 million $1.80
Monthly total Compute + requests $11.80
Even 10 million requests can be inexpensive when execution duration and memory requirements are modest.

Example 3: Heavy Processing

Now consider 10 million requests using 1,024 MB of memory for 500 milliseconds each.
Component Calculation Cost
Total compute usage 5M GB-seconds Usage only
Billable compute 4.6M GB-seconds $76.67
Billable requests 9 million $1.80
Monthly total Compute + requests $78.47
Although request volume matches Example 2, the bill is substantially higher because each invocation consumes more GB-seconds.

Monthly Cost Comparison

Workload Requests Memory Duration Monthly cost
Small API 3M 512 MB 200 ms $0.40
Production API 10M 512 MB 200 ms $11.80
Heavy processing 10M 1,024 MB 500 ms $78.47
Illustrative Event Function costs after the standard free tier. Additional AWS charges are excluded.

Memory Versus Duration

Choosing the smallest memory allocation does not always produce the lowest Lambda bill.

Higher memory also provides additional CPU resources, potentially shortening execution time.
Metric Configuration A Configuration B
Memory 512 MB 1,024 MB
Duration 400 ms 180 ms
Compute per request 0.20 GB-seconds 0.18 GB-seconds
Compute for 5M requests 1M GB-seconds 900K GB-seconds
Configuration B consumes 10% fewer GB-seconds despite allocating twice the memory.

The difference is approximately $1.67 in gross x86 compute charges for five million invocations, before free-tier allowances.

Benchmark actual latency and total compute consumption rather than optimizing memory size alone.

Provisioned Concurrency Pricing

Provisioned Concurrency keeps execution environments initialized to reduce startup latency.

Unlike ordinary On-Demand execution, configured capacity is billed while provisioned, even when traffic is low.

Suppose an application provisions 10 environments, each with 1 GB of memory, continuously for 720 hours.
10 × 1 GB × 720 × 3,600 × $0.0000041667
Monthly provisioned capacity: approximately $108.

This excludes execution-duration and request charges.
Feature Reserved concurrency Provisioned concurrency
Additional capacity fee No Yes
Controls concurrency Yes Yes
Keeps environments initialized No Yes
Main purpose Capacity limits Startup latency
Provisioned Concurrency makes financial sense when latency requirements justify paying for capacity ahead of demand.

Lambda Web Functions Pricing

Introduced in October 2026, Lambda Web Functions support conventional HTTP applications with a billing model different from Event Functions.

Instead of charging for the entire request duration, Web Functions charge for active CPU usage and the memory consumed by running environments.

Web Function Rates

The following rates are verified from AWS’s official US East (N. Virginia) Arm pricing examples.
Billing component Rate
Requests $0.30 per million
Active CPU $0.0000276944 per vCPU-second
Memory $0.0000036667 per GB-second
Data transfer Standard applicable AWS rates
Web Function requests cost 50% more than Event Function requests: $0.30 versus $0.20 per million.

However, request charges are only one part of the comparison.

A Web Function that spends most of its time waiting for a database or an AI model may use relatively little active CPU.

The important caveat is that memory is billed throughout the execution environment’s running lifetime, including time between requests.

AWS does not specify a universal idle-environment lifetime on the pricing page. Consequently, actual costs depend on traffic patterns and how Lambda scales execution environments.

Event vs. Web Functions

Cost factor Event Functions Web Functions
Requests $0.20/M $0.30/M
Compute billing Execution GB-seconds Active vCPU-seconds
Memory billing During execution While environment runs
Waiting on external services Included in execution duration Little active CPU, but memory remains billed
Concurrent requests Separate invocations Can share an environment

Real Web Function Example

AWS provides an I/O-heavy API example with these assumptions:

  • 10 million monthly requests
  • 200 ms end-to-end request duration
  • 50 ms active CPU time
  • Approximately 300 MB memory consumption
  • One running environment throughout a 30-day month
Component Monthly cost
Active CPU $13.85
Memory $2.76
Requests $3.00
Total $19.61
This example excludes free-tier benefits and data transfer.

Importantly, Web Functions are not automatically cheaper.

For example, AWS’s illustrative LLM streaming endpoint costs approximately $33.94 as a Web Function because its requests spend most of their time waiting rather than actively using CPU.

The best choice depends on CPU utilization, request concurrency, memory lifetime, and traffic patterns.

Source: AWS Lambda Pricing

Lambda Managed Instances

Lambda Managed Instances run Event Functions on Lambda-managed EC2 instances.

Unlike standard Event Functions, they do not separately charge for each request’s execution duration.

Instead, billing includes:
Component Charge
Requests $0.20 per million
EC2 compute Applicable instance price
Management fee, CPU instances 15% of EC2 On-Demand instance price
Management fee, supported GPU G-series 9.75% of EC2 On-Demand instance price
EC2 discounts may reduce the underlying instance charge, but the management fee is calculated against the applicable On-Demand instance price.

Managed Instances are worth evaluating for steady, high-volume workloads that can utilize instance capacity efficiently.

They are not necessarily cheaper for intermittent applications because provisioned EC2 capacity can remain billable during low traffic.

Hidden Lambda Costs

Lambda’s execution charges do not represent the complete cost of most serverless applications.
Additional cost What creates it
CloudWatch Logs Log ingestion and retention
API Gateway HTTP and API requests
NAT Gateway Hourly charges and data processing
S3 Storage and object requests
SQS Queue operations
Ephemeral storage Configured storage beyond 512 MB
Retries Additional executions
Data transfer Applicable networking traffic

Retries Increase Usage

Suppose an application receives 10 million events but averages 1.1 execution attempts per event.

That creates 11 million invocations, increasing both request and duration consumption.

Track retries, errors, and invocation counts together.

Logging Adds Charges

High-volume functions can produce substantial CloudWatch log ingestion charges.

Reduce unnecessary debug output and configure retention appropriately.

Networking Adds Charges

Lambda VPC connectivity does not automatically create a separate Lambda networking fee, but NAT gateways, endpoints, and data transfer may incur charges.

See our AWS data transfer pricing guide for more detail.

Reduce AWS Lambda Costs

The best optimization strategy depends on the main billing driver.
Main cost driver Recommended action
High GB-seconds Benchmark memory and execution duration
Excessive invocations Review triggers, batching, and retries
Provisioned capacity Adjust concurrency schedules
High log ingestion Reduce unnecessary logging
Network charges Review NAT and transfer patterns
Stable eligible compute Evaluate Compute Savings Plans
I/O-heavy HTTP traffic Compare Event and Web Functions

Optimize Before Discounts

Start by reducing unnecessary invocations, improving code efficiency, and benchmarking memory allocations.

Then assess the remaining predictable compute usage.

Evaluate Compute Savings Plans

AWS Compute Savings Plans can discount eligible Lambda duration and Provisioned Concurrency usage.

AWS advertises savings of up to 17% for eligible Lambda usage, depending on the commitment.

Learn more in our Compute Savings Plans guide and Lambda and Fargate coverage guide.

Request charges and unrelated CloudWatch or networking fees are not covered by those Lambda discounts.

Where Usage.ai Fits

AWS Lambda cost optimization combines engineering improvements with eligible compute discounts. Reducing invocation volume, memory consumption, and execution time addresses usage costs, while commitment management can reduce rates on qualifying usage.

At Usage.ai, we help organizations identify and manage supported AWS commitment savings opportunities. For eligible Lambda usage, Compute Savings Plans can provide discounts without requiring changes to application code.

Our AWS Savings Plans guide explains commitment coverage, flexibility, and potential savings. Organizations should assess existing commitments and net savings before purchasing additional coverage.
More AWS Savings
Find More AWS Savings

Explore potential savings on eligible AWS compute commitments.

Final Thoughts

AWS Lambda pricing depends on much more than request volume. Event Functions charge for requests and execution duration, while Web Functions separate active CPU from memory billing. Managed Instances use EC2-based economics.

Estimate the complete application cost, including retries, logging, networking, and concurrency. Then optimize for the lowest cost per successful request rather than the lowest advertised rate.

Frequently asked questions

How much does AWS Lambda cost?

Standard Event Functions in US East (N. Virginia) start at $0.20 per million requests and $0.0000166667 per GB-second for x86 compute.

Is AWS Lambda free?

Eligible Event Functions receive 1 million free requests and 400,000 GB-seconds monthly. Connected AWS services may still incur charges.

Is Lambda Arm cheaper than x86?

Arm compute starts at $0.0000133334 per GB-second versus $0.0000166667 for x86, approximately 20% lower. Actual savings depend on performance and workload compatibility.

Are Web Functions cheaper?

Not always. Web Functions can benefit workloads with substantial waiting time, but they charge more per request and bill memory while execution environments remain running.

Does Lambda charge for idle time?

Standard Event Functions generally do not charge for idle execution environments. Provisioned Concurrency and running Web Function environments have different capacity and memory billing rules.

Editorial Disclosure: This article was reviewed in November 2026 using official AWS pricing documentation. AWS pricing may vary by Region, configuration, and usage. Check the official AWS Lambda pricing page for the latest rates.
Share
Facebook
X
LinkedIn
Reddit
See your savings first
More from Usage.ai
Latest from our blogs