Ibravra is the decision engine and digital knowledge hub for modern founders, operators, and cross-border businesses. We publish research-backed incorporation guides, interactive financial tools, and head-to-head software reviews.

Are Ibravra business tools and calculators free to use?

Yes, all interactive financial calculators, invoice generators, and business launch checklists are 100% free with no registration or credit card required.

How does Ibravra verify software reviews and guides?

All IBRAVRA content follows our strict Editorial Constitution and Post-AI Value Rule, requiring real practitioner experience, primary source statutory checks (IRS/FinCEN), and verifiable benchmarks.

Does AWS App Runner scale to zero?

No. App Runner always keeps at least one provisioned container instance warm by default, billed at $0.007 per GB-hour — $10.22 a month for a 2 GB instance. Pausing the service stops the charge, but a running service never bills zero. Cloud Run and Container Apps both scale to zero.

What does it cost to keep one serverless container warm all month?

For 1 vCPU and 2 GiB running 24/7: $10.22 on App Runner, $18.36 on Cloud Run under request-based billing, $22.03 on Container Apps, and $52.59 on Cloud Run under instance-based billing, all after free tiers.

Why does Container Apps cost more than Cloud Run at 10 million requests?

Both charge $0.000024 per active vCPU-second and $0.40 per million requests, so the difference is memory: Container Apps charges $0.000003 per GiB-second against Cloud Run's $0.0000025 under request-based billing. At 10 million requests that gap is $1.82 a month.

Comparisons • 12 min read

Cloud Run vs App Runner vs Container Apps: Serverless Container Pricing

The same container costs $0 on one platform and $13.78 on another at one million requests — the pricing model, not the headline rate, decides the bill.

By Enow A. Jovial • Published 2026-11-06

Cloud Run vs App Runner vs Container Apps: Serverless Container Pricing

Three vendors sell the same promise: put a container image in, get a URL out, pay only when requests arrive. Google Cloud Run, AWS App Runner, and Azure Container Apps all run the same Docker image — but their bills come from three different machines: Cloud Run charges by the vCPU-second and GiB-second, with two billing modes; App Runner by the vCPU-hour and GB-hour, never letting the meter fall to zero; Container Apps by the vCPU-second, with an active rate and an idle rate.

That difference is the comparison: the wrong model means a floor charge for an idle service, or a per-request fee that dwarfs compute. Our editorial analysis puts the cheapest option at zero at low volume and the gap at $268 a month at 100 million requests. Every rate below comes from the vendors' own published pricing pages, read on 6 November 2026, with the arithmetic shown.

> [!FOUNDER]

> "The cheapest serverless container is never the one with the lowest headline rate. It is the one whose billing model matches the shape of your traffic. A service that idles all night wants scale to zero; one that never sleeps wants the lowest rate per vCPU-second and no per-request fee at all. Buy the model first, then compare the numbers inside it."

> — Enow A. Jovial, Founder & Chief Executive Officer

The three pricing models, side by side

Cloud Run offers two billing modes. Under instance-based billing, CPU is always allocated and you pay for every second the instance exists, handling requests or not. Under request-based billing, CPU is allocated only while a request is being processed, idle minimum instances bill at a much lower idle rate, and requests cost $0.40 per million after the first two million free. The same workload therefore has two different Cloud Run prices.

App Runner has no equivalent choice: a service always keeps at least one provisioned container instance warm — one by default — at $0.007 per GB-hour for its memory, for as long as the service is running. When requests arrive, the instance switches to active billing at $0.064 per vCPU-hour plus $0.007 per GB-hour, with the vCPU rate charged on top of the provisioned memory charge. Billing is per second, with a one-minute minimum vCPU charge per instance start. Pausing stops the provisioned charge — the only way to reach zero.

!App Runner provisioned and active instance pricing

Container Apps on the Consumption plan bills per second: an active rate while a replica works, a reduced idle rate while it waits. The idle discount applies to vCPU only: $0.000024 per second active, $0.000003 idle; memory costs $0.000003 per GiB-second either way.

| --- | --- | --- | --- | --- |

| Idle / minimum | $0.0000025 / vCPU-second (request-based minimum instances) | No idle rate — provisioned memory at $0.007 / GB-hour | $0.000003 / vCPU-second | Cloud Run pricing; App Runner pricing; Container Apps billing docs |

App Runner's active vCPU rate converts to $0.0000178 per vCPU-second, the lowest of the three — but with no free tier and no scale to zero, it starts every month behind. Container Apps and Cloud Run's request-based mode share the $0.000024 active vCPU rate and $0.40 per million request fee, so their difference is memory: $0.000003 against $0.0000025 per GiB-second, a 20 percent premium. For the functions version, see our guide to AWS Lambda vs Google Cloud Functions vs Azure Functions pricing.

The model: one profile, three bills

One service, 1 vCPU and 2 GiB of memory, average request duration 200 milliseconds, concurrency of one request at a time per instance — so instance-seconds equal requests multiplied by 0.2, and GiB-seconds are twice that. A month is 730 hours.

Concurrency of one is the conservative baseline: in production one instance serves many requests at once — Cloud Run defaults to 80 per instance — and overlapping requests share instance-seconds. Anyone can re-run the arithmetic from the published rates.

The monthly math: 1 million, 10 million, 100 million requests

At one million requests a month, the free tiers decide everything. Cloud Run instance-based billing grosses $4.40 — 200,000 vCPU-seconds at $0.000018 is $3.60, 400,000 GiB-seconds at $0.000002 is $0.80 — and the free tier covers all of it: the bill is zero. Cloud Run request-based billing totals $0.58 and Container Apps $0.60. App Runner is the outlier at $13.78: 55.56 active instance-hours at $0.064 cost $3.56, plus a $10.22 provisioned floor with no free tier to absorb any of it.

At ten million requests the free tiers are exhausted; Cloud Run instance-based billing is cheapest at $38.78:

$2{,}000{,}000 \times \$0.000018 - 240{,}000 \times \$0.000018 = \$36.00 - \$4.32 = \$31.68$

$4{,}000{,}000 \times \$0.000002 - 450{,}000 \times \$0.000002 = \$8.00 - \$0.90 = \$7.10$

$\$31.68 + \$7.10 = \$38.78$

App Runner follows at $45.78: 555.56 active hours at $0.064 is $35.56, plus the $10.22 floor. Cloud Run request-based billing totals $55.98 — CPU $43.68, memory $9.10, and 8 million billable requests adding $3.20. Container Apps is most expensive at $57.80, trailing on memory alone.

At one hundred million requests the order flips. App Runner becomes cheapest at $365.78: no per-request fee, and its effective vCPU-second rate of $0.0000178 sits a fraction below Cloud Run's $0.000018. Cloud Run instance-based billing totals $434.78; request-based Cloud Run $613.98 and Container Apps $633.80, each carrying $39.20 of request fees on 98 million billable requests. The per-request fee is a volume tax that grows linearly forever while compute rates stay flat.

| --- | --- | --- | --- | --- |

| 1 million | $0.00 | $0.58 | $0.60 | $13.78 |

| 10 million | $38.78 | $55.98 | $57.80 | $45.78 |

| 100 million | $434.78 | $613.98 | $633.80 | $365.78 |

> [!KEY TAKEAWAY]

> The cheapest platform changes with volume. Below the free tiers, Cloud Run and Container Apps cost almost nothing; App Runner costs $13.78. At 10 million requests, Cloud Run instance-based billing wins at $38.78. At 100 million, App Runner wins at $365.78 — no per-request fee.

The floor: what always-on costs

Request math hides the second half of the bill: what the service costs when nobody is calling it. Keep one instance warm for a month — 2,628,000 seconds — and the floors are $18.36 on Cloud Run request-based billing, $22.03 on Container Apps, $52.59 on Cloud Run instance-based billing, and $10.22 on App Runner:

$2\ \text{GB} \times 730\ \text{hours} \times \$0.007 = \$10.22\ \text{per month}$

Cloud Run's request-based floor is cheap: its idle vCPU rate is nearly ten times lower than its active rate: 2,448,000 billable vCPU-seconds at $0.0000025 is $6.12, and 4,896,000 billable GiB-seconds at $0.0000025 is $12.24. Container Apps lands at $22.03: idle vCPU $7.34, but memory bills at the full active rate even when idle — $14.69, two-thirds of the total. Cloud Run instance-based billing is the expensive way to stay warm at $52.59: a minimum instance bills at the full default rate all month. Never pay for one when request-based billing offers the same warm instance for $18.36.

Scale to zero, cold starts, and concurrency

Scale to zero is the defining feature of this category, and two of the three services offer it. Cloud Run scales to zero by default; Container Apps does the same, with minimum replicas defaulting to zero. App Runner does not scale to zero at all: the provisioned instance is the product's answer to cold starts, and you pay for it continuously instead.

A service that scales to zero pays nothing between requests, and its first request after idle waits while a container starts; the floor prices above are the cost of removing that wait. No vendor page read for this guide publishes a guaranteed cold-start time, so this guide prints none. On Container Apps a replica counts as idle only at the minimum replica count, with no HTTP requests, under 0.01 vCPU cores, and under 1,000 bytes per second of traffic. On Cloud Run, minimum instances are a best-effort target, not a guarantee.

An API receiving a request every few minutes gains almost nothing from scale to zero; a webhook receiver firing a few hundred times a day in bursts gains everything, and App Runner's $10.22 floor is a tax on silence. To plan the hosting side, compare the orchestration alternative in our guide to Docker vs Kubernetes vs Amazon ECS pricing.

Concurrency is the lever that moves the bill most: every figure so far assumes one request at a time per instance. Raise it and one instance serves many requests at once, so the same volume consumes far fewer instance-seconds. Cloud Run defaults to 80 concurrent requests per instance; maximum instances default to 100 per revision. Container Apps adds a replica past 10 concurrent requests, with maximum replicas defaulting to 10 and configurable up to 1,000. App Runner's examples configure 80 requests per instance, and its one-minute minimum vCPU charge means short bursts still pay for a full minute. Doubling effective concurrency roughly halves instance-seconds on Cloud Run and Container Apps, while App Runner's provisioned floor stays fixed. Set concurrency from a load test, then re-run the monthly math with the measured instance-seconds.

> [!TIP]

> Set concurrency from a load test before comparing vendors: a service at 80 concurrent requests per instance can cost a fifth of the same service running one request at a time.

Which service wins, and when

| --- | --- | --- | --- |

| Side project, under 1M requests a month | Cloud Run or Container Apps | Free tiers cover the whole bill; App Runner charges $13.78 | Cloud Run pricing; Container Apps pricing; App Runner pricing |

| Spiky traffic, long idle nights | Cloud Run or Container Apps | Scale to zero; App Runner's $10.22 floor bills through the silence | Cloud Run docs; Container Apps billing docs |

No single column wins. Cloud Run takes the middle of the range; App Runner takes high volume and latency and loses low volume outright; Container Apps wins no row on price alone; its case is Azure integration for teams already on Azure. For the edge-functions version, see Cloudflare Workers vs Vercel Edge Functions.

Operator boundaries: who this is for, and who must not use it

Serverless containers suit a specific shape: stateless HTTP APIs, webhook receivers, lightweight background workers, and internal tools with bursty or unpredictable traffic, where the platform can start and stop instances freely and the bill follows demand. They fit teams that want a URL without operating a cluster.

They do not fit everything with a Dockerfile. A service that holds connections open for hours, keeps large in-memory state, or runs one request past the platform's timeout has no business here — long-running jobs belong on a worker queue or a dedicated host. A flat, predictable 24-hour load is usually cheaper on reserved capacity: at 100 million requests the cheapest serverless option still costs $365.78 a month for one vCPU. Regulated workloads needing fixed IPs or private networking should verify those features first. Teams dominated by a few large customers should model per-customer cost separately: one customer sending 50 million requests a month changes the ranking for the whole account.

> [!WARNING]

> Do not choose a serverless container platform on the free tier alone. The free tier ends at 180,000 vCPU-seconds on Cloud Run under request-based billing and 180,000 on Container Apps, and App Runner has none at all. A service that costs nothing in its first month can cost $45 or more in its second. Model the second month, not the first.

Execution checklist: price your own workload before you commit

1. Record one week of real traffic: total requests, average duration, peak concurrent requests, and the 95th-percentile latency your users accept.

2. Convert the week to instance-seconds at your measured concurrency, then multiply by 4.33 for the month.

3. Price the same instance-seconds on all three platforms using the rates above, including free tiers, the $0.40 per million request fee, and the always-on floor.

4. Add the charges the rate tables omit: App Runner's automated-deployment and build fees (amounts not printed on its pricing page), plus data transfer, logging, and any load balancer in front of the container.

5. Deploy the same image to two platforms for one week, compare the invoices against the model, and keep the platform whose invoice matches its promise.

6. Set billing alerts at 50 and 100 percent of expected spend on day one, and cap maximum instances or replicas so a spike or retry storm cannot multiply the bill overnight.

7. Re-price every quarter: this ranking is a snapshot of prices published on 6 November 2026.

Use our free pricing calculator to sanity-check the monthly totals from your own request counts.

Verdict

There is no cheapest serverless container platform, only a cheapest platform for a given traffic shape. Under one million requests a month, Cloud Run and Container Apps are effectively free and App Runner is not. At ten million, Cloud Run's instance-based billing leads at $38.78. At one hundred million, App Runner leads at $365.78. Match the model to the traffic, then verify with a week of real invoices.