The Cloud Run free tier, explained: what is free, how far it goes, what ends it

The Cloud Run free tier is $4.32 of CPU and $0.90 of memory a month at Tier 1 prices, plus 2 million requests on request-based services, for each billing account and with no end date. At 1 vCPU and 512 MiB it covers 1.8 million requests of 100 ms or 180,000 of one second. Every project on the account shares it, and it never stops a bill.

In short

• The free tier is $4.32 of CPU, $0.90 of memory and 2 million requests a month per billing account; the four lists of seconds on the pricing page are that money in different units, never to be added.
• At 1 vCPU and 512 MiB with no overlap it covers 1.8 million requests of 100 ms or 180,000 of 1 second; in a Tier 2 region the $4.32 buys 128,571 vCPU-seconds, not 180,000.
• One minimum instance's idle time costs $9.63 a month, more than the whole free tier; one instance-based instance kept up all month costs $44.71 after it.
• Cloud SQL has no free tier, and the $300 Free Trial for 90 days is a different offer.

Prices are Google's list prices for Tier 1 regions, read on October 11, 2026.

What is free

Every month, every Cloud Run billing account gets this much at no charge, by Google's pricing page:

• Services on request-based billing, the default: 180,000 vCPU-seconds, 360,000 GiB-seconds of memory and 2 million requests.
• Services on instance-based billing: 240,000 vCPU-seconds and 450,000 GiB-seconds. There is no request charge on this setting, so there is no request allowance either.
• Jobs: 240,000 vCPU-seconds and 450,000 GiB-seconds.
• Worker pools: 384,204 vCPU-seconds and 728,744 GiB-seconds.

A vCPU-second is one virtual CPU busy for one second; a GiB-second is one gibibyte of memory held for one second, or 512 MiB held for two. A service with 1 vCPU and 512 MiB that is billed for one second uses one vCPU-second and half a GiB-second.

Two sentences on the pricing page matter more than the numbers. The free tier "is aggregated across projects by billing account and resets every month", which says who shares it. And it "is applied as a spending based discount using Tier 1 pricing", which says it is money, not seconds.

The Free Tier is also a program with rules of its own. Google's free features page says it needs a billing account, that it has no end date, and that Google may change or remove the limits with 30 days' notice. An account with a negotiated pricing contract is not eligible, apart from a few products the page names. So "free forever" means "free until announced otherwise".

Same money, different seconds

Price each allowance at its own list price and they all come to the same two amounts. 180,000 vCPU-seconds at the request-based price of $0.000024 is $4.32. 240,000 at the instance-based price of $0.000018 is $4.32. 384,204 at the worker pool price of $0.000011244 is $4.32 too. Memory comes to $0.90 every time. The 2 million requests are worth $0.80 at $0.40 a million.

So the real free tier is $4.32 of CPU and $0.90 of memory a month, plus 2 million requests on request-based services. The lists of seconds are that money divided by each kind's price. Three things follow.

Do not add the lists. A request-based service and an instance-based service do not get 420,000 vCPU-seconds between them. Watch for "2 million requests, 240,000 vCPU-seconds and 450,000 GiB-seconds" in one sentence: it mixes the request allowance of one billing mode with the seconds of the other.

One pool or several? Google does not say in words whether services, jobs and worker pools draw on one $4.32 or on one each. Every list is priced to the same dollars and the whole thing is described as one spending based discount, which reads like one pool. Plan as if it is one. If it turns out to be one each, the bill comes in lower than planned, not higher.

In a Tier 2 region the same money buys fewer seconds. The discount is fixed at Tier 1 prices, and Tier 2 regions such as London, Frankfurt, Zurich or Singapore charge more per second: $0.0000336 per request-based vCPU-second instead of $0.000024. The $4.32 then covers 128,571 vCPU-seconds, not 180,000, and the $0.90 covers 257,143 GiB-seconds. The guide on choosing a Cloud Run region has the full price difference between the tiers.

One more kind is listed: delayed jobs, which have lower prices of their own, get 342,857 vCPU-seconds and 642,857 GiB-seconds. Same $4.32 and $0.90 again.

How far it goes

On request-based billing, an instance is billed only while it starts, shuts down or handles at least one request, in steps of 100 ms; nothing is billed between requests, unless you asked for minimum instances (below). The request-based or instance-based billing guide draws this timeline in detail.

