AWS Lambda Pricing Calculator & Complete Cost Guide
Interactive AWS Lambda pricing calculator. Compare x86 vs ARM architecture, understand tiered pricing, and calculate costs for serverless functions.
Pricing TLDR
- • Free Tier: 1M requests + 400K GB-seconds/month (always free)
- • x86: $0.0000166667/GB-second • ARM/Graviton2: 20% cheaper • Requests: $0.20/1M
- • Available in 36 regions worldwide • Regional pricing varies by up to 25%
AWS Lambda Pricing Calculator
Quick Examples:
Monthly requests
0
10M
Memory (MB)
128
10,240
Duration (ms)
1
5,000
Architecture
Region
Regional pricing variations
Provisioned concurrency
Estimated Monthly Cost
$0.00
✓ Within free tier limits
About AWS Lambda
What is AWS Lambda?
AWS Lambda is a serverless compute service that runs your code in response to events without requiring server management. It automatically scales from zero to thousands of concurrent executions, charging only for actual compute time used.
- Event-Driven Execution: Automatically triggers functions from 200+ AWS services and SaaS applications with built-in event sources
- Automatic Scaling: Handles 1 to 10,000+ concurrent executions seamlessly without capacity planning or manual intervention
- Multiple Runtimes: Supports Node.js, Python, Java, Go, .NET, Ruby, and custom runtimes with container image support up to 10GB
- Flexible Architecture: Choose between x86 (Intel/AMD) or ARM64 (Graviton2) with ARM offering 20% cost savings and better price-performance
- Provisioned Concurrency: Optional feature keeping functions warm for consistent single-digit millisecond response times
When to Use AWS Lambda
Lambda excels at event-driven, variable workloads where you pay only for execution time. The generous free tier (1M requests + 400K GB-seconds monthly) makes it ideal for small applications and development. However, for consistently high-traffic applications running 24/7, traditional compute (EC2) may be more cost-effective.
Ideal for
- Event-driven architectures triggered by API calls, file uploads, database changes, or schedules
- Microservices and API backends with variable or sporadic traffic patterns
- Data processing pipelines handling ETL jobs, image/video processing, or log analysis
- Real-time file processing responding to S3, DynamoDB, or Kinesis events
- Scheduled tasks like backups, reports, or maintenance running on cron schedules
- Prototype and development environments leveraging generous free tier limits
- Serverless websites and mobile backends with automatic scaling requirements
Not ideal for
- Long-running processes exceeding 15-minute timeout limit
- Consistently high-traffic applications running 24/7 (EC2 may be cheaper)
- Applications requiring persistent connections or stateful sessions
- Workloads needing extensive local disk storage beyond 10GB
- Latency-sensitive applications unable to tolerate cold starts (unless using provisioned concurrency)
AWS Lambda Pricing Breakdown
Free Tier (Always Available)
AWS Lambda's perpetual free tier never expires and is available to all customers, making it ideal for small applications, development, and learning. The free tier resets monthly.
- 1 million requests per month across all functions
- 400,000 GB-seconds of compute time monthly
- Equivalent to running a 128MB function for 3.2M seconds or a 1GB function for 400K seconds
- Free tier applies to both x86 and ARM architectures
- Available in all AWS regions worldwide
- No expiration - free tier continues indefinitely
- Perfect for prototypes, development, and low-traffic production applications
Request Pricing
Lambda charges for each function invocation regardless of execution duration. Request pricing is consistent across all regions and architectures.
All Requests
$0.20 per 1M requests
Consistent pricing after free tier
- $0.0000002 per request ($0.20 per million)
- Same rate for x86 and ARM architectures
- Uniform pricing across all AWS regions
- Includes both successful and failed invocations
- No volume discounts for request charges
- Free tier: First 1M requests monthly at no cost
Compute Pricing (x86 Architecture)
Compute costs are calculated as GB-seconds: memory allocated (GB) × execution time (seconds). Pricing uses tiered discounts based on monthly consumption with prices rounded up to nearest millisecond.
Tier 1 (First 6 Billion GB-seconds/month)
$0.0000166667 per GB-second
Standard pricing for x86
- Applies to first 6 billion GB-seconds monthly
- Example: 128MB function × 100ms × 1M requests = 12,500 GB-seconds
- After free tier: ~$0.21 for example above
- Memory ranges: 128MB to 10,240MB (10GB)
- Execution time: 1ms minimum, 15 minutes maximum
Tier 2 (6-15 Billion GB-seconds/month)
$0.000015 per GB-second
10% discount on high-volume compute
- Automatic 10% discount after 6 billion GB-seconds
- Applies to consumption between 6-15 billion monthly
- No configuration required - discount applies automatically
- Relevant for applications with millions of daily invocations
Tier 3 (15+ Billion GB-seconds/month)
$0.00001333334 per GB-second
20% discount for enterprise scale
- Automatic 20% discount after 15 billion GB-seconds
- Applies to all consumption above 15 billion monthly
- Enterprise-scale pricing for massive workloads
- Combines with ARM architecture for up to 36% total savings
Compute Pricing (ARM Architecture)
ARM64 (Graviton2) processors offer 20% cost savings over x86 with equivalent or better performance for most workloads. Tiered discounts stack with the ARM discount for maximum savings.
Tier 1 (First 7.5 Billion GB-seconds/month)
$0.0000133334 per GB-second
20% cheaper than x86
- 20% lower cost compared to x86 tier 1
- Best price-performance for most workloads
- Compatible with common runtimes: Node.js, Python, Java, Go, .NET, Ruby
- Container images up to 10GB supported
- Simply change architecture setting - no code changes needed for most apps
Tier 2 (7.5-18.75 Billion GB-seconds/month)
$0.0000120001 per GB-second
28% total savings vs x86 baseline
- 10% tiered discount + 20% ARM discount = 28% total savings
- Automatic application after 7.5 billion GB-seconds
- Significant cost reduction for high-volume applications
Tier 3 (18.75+ Billion GB-seconds/month)
$0.00001066667 per GB-second
36% total savings vs x86 baseline
- 20% tiered discount + 20% ARM discount = 36% total savings
- Maximum available discount for Lambda compute
- Enterprise-scale workloads can save thousands monthly
Provisioned Concurrency Pricing
Provisioned Concurrency keeps functions initialized and ready to respond in single-digit milliseconds, eliminating cold starts. This is a premium feature with additional costs beyond standard Lambda pricing.
Idle Charges
$0.0000041667 per GB-second for keeping functions warm. Calculated as: memory (GB) × concurrent executions × hours per month × idle rate. Example: 512MB × 10 concurrent × 730 hours = $15.21/month idle cost.
Execution Charges
$0.0000097222 per GB-second during execution (58% higher than standard). This replaces the standard compute charges when provisioned concurrency is used. Does not count toward tiered discount thresholds.
Request Charges
Standard $0.20 per 1M requests still applies in addition to provisioned concurrency charges. Free tier requests (1M monthly) apply before provisioned invocations.
When to Use
Justifiable for latency-sensitive applications where cold starts impact user experience: financial trading systems, gaming backends, real-time APIs during peak traffic, or functions with strict SLA requirements (<100ms response time).
Cost Example
1GB function with 10 concurrent executions, 5M monthly invocations at 200ms: Idle = $30.42, Execution = $97.22, Requests = $0.80 → Total = $128.44/month vs $17 standard Lambda.
Regional Pricing Differences
AWS Lambda is available in 36 regions worldwide. Pricing varies by region with significant markups in APAC (up to +25%) and moderate increases in Europe (+11%). The calculator shows 4 representative regions below:
Region
US East (N. Virginia)
Request Cost
$0.20/1M
Compute (x86)
$0.0000166667
Compute (ARM)
$0.0000133334
Markup
Baseline
Region
US West (Oregon)
Request Cost
$0.20/1M
Compute (x86)
$0.0000166667
Compute (ARM)
$0.0000133334
Markup
Baseline
Region
EU (Ireland)
Request Cost
$0.22/1M
Compute (x86)
$0.0000185001
Compute (ARM)
$0.0000148001
Markup
+11%
Region
Asia Pacific (Singapore)
Request Cost
$0.25/1M
Compute (x86)
$0.0000208334
Compute (ARM)
$0.0000166667
Markup
+25%
Free tier limits (1M requests, 400K GB-seconds) remain constant across all regions. Choose regions based on user latency, data residency requirements, and cost sensitivity. For cost-optimized multi-region deployments, prioritize US regions when latency permits.
Hidden Costs & Considerations
Beyond the core Lambda charges, several additional costs and architectural decisions can significantly impact your total bill:
- Data Transfer Charges: Lambda functions generate data transfer costs: $0.09/GB for outbound internet traffic (first 100GB/month free across AWS), $0.01/GB for cross-region traffic, and $0.01-0.02/GB for cross-AZ traffic within VPCs. High-traffic APIs can accumulate substantial transfer fees.
- VPC Networking Costs: Functions in VPCs require ENIs with potential charges: NAT Gateway ($0.045/hour + $0.045/GB), VPC endpoints for AWS services ($0.01/hour + $0.01/GB), and PrivateLink for third-party integrations. These can exceed Lambda compute costs for VPC-heavy architectures.
- CloudWatch Logs Storage: Lambda automatically logs to CloudWatch: $0.50/GB ingestion, $0.03/GB/month storage. Verbose logging for high-volume functions (10M+ invocations) can cost $50-200/month. Implement log filtering and retention policies to control costs.
- Trigger Service Costs: Event sources have their own pricing: API Gateway ($3.50/million requests + $0.09/GB), EventBridge ($1/million events), SQS ($0.40/million requests), DynamoDB Streams (free for Lambda but DynamoDB has table costs). Choose cost-effective trigger patterns.
- Cold Start Overhead: Cold starts waste compute time (1-5 seconds) you pay for but don't use. For sporadic functions, cold start costs can double actual execution costs. Consider: keep functions warm with scheduled pings ($5-20/month), use provisioned concurrency ($100-500/month), or optimize init code.
- Memory Over-Provisioning: Many users allocate more memory than needed. Lambda charges linearly with memory: 1024MB costs 8× more than 128MB. Test optimal memory with Lambda Power Tuning - reducing 2048MB to 512MB can save 75% on compute costs without performance degradation.
- Storage and Layers: Lambda Layers and deployment packages stored in S3: Standard storage ($0.023/GB/month), frequent updates with versioning can accumulate. Container images in ECR: $0.10/GB/month storage. Clean up old versions regularly.
Real-World AWS Lambda Pricing Examples
Small Startup - Free Tier
$0/month
• 500K requests/month
• 128MB memory, 100ms duration
• Within free tier limits
• Perfect for prototyping
Personal project or MVP with minimal traffic
Mid-Size Company - Web API
$3.36/month
• 5M requests/month
• 512MB ARM architecture
• 200ms avg duration
• ~$40/year total cost
REST API backend with moderate traffic
Large Enterprise - High Volume
$412/month
• 50M requests/month
• 1024MB ARM architecture
• 500ms avg duration
• 36% savings with ARM + tier 2
Production microservices with heavy load
Enterprise with Provisioned
$1,284/month
• 100M requests/month
• 2048MB x86 architecture
• 300ms duration, 50 concurrent
• Eliminates cold starts
Latency-sensitive trading application
AWS Lambda vs EC2: Cost Comparison
Lambda is typically cheaper for sporadic workloads, while EC2 becomes more cost-effective for consistent 24/7 traffic. Break-even point depends on memory requirements and usage patterns.
Factor
Pricing Model
Lambda
Pay per execution
EC2 (t3.small)
Pay per hour (24/7)
Factor
Baseline Cost
Lambda
$0 (free tier)
EC2 (t3.small)
$15-30/month
Factor
Scaling
Lambda
Automatic, instant
EC2 (t3.small)
Manual or auto-scaling
Factor
Best For
Lambda
Variable, sporadic traffic
EC2 (t3.small)
Consistent 24/7 workloads
Factor
Break-Even Point
Lambda
< 30% utilization
EC2 (t3.small)
> 50% utilization
Factor
Cold Starts
Lambda
Yes (1-5 seconds)
EC2 (t3.small)
No
Factor
Maintenance
Lambda
Zero (fully managed)
EC2 (t3.small)
OS patches, security updates
For a web API with 5M requests/month at 200ms duration: Lambda costs ~$4/month, while EC2 (t3.small) costs ~$15/month but can handle much higher traffic without additional cost.
13 AWS Lambda Cost Optimization Tips
Switch to ARM architecture for 20% instant savings
ARM64 (Graviton2) processors offer identical or better performance at 20% lower cost. Most workloads require zero code changes - simply update architecture setting. Savings compound with tiered discounts (up to 36% total).
Optimize memory allocation to actual requirements
Use Lambda Power Tuning to find optimal memory. Many functions over-allocate memory 2-4x what's needed. Reducing from 2048MB to 512MB cuts costs by 75% with no performance degradation. Test methodically before production.
Implement intelligent CloudWatch logging controls
Verbose logging costs $50-200/month for high-volume functions. Use structured logging with log levels, filter noisy logs, set 7-30 day retention (default: never expire), and aggregate metrics instead of logging every request.
Batch processing to reduce request counts
Process multiple records per invocation vs individual triggers. SQS batch size of 10 reduces requests 10x. DynamoDB Streams batching can cut invocations by 100x. Balance batch size vs timeout limits (15 min max).
Leverage free tier strategically across accounts
1M requests + 400K GB-seconds per account/month. Multi-account setups get free tier per account. Development/staging/production accounts each get full free tier. Small services can run free indefinitely.
Minimize cold starts without provisioned concurrency
Cold starts waste 1-5 seconds of billable time. Optimize init code: lazy-load dependencies, cache SDK clients outside handler, minimize imports, use Lambda Layers for common code. Consider scheduled pings ($5-20/month) vs provisioned concurrency ($100-500/month).
Choose cost-effective trigger patterns
API Gateway costs $3.50/million vs ALB at $0.10/million (plus load balancer fee). EventBridge costs $1/million vs SQS at $0.40/million. Direct S3 triggers are free. Select trigger service based on features needed and volume.
Avoid unnecessary VPC networking costs
VPC functions need NAT Gateway ($33/month + $0.045/GB) or VPC endpoints ($7/month/endpoint + $0.01/GB). Only use VPC when accessing private resources. Public AWS services (S3, DynamoDB) work without VPC via HTTPS.
Set aggressive timeout limits to prevent runaway costs
Default 3-second timeout prevents expensive hangs. Set minimum timeout needed (e.g., API: 5s, data processing: 60s). A stuck function at max timeout (15 min) costs 180x more than intended 5-second execution.
Clean up old function versions and layers
Each version stored in S3 costs $0.023/GB/month. Deployment packages + layers can accumulate to 10+ GB for mature applications ($0.23/month per GB). Delete old versions, implement lifecycle policies.
Use tiered pricing awareness for workload planning
After 6B GB-seconds: 10% discount (x86) or after 7.5B (ARM). After 15B (x86) or 18.75B (ARM): 20% discount. For applications near tier boundaries, consolidate workloads into fewer accounts to reach discount thresholds faster. Monitor monthly consumption trends.
Consider reserved concurrency vs provisioned concurrency
Reserved concurrency is free (guarantees capacity) vs provisioned concurrency ($0.0000041667/GB-second idle). For predictable traffic, reserved concurrency prevents throttling without idle charges. Use provisioned only for strict latency SLAs.
Monitor Lambda Costs by Function and Architecture
Track Lambda spending across all functions, memory configurations, and architectures with CostGoat. Get instant alerts when functions exceed expected costs, detect memory over-provisioning, identify opportunities to switch from x86 to ARM for 20% savings, and catch cold start inefficiencies driving up compute time.
Monitor Your AWS Costs in Real-Time
CostGoat is a privacy-first desktop app that tracks your actual AWS spending as you use it. Get instant visibility into your usage and never get surprised by your cloud bills again. 7-day free trial, then $9/month.
Start Free TrialAWS Lambda Pricing FAQ
Common questions about AWS Lambda costs, free tier, and pricing optimization
