Lambda-GB-Second - the Lambda compute line, and the 20% cheaper arm64

What it costs

US East (N. Virginia); other regions differ. Checked 2026-11-04. Sources: AWS Lambda pricing, AWS price list file, Lambda offer, us-east-1.

Example with made-up numbers

Typical causes

Functions created before arm64 existed

Older functions default to x86 and nobody revisited them.

Templates pinned to x86_64

Infrastructure modules copy the architecture setting into every new function.

Over-provisioned memory

Memory is billed per GB-second; a function set to 3 GB that uses 400 MB pays for the 3 GB.

Retry loops and slow downstream calls

Duration grows when functions wait on slow services, and billing follows duration.

Find it in your bill

Have a CUR file queryable in Athena? Paste this and run it:

SELECT date_trunc('month', line_item_usage_start_date) AS month,
       line_item_product_code,
       line_item_usage_type,
       line_item_resource_id,
       SUM(line_item_usage_amount)  AS usage_amount,
       SUM(line_item_unblended_cost) AS cost
FROM your_cur_table
WHERE line_item_usage_type LIKE '%Lambda-GB-Second'
GROUP BY 1, 2, 3, 4
ORDER BY month DESC, cost DESC
LIMIT 50;

Columns used: line_item_usage_start_date, line_item_product_code, line_item_usage_type, line_item_resource_id, line_item_usage_amount, line_item_unblended_cost.

No CUR file? Use Cost Explorer

1. Open Billing and Cost Management, then Cost Explorer, and set the date range to the last 3 months with Monthly granularity.
2. Set Group by to Usage type.
3. In the Filters panel choose Usage type and tick the entries ending in Lambda-GB-Second (the region prefix, such as USE1-, differs by region).
4. Read the monthly cost per usage type. A line that grows faster than your traffic is the one to chase with the fix below.
5. To see which resource drives it, query the CUR above; resource IDs appear only if your CUR was set up with resource IDs included, otherwise the resource column is empty.

Column names checked against: docs.aws.amazon.com/cur/latest/userguide/Lineitem-columns.html, docs.aws.amazon.com/cur/latest/userguide/cur-ate-run.html.

The fix, step by step

Verify first

Check these before you change anything: the steps below are suggestions, and only you can see your own configuration.

• Check for native dependencies (compiled Python wheels, Node addons, bundled binaries) and Lambda layers or container images built for x86; they must be rebuilt for arm64.
• Compare duration before and after: the saving is per GB-second, so a function that gets slower on arm64 can lose part of it.
• Deploy through an alias or a canary percentage so a bad build can be shifted back quickly.
• Check that third-party extensions you attach (monitoring agents) publish arm64 builds.

In the console

1. Lambda console > Functions; add the Architecture column and sort by x86_64.
2. Open one low-risk function > Code > Runtime settings > Edit > Architecture arm64 (re-upload or rebuild the package if it has native binaries).
3. Run its tests, deploy to a staging alias and compare duration and errors for a day.
4. Repeat for the rest, highest GB-seconds first (Cost Explorer > Usage type Lambda-GB-Second).
5. Update the infrastructure-as-code architecture setting.

With the CLI

aws lambda list-functions --query 'Functions[?Architectures[0]==`x86_64`].[FunctionName,MemorySize,Runtime]' --output table

aws lambda get-function-configuration --function-name my-function --query Architectures

aws lambda update-function-code --function-name my-function --zip-file fileb://function-arm64.zip --architectures arm64

aws lambda get-function-configuration --function-name my-function --query LastUpdateStatus

Rollback

Update the function code with the x86_64 package and --architectures x86_64, or shift the alias back to the previous version.

Find your Lambda line in your own bill

Drop in your Cost Explorer or CUR CSV. Billtrim reads it in your browser, finds the Lambda compute line and shows the monthly dollars.

Get my ranked savings list See a sample result

Paste your export: how to export a Cost Explorer CSV or CUR file in two minutes.

Questions people ask

Does arm64 change the price per request?

The request charge is separate and the same for both architectures; the saving is on the GB-second line.

Do all functions run on arm64?

Most pure-language code does. Functions with native x86 binaries, layers or container images built for x86 need a rebuild first.

Related

• Fargate-vCPU-Hours:perCPU and Fargate-GB-Hours - Fargate task cost, and the cheaper arm64
• CloudWatch Logs DataProcessing-Bytes: the log ingestion line
• NatGateway-Bytes: the NAT Gateway data-processing line

Part of the guide: Reduce your AWS bill as a startup: a checklist for teams with no FinOps person