Take the most common size for a small web app, 1 vCPU and 512 MiB, and requests that do not overlap. Every billed second uses one vCPU-second of the 180,000 and half a GiB-second of the 360,000. CPU runs out first: at 512 MiB the memory pool would last 720,000 seconds. So the number of requests a month that cost nothing depends almost entirely on how long a request takes:

• 100 ms each: 1.8 million requests. The 2 million request allowance is not reached; CPU ends first.
• 200 ms: 900,000.
• 500 ms: 360,000.
• 1 second: 180,000.
• 2 seconds: 90,000.

Three things move these numbers.

Overlap stretches them. An instance is billed for the time it has at least one request in flight, so two requests running at once on one instance cost one billed second, not two. A web handler that mostly waits on a database, with concurrency 80, bills far fewer seconds than requests times duration; the guide on concurrency on Cloud Run measures this.

Short requests round up. A lone 30 ms request, with nothing else in flight, is billed as 100 ms. A service that answers health pings or webhooks one at a time pays for more time than it uses.

More memory per CPU flips which pool ends first. The request-based allowance has exactly 2 GiB-seconds for every vCPU-second. Up to 2 GiB per vCPU, CPU runs out first. Above that, memory does: 1 vCPU with 4 GiB lasts 90,000 seconds on the memory pool.

Also worth knowing: requests that Cloud Run refuses because IAM denies them are not billed, by the pricing page. A private service hammered by anonymous scanners does not spend its request allowance on them.

What the bill looks like as traffic grows

The free tier is a flat amount taken off the top, so the bill of a growing app has a floor at zero and then climbs at the list price. For one service on 1 vCPU and 512 MiB with 200 ms requests in a Tier 1 region:

• Up to 900,000 requests a month: $0. At list price they would cost $4.91.
• 1 million: $0.48.
• 2 million: $5.28.
• 3 million: $10.48. In a Tier 2 region the same traffic costs $16.39 after the free tier.
• 5 million: $21.23, against $27.25 at list price.

Once every allowance is used (here from 3.6 million requests, when memory runs out too), the gap between the two lines stops growing: $4.32 of CPU, $0.90 of memory and $0.80 of requests, $6.02 in all. That is the honest size of the Cloud Run free tier for a busy app. For a quiet app it is the whole bill.

Google's own pricing examples agree. Example 1, 10 million requests of 400 ms with concurrency 20 in Belgium, costs $13.69 a month and $18.91 without the CPU and memory free tier: $5.22 apart, $4.32 plus $0.90. Examples 3, 4 and 6 differ by the same $5.22. Example 2 differs by $4.77, and the job in example 5 and the worker pool in example 6 do not reproduce from the price table on the same page (it gives $0.83 and $31.17 for them; the page says $0.45 and $16.83 before the free tier). For your own numbers use the table.

The free trial is a different thing

New accounts meet two offers with "free" in the name, and they are easy to mix up.

The Free Trial is $300 of credit for 90 days, for people who have never paid for Google Cloud, Google Maps Platform or Firebase. It sits on a Free Trial billing account, and when the 90 days pass or the $300 is spent, an account that was not upgraded to a paid one is closed and its resources are stopped.

The Free Tier is what this guide is about. It runs during the trial, keeps running after you upgrade, and has no end date. Usage inside it costs nothing on any account in good standing. Usage beyond it is paid from the trial credit while there is credit, and by card after that.

So an app that fits in the free tier does not need the trial at all, but it does need a billing account: the free features page says the Free Tier is only available through one. The guide on setting up a Google Cloud project for a small team covers the billing account, the trial's limits and what happens to resources when it ends.

What else around Cloud Run is free

Most products a Cloud Run app leans on have monthly allowances of their own, nearly all per billing account:

• Cloud Build: 2,500 build-minutes a month on the default e2-standard-2 machine. Google calls this a promotional tier that may change. A source deploy (gcloud run deploy --source .) builds here.
• Artifact Registry: 0.5 GB of stored images, for total usage across all the projects on the account. Cloud Run's pricing page warns that source deploys can cost money through this line even when Cloud Run itself is inside its free tier, because every deploy stores another image. Buildpacks or a Dockerfile prices both and shows a cleanup policy.
• Secret Manager: 6 active secret versions, 10,000 access operations and 3 rotation notifications.
• Cloud Scheduler: 3 jobs. Google's own example: five projects with two jobs each get 3 free jobs and pay for 7.
• Cloud Tasks: 1 million operations.
• Egress: 1 GiB a month of data sent to the internet within North America. Exodus team: on our bill, egress from Belgium to European users was charged from the first gigabyte.
• Cloud Storage: 5 GB-months of storage, 5,000 class A and 50,000 class B operations a month. The free features page limits all of it to us-east1, us-west1 and us-central1. Exodus team: on our bill the operations allowance also applied in Europe; plan by the page.

Two are per project instead: Cloud Logging gives each project its first 50 GiB of logs a month, and Firestore gives each project 1 GiB of storage and 50,000 reads, 20,000 writes and 20,000 deletes a day.

One thing is missing from the list. Cloud SQL has no free tier. Its pricing page offers only the $300 trial credit. For most small apps the database is the first line of the bill that is never zero; what Cloud Run costs prices a small app line by line, the database included.

What uses it up

Most surprises with the free tier come from one of these.

Other projects on the same account. The pool belongs to the billing account, and the first usage in the month spends it, whichever project that is. A staging copy, a teammate's experiment, an old prototype that still gets bot traffic: each takes from the same $4.32. Exodus team: our account carries four projects that share one free tier. To see which projects share yours:

gcloud billing projects describe PROJECT_ID --format='value(billingAccountName)'
gcloud billing projects list --billing-account=BILLING_ACCOUNT_ID --format='value(projectId)'

The second command takes the ID without billingAccounts/.

Minimum instances. On request-based billing an instance that waits for requests is free, unless it is a minimum instance, which is kept warm and billed at an idle rate of $0.0000025 per vCPU-second and per GiB-second. Take 300,000 requests of 200 ms a month on 1 vCPU and 512 MiB, which cost $0, and add one minimum instance. Its idle time, most of a 730-hour month, costs $9.63 at that rate, more than the whole free tier. The pricing page does not say whether the free tier covers idle time; if it does, the service costs $5.93, if not, $9.63. Either way it is out of the free tier; min instances and startup CPU boost weighs that cost against a cold start.

Instance-based billing. An instance-based service pays for every second the instance lives, busy or idle, with a minimum of one minute. One instance kept up all month at 1 vCPU and 512 MiB costs $49.93 at list price and $44.71 after the free tier. The free tier covers about three days of it.

Builds and images. Source deploys use Cloud Build minutes and leave images in Artifact Registry. The registry's 0.5 GB is shared by the whole account, which is two images of 250 MB; every deploy after that adds to the bill unless something deletes old images.

GPUs. The free tier is CPU and memory only. Google's example 3, a GPU service at $822.40 a month, saves the same $5.22 from the free tier as a tiny one does.

And one thing the free tier never does: it does not stop spending. Usage beyond it is billed at list price, without warning, unless you set a budget. Google's spend cap budgets can pause new Cloud Run usage in one project when a monthly amount is reached; the project setup guide sets one up. Mind how a cap counts: by Google's page it uses "gross, estimated" costs at list price, which "don't include savings and credits". Cloud Run's free tier reaches the bill as a credit, so a cap counts free usage too. A $5 cap on the service in the chart above pauses it at about 920,000 to 990,000 requests in a month (depending on whether the free requests count), while its real bill is still under $0.50. Set the cap above the gross cost you expect, not the net.

How to see how much you have used

There are three places to look.

Per service, from Cloud Monitoring. Google exposes the billed time of every Cloud Run service as the Cloud Monitoring metric container/billable_instance_time, under run.googleapis.com. The sum over a period, multiplied by the service's vCPUs, is the vCPU-seconds it took from the free tier. The command that reads it, with the access token kept out of the command line, is in request-based or instance-based billing. For a month, change 1 day ago to 30 days ago and 86400s to 2592000s in it.

Exodus team: for the service behind the staged Exodus site, 1 vCPU, this printed 110.8 seconds for the 30 days to October 11, 2026. That is 0.06% of the 180,000. The instance was up for much longer than that; request-based billing counts only the time it handled requests.

For the whole account, from the billing export. Cloud Billing can export every cost line to BigQuery. Once it is on, you can ask how much of the pool is gone this month. The export is set up in the console, as budget alerts and the billing export shows; if you enable it for the first time into an EU or US multi-region dataset, it also brings back data from the start of the previous month. Find the table name with bq ls PROJECT_ID:DATASET, put it into this query and save it as free-tier.sql:

WITH m AS (
  SELECT
    -SUM((SELECT SUM(c.amount) FROM UNNEST(credits) c
          WHERE c.name = 'CPU Allocation Time')) AS cpu,
    -SUM((SELECT SUM(c.amount) FROM UNNEST(credits) c
          WHERE c.name = 'Memory Allocation Time')) AS mem,
    SUM(IF(sku.description = 'Requests', usage.amount, 0)) AS req
  FROM `PROJECT_ID.DATASET.gcp_billing_export_v1_XXXXXX_XXXXXX_XXXXXX`
  WHERE service.description = 'Cloud Run'
    AND invoice.month = FORMAT_DATE('%Y%m', CURRENT_DATE())
)
SELECT 'CPU, USD' AS pool, ROUND(cpu, 2) AS used, 4.32 AS free,
       ROUND(100 * cpu / 4.32) AS pct FROM m
UNION ALL
SELECT 'Memory, USD', ROUND(mem, 2), 0.90, ROUND(100 * mem / 0.90) FROM m
UNION ALL
SELECT 'Requests', req, 2000000, ROUND(100 * req / 2000000) FROM m

Then run it from a project where you may run BigQuery jobs:

bq query --nouse_legacy_sql --format=pretty < free-tier.sql

On our account it printed 20% of the CPU pool, 5% of memory and 13% of requests used from October 1 to 11, 2026, for four projects together. Amounts are in the account's currency; ours is US dollars.

Google's export documentation says free tier usage appears as credits of type FREE_TIER. On our account Cloud Run's arrives differently: the CPU and memory lines carry their full list cost and a credit of type DISCOUNT, named "CPU Allocation Time" or "Memory Allocation Time" (the console's reports call that type "Spending-based discounts"). Free requests carry no credit; they are priced $0 below 2 million. That is why the query matches credit names and counts requests. If your export shows other names, list them first with SELECT DISTINCT c.type, c.name over UNNEST(credits) c. The export lags; ours ran about three and a half hours behind.

In the console, the cost breakdown report under Billing shows the month's credits by type. It needs no setup, and it covers the account, not one service.

Last, check the two settings that decide most of the free tier for a small service. In the terminal above, minScale: '0' means no minimum instances, so nothing is billed while the service waits, and cpu-throttling: 'true' means request-based billing:

gcloud run services describe SERVICE --region REGION \
    --format='yaml(spec.template.metadata.annotations)' \
    | grep -E 'minScale|cpu-throttling'

Where Exodus comes in

Exodus prices an audited app at Google's list prices for the region and takes the free tier off. Its cost report says that there is one free tier per billing account and that it counts all of it for this app. If the app will share an account with a staging copy or other apps, the real bill is that much higher.

FAQ

Is the Cloud Run free tier per project or per billing account?

Per billing account. Google's pricing page says the free tier is aggregated across projects by billing account and resets every month. Every project linked to the account draws from the same pool, and the first usage of the month spends it, whichever project that is. Cloud Logging and Firestore are the exceptions that count per project.

Does the Cloud Run free tier expire?

No. The Free Tier has no end date, needs a billing account, and Google may change or remove its limits with 30 days' notice. It is a different offer from the Free Trial, which is $300 of credit for 90 days. An account with a negotiated pricing contract is not eligible.

Does a spend cap stop Cloud Run at the free tier?

No. The free tier does nothing to stop spending; usage beyond it is billed at list price. A spend cap budget can pause new Cloud Run usage in one project, but it counts gross costs at list price, free usage included, so set it above the gross cost you expect, not the net.

Do minimum instances fit in the Cloud Run free tier?

Usually not. A minimum instance is billed at an idle rate of $0.0000025 per vCPU-second and per GiB-second, and one at 1 vCPU and 512 MiB costs $9.63 a month for its idle time, more than the whole free tier. The pricing page does not say whether the free tier covers idle time.

Does Cloud SQL have a free tier?

No. Cloud SQL's pricing page offers only the $300 Free Trial credit, so for most small apps the database is the first line of the bill that is never zero. Firestore, by contrast, gives each project 1 GiB of storage and 50,000 reads, 20,000 writes and 20,000 deletes a day.