Gemini's free tier, measured: 20 requests a day, and Google no longer publishes the number

Shawn Yang — Wed, 02 Sep 2026 11:58:34 +0000

If you want to know how many requests the Gemini free tier gives you, you can no longer look it up. Google pulled the RPM/RPD tables out of its docs and left one sentence: check Google AI Studio for your own.

So we measured every model with a key created that morning. Numbers and method below.

The numbers

Measured 2026-09-02, on a Google account, project and API key all created that day, with no billing attached:

Model	RPM	RPD
`gemini-3.7-flash`	5	20
`gemini-3.6-flash`	5	20
`gemini-3.5-flash`	5	20
`gemini-3-flash-preview`	5	20
`gemini-3.5-flash-lite`	15	500
`gemini-3.1-flash-lite`	15	500
`gemini-embedding-2`	100	1000

Two caveats belong with those figures. Quota is counted per project, not per key — minting extra keys in the same project buys you nothing. And RPD resets at midnight Pacific, not at your local midnight.

Google stopped publishing them

This is not a case of the table being hard to find. The Gemini rate-limits page now contains zero occurrences of the phrase "free tier". Its only tables are spend-based rate limits, the qualification thresholds for each paid tier, and batch quotas for Tiers 1 through 3. There is no free-tier table at all.

The prose says limits "can be viewed in Google AI Studio" and that "specified rate limits are not guaranteed". The individual model pages carry no RPM or RPD either.

The third-party articles that still quote figures are mostly copies of an older revision of that page. They disagree with each other, and none of them cover the 3.x models currently on sale, so republishing one amounts to inventing a vendor's numbers.

You don't have to count — the 429 tells you

The obvious way to measure a rate limit is to hammer the endpoint until it fails and count what got through. That only ever gives you a lower bound: concurrency, retries and window boundaries all cost you a few requests, and you never learn how many.

You don't need to. When Gemini rejects you, the 429 body contains the limit itself. The error's details array carries a google.rpc.QuotaFailure, and each violation names the quota and its value:

{
  "quotaMetric": "generativelanguage.googleapis.com/generate_content_free_tier_requests",
  "quotaId": "GenerateRequestsPerDayPerProjectPerModel-FreeTier",
  "quotaDimensions": { "model": "gemini-3.5-flash", "location": "global" },
  "quotaValue": "20"
}

Trip the limit once and Google hands you the answer. Every figure in the table above was read out this way rather than counted, which makes each one the limit rather than an observed floor — a distinction worth caring about if you plan to design around the number.

Three quota ids are worth knowing:

GenerateRequestsPerMinutePerProjectPerModel-FreeTier → RPM
GenerateRequestsPerDayPerProjectPerModel-FreeTier → RPD
EmbedContentRequestsPerDayPerUserPerProjectPerModel-FreeTier → embeddings

Note the extra PerUser in the last one. Embeddings are metered on a different basis from text generation.

The 2.5 models are closed to new signups

Something else fell out of the run. gemini-2.5-pro, gemini-2.5-flash and gemini-2.5-flash-lite all return 404 to a freshly created key, with the message that the model "is no longer available to new users". We reproduced it from Singapore and Tokyo.

Google's pricing page still lists all three as free of charge.

Vendor documentation can lag the vendor's own API. That is worth remembering if you maintain any kind of comparison table: what a page says is available is not the same as what a key can actually reach. It caught us too — our own free-tier listing was serving three entries no new reader could open, and this run is how we found out.

There is a knock-on effect. Free Google Search grounding — 500 requests a day, shared — is attached to exactly two models, gemini-2.5-flash and gemini-2.5-flash-lite. On every 3.x model the free-tier column reads "Not available". So new signups cannot get free grounding at all any more. The allowance did not shrink; the route to it closed.

3.7 Flash works, but you'll wait

The newest model, gemini-3.7-flash, is genuinely usable on the free tier — it just queues badly. Issued one at a time, requests came back in 27 to 148 seconds. Under concurrency, latency rose monotonically with queue depth: we logged 27, 71, 132, 141, 178, 171, 174, 270 and 354 seconds, and one request was still unanswered when a 500-second timeout fired.

That is not a rate limit and will never appear in an RPM or RPD figure, but it shapes what the model is good for far more directly.

A methodological aside, because it nearly cost us the finding: our first probes used 30- and 45-second timeouts. All four failed, from two continents, while countTokens on the same model answered in 0.2s — and we were about to write the model up as gated on the free tier. A timeout is not evidence of absence. Four probes that share one too-short budget are one probe, not four. Give an endpoint an absurd budget once before you declare it dead.

What 20 requests a day actually buys

Note that this is 20 requests per day, not per minute.

A single agent run with tool calls will make a dozen or more round trips, so the Flash free allowance covers roughly one or two complete agent tasks a day. Any batch script, or any automation you wire into a pipeline, hits the wall on its first run.

Flash-Lite is meaningfully more generous and remains fine for classification, extraction and tagging work, and 1000 embedding calls a day is enough to index a personal project. What has effectively gone away is running a real workload on free Flash.

Check it yourself

These numbers can change at any time, and Google explicitly does not guarantee them. Reproducing the measurement takes one command: grab a key, fire a dozen requests at one model as fast as you can, and read the first 429.

for i in $(seq 1 12); do
  curl -s -X POST \
    "https://generativelanguage.googleapis.com/v1beta/models/gemini-3.5-flash:generateContent" \
    -H "x-goog-api-key: $KEY" -H "content-type: application/json" \
    -d '{"contents":[{"parts":[{"text":"hi"}]}],
         "generationConfig":{"maxOutputTokens":8}}' &
done; wait

Whatever quotaValue comes back is your project's real limit.

For RPD, keep sending just under the RPM figure until the day's allowance runs out — and use a throwaway key, because that project is finished for the day once you do.

We keep these figures, alongside other providers' free allowances, on a free-tier comparison page that is recollected daily, and mirror the underlying dataset to a public repo under CC BY 4.0 if you'd rather diff the raw JSON.

If you want the other fields worth checking before you commit to a provider, there's a ten-minute checklist.

DEV Community: Shawn Yang