The Gemini API has a free tier and three paid tiers (Tier 1, 2, 3). Limits are measured in requests per minute (RPM), input tokens per minute (TPM) and requests per day (RPD), and exceeding just one of them is enough to get an error. As of 13 November 2026 four facts change decisions. The limits apply per project, not per key. The limits page does not publish the numbers for the generation models: it points to AI Studio and warns that they are not guaranteed (the only numeric tables concern two specific models, Gemini Omni Flash and Gemini Decision 1). The spend limit over ten minutes is 10 dollars on Tier 1 and 200 on Tier 2 and Tier 3. And on data the terms distinguish free and paid services, but with a clause for those in the European Economic Area (EEA), in Switzerland or in the United Kingdom: for them the data-use rules of the paid services also apply to the free ones.
Series "Google Gemini for Developers", article 5 of 6. Prerequisite: the key and the Interactions API (article 2). I am not affiliated with Google and I am not a legal consultant: where I touch the law I report what the official texts say and point out the questions to ask, I do not give answers. I used no key: the calculation listing was run, and it calls no service.
What the limits say, and what they do not
The three dimensions are evaluated together: if your limit is 20 requests per minute, the twenty-first gives an error even with tokens to spare. Daily quotas reset at midnight, Pacific time, which in Italy falls at 9 in the morning (at 8 in the few weeks when the United States and Europe change the clocks on different dates: calculation done with the time-zone database). There are other limits: images per minute for models that generate images, tokens per day for some models, limits specific to tools. Grounding with Google Search on Gemini 3 models and later has a default cap of 1,500 requests per day per project on the Gemini Developer API. Experimental and preview models have tighter limits.
The sentence to remember is this one, from the page: "Specified rate limits are not guaranteed and actual capacity may vary". You cannot build a service agreement with your customers on a number the supplier does not guarantee, nor write it into the code: it has to be read from AI Studio for your project. Instead, design for the case in which a 429 arrives: retry with growing wait and a bit of randomness, a request queue, and a degraded path that does not break the application.
"""Retry with growing wait and randomness after a 429. The call is fake: it stands in for the
API, which is never reached here. In production 'sleeps' is time.sleep."""
import random
class Exhausted(Exception):
"""Stands in for the 429 RESOURCE_EXHAUSTED error."""
def with_backoff(call, attempts=5, base=1.0, cap=60.0, seed=7, sleeps=lambda seconds: None):
chance = random.Random(seed) # fixed seed: the output is reproducible
for n in range(attempts):
try:
return call(n)
except Exhausted:
if n == attempts - 1:
raise # attempts used up: the caller decides
wait = min(cap, base * 2 ** n) + chance.uniform(0, 1)
print(f"attempt {n + 1}: 429, waiting {wait:.2f} s")
sleeps(wait)
def api_that_gives_way_twice(n):
if n < 2:
raise Exhausted()
return "response"
def api_always_exhausted(n):
raise Exhausted()
print("outcome:", with_backoff(api_that_gives_way_twice))
try:
with_backoff(api_always_exhausted)
except Exhausted:
print("outcome: degraded path (cached response, queue or message to the user)")
# Output (run twice, identical output):
# attempt 1: 429, waiting 1.32 s
# attempt 2: 429, waiting 2.15 s
# outcome: response
# attempt 1: 429, waiting 1.32 s
# attempt 2: 429, waiting 2.15 s
# attempt 3: 429, waiting 4.65 s
# attempt 4: 429, waiting 8.07 s
# outcome: degraded path (cached response, queue or message to the user)
The function with_backoff doubles the wait at every 429 (1, 2, 4, 8 seconds, up to a cap of 60) and adds a random number between 0 and 1: without that margin, a hundred clients blocked at the same instant all retry at the same instant. The fixed seed serves only to make the output reproducible; in production you remove it. When the attempts run out, the function re-raises the exception and does not decide for you: the choice between a cached response, a message to the user or a queue belongs to the caller, and it is the "degraded path" mentioned above. Do not retry forever: whoever has reached the monthly spend cap is not unblocked by waiting.
Tiers and spend thresholds
| Tier | Requirement | Monthly cap of the tier | Spend every 10 minutes |
|---|---|---|---|
| Free | Active project or free trial | n/a | n/a |
| Tier 1 | Active linked billing | 250 dollars | 10 dollars |
| Tier 2 | 100 dollars paid and 3 days since the first successful payment | 2,000 dollars | 200 dollars |
| Tier 3 | 1,000 dollars paid and 30 days since the first successful payment | from 20,000 to over 100,000 dollars | 200 dollars |
Two clarifications on the table, from the Rate limits and Billing pages. The cap is monthly and applies to the billing account, summing all linked projects: once the cap is reached, the service stops for everyone until the first of the following month. Qualification for tiers 2 and 3 depends on the cumulative Google Cloud spend of the linked account; meeting the requirements is "usually sufficient", but in rare cases an upgrade can be denied. From Free to Tier 1 the move is normally immediate, the later ones within ten minutes. In addition, AI Studio is moving accounts from postpaid to prepaid billing, with credits of at least 5 dollars.
"""Three calculations on the Gemini API limits. The numbers in (1) and (2) are those of the Rate limits and
Billing pages (2026-11-13); those in (3) are MY EXAMPLES: the page does not publish RPM, TPM and RPD of the text models."""
from collections import deque
from datetime import date, timedelta
# --- 1) The spend limit on a rolling 10-minute window, and the tier's monthly cap
WINDOW_S = 600
SPEND_10_MIN = {1: 10.0, 2: 200.0, 3: 200.0} # dollars, Rate limits: Spend-based rate limits
MONTHLY_CAP = {1: 250.0, 2: 2_000.0, 3: 20_000.0} # Billing: Tier 3 goes from 20,000 to 100,000+, here the minimum
COST_PER_REQUEST = 2.097152 # Argon ($2/M until 30 Nov 2026), 1,048,576 input tokens, no cache
def simulate_spend(tier, every_s, duration_s):
"""The model rejects (429) the request that would take the spend of the last 600 s over the limit.
It is my own assumption about the semantics: the page only says 'rolling 10-minute window'."""
recent, accepted, rejected = deque(), 0, 0
for t in range(0, duration_s, every_s):
while recent and recent[0][0] <= t - WINDOW_S:
recent.popleft()
if sum(c for _, c in recent) + COST_PER_REQUEST <= SPEND_10_MIN[tier]:
recent.append((t, COST_PER_REQUEST))
accepted += 1
else:
rejected += 1
return accepted, rejected
for tier in (1, 2, 3):
a, r = simulate_spend(tier, 30, 1_800) # one request every 30 s for half an hour = 60 requests
print(f"Tier {tier}: of 60 full requests in 30 minutes, accepted {a}, rejected {r}; "
f"monthly cap = {int(MONTHLY_CAP[tier] // COST_PER_REQUEST)} full requests")
# --- 2) The calendar: from when are you on Tier 3?
def first_day_tier3(payments):
"""payments = [(date, dollars)]. Tier 3: $1,000 paid and 30 days from the first successful payment."""
ordered = sorted(payments)
first = ordered[0][0]
cumulative = 0
for day, amount in ordered:
cumulative += amount
if cumulative >= 1_000:
return max(day, first + timedelta(days=30))
return None
payments = [(date(2026, 12, 1), 100), (date(2026, 12, 5), 900)]
d = first_day_tier3(payments)
print("Tier 3 not before", d, f"({(d - payments[0][0]).days} days after the first payment)")
assert d == date(2026, 12, 31) # second calculation: 1 December + 30 days, by hand
# --- 3) Three dimensions together, with EXAMPLE limits (not Google's)
RPM, TPM, RPD = 10, 250_000, 250
def trial(requests, tokens_per_request):
last_minute, minute_tokens, today = deque(), 0, 0
for n in range(1, requests + 1):
if len(last_minute) + 1 > RPM:
return n, "RPM"
if minute_tokens + tokens_per_request > TPM:
return n, "TPM"
if today + 1 > RPD:
return n, "RPD"
last_minute.append(tokens_per_request)
minute_tokens += tokens_per_request
today += 1
return None, None
print("12 requests of 30,000 tokens in one minute: first rejection =", trial(12, 30_000))
print("12 requests of 5,000 tokens in one minute: first rejection =", trial(12, 5_000))
# Output (run twice, identical output):
# Tier 1: of 60 full requests in 30 minutes, accepted 12, rejected 48; monthly cap = 119 full requests
# Tier 2: of 60 full requests in 30 minutes, accepted 60, rejected 0; monthly cap = 953 full requests
# Tier 3: of 60 full requests in 30 minutes, accepted 60, rejected 0; monthly cap = 9536 full requests
# Tier 3 not before 2026-12-31 (30 days after the first payment)
# 12 requests of 30,000 tokens in one minute: first rejection = (9, 'TPM')
# 12 requests of 5,000 tokens in one minute: first rejection = (11, 'RPM')
The listing does three calculations. The first applies the ten-minute spend limit to requests that fill the Argon window (2.10 dollars each, article 4): on Tier 1 four go through every ten minutes, and out of sixty requests in half an hour 12 are accepted; on Tiers 2 and 3 all go through. For the monthly cap, 119 full requests remain on Tier 1. The documentation does not give the exact semantics of the window, and the model rejects the request that would take the sum over the limit: it is my own assumption. The second calculation is the calendar: with a first payment on 1 December, Tier 3 does not arrive before 31 December, even if the 1,000 dollars are already paid on the 5th. The third shows which limit triggers first; the values (10 RPM, 250,000 TPM, 250 RPD) are my own examples, because the page does not publish those of the text models.
The least obvious consequence is about time: you cannot buy capacity in a day. If a platform estimates 5,000 dollars of consumption per month at full speed (assumption), the Tier 1 cap is 250 and the Tier 2 cap is 2,000: only Tier 3 covers it, and you get there after at least thirty days from the first payment. Whoever notices on launch day finds out from a page of errors. For each project you can also set a monthly spend cap in AI Studio, but the page declares it experimental and warns of possible overruns for about ten minutes.
Data: what the terms say today
The additional terms of the Gemini API (in force since 23 March 2026) distinguish unpaid services from paid services. The API is a paid service only if the call goes through a Cloud project with active billing; AI Studio is one if the account has access to a project with active billing or is a Workspace enterprise account. The main rules, as the texts state them:
- Unpaid services. Google uses the submitted content and the responses to provide, improve and develop products and machine-learning technologies; human reviewers may read and annotate inputs and outputs, after disconnecting them from account, key and project. The terms say: "Do not submit sensitive, confidential, or personal information to the Unpaid Services".
- Paid services. Google does not use prompts and responses to improve products and processes them under the data processing addendum in which Google is a processor (data processor). It logs prompts and responses for a limited period, to detect and prevent violations of the usage policy, for the security of the service and for any communications required by law; the abuse monitoring page says fifty-five days.
- In the EEA, Switzerland and the United Kingdom. For those who are there, the data-use rules of the paid services also apply to the free ones. And to make an application available to users in those areas, the terms allow only paid services.
- Conversations on the server. The Interactions API keeps interactions by default: 1 day on the free tier, 55 in paid projects, reducible to 7, 14, 28 or 55 days;
store=falseavoids them. - Grounding with Google Search. Google keeps prompts, context and outputs for 30 days to build the results and for debugging.
The five rules are not alternatives: they add up. The point that surprises is the third, and it has to be read next to a page that seems to say something else: the billing FAQ confirms that the free tier is available in the EEA. The two things do not contradict each other. You can use the free tier to try things out, and for your data the terms of the paid services apply; but a product that European users actually use must sit on a paid project. What I have not verified: the text of the data processing addendum, where processing and storage really happen (the terms speak of "any country in which Google or its agents maintain facilities") and the safeguards for transfers to third countries. The GDPR (art. 28) requires that processing on behalf of the controller be governed by a contract or another legal act; whether the addendum is enough for your case is decided by whoever answers for the processing, not by the programmer.
Classify before choosing
| What kind of data it is | What to do |
|---|---|
| Invented, test, or public | Fine at any tier |
| Yours, not sensitive (code you could publish) | Fine; on the free tier know how the terms treat the content |
| Confidential company data (trade secrets, contracts) | Only on a paid project, with an explicit decision by the company |
| Personal data of third parties | Only paid, with a legal basis, notice and agreement; minimise and consider store=false |
| Special categories (health, etc.) and minors | First an impact assessment and legal advice: art. 9 of the GDPR generally prohibits the processing of data concerning health |
The table is a working criterion of mine, to put in the project README, not an opinion. It has one purpose: to move the decision about data before the code, when it costs a meeting, instead of after, when it costs a report. For health data, art. 9, paragraph 1, of the GDPR says that the processing of "data concerning health" is prohibited, save for the exceptions of paragraph 2.
Four scenarios, with the constraint written down
These are scenarios built by me with declared assumptions; none is a real case. In each one the limit is not capacity but what can be sent.
Law firm: the summary of a case file
By hand today. A trainee summarises for the partner a 300-page case file, hours of work (assumption). What changes. With the large window (article 4) the file fits in one request, about 135,000 estimated tokens, 0.20 dollars of input with Hydrogen; the model produces a chronology with page citations. What goes wrong. The file contains data of the client and of the counterparty, covered by professional secrecy: the free tier is excluded, and even on a paid tier the decision belongs to the firm, not to the programmer. Anonymising the names before sending is the minimum measure, with the map of pseudonyms on the firm's server. Every date and every citation is checked against the document.
Medical practice: visit notes
By hand today. A family doctor spends ten minutes per patient transcribing notes (assumption). What changes. A model would tidy dictated notes into a structured note. What goes wrong. These are health data (art. 9 GDPR) and, at the same time, the terms say that you may not use the services "in clinical practice, to provide medical advice". A transcription of clinical notes seems to fall within the clinical use that the text prohibits; whether you really fall within it is established by whoever answers for compliance. The prudent road is not to do it with this service.
School: marking essays
By hand today. A teacher marks 25 essays a week. What changes. A model proposes remarks on structure and clarity, which the teacher reviews. With an essay of 1,000 tokens in and 300 out the cost is 0.0019 dollars with 3.8 Flash and 0.0038 with Hydrogen. What goes wrong. The essays are by minors and contain name, opinions, sometimes family situations. The terms say to be at least 18 years old and not to use the service in an application directed at minors or likely to be used by minors; what this means for a tool used by the teacher alone I do not know. It remains in any case a decision for the school as controller, not for the individual teacher with a personal account. The mark is the teacher's.
Retail: analysing reviews
By hand today. A shop with three outlets reads public reviews by hand to understand recurring faults. What changes. The public text, with the author's name removed, is classified by theme with a cheap model. What goes wrong. Here the sensitivity of the data is low. The risk is commercial: a count of themes does not measure representativeness, and whoever changes a product on 40 reviews is deciding on a sample.
What you can do now
You can read the limits for what they are: three dimensions evaluated together, per project, with no guaranteed numbers. You can build the calendar of a launch starting from the monthly cap and from the thirty days of Tier 3, and predict with a simulator where a spend 429 triggers. You can tell what the terms say for free services and for paid ones, and you know that for those in the EEA the distinction narrows. In article 4 you have the costs of a full request; article 6 applies the same criteria to terminal assistants.
What I did not verify
- The numeric limits of the text models (RPM, TPM, RPD): the page does not publish them.
- The text of the data processing addendum and the safeguards for non-EU transfers: not read.
- The exact semantics of the ten-minute window of the spend limit: the simulator uses an assumption of mine.
- The concrete application of the prohibitions on clinical use and on minors to the four scenarios: it is a question for a lawyer.
These are four points that only the supplier or a professional can close. The first is read in AI Studio for your project; the other three are asked for in writing before writing the code, and the answer is kept together with the project README.
Frequently asked questions
Where do I find the request limits of each model?
Not on the documentation's rate-limits page, which as of 13 November 2026 does not publish the numbers of the generation models (only two specific models have a table) and points to AI Studio, adding that limits are not guaranteed and actual capacity may vary.
How long does it take to reach Tier 3?
According to the table: 1,000 dollars paid and 30 days from the first successful payment. Tier 2 requires 100 dollars and 3 days. Anyone planning a high-traffic launch must plan it more than a month ahead.
Can I use the free tier with customer data?
The terms say not to send sensitive, confidential or personal information to unpaid services, and to use paid services for applications aimed at users in the EEA, Switzerland or the United Kingdom. For customer data choose a paid project.
The same series also includes the models and prices (article 1) and the function calling loop (article 3).
Sources
- Rate limits - RPM, TPM, RPD, per-project limits, table of tiers, spend limits over ten minutes, batch job limits, consulted on 2026-11-13
- Billing - monthly spend caps per tier, prepaid billing, per-project caps, frequently asked questions, consulted on 2026-11-13
- Gemini API Additional Terms of Service - unpaid and paid services, clause for the EEA, Switzerland and the United Kingdom, age limits, clinical use, 30 days for grounding (in force since 23 March 2026), consulted on 2026-11-13
- Abuse monitoring - 55-day retention of prompts and outputs for abuse detection, consulted on 2026-11-13
- Interactions API - retention of interactions (1 day and 55 days) and
store=false, consulted on 2026-11-13 - Regulation (EU) 2016/679 (General Data Protection Regulation, GDPR) - article 9, paragraph 1, and article 28, paragraph 3, consulted on 2026-11-13
Commenti
Caricamento commenti...
Sign in to comment