# What Cloud Run costs at 100 thousand, 1 million, 10 million and 100 million requests a month

> One web app priced line by line at 100 thousand to 100 million requests a month: Cloud Run, database, egress, logs, images, every assumption written down, and how to check the prices yourself.

Published 2026-10-11 · Updated 2026-10-12 · [By Exodus team](https://exodus.elim.io/about) · Pricing
<https://exodus.elim.io/blog/cloud-run-costs-worked-examples-by-traffic>

One web app with a Postgres database costs $9.72 a month on Cloud Run at 100 thousand requests, $12.51 at 1 million, $83.02 at 10 million and $578.00 at 100 million, with the database, egress, logs and images included. The Cloud Run line itself is $0.00, $0.09, $23.98 and $145.96: the database is most of a small bill, egress most of a large one.

## In short

- Billed time is the time an instance has at least one request in flight; at 10 million requests a month it is half of requests times duration.
- For a small app the database is the bill: $9.37 of a $9.72 total at 100,000 requests, $9.37 of $12.51 at a million.
- At 10 million requests the bill is $83.02, and egress is the largest line.
- At 100 million it is $578.00, more than half of it egress; instance-based billing is $70 cheaper there, and for this app the two settings cross near 26 million requests a month.

Prices are Google's list prices for `europe-west1` (Belgium), a Tier 1 region, read on October 11, 2026.

## The app in every example

The app is a typical API or server-rendered site with a Postgres database. Each example is the whole bill, and every assumption is written down, so you can swap in your own. The same assumptions hold at every level, so the only thing that changes is traffic:

- **One Cloud Run service** on request-based billing, the default, with 1 vCPU, 512 MiB of memory and the default concurrency of 80 requests per instance.
- **200 ms per request**, of which 40 ms is the CPU working and the rest is waiting for the database.
- **30 KiB per response** on average, HTML or JSON plus whatever static files the app serves itself.
- **A daily curve.** 80% of the day's requests arrive between 08:00 and 20:00, rising to a peak at 14:00 and falling again; the other 20% are spread evenly over 24 hours. Every day of the month looks the same.
- **No minimum instances**, so the service scales to zero when nobody calls it. The cost of keeping one instance warm is given separately for each level.
- **One Cloud SQL for PostgreSQL instance**, sized for the traffic, plus 1 GiB of images in Artifact Registry.
- **Nothing else on the billing account**, so this app gets the whole free tier.

A month is 730 hours. Tax, support plans and any committed use discount are left out until the last example.

## How traffic becomes a bill

Request-based billing charges for the seconds an instance is handling at least one request, rounded up to the nearest 100 ms, plus a fee per request. An idle instance between requests costs nothing unless it is a minimum instance.

The words "at least one" carry the whole calculation. If two requests overlap on the same instance, that second of instance time is billed once, not twice. So the billed time is not simply requests multiplied by duration. It is that product reduced by how much the requests overlap, and the overlap grows with traffic.

![A diagram: requests a month, time per request and overlap give billed instance-seconds, which are priced per vCPU-second and GiB-second; requests add $0.40 per million; the free tier comes off](https://exodus.elim.io/media/v2026-09-16/t/exodus/assets/image-c441ab7f2978445525f06d13ac60fab05016418fccc7de456ea4c7d9e06ebffd-680x430-svg/bytes "Three facts about your app decide the billed seconds; the price list does the rest. Prices of October 11, 2026, europe-west1")

The prices, from Google's pricing page: $0.000024 per vCPU-second and $0.0000025 per GiB-second while an instance is active, and $0.40 per million requests. Every month each billing account also gets a free allowance, applied as a discount in money: $4.32 of CPU, $0.90 of memory and the first 2 million requests. The guide on [the Cloud Run free tier](https://exodus.elim.io/blog/the-cloud-run-free-tier-explained) covers the lists of seconds and who shares it, and [what Cloud Run costs](https://exodus.elim.io/blog/what-cloud-run-costs) explains each price line.

How much do requests overlap? When requests arrive at random, which is what independent users do, the share of time an instance has at least one request in flight is 1 - e^(-L), where L is the average number of requests in flight on that instance: requests per second times the time per request. At 1 request per second of 200 ms, L is 0.2 and the instance is busy 18% of the time, a little less than the 20% you get by multiplying. At 13 requests per second, L is 2.6 and the instance is busy 93% of the time, far less than the 260% that multiplying gives.

We wrote the model as a short program. For each minute of the day it takes the request rate from the curve, works out how many instances Cloud Run would run (Google's autoscaling page: average CPU and concurrency kept near a 60% target, rounded up to a whole instance), and applies the formula to each. A request-by-request simulation of every level agrees with it within 1%. Every number below comes from that program.

## 100,000 requests a month

This is about 3,300 requests a day: a side project, an internal tool for a team of twenty, a small business site with a contact form, the admin panel of a larger product. At the busiest minute of the afternoon it handles one request every eight seconds.

- **Cloud Run.** Requests hardly ever overlap at this rate, so the billed time is nearly the product: 19,828 instance-seconds, against 20,000 if none overlapped. At list prices that is $0.48 of CPU, $0.02 of memory and $0.04 of requests, $0.54 in all, and the free tier covers every cent. **$0.00.**
- **Cloud SQL.** The smallest instance, `db-f1-micro` with a shared vCPU and 0.6 GiB of memory, is $0.0105 an hour: $7.67 a month. 10 GiB of SSD storage at $0.17 per GiB adds $1.70. **$9.37.**
- **Egress.** 100,000 responses of 30 KiB are 2.9 GiB. Cloud Run bills data sent to users in Europe or North America on its own price line, $0.105 per GiB for the first 10 TiB a month; the $0.12 on the network pricing page is the price for virtual machines, and the [egress guide](https://exodus.elim.io/blog/egress-on-google-cloud-explained) explains the difference. **$0.30.**
- **Logs.** Cloud Run writes a log entry for every request on its own. Cloud Run has no switch for it; a log exclusion in Cloud Logging can drop them. Our own entries average about 1.06 KB, so this is 0.1 GiB, far inside the 50 GiB per project that Cloud Logging stores for free each month. **$0.00.**
- **Images.** 1 GiB of container images in Artifact Registry, of which 0.5 GiB is free and the rest costs $0.10 per GiB a month. **$0.05.**

**Total: $9.72 a month**, and $9.37 of it is the database. At this size the database is the bill. A serverless Postgres with a free plan outside Google, or no database at all, takes this app to cents.

Two warnings. First, `db-f1-micro` and `db-g1-small` are shared-core machines, and Google's Cloud SQL pricing page says they are not covered by the Cloud SQL SLA. Fine for a side project, a risk for anything people pay for. Second, there are cold starts. With no minimum instances, a request after a quiet spell waits for a new instance to start. Keeping one instance warm costs its idle time at $0.0000025 per vCPU-second and per GiB-second, which is $9.78 a month here: more than the whole compute bill, about the same as the database.

## 1 million requests a month

About 33,000 requests a day, at most 1.3 a second at the peak: a small SaaS with a few hundred active customers, a marketing site with a busy blog, the API of a mobile app with a few thousand users.

- **Cloud Run.** Requests now overlap a little. The billed time is 183,813 instance-seconds, 8% less than the 200,000 the product gives. At list prices that is $4.41 of CPU, $0.23 of memory and $0.40 of requests, $5.04 in all. The free tier covers the memory and the requests in full and $4.32 of the CPU. **$0.09.**
- **Cloud SQL.** Still `db-f1-micro` with 10 GiB. A real product of this size would usually take `db-g1-small` with 1.7 GiB of memory at $0.035 an hour; [the smallest Cloud SQL instances](https://exodus.elim.io/blog/cloud-sql-smallest-instances-and-what-they-cost) compares them. **$9.37.**
- **Egress.** 28.6 GiB. **$3.00.**
- **Logs.** 1.0 GiB. **$0.00.**
- **Images.** **$0.05.**

**Total: $12.51 a month.** Ten times the traffic has added $2.79, and most of that is egress, not Cloud Run. This is the range where request-based billing pays off most, because the app is idle most of the month and idle time costs nothing. If the same app kept one instance always on under instance-based billing, Cloud Run alone would be $44.71 after the free tier, and the total $57.13.

One warm minimum instance would add $9.17 here, a little less than at 100,000 requests, because more of its time is now ordinary busy time.

## 10 million requests a month

About 330,000 requests a day, 3.8 a second on average and 13 at the afternoon peak. One instance still handles all of it: at the peak its CPU is about 52% busy, below the 60% target, so the autoscaler sees no reason to add a second. The table below has all four levels side by side.

![A table of the monthly bill at four levels of traffic: Cloud Run, Cloud SQL, egress, logs and images; totals $9.72, $12.51, $83.02 and $578.00](https://exodus.elim.io/media/v2026-09-16/t/exodus/assets/image-a6008a2a3f8ea85e2880421437cef0c327593cb490f8d5fe1b009bc20f787dc7-680x460-svg/bytes "The whole monthly bill of one app at four levels of traffic. The total takes the cheaper billing setting. List prices of October 11, 2026, europe-west1")

- **Cloud Run.** Overlap now halves the bill. The one instance has a request in flight 39% of the month, and the billed time is 1,029,844 instance-seconds, about half of the 2 million the product gives. At list prices that is $24.72 of CPU, $1.29 of memory and $4.00 of requests, $30.00 in all; the free tier takes $6.02 off it. **$23.98.**
- **Cloud SQL.** `db-g1-small` with 20 GiB: $25.55 for the instance and $3.40 for storage. **$28.95.**
- **Egress.** 286 GiB. **$30.04.**
- **Logs.** 9.9 GiB, still inside the free 50 GiB. **$0.00.**
- **Images.** **$0.05.**

**Total: $83.02 a month.** Cloud Run is now 29% of the bill and egress is the largest single line. A warm minimum instance costs $5.99 here. Instance-based billing would cost $44.71 for Cloud Run, almost twice the request-based $23.98, because the instance is still idle 61% of the month.

Had every request been billed on its own, requests times duration would give 2 million seconds and a Cloud Run bill of $48.48, twice the real one. That product is an upper bound, and from about a million requests a month on it is a loose one. Google's own first pricing example shows the same thing from the other side. It prices 10 million requests of 400 ms with up to 20 requests per instance at $18.91 before the free tier. Take the request fee out and the remaining $14.91 pays for about 590,000 instance-seconds, so the calculator assumed that about 6.8 requests share each billed second on average. Our app overlaps less, about 1.9, because its requests are half as long and spread over more of the day. Neither figure is yours until you measure it.

## 100 million requests a month

About 3.3 million requests a day, 38 a second on average and 129 at the peak. This is a busy product: a popular API, a consumer app with a large audience. Here the CPU sets the number of instances. At the peak the requests need about 5.2 vCPUs of work, and at a 60% target that is 9 instances; at night 1 is enough.

- **Cloud Run, request-based.** The instances are busy 91% of the time they exist, so overlap no longer saves much: 7,208,408 billed instance-seconds against 7,957,000 seconds of instances existing. At list prices that is $173.00 of CPU, $9.01 of memory and $40.00 of requests. After the free tier, **$215.99.**
- **Cloud Run, instance-based.** Every second an instance exists is billed, at the lower rate of $0.000018 per vCPU-second and $0.000002 per GiB-second, with no fee per request. $151.18 at list price, **$145.96** after the free tier. At this level instance-based billing is $70 a month cheaper, so the total uses it.
- **Cloud SQL.** A dedicated-core instance with 2 vCPUs and 7.5 GiB of memory: 2 x $0.0413 + 7.5 x $0.007 an hour is $98.62 a month, plus $8.50 for 50 GiB of storage. **$107.12.**
- **Egress.** 2,861 GiB. The first 10,240 GiB cost $0.105 each and the rest $0.08. **$300.41.**
- **Logs.** 98.9 GiB of request logs, 48.9 GiB over the free 50 at $0.50 per GiB. **$24.45.**
- **Images.** **$0.05.**

**Total: $578.00 a month** with instance-based billing, $648.03 with request-based. Egress is now more than half of the bill, which is the usual shape for a busy app on any cloud that charges for data out. Serving static files from Cloud Storage behind Cloud CDN, compressing responses and caching in the browser all cut it; they also have their own prices, which this example does not include.

The request fee of $40.00 is now nearly a fifth of the request-based Cloud Run bill, which is one reason instance-based billing wins. And committed use discounts become worth a look. The pricing page lists a Cloud Run commitment that takes request-based prices down to $0.00001992 per vCPU-second, 17% off, and compute flexible commitments that take instance-based CPU to $0.00001296 for one year or $0.00000972 for three. A commitment is a promise to pay for a level of use whether you reach it or not, so it belongs to apps whose traffic floor you know.

## Where the two settings cross

The examples give one point each. The chart below runs the same model across the whole range, for Cloud Run alone after the free tier.

![A line chart of the Cloud Run bill against requests a month: request-based rises from $0 to $215.99, instance-based is flat at $44.71 up to 10 million then rises to $145.96; they cross near 26 million](https://exodus.elim.io/media/v2026-09-16/t/exodus/assets/image-6ea24f6941bcf414cbc3dde3a988109f678f555efebe10fa08d01dcfc737442c-680x340-svg/bytes "Cloud Run alone for the example app, after the free tier. Request-based billing is cheaper below about 26 million requests a month. List prices of October 11, 2026")

For this app, request-based billing is cheaper below about 26 million requests a month and instance-based above it. At the crossing, the instances are busy about 65% of the time they exist. The guide on [request-based or instance-based billing](https://exodus.elim.io/blog/request-based-or-instance-based-billing) finds the same 65-70% from the other direction, for a single instance. The busy share is the number to watch, not the request count: an app with longer requests or a flatter day reaches 65% at lower traffic, and an app with short requests and a sharp peak reaches it later.

Below 10 million requests instance-based billing stays at $44.71 because one instance never gets to stop: an idle instance is kept for up to 15 minutes (Google's container contract), and here a request arrives every few minutes even at night. That trade is right only if the app needs a CPU between requests, and for an app that keeps a CPU busy all month, [Cloud Run or a VPS](https://exodus.elim.io/blog/cloud-run-or-a-vps) prices the same work on a server.

## What the examples leave out

The model is honest about its assumptions, and these are the ones most likely to differ for you:

- **Region.** In Tier 2 regions such as London, Frankfurt or Singapore, Cloud Run costs about 1.4 times as much per second. The guide on [choosing a Cloud Run region](https://exodus.elim.io/blog/choosing-a-cloud-run-region) has the prices.
- **Requests under 100 ms.** Billing rounds up to the nearest 100 ms. A fast endpoint answering in 10 ms, on a quiet service, is billed as if it took ten times as long. Our own service shows it below.
- **CPU-heavy requests.** If a request spends 200 ms of CPU rather than 40, the autoscaler adds instances much sooner, overlap per instance drops, and the bill grows close to requests times duration. The guide on [concurrency on Cloud Run](https://exodus.elim.io/blog/concurrency-on-cloud-run) shows what a server that handles one request at a time does to the same numbers.
- **Memory.** A Rails or Django app with 2 GiB pays four times as much for memory as this one, still less than its CPU line.
- **Database backups and high availability.** Cloud SQL backups cost $0.08 per GiB a month for the space they use, and a high-availability instance costs twice the zonal price.
- **Bots and errors.** A crawler is traffic like any other. Requests that IAM refuses before they reach your container are not billed, but a public service accepts every request and bills it.

## Measure your own numbers

Three of the four inputs come from your traffic: how many requests, how long each takes, and how big each response is. If your app is already on Cloud Run, its request logs have all three. This command reads the last 7 days of a service's request logs and prints them:

```shell
gcloud logging read \
  'resource.type="cloud_run_revision" AND resource.labels.service_name="SERVICE" AND httpRequest.latency:*' \
  --freshness=7d --limit=100000 \
  --format='value(httpRequest.latency,httpRequest.responseSize)' |
  awk -F'\t' '{n++; t+=$1; b+=$2} END {printf "requests in 7 days  %d\nrequests a month    %d\nmean request time   %.3f s\nmean response       %.1f KiB\n", n, n*730/168, t/n, b/n/1024}'
```

It reads logs and changes nothing. `--limit` stops it at 100,000 entries, which is plenty for a small service; a busier one should read the request count from Cloud Monitoring instead. On another platform, the same three numbers are in its access log or its metrics page: count the requests, average the response time, average the bytes sent.

![A terminal: the request logs of our service give 1,002 requests in 7 days, 0.011 s per request and 9.2 KiB per response; the Catalog API lists the request-based prices](https://exodus.elim.io/media/v2026-09-16/t/exodus/assets/image-25049f0391358f51b4d8aff4dc5eccbeb4379e824f29116ba1be37d347015d80-680x380-svg/bytes "Our own service's inputs from its request logs, and the current prices from Google's Catalog API. Run October 11, 2026")

Exodus team: on the staged copy of this site (Cloud Run, 1 vCPU, 128 MiB) it shows 1,002 requests in 7 days, 0.011 s per request and 9.2 KiB per response. Cloud Monitoring counted 990 requests in the same 7 days and 111.8 billed instance-seconds: 0.113 s per request, ten times the request time. That is the 100 ms rounding plus the time instances spend starting, both billed. For a quiet service with fast requests, plan on at least 0.1 s per request. Even so, at about 4,300 requests a month this service costs about 1.4 cents a month at list price, inside the free tier.

The fourth input, overlap, is the one you cannot read from a log line. Take it from the model above for a first estimate, or deploy and read Cloud Run's own billed time a week later; [request-based or instance-based billing](https://exodus.elim.io/blog/request-based-or-instance-based-billing) has the Cloud Monitoring query for it.

## Check the prices yourself

Prices change, and every number above carries the date it was read. Google publishes its price list as an API, the Cloud Billing Catalog API, and reading it needs only an access token. Cloud Run's service ID in the catalog is `152E-C115-5142`. This prints Cloud Run's request-based prices:

```shell
(umask 077; gcloud auth print-access-token | sed 's/^/Authorization: Bearer /' > token)
curl -s -H @token \
  "https://cloudbilling.googleapis.com/v1/services/152E-C115-5142/skus?pageSize=5000" |
  jq -r '.skus[] | select(.description | test("Request-based|^Requests$")) |
    select(.description | test("Tier 2") | not) |
    (.description | sub("Services "; "") | sub(" \\(Request-based billing\\)"; "")) as $d |
    .pricingInfo[0].pricingExpression | .usageUnit as $u | .tieredRates[] |
    [$d, $u, .startUsageAmount, (.unitPrice.units | tonumber) + .unitPrice.nanos / 1e9] | @tsv' |
  awk -F'\t' '{printf "%-20s %-7s from %-8s $%.7f\n", $1, $2, $3, $4}'
rm token
```

The token goes through a file only you can read, so it stays out of your shell history. The output matches the pricing page as read on October 11, 2026. Requests have a price tier that is free up to 2 million; CPU and memory have one price from zero, because their free tier is applied later as money. The same API, with Cloud SQL's service ID, gave the database prices above. Google's pricing calculator does the same arithmetic in a browser, with an overlap assumption of its own.

## Where Exodus comes in

Exodus does this arithmetic for a real repository: the report puts what the app costs today next to the same lines on Cloud Run, with the assumptions written out. When Cloud Run costs more, as it can for a busy app with heavy egress or a steady CPU-bound worker, the report says so.

## FAQ

### Is Cloud Run free for a small app?

Its compute often is. At 100,000 requests a month the example app's Cloud Run line is $0.54 at list prices, and the free tier covers all of it. The rest of the bill is not free: the smallest Cloud SQL instance with 10 GiB of storage is $9.37 a month.

### When is instance-based billing cheaper than request-based?

For the example app, above about 26 million requests a month, when instances are busy about 65% of the time they exist. At 100 million requests instance-based billing is $145.96 after the free tier against $215.99 request-based. The busy share is the number to watch, not the request count.

### How much does a warm minimum instance add?

For the example app, $9.78 a month at 100,000 requests, $9.17 at 1 million and $5.99 at 10 million, at the idle rate of $0.0000025 per vCPU-second and per GiB-second. It costs less as traffic grows because more of its time becomes ordinary busy time.

### Why is a Cloud Run bill lower than requests times duration?

Request-based billing charges an instance's seconds once, however many requests overlap in them. At 10 million requests a month the example app is billed 1,029,844 instance-seconds against the 2 million that requests times duration gives. Billing also rounds up to 100 ms, so very fast requests are billed for more than their duration.

### What is the largest cost for a busy Cloud Run app?

Egress, in this example. At 100 million requests a month of 30 KiB each, 2,861 GiB sent to users costs $300.41, more than half of the $578.00 total. Serving static files from Cloud Storage behind Cloud CDN, compressing responses and caching in the browser all cut it.

## Sources

1. [Cloud Run pricing, Google (request-based and instance-based prices, idle minimum instance price, $0.40 per million requests, free tier aggregated by billing account and applied as a spending based discount at Tier 1 prices, billing rounded up to 100 ms, egress at Premium Tier with 1 GiB free within North America, same-region traffic free, committed use discount prices, pricing example 1; read Oct 11, 2026)](https://cloud.google.com/run/pricing)
2. [Billing settings for services, Cloud Run, Google (request-based billing charges while requests are processed, instance-based billing for the whole life of the instance; read Oct 11, 2026)](https://docs.cloud.google.com/run/docs/configuring/billing-settings)
3. [Container runtime contract, Cloud Run, Google (an idle instance is not kept for longer than 15 minutes unless it is a minimum instance; read Oct 11, 2026)](https://docs.cloud.google.com/run/docs/container-contract)
4. [About instance autoscaling in Cloud Run services, Google (CPU and concurrency drivers, default 60% targets, rounding up to the next whole instance; read Oct 11, 2026)](https://docs.cloud.google.com/run/docs/about-instance-autoscaling)
5. [Maximum concurrent requests for services, Cloud Run, Google (default concurrency; read Oct 11, 2026)](https://docs.cloud.google.com/run/docs/about-concurrency)
6. [Network pricing, Google Cloud (the price for virtual machines and load balancers, Premium Tier to Europe and North America: $0.12 per GiB to 1,024 GiB, $0.11 to 10,240 GiB a month; read Oct 11, 2026)](https://cloud.google.com/vpc/network-pricing)
7. [Cloud SQL pricing, Google (db-f1-micro $0.0105 an hour, db-g1-small $0.035, Enterprise edition $0.0413 per vCPU-hour and $0.007 per GiB-hour, SSD storage, backups, shared-core instances outside the SLA; read Oct 11, 2026)](https://cloud.google.com/sql/pricing)
8. [Google Cloud Observability pricing, Google (Logging $0.50 per GiB, first 50 GiB per project per month; read Oct 11, 2026)](https://cloud.google.com/products/observability/pricing)
9. [Artifact Registry pricing, Google (0.5 GiB-month free, then $0.10 per GiB-month; read Oct 11, 2026)](https://cloud.google.com/artifact-registry/pricing)
10. [Logging and viewing logs in Cloud Run, Google (request logs are created automatically; control their volume with log exclusions; read Oct 11, 2026)](https://docs.cloud.google.com/run/docs/logging)
11. [Get Google Cloud pricing information with the Cloud Billing Catalog API, Google (public services, SKUs and prices; read Oct 11, 2026)](https://docs.cloud.google.com/billing/docs/how-to/get-pricing-information-api)
12. [Estimate your monthly costs, Cloud Billing, Google (the pricing calculator; read Oct 11, 2026)](https://docs.cloud.google.com/billing/docs/how-to/estimate-costs)
13. [gcloud logging read reference, Google Cloud SDK 587.0.0 (run Oct 11, 2026)](https://docs.cloud.google.com/sdk/gcloud/reference/logging/read)
14. Exodus team: Cloud Billing Catalog API read Oct 11, 2026 for Cloud Run's request-based SKUs and Cloud SQL's europe-west1 SKUs (same prices as the pricing pages) and for Cloud Run's internet egress SKU (Europe to Europe $0.105 per GiB to 10 TiB, then $0.08, as on our bill); the staged Exodus site's own service over 7 days to Oct 11, 2026 16:19 UTC (990 requests and 111.8 billable instance-seconds from Cloud Monitoring, 1,002 request log entries, about 1.06 KB each); a cost model with a discrete-event check of its billed time, kept in our research notes