AWS Lambda pricing explained

AWS Lambda pricing has two items per function: a price per million requests and a price per GB-second, that is the configured memory times the billed duration to the millisecond, with a lower rate for arm64, plus a price per GB-second for ephemeral storage above 512 MB, for provisioned concurrency and for SnapStart snapshots, and for Lambda@Edge at rates of its own. On the bill the GB-seconds almost always dominate, not the requests, and the second largest item of a Lambda architecture usually sits not under Lambda but under CloudWatch for the logs.

Pricing dimensions

Lambda prices the work, not the provisioning: there is no instance, no hour and no storage that runs while nothing happens, until provisioned concurrency changes that. The unit is the GB-second, the product of configured memory and duration, and every item carries its own usage type.

The price per request is the same in every region and small; what makes a function's price is the memory. Lambda allocates CPU and network in proportion to the configured memory, so a function with 1,024 MB costs twice as much per millisecond as one with 512 MB but often runs less than twice as fast; the price per invocation is memory times duration, and the minimum is often not at the smallest memory. The billed duration is rounded up to the full millisecond, and since 2025-08-01 the INIT phase of a cold start, that is loading the code and running the static initialisation code, counts in every configuration, which before applied only to container images, custom runtimes and provisioned concurrency. Functions with heavy initialisation and many cold starts have seen a higher bill at the same traffic since.

The tiers apply per architecture and region to the account's monthly volume: up to six billion GB-seconds on x86 the first rate applies, up to fifteen billion the second, beyond it the third; arm64 has its own, higher tier boundaries at lower rates. The free allowance of one million requests and 400,000 GB-seconds a month does not expire, but does not apply to functions with provisioned concurrency. Provisioned concurrency keeps a configured number of execution environments initialised and charges them per GB-second from enabling, whether invocations come or not; invocations on it pay a lower duration rate, and invocations beyond the configured number the normal one. Lambda@Edge counts every execution at a CloudFront location as a request at three times the rate and the duration at three times the rate per GB-second, at 1 ms granularity and without a free allowance. Function URLs, which make functions reachable directly over HTTPS, have no line of their own; their invocations count as requests and duration. Beside the classic Event Functions, AWS now also prices Web Functions per request and active CPU time and MicroVMs per instance-second; this page describes the Event Functions the other two build on.

How it appears in your billing data

In the Cost and Usage Report the lines carry the product code AWSLambda, lineItem/Operation Invoke and lineItem/ResourceId the function's ARN; the usage type names the dimension, the prefix is the region code, EUC1 for Frankfurt. Requests appear as EUC1-Request and EUC1-Request-ARM, duration as EUC1-Lambda-GB-Second and EUC1-Lambda-GB-Second-ARM in GB-seconds, with the tiers appearing as separate lines of the same usage type at their own rate. The free allowance appears as Global-Request and Global-Lambda-GB-Second at a price of 0 and stretches across all regions, which is why a function in Frankfurt can look dearer in the report than one in Ireland although both have the same rate.

Provisioned concurrency appears as EUC1-Lambda-Provisioned-Concurrency for the configured GB-seconds and EUC1-Lambda-Provisioned-GB-Second for the duration on it, each with -ARM for arm64; ephemeral storage as EUC1-Lambda-Storage-GB-Second, SnapStart as EUC1-Lambda-SnapStart-Cached-GB-S and EUC1-Lambda-SnapStart-Restored-GB, response streaming as EUC1-Lambda-Streaming-Response-Processed-Bytes. Lambda@Edge appears as EUC1-Lambda-Edge-Request and EUC1-Lambda-Edge-GB-Second under the region code where the execution took place, not under the function's. The volume per function comes from the report through lineItem/ResourceId; which invocations ran how long, only from CloudWatch with Invocations, Duration and the REPORT line in the log, which names Billed Duration, Memory Size, Max Memory Used and Init Duration per invocation.

What does not sit under AWSLambda: the functions' logs, which appear under AmazonCloudWatch as EUC1-DataProcessing-Bytes and EUC1-TimedStorage-ByteHrs, the traces under AWSXRay, the invocations through API Gateway under AmazonApiGateway and the data transfer of the responses. A Lambda architecture therefore costs in four or five places in the report, and the function itself is rarely the largest of them. The report's structure is described in the AWS Cost and Usage Report. In the FOCUS export, ServiceName carries AWS Lambda and x_ServiceCode AWSLambda; requests, duration and provisioned concurrency are ChargeCategory Usage, duration under a Compute Savings Plan PricingCategory Committed (FOCUS columns).

Levers

Configuration: memory is the first lever, because it sets the price per millisecond linearly and the duration non-linearly; the cheapest point is where memory times duration is smallest, and only a measurement across several memory sizes shows it. Architecture is the second: arm64 costs a fifth less per GB-second and runs on many runtimes without a code change. The timeout is the third: a function that waits for a response pays the waiting time in GB-seconds, which is why waiting for events belongs in Step Functions or queues, not in the function. Initialisation has been the fourth since 2025-08-01: small packages, few dependencies and initialisation code that loads only what the handler needs shorten the INIT phase, which is paid on every cold start; the general method is in serverless functions.

Purchase option: a Compute Savings Plan lowers the rate for duration, provisioned concurrency and ephemeral storage against an hourly commitment over one or three years, across Lambda, Fargate and EC2; it does not cover requests or Lambda@Edge. Where Lambda is an account's baseline, the duration belongs in the arithmetic of commitment strategy.

Architecture: provisioned concurrency only for functions whose cold start a user notices, in the number the daytime traffic needs, with a schedule for the night; SnapStart as the cheaper answer to long initialisations. Keep logs to what is needed and give them a retention period, because every line costs under CloudWatch. Functions under load around the clock are dearer per GB-second than a container on Fargate or an instance; the boundary shows in the comparison in EKS, ECS and Fargate.

Where it goes wrong

• The bill rose in August 2025 without more traffic. Since 2025-08-01 the INIT phase counts on every cold start. The REPORT line in the log shows Init Duration; functions with long initialisation and low traffic lose the most.
• Provisioned concurrency runs on at night. Configured units cost per GB-second whether invocations come or not, and the free allowance lapses. Lines with Lambda-Provisioned-Concurrency without invocations at night are the clue; Application Auto Scaling with a schedule switches them off.
• The function waits and pays. A function that waits ten seconds for a database or an API pays ten seconds times memory. Asynchronous patterns through queues or Step Functions take the waiting out of the function.
• The memory is too small, not too large. A CPU-bound function with 128 MB runs eight times as long as with 1,024 MB and costs the same or more. Measure the duration across several memory sizes before choosing the smallest.
• The logs cost more than the function. Debug output in every invocation produces GB per month under CloudWatch that are invisible under Lambda. Log structured and with a retention period.
• Retries double the line. Failed asynchronous invocations are retried up to twice, and a queue consumer without a dead-letter queue tries again and again. Every attempt counts as a request and duration.
• Lambda@Edge charges threefold. A function at CloudFront locations pays three times per request and per GB-second and no free allowance. CloudFront Functions cost a fraction of that for simple header changes.

Example

List prices in USD for Frankfurt (eu-central-1), read on 2026-10-21 from the AWS price list: requests cost USD 0.20 per million, duration USD 0.0000166667 per GB-second on x86 up to six billion GB-seconds a month, USD 0.000015 up to fifteen billion and USD 0.0000133334 beyond, on arm64 USD 0.0000133334 up to 7.5 billion, USD 0.0000120001 up to 18.75 billion and USD 0.0000106667 beyond. Provisioned concurrency costs USD 0.0000050147 per configured GB-second and USD 0.0000117011 per GB-second of duration on it, on arm64 USD 0.0000040118 and USD 0.0000093609; ephemeral storage USD 0.0000000367 per GB-second above 512 MB; SnapStart USD 0.0000015046 per GB-second of snapshot and USD 0.0001398 per restored GB; Lambda@Edge USD 0.60 per million requests and USD 0.00005001 per GB-second.

A function with 1,024 MB on x86 that receives ten million invocations a month at an average billed duration of 200 ms consumes two million GB-seconds and costs USD 33.33 of duration plus USD 2.00 of requests, less USD 6.67 and USD 0.20 of free allowance, USD 28.46 in all; the same function on arm64 costs 26.67 plus 2.00 less 5.33 and 0.20, USD 23.14 in all. With ten units of provisioned concurrency around the clock, 10 × 1 GB × 2,628,000 seconds × 0.0000050147 = USD 131.79 come on top, while the duration drops to USD 23.40 and the free allowance lapses: USD 157.19 instead of USD 28.46, five times as much. The same function with 2,048 MB of ephemeral storage pays 1.5 × 2,000,000 × 0.0000000367 = USD 0.11 for the 1.5 GB above 512 MB. As Lambda@Edge with 128 MB and 10 ms per execution, the same ten million invocations cost USD 6.00 of requests and 12,500 GB-seconds × 0.00005001 = USD 0.63 of duration. The figures show that duration in GB-seconds exceeds the requests more than fifteen times over, that arm64 saves just under a fifth, and that provisioned concurrency turns a USD 28 function into a USD 157 one before the first invocation arrives.

Sources

Read on 2026-10-21. Prices: AWS Lambda pricing, AWS Price List, offer AWSLambda for eu-central-1. Billing data: Cost and Usage Report columns: lineItem, FOCUS 1.0 with AWS columns. Service: AWS Lambda standardizes billing for INIT phase, runtime environment lifecycle, provisioned concurrency, ephemeral storage, function URLs.