Amazon Lambda Pricing

  • Event Functions
  • icon-free-tier

    Amazon Lambda Free Tier

    Lambda Free Tier is available in the Amazon Web Services China (Ningxia) Region operated by NWCD and Amazon Web Services China (Beijing) Region operated by Sinnet. The free tier includes one million requests and 400,000 GB-seconds per month.

    icon-pricing-caculator

    Amazon Pricing Calculator

    You can estimate your monthly bill using the Amazon Pricing Calculator. The calculator allows you to estimate the Amazon Lambda cost.

    Requests

    You are charged for the total number of requests across all your functions. Lambda counts a request each time it starts executing in response to an event notification or invoke call, including test invokes from the console.

    ¥ 1.36 per 1 million requests (¥ 0.00000136 per request)

    Duration

    Duration is calculated from the time your code begins executing until it returns on otherwise terminates, rounded up to the nearest 1ms. The price depends on the amount of memory you allocate to your function.

    For x86-functions, you are charged ¥ 0.000113477 for every GB-second used. 

    For Arm-functions, you are charged ¥ 0.000090782 for every GB-second used

    The table below shows the approximate price per 1ms associated for different memory sizes.

    • x86 Price
    • Memory (MB)

      Price per 1ms (¥) (Beijing)

      Price per 1ms (¥) (Ningxia)

      128

      0.0000000142

      0.0000000142

      512

      0.0000000567

      0.0000000567

      1024

      0.0000001135

      0.0000001135

      1536

      0.0000001702

      0.0000001702

      2048

      0.0000002270

      0.0000002270

      3072

      0.0000003404

      0.0000003404

      4096

      0.0000004539

      0.0000004539

      5120

      0.0000005674

      0.0000005674

      6144

      0.0000006809

      0.0000006809

      7168

      0.0000007943

      0.0000007943

      8192

      0.0000009078

      0.0000009078

      9216

      0.0000010213

      0.0000010213

      10240

      0.0000011348

      0.0000011348

    • Arm Price
    • Memory (MB)

      Price per 1ms (¥) (Beijing)

      Price per 1ms (¥) (Ningxia)

      128

      0.0000000114 0.0000000114

      512

      0.0000000454 0.0000000454

      1024

      0.0000000908 0.0000000908

      1536

      0.0000001362 0.0000001362

      2048

      0.0000001816 0.0000001816

      3072

      0.0000002724 0.0000002724

      4096

      0.0000003632 0.0000003632

      5120

      0.0000004540 0.0000004540

      6144

      0.0000005448 0.0000005448

      7168

      0.0000006356 0.0000006356

      8192

      0.0000007264 0.0000007264

      9216

      0.0000008172 0.0000008172

      10240

      0.0000009080 0.0000009080

    All examples below are based on price in China (Ningxia) region.

    Pricing Examples

    Example 1: If you allocated 512MB of memory to your function, executed it 3 million times in one month, and it ran for 1 second each time, your charges would be calculated as follows:

    Monthly compute charges

    The monthly compute price is ¥0.000113477 for every GB-second used and the free tier provides 400,000 GB-s.

    Total compute (seconds) = 3M * (1s) = 3,000,000 seconds

    Total compute (GB-s) = 3,000,000 * 512MB/1024 = 1,500,000 GB-s

    Total compute – Free tier compute = Monthly billable compute GB- s1,500,000 GB-s – 400,000 free tier GB-s = 1,100,000 GB-s

    Monthly compute charges =  1,100,000 * ¥0.000113477 = ¥124.82 

    Monthly request charges

    The monthly request price is ¥1.36 per 1 million requests and the free tier provides 1M requests per month.

    Total requests – Free tier requests = Monthly billable requests

    3M requests – 1M free tier requests = 2M Monthly billable requests

    Monthly request charges = 2M * ¥ 1.36/M = ¥2.72 

    Total monthly charges

    Total charges = Compute charges + Request charges = ¥124.82 + ¥2.72 = ¥127.54 per month

    Example 2: If you allocated 128MB of memory to your function, executed it 30 million times in one month, and it ran for 200ms each time, your charges would be calculated as follows:

    Monthly compute charges

    The monthly compute price is ¥0.000113477 per GB-s and the free tier provides 400,000 GB-s.

    Total compute (seconds) = 30M * (0.2sec) = 6,000,000 seconds

    Total compute (GB-s) = 6,000,000 * 128MB/1024 = 750,000 GB-s

    Total Compute – Free tier compute = Monthly billable compute seconds

    750,000 GB-s – 400,000 free tier GB-s = 350,000 GB-s

    Monthly compute charges = 350,000 * ¥0.000113477 = ¥39.72

    Monthly request charges

    The monthly request price is ¥1.36 per 1 million requests and the free tier provides 1M requests per month.

    Total requests – Free tier request = Monthly billable requests

    30M requests – 1M free tier requests = 29M Monthly billable requests

    Monthly request charges = 29M * ¥1.36/M = ¥39.44

    Total compute charges

    Total charges = Compute charges + Request charges = ¥39.72 + ¥39.44 = ¥79.16 per month

    Example 3: This example shows how charges are calculated when you are running functions with different memory sizes. For the example, let’s assume you have three functions, each with different memory sizes as described below:

    Function 1

    128MB of memory, executed 25M times in one month, runs for 200ms each time

    Total compute (seconds) = 25M * (0.2sec) = 5M seconds

    Function 2

    448MB of memory, executed 5M times in one month, runs for 500ms each time

    Total compute (seconds) = 5M * (0.5sec) = 2M seconds

    Function 3

    1024MB of memory, executed 2.5M times in one month, runs for 1 second each time

    Total compute (seconds) = 2.5M * (1sec) = 2.5M seconds

    If you ran these functions, your charges would be calculated as follows:

    Monthly compute charges

    Amazon Lambda normalizes the total compute time to GB-s and then sums the total across all functions

    Function 1 (GB-S) = 5M seconds * (128MB/1024) = 625,000 GB-s

    Function 2 (GB-S) = 2.5M seconds * (448MB/1024) = 1,093,750 GB-s

    Function 3 (GB-S) = 2.5M seconds * (1024MB/1024) = 2,500,000 GB-s

    Total monthly compute usage (GB-S) = 4,218,750 GB-s

    The monthly compute price is ¥0.000113477 per GB-s and the free tier provides 400,000 GB-s.

    Monthly charged compute usage = Total monthly compute usage – Free tier usage

    Monthly charged compute usage = 4,218,750 – 400,000 = 3,818,750 GB-s

    Monthly compute charges = 3,818,750 * ¥0.000113477 = ¥433.34

    Monthly request charges

    The monthly request price is ¥1.36 per 1 million requests and the free tier provides 1M requests per month.

    Total requests – Free tier requests = Monthly billable requests(25M+5M+2.5M) requests – 1M free tier requests = 31.5M Monthly billable requests

    Monthly request charges = 31.5M * ¥1.36/M = ¥42.84

    Total Monthly Charges

    Total charges = Compute charges + Request charges = ¥433.34 + ¥42.84= ¥476.18 per month

    Provisioned Concurrency Pricing

    You can enable Provisioned Concurrency for your Lambda functions for greater control over the performance of your serverless applications. When enabled, Provisioned Concurrency is designed to keep functions initialized and hyper-ready to respond in double-digit milliseconds. You only pay for the amount of concurrency that you configure and for the period of time that you configure it. When Provisioned Concurrency is enabled for your function and you execute it, you pay for Requests and Duration based on the prices below. If the concurrency for your function exceeds the configured concurrency, you will be billed for executing the excess functions at the rate outlined in the Amazon Lambda Pricing section above. You can enable Provisioned Concurrency for functions running on x86 architectures. To learn more about Provisioned Concurrency, visit the documentation.

    Provisioned Concurrency is calculated from the time you enable it on your function until it is disabled, rounded up to the nearest 5 minutes. The price depends on the amount of memory you allocate to your function and the amount of concurrency that you configure on it.

    Duration is calculated from the time your code begins executing until it returns or otherwise terminates, rounded up to the nearest 1ms. The price depends on the amount of memory you allocate to your function.

    The Lambda free tier, if available, does not apply to functions that have Provisioned Concurrency enabled. If you enable Provisioned Concurrency for your function and execute it, you will be charged for Requests and Duration based on the price below.

    • x86 Price
    •   Price in Amazon Web Services China (Beijing) region, operated by Sinnet Price in Amazon Web Services China (Ningxia) region, operated by NWCD
      Provisioned Concurrency ¥ 0.0000407741 for every GB-second ¥ 0.000030536 for every GB-second
      Requests ¥ 1.36 per million requests ¥ 1.36 per million requests
      Duration ¥ 0.0000951387 for every GB-second ¥ 0.0000712498 for every GB-second
    • Arm Price
    •   Price in Amazon Web Services China (Beijing) region, operated by Sinnet Price in Amazon Web Services China (Ningxia) region, operated by NWCD
      Provisioned Concurrency ¥ 0.00003261928 for every GB-second ¥ 0.0000244288 for every GB-second
      Requests ¥ 1.36 per million requests ¥ 1.36 per million requests
      Duration ¥ 0.00007611096 for every GB-second ¥ 0.00005699984 for every GB-second

    The prices for Duration and Provisioned Concurrency depend on the amount of memory you allocate to your function. You can allocate any amount of memory to your function between 128MB and 10,240MB, in 1MB increments. The table below contains a few examples of the price per 1ms associated with different memory sizes.

    Provisioned Concurrency

    • x86 Price
    • Memory (MB)

      Price per second (¥) Amazon Web Services China (Beijing) region, operated by Sinnet

      Price per second (¥) Amazon Web Services China (Ningxia) region, operated by NWCD

      128

      0.0000050968

      0.0000038170

      512

      0.0000203871

      0.0000152680

      1024

      0.0000407741

      0.0000305360

      1536

      0.0000611612

      0.0000458040

      2048

      0.0000815482

      0.0000610720

      3072

      0.0001223223

      0.0000916080

      4096

      0.0001630964

      0.0001221440

      5120

      0.0002038705

      0.0001526800

      6144

      0.0002446446

      0.0001832160

      7168

      0.0002854187

      0.0002137520

      8192

      0.0003261928

      0.0002442880

      9216

      0.0003669669

      0.0002748240

      10240

      0.0004077410

      0.0003053600

    • Arm Price
    • Memory (MB)

      Price per second (¥) Amazon Web Services China (Beijing) region, operated by Sinnet

      Price per second (¥) Amazon Web Services China (Ningxia) region, operated by NWCD

      128

      0.00000407744

      0.0000030536

      512

      0.00001630968

      0.0000122144

      1024

      0.00003261928

      0.0000244288

      1536

      0.00004892896

      0.0000366432

      2048

      0.00006523856

      0.0000488576

      3072

      0.00009785784

      0.0000732864

      4096

      0.00013047712

      0.0000977152

      5120

      0.0001630964

      0.000122144

      6144

      0.00019571568

      0.0001465728

      7168

      0.00022833496

      0.0001710016

      8192

      0.00026095424

      0.0001954304

      9216

      0.00029357352

      0.0002198592

      10240

      0.0003261928

      0.000244288

    Duration

    • x86 Price
    • Memory (MB)

      Price per 1ms (¥) Amazon Web Services China (Beijing) region, operated by Sinnet

      Price per 1ms (¥) Amazon Web Services China (Ningxia) region, operated by NWCD

      128

      0.0000000119

      0.0000000089

      512

      0.0000000476

      0.0000000356

      1024

      0.0000000951

      0.0000000712

      1536

      0.0000001427

      0.0000001069

      2048

      0.0000001903

      0.0000001425

      3072

      0.0000002854

      0.0000002137

      4096

      0.0000003806

      0.0000002850

      5120

      0.0000004757

      0.0000003562

      6144

      0.0000005708

      0.0000004275

      7168

      0.0000006660

      0.0000004987

      8192

      0.0000007611

      0.0000005700

      9216

      0.0000008562

      0.0000006412

      10240

      0.0000009514

      0.0000007125

    • Arm Price
    • Memory (MB)

      Price per 1ms (¥) Amazon Web Services China (Beijing) region, operated by Sinnet

      Price per 1ms (¥) Amazon Web Services China (Ningxia) region, operated by NWCD

      128

      0.0000000095 0.0000000071

      512

      0.0000000381 0.0000000285

      1024

      0.0000000761 0.0000000570

      1536

      0.0000001142 0.0000000855

      2048

      0.0000001522 0.0000001140

      3072

      0.0000002283 0.0000001710

      4096

      0.0000003044 0.0000002280

      5120

      0.0000003806 0.0000002850

      6144

      0.0000004567 0.0000003420

      7168

      0.0000005328 0.0000003990

      8192

      0.0000006089 0.0000004560

      9216

      0.0000006850 0.0000005130

      10240

      0.0000007611 0.0000005700
    • Let’s assume you allocated 1024MB to your function and enabled Provisioned Concurrency on it for 2 hours. The concurrency that you configured was 1,000. You executed the function 1.2M times during the 2 hours and it ran for 1 second each time. Your charges would be calculated as follows:

      Charges in Amazon Web Services China (Beijing) region, operated by Sinnet

      Provisioned Concurrency charges
      The Provisioned Concurrency price is ¥ 0.0000407741 for every GB-second

      Total period of time for which Provisioned Concurrency is enabled (seconds) = 2 hours = 7,200 seconds

      Total concurrency configured (GB): 1000 * 1024MB/1024MB = 1000 GB

      Total Provisioned Concurrency amount (GB-s) = 1000 GB * 7,200 seconds = 7.2M GB-s

      Provisioned Concurrency charges = 7.2M GB-s * ¥ 0.0000407741 = ¥ 293.573520

      Request charges
      The monthly request price is ¥ 1.36 per 1 million requests.

      Monthly request charges = 1.2M * ¥ 1.36 /M = ¥ 1.632

      Compute charges
      The compute price is ¥ 0.0000951387 per GB-s

      Total compute duration (seconds) = 1.2M * 1 second = 1.2M seconds

      Total compute (GB-s) = 1.2M seconds * 1024MB / 1024MB = 1.2M GB-s.

      Total compute charges = 1.2M GB-s * ¥ 0.0000951387 = ¥ 114.166440

      Total charges
      Total charges = Provisioned Concurrency charges + Request charges + Compute charges

      Total charges = ¥ 293.573520 + ¥ 1.632+ ¥ 114.166440 = ¥ 409.371960

    • Amazon Web Services China (Ningxia) region, operated by NWCD 

      Provisioned Concurrency charges
      The Provisioned Concurrency price is ¥ 0.000030536 for every GB-second

      Total period of time for which Provisioned Concurrency is enabled (seconds) = 2 hours = 7,200 seconds

      Total concurrency configured (GB): 1000 * 1024MB/1024MB = 1000 GB

      Total Provisioned Concurrency amount (GB-s) = 1000 GB * 7,200 seconds = 7.2M GB-s

      Provisioned Concurrency charges = 7.2M GB-s * ¥ 0.000030536 = ¥ 219.8592

      Request charges
      The monthly request price is ¥ 1.36 per 1 million requests.

      Monthly request charges = 1.2M * ¥ 1.36 /M = ¥ 1.632

      Compute charges
      The compute price is ¥ 0.0000712498 per GB-s

      Total compute duration (seconds) = 1.2M * 1 second = 1.2M seconds

      Total compute (GB-s) = 1.2M seconds * 1024MB / 1024MB = 1.2M GB-s.

      Total compute charges = 1.2M GB-s * ¥ 0.0000712498 = ¥ 85.49976

      Total charges
      Total charges = Provisioned Concurrency charges + Request charges + Compute charges

      Total charges = ¥ 219.8592 + ¥ 1.632 + ¥ 85.49976= ¥ 306.990960

      Example 2: Let’s assume you allocated 256 MB of memory to your function and enabled Provisioned Concurrency on it for 31 days. The concurrency that you configured was 100. You executed the function 100 million times during the 31 days and the function ran for 1 second each time. Your charges would be calculated as follows:

      Amazon Web Services China (Ningxia) region, operated by NWCD 

      Provisioned Concurrency charges

      The Provisioned Concurrency price is ¥0.000030536 per GB-s

      Total period of time for which Provisioned Concurrency is enabled (seconds) = 31 * 24 * 3600 seconds = 2,678,400 secondsTotal concurrency configured (GB): 100 * 256MB/1024MB = 25 GB

      Total Provisioned Concurrency amount (GB-s) = 25 GB * 2,678,400 seconds = 66,960,000 GB-s

      Monthly Provisioned Concurrency charges = 66,960,000 * ¥0.000030536 = ¥2,044.69

      Monthly request charges

      The monthly request price is ¥1.36 per 1 million requests.

      Monthly request charges = 100M requests * ¥1.36/M = ¥136

      Monthly compute charges

      The monthly compute price is ¥0.000113477 per GB-sTotal compute (seconds) = 100M * 1 second = 100M seconds

      Total compute (GB-s) = 100M seconds * 256MB/1024 = 25M GB-s

      Monthly compute charges = 25M GB-s * ¥0.000113477 = ¥2836.93

      Total charges

      Total charges = Provisioned Concurrency charges + Request charges + Compute charges

      Total charges = ¥2,044.69 + ¥136 + ¥2836.93= ¥5017.62

      Example 3: Let’s assume you allocated 256 MB of memory to your function and enabled Provisioned Concurrency on it for four hours every day. The concurrency that you configured was 100. You executed the function 100 million times during one month and the function ran for 1 second each time. 30 million of those executions happened while Provisioned Concurrency was enabled and 70 million executions happened while Provisioned Concurrency was disabled. Your charges would be calculated as follows:

      Amazon Web Services China (Ningxia) region, operated by NWCD 

      Provisioned Concurrency charges

      The Provisioned Concurrency price is ¥0.000030536 per GB-s

      Total period of time for which Provisioned Concurrency is enabled (seconds) = 31 * 4 * 3600 seconds = 446,400 seconds

      Total concurrency configured (GB): 100 * 256MB/1024MB = 25 GBTotal Provisioned Concurrency amount (GB-s) = 25 GB * 446,400 = 11,160,000 GB-s

      Monthly Provisioned Concurrency charges = 11,160,000 * ¥0.000030536 = ¥340.78

      Monthly request charges when Provisioned Concurrency is enabled

      The monthly request price is ¥1.36 per 1 million requests.

      Monthly request charges = 30M requests * ¥1.36 = ¥40.8

      Monthly compute charges when Provisioned Concurrency is enabled

      The monthly compute price is ¥0.000113477 per GB-s

      Total compute (seconds) = 30M * 1 second = 30M secondsTotal compute (GB-s) = 30M * 256MB/1024 = 7.5M GB-s

      Monthly compute charges = 7.5M * ¥0.000113477 = ¥851.08

      Let's now calculate the charges for the function when Provisioned Concurrency is NOT enabled.

      Monthly request charges

      The monthly request price is ¥1.36 per 1 million requests and the free tier provides 1M requests.

      Total requests – Free tier requests = Monthly billable requests

      70M requests – 1M free tier requests = 69M Monthly billable requests

      Monthly request charges = 69M * ¥1.36/M = ¥93.84

      Monthly compute charges

      The monthly compute price is ¥0.000113477 per GB-s and the free tier provides 400,000 GB-s.

      Total compute (seconds) = 70M * 1 second = 70M secondsTotal compute (GB-s) = 70M * 256MB/1024MB = 17.5M GB-s

      Total compute – Free tier compute = Monthly billable compute GB- s17.5M GB-s – 400,000 free tier GB-s = 17.1M GB-s

      Monthly compute charges = 17.1M GB-s * ¥0.000113477 = ¥1940.46

      Total charges

      Total charges = Provisioned Concurrency charges + Total Request charges + Total Compute charges

      Total charges = ¥340.78 + (¥40.8 + ¥93.84) + (¥851.08 + ¥1940.46) = ¥3266.96

      Example 4: Let’s assume you allocated 1024MB to your function and enabled Provisioned Concurrency on it for two hours. The concurrency that you configured was 1,000. Due to a burst in demand, the function reached a concurrency level of 1,200 several times during these two hours. For the remainder of the time, the concurrency stayed under 1,000. You executed the function 1.2M times during the two hours and it ran for 1 second each time. Of the 1.2M executions, 1M used Provisioned Concurrency and 200,000 did not. Let’s also assume that you have already used up all available requests and duration included in the free usage tier. Your charges would be calculated as follows:

      Amazon Web Services China (Ningxia) region, operated by NWCD 

      Provisioned Concurrency charges

      The Provisioned Concurrency price is ¥0.000030536 per GB-s

      Total period of time for which Provisioned Concurrency is enabled (seconds) = 2 hours = 7,200 seconds

      Total concurrency configured (GB): 1000 * 1024MB/1024MB = 1000 GB

      Total Provisioned Concurrency amount (GB-s) = 1000 GB * 7,200 seconds = 7.2M GB-s

      Provisioned Concurrency charges = 7.2M * ¥0.000030536 = ¥219.86

      Request charges for Provisioned Concurrency when usage is under 1,000 concurrency

      The monthly request price is ¥1.36 per 1 million requests.

      Monthly request charges = 1M * ¥1.36/M = ¥1.36

      Compute charges for Provisioned Concurrency when usage is under 1,000 concurrency 

      The compute price is ¥0.000113477 per GB-s

      Total compute duration (seconds) = 1M * 1 second = 1M seconds

      Total compute (GB-s) = 1M seconds * 1024MB / 1024MB = 1M GB-s.

      Total compute charges = 1M GB-s * ¥0.000113477 = ¥113.48

      Monthly request charges for requests over the 1,000 concurrency level

      The monthly request price is ¥1.36 per 1 million requests.

      Monthly request charges = (1.2M – 1M) * ¥1.36 / M = ¥0.27

      Monthly compute charges for compute over the 1,000 concurrency level

      The monthly compute price is ¥0.000113477 per GB-s.

      Total compute (seconds) = 200,000 * 1 second = 200,000 seconds

      Total compute (GB-s) = 200,000 seconds * 1024MB/1024MB = 200,000 GB-sMonthly compute charges = 200,000 GB-s * ¥0.000113477 = ¥22.7

      Total charges

      Total charges = Provisioned Concurrency charges + Total Request charges + Total Compute charges

      Total charges = ¥219.86 + (¥1.36 + ¥0.27) + (¥113.48 + ¥22.7) = ¥357.67

    * Duration charges apply to code that runs in the handler of a function as well as initialization code that is declared outside of the handler. For more details, see the Lambda Programming Model documentation. 

    Lambda Durable Functions Pricing

    Lambda durable functions simplify how you build reliable multi-step applications and AI workflows directly within Lambda’s existing programming model, enabling resilient and cost-effective long-running workloads. In durable functions, you use durable operations like “steps” and “waits”, which are checkpoints with optional data stored for extended periods, allowing your function to resume execution after interruptions. When functions resume, the system performs replay, automatically re-executing the event handler from the beginning while skipping completed checkpoints and continuing from the point of interruption. The lifecycle may include multiple sub-invocations (Lambda function invocations that occur when resuming after wait operations, retries, or infrastructure failures) to complete the execution. 

    Existing Lambda compute charges apply, including for sub-invocations from replays. When using wait operations, the function suspends execution and, for on-demand functions, does not incur duration charges until execution resumes. In addition, you are charged for durable operations (such as starting executions, completing steps, and creating waits). You also pay for the amount of data written by these operations (in GB) and for data retention during and after execution (in GB-month, prorated). The retention period after completion is configurable from 1 to 90 days (default 14 days). 

    For a full list and detailed description of durable operations, see the Lambda Developer Guide.

    Durable Operations    
      Beijing region Ningxia region
    Operations such as Steps, Waits, and Callbacks 78 CNY per million operations 62 CNY per million operations
    Storage    
    Data Written 2.46 CNY per GB 1.96 CNY per GB
    Data Retained 1.41 CNY per GB-month 1.18 CNY per GB-month
    • An insurance claim processing system uses Lambda durable functions to analyze claims for fraud detection, coordinate human review for high-value claims, and process approved payments. The process begins with a document analysis step that takes 30 seconds to perform LLM-based fraud detection and risk assessment. The execution then uses a wait to suspend execution for a human review (typically 7 days wait) where an adjuster reviews claims exceeding automatic approval thresholds. Finally, a payment step taking 2 seconds to process the approval decision to initiate the payment. The system processes 1,000,000 insurance claims per month. Each execution uses an 8KB invocation payload and 32KB payloads for claim analysis (step 1), approval decisions (wait), and final payment processing (step 2). The function is configured with 1GB of memory on an ARM-based processor. Completed claim records are retained for 14 days for audit and compliance.

      Note: All examples below are based on price in China (Ningxia) region. All executions start at the beginning of the month and all steps succeed on first attempt without retries to simplify the calculations.

      Monthly Compute Charges

      Total compute (seconds)

      1,000,000 × 32s = 32,000,000 seconds

      Total compute (GB-s)

      32,000,000 × 1GB = 32,000,000 GB-s

      Billable compute

      32,000,000 - 400,000 free tier = 31,600,000 GB-s

      Compute cost

      31,600,000 × ¥0.000090800= ¥2,869.28

      Monthly Request Charges

      Total requests

      2 invocations (initial + after wait) × 1,000,000 = 2,000,000 requests

      Billable requests

      2,000,000 - 1M free tier = 1,000,000

      Request cost

      1M × ¥1.36/M = ¥1.36


      Monthly Durable Functions Charges

      Operations

      1M × (1 start execution + 2 steps + 1 wait) = 4M

      Operations cost

      4M × ¥62/M = ¥248

      Data Written

      1M × (8KB invoke + 3 × 32KB steps/waits) = 104GB

      Data written cost

      104GB × ¥1.96 /GB = ¥203.84

      Storage (running incl. 7 day wait)

      104GB × (7/30) = 24.27 GB-month

      Storage (retained 14 days)

      104GB × (14/30) = 48.53 GB-month

      Data Retained cost

      (24.27 + 48.53) GB-month × ¥1.18/GB-month = ¥85.904

      Total Monthly Charges

      Total charges

      ¥2,869.28+ ¥1.36+ ¥248+ ¥203.84+ ¥85.904= ¥3,408.384

    Tenant Isolation Pricing

    Enable tenant isolation mode to isolate request processing for individual end-users or tenants invoking your Lambda function. The underlying execution environments for a tenant-isolated Lambda function are always associated with a particular tenant and are never used to execute requests from other tenants invoking the same function. This capability simplifies developing and maintaining multi-tenant applications that process tenant-specific code or data with strict isolation requirements across tenants. You are charged when Lambda creates a new tenant-isolated execution environment to serve a request, depending on the amount of memory you allocate to your function and the CPU architecture you use. To learn more about Lambda's tenant isolation capability, read the documentation.

    Tenant isolation rates

    Region

    Billing Unit

    X86

    ARM

    Currency

    Beijing

    Tenant isolated environments

    0.001134770 per 1 GB environment

    0.000907820 per 1 GB environment

    CNY

    Ningxia

    Tenant isolated environments

    0.001134770 per 1 GB environment

    0.000907820 per 1 GB environment

    CNY

    • Let's assume you are building an automation platform that executes user-provided code in response to events. For example, an IT team may want to execute an automated workflow when a new employee joins their organization or transfers across departments. As another example, a DevOps team may want to trigger a CI/CD workflow when a developer commits code changes to their source code repository. Your automation platform is multi-tenant, meaning that it serves multiple end-users. Because you expect high variation in demand, by time of day and for each end-user or tenant, you build your platform using serverless services including Amazon Lambda.

      Your automation platform supports the ability to run user-supplied code in response to events. Since you do not control the code provided by users, you enable tenant isolation mode to ensure that Lambda function invocations for each end-user are processed in separate execution environments that are isolated from one another.

      Assume that you have configured your Lambda function with 1024 MB of memory and x86 CPU architecture. During a typical month, your function processes 10M invokes with an average duration of 2 seconds per invoke. Your SaaS platform is used by 1K end-users or tenants. For simplicity, let's assume that on average each tenant generates 10K invokes per month and Lambda creates 200 execution environments per tenant (i.e. a cold-start rate of 2% per tenant).

      Your charges would be calculated as follows:

      Request charges

      Per month, your function executes 10M times.

      Monthly request charges: 10M * ¥1.36/M = ¥13.6.

      Compute charges

      Per month, your function executes 10M times with an average duration of 2s. Your function's configured memory is 1024 MB.

      Monthly compute duration (seconds): 10M * 2s = 20M seconds

      Monthly compute (GB-s): 20M seconds * 1024 MB / 1024 MB = 20M GB-s

      Monthly compute charges: 20M * ¥0.000113477 = ¥2269.54

      Tenant isolation charges

      Per month, on average, your function serves 1K unique tenants. Each tenant invokes the function 10K times with an average of 200 execution environments created per tenant (i.e. average cold-start rate of 2% for each tenant).

      Monthly execution environments created for 1K tenants: 200 * 1K = 200K

      Monthly tenant isolation charges: 200K * ¥0.001134770 * 1024 MB / 1024MB = ¥226.95

      Total monthly charges

      Total charges = Request charges + Compute charges + Tenant isolation charges

      Total charges = ¥13.6 + ¥2269.54 + ¥226.95 = ¥2510.09

    Amazon Lambda Ephemeral Storage Pricing

    Ephemeral storage cost depends on the amount of ephemeral storage you allocate to your function, and function execution duration, measured in milliseconds. You can allocate any additional amount of storage to your function between 512 MB and 10,240 MB, in 1 MB increments. You can configure ephemeral storage for functions running on x86 architectures. 512 MB of ephemeral storage is available to each Lambda function at no additional cost. You only pay for the additional ephemeral storage you configure. Price for the additional ephemeral storage is ¥0.0000002303 for every GB-second in Amazon Web Services China (Beijing) region, operated by Sinnet. Price for the additional ephemeral storage is ¥0.0000002049 for every GB-second in Amazon Web Services China (Ningxia) region, operated by NWCD.

    The table below shows the approximate price per 1ms associated for a few examples with different storage sizes.

    Memory (MB)

    Price per 1ms (¥) (Beijing)

    Price per 1ms (¥) (Ningxia)

    1024

    ¥0.00000000012

    ¥0.00000000010

    1536

    ¥0.00000000024

    ¥0.00000000021

    2048

    ¥0.00000000035

    ¥0.00000000031

    3072

    ¥0.00000000059

    ¥0.00000000052

    4096

    ¥0.00000000083

    ¥0.00000000073

    5120

    ¥0.00000000106

    ¥0.00000000094

    6144

    ¥0.00000000130

    ¥0.00000000115

    7168

    ¥0.00000000153

    ¥0.00000000136

    8192

    ¥0.00000000177

    ¥0.00000000157

    9216

    ¥0.00000000200

    ¥0.00000000178

    10240

    ¥0.00000000224

    ¥0.00000000199

    Additional Charges

    You may incur additional charges if your Lambda function utilizes other Amazon Web Services services or transfers data. For example, if your Lambda function reads and writes data to or from Amazon S3, you will be billed for the read/write requests and the data stored in Amazon S3.

    For details on Amazon Web Services service pricing, see the pricing section of the relevant Amazon Web Services service. Links to pricing for some of the commonly used services are listed below.

    Data transfer (If your Lambda function initiates external data transfers, they will be charged at the EC2 data transfer rate)

    Amazon S3 pricing (includes pricing for storage, requests, and data transfer)

    Amazon DynamoDB (includes pricing for data storage, throughput capacity, and data transfer)

  • MicroVMs
  • Amazon Lambda MicroVMs Pricing

    Amazon Lambda MicroVMs pricing is based on the compute resources you use, snapshot read/write operations and storage, and data transfer at standard Amazon Web Services rates.

    Compute

    Amazon Lambda MicroVMs eliminate the need to right-size each compute environment for peak activity. You configure a baseline by setting memory, and CPU is allocated in a 2:1 memory-to-CPU ratio — the default is 2 GB / 1 vCPU. During peak activity, your MicroVM can vertically scale up to 4x the baseline (up to 8 GB / 4 vCPU), with no action required on your part.

    You pay for baseline compute resources while your MicroVM is running. When your workload consumes resources above the baseline, you are charged only for the active duration of the additional memory and vCPU consumed — not for the peak capacity. This means you can configure for your typical workload and let Lambda handle the spikes. Compute usage is billed per second. For details on sizing your MicroVMs, see creating a MicroVM image.

    Graviton (ARM) compute rates — Amazon Web Services China (Beijing) Region, operated by Sinnet / Amazon Web Services China (Ningxia) Region, operated by NWCD:

    Resource

    Price

    vCPU

    ¥0.000209731 per vCPU-second

    Memory

    ¥0.000027768 per GB-second

    Snapshots

    Amazon Lambda MicroVMs uses snapshots to deliver near-instant startup and reduce idle costs. A MicroVM image is a snapshot of your application's pre-initialized state. Instead of cold-starting from scratch, your MicroVM launches from this image. During idle periods, you can suspend a running MicroVM for up to 8 hours, preserving its memory and disk state without paying compute charges. When traffic returns, the suspended MicroVM resumes rapidly, either automatically or programmatically. You are charged for snapshot storage, snapshot data read (on start or resume), and snapshot data written (on suspend).

    Region: Amazon Web Services China (Beijing) Region, operated by Sinnet / Amazon Web Services China (Ningxia) Region, operated by NWCD

    Snapshot charge

    Price

    Snapshot data written (suspend)

    ¥0.030998658 per GB

    Snapshot data read (start/resume)

    ¥0.012293318 per GB

    Snapshot storage

    ¥0.596800000 per GB-month

    * MicroVM Image storage has a 1-week minimum retention period.

    Data Transfer

    You are charged for data transfer at standard Amazon Web Services Data Transfer rates. You are also charged for data transferred between your Amazon Lambda MicroVMs and your Amazon VPC, as outlined in Data Transfer within the same Amazon Web Services China Region.

    Amazon Lambda MicroVMs — Pricing Examples

    All examples below are calculated using the Amazon Web Services China (Beijing) Region, operated by Sinnet / Amazon Web Services China (Ningxia) Region, operated by NWCD, and use ARM (Graviton) rates. For each GB of memory configured, Lambda MicroVMs allocates vCPU in a 2:1 ratio (e.g., configuring 8 GB memory allocates 4 vCPU).

    Pricing Example 1: Sandboxed environments for coding assistants

    Let's assume you are building a platform that provides each developer with an isolated, sandboxed Linux environment for AI-assisted coding. Each environment runs in a Lambda MicroVM configured with a 2 GB memory and 1 vCPU baseline that can vertically scale to 8 GB memory and 4 vCPU for resource-intensive tasks like compilation and test execution. Your organization maintains 5 standard MicroVM images (Rust, Python, Node.js, Java, Go), each 2 GB in size. Every developer launches one environment per day from a 2 GB image. Over an 8-hour workday, each environment is used for 2.5 hours: using baseline resources provisioned for 75% of this period (2 GB & 1 vCPU) and vertically scaling to peak resources for 25% of this period (8 GB & 4 vCPU). During the remaining 5.5 idle hours of the workday the environment automatically suspends, preserving 2 GB of state i.e. working directory, process state, and file caches. Each environment experiences 6 suspend/resume cycles per day as developers context switch between coding and their other activities. With suspend/resume, you avoid paying for always-on compute during idle periods while preserving your complete working state. Developers pick up exactly where they left off without restarting their environment or re-initializing state. Your team has 100 developers, each using the development platform for 20 days per month. All amounts use ARM (Graviton) rates for the Beijing Region. Your monthly charges would be calculated as follows:

    Monthly compute charges

    To recap, 75% of compute time is spent at baseline resource consumption and 25% at peak resource consumption.

    Peak usage seconds: 100 developers × 20 days × 2.5 hours × 25% = 4.5M seconds

    • vCPU: 4.5M × 4 vCPU × ¥0.000209731 = ¥3,775.16
    • Memory: 4.5M × 8 GB × ¥0.000027768 = ¥999.65
    • Total: ¥4,774.81

    Baseline usage seconds: 100 × 20 × 2.5 × 75% = 13.5M seconds

    • vCPU: 13.5M × 1 vCPU × ¥0.000209731 = ¥2,831.37
    • Memory: 13.5M × 2 GB × ¥0.000027768 = ¥749.74
    • Total: ¥3,581.10

    Monthly compute charges: ¥4,774.81 + ¥3,581.10 = ¥8,355.91

    Monthly snapshot charges

    Snapshot read/write:

    • Monthly suspend/resume cycles: 100 × 20 × 6 = 12,000 cycles
    • Snapshot write (suspend): 12,000 × 2 GB × ¥0.030998658 = ¥743.97
    • Snapshot read (resume): 12,000 × 2 GB × ¥0.012293318 = ¥295.04
    • Monthly launches: 100 × 1 × 20 = 2,000 launches
    • Snapshot read (launch): 2,000 × 2 GB × ¥0.012293318 = ¥49.17
    • Total snapshot read/write: ¥1,088.18

    Snapshot storage:

    • MicroVM image storage: 5 images × 2 GB × ¥0.596800000 = ¥5.97
    • Suspended MicroVM: 100 × 2 GB × (5.5 idle-hrs × 20 days / 720 hrs) × ¥0.596800000 = ¥18.24
    • Monthly snapshot storage: ¥24.20

    Total monthly charges = ¥8,355.91 + ¥1,088.18 + ¥24.20 = ¥9,468.29

    Monthly cost per developer: ¥9,468.29 / 100 = ¥94.68

    Pricing Example 2: Ephemeral isolated environments for security scans and CI/CD jobs

    Let's assume you are building a platform that runs security scans or CI/CD jobs on behalf of multiple end-users. Each job executes untrusted or semi-trusted code - dependency installation, build scripts, vulnerability scanners. For this reason, each job requires its own hardware-isolated environment. Traffic is unpredictable, so you previously maintained a large pool of idle environments on standby to meet latency requirements. With Lambda MicroVMs, environments launch fast from snapshots, so you no longer need an idle pool. Each environment is configured with an 8 GB memory & 4 vCPU baseline that can vertically scale to 32 GB & 16 vCPU for resource-intensive compilation or scanning phases. Jobs run to completion in a single shot; no suspend/resume is needed. Each job runs for an average of 10 minutes, with 10% of that time at peak (32 GB & 16 vCPU) and 90% at baseline (8 GB & 4 vCPU). You maintain a single standard MicroVM image (2 GB). With snapshot-based startup, you no longer pay for idle standby pools - each environment launches rapidly on demand and terminates when the job completes. Your platform runs 10,000 jobs per month. All amounts use ARM (Graviton) rates for the Beijing Region. Your charges would be calculated as follows:

    Monthly compute charges

    To recap, 90% of compute time is spent at baseline resource consumption and 10% at peak resource consumption.

    Peak usage seconds: 10,000 jobs × 600s × 10% = 600K seconds

    • vCPU: 600K × 16 vCPU × ¥0.000209731 = ¥2,013.42
    • Memory: 600K × 32 GB × ¥0.000027768 = ¥533.15
    • Total: ¥2,546.56

    Baseline usage seconds: 10,000 × 600s × 90% = 5.4M seconds

    • vCPU: 5.4M × 4 vCPU × ¥0.000209731 = ¥4,530.19
    • Memory: 5.4M × 8 GB × ¥0.000027768 = ¥1,199.58
    • Total: ¥5,729.77

    Monthly compute charges: ¥2,546.56 + ¥5,729.77 = ¥8,276.33

    Monthly snapshot charges

    Snapshot read/write:

    • Monthly launches: 10,000 jobs × 1 launch each = 10,000 launches
    • Snapshot read (launch): 10,000 × 2 GB × ¥0.012293318 = ¥245.87
    • Total snapshot read/write: ¥245.87

    Snapshot storage:

    • MicroVM image storage: 1 image × 2 GB × ¥0.596800000 = ¥1.19
    • Monthly snapshot storage: ¥1.19

    Total monthly charges = ¥8,276.33 + ¥245.87 + ¥1.19 = ¥8,523.39

    Cost per job: ¥8,523.39 / 10,000 = ¥0.8523