Fix Gemini 3.6 Flash 429 Errors in Python
ResourceExhausted: 429. The pipeline stalls, your async tasks pile up, and the retry loop you slapped together with time.sleep(2) is somehow making things worse, not better.
If you're building anything serious on top of Gemini 3.6 Flash — a scraping pipeline, a multi-agent workflow, a bulk summarization job — you will hit this wall. It's not a bug on your end. It's Google's API gateway telling you that you've crossed a quota boundary, and it's doing so in the least helpful way possible: a generic exception with almost no actionable guidance.
This guide fixes that. We'll go from "what does this error even mean" to a production-grade retry and throttling system using tenacity and aiolimiter, plus a fallback strategy for when quota exhaustion isn't temporary.
1. Anatomy of the 429 Resource Exhausted Error
Here's what actually shows up in your console when the google-genai SDK hits a wall:
google.genai.errors.ClientError: 429 Resource has been exhausted (e.g. check quota).
Quota exceeded for quota metric 'GenerateContent requests' and limit
'Requests per minute' of model 'gemini-3.6-flash'If you're still on the legacy google.generativeai package, the same failure surfaces as google.api_core.exceptions.ResourceExhausted instead. Same root cause, different wrapper.
Here's what Gemini 3.6 Flash's quota actually looks like across tiers, straight from the official rate-limits documentation:
| Quota Metric | Free Tier | Pay-as-you-go Tier | Why It Matters |
|---|---|---|---|
| RPM (Requests/Min) | 15 | 1,000–2,000 | Hit this in bursty loops or fast for loops with no delay |
| TPM (Tokens/Min) | 1,000,000 | 4,000,000+ | Long documents or large batch prompts burn this fast |
| RPD (Requests/Day) | 1,500 | Effectively unlimited | Silent killer for daily cron jobs that run hourly |
Notice that RPM is almost always the first ceiling you hit — not TPM. A tight while loop firing requests with no throttling will exhaust 15 RPM in under four seconds.
2. The Wrong Way vs. The Production Way
The instinctive fix is a fixed delay: catch the exception, time.sleep(2), try again. It "works" in a single-threaded script. It falls apart the moment you introduce concurrency.
Here's why: if 20 async tasks all get rejected at the exact same millisecond, and they all sleep for exactly 2 seconds, they all wake up together and slam the API in unison. This is the classic Thundering Herd Problem.
| Approach | Retry Timing | Concurrency Safe? | Production Ready? |
|---|---|---|---|
time.sleep(2) loop |
Fixed interval | ❌ No — collisions occur | ❌ No |
| Exponential backoff (no jitter) | Doubling delay, synchronized | ⚠️ Partial | ⚠️ Risky at scale |
| Full Jitter Exponential Backoff | Randomized growing window | ✅ Yes | ✅ Yes |
The fix Google and AWS both recommend is Full Jitter Exponential Backoff: delay = random(0, min(cap, base * 2^attempt)). Each failed request waits a randomized amount of time within an expanding ceiling, spreading retries naturally across the timeline.
You don't need to hand-roll this math. tenacity implements it cleanly out of the box:
import logging
from google import genai
from google.genai import errors
from tenacity import (
retry,
retry_if_exception_type,
stop_after_attempt,
wait_random_exponential,
before_sleep_log,
)
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger("gemini_client")
client = genai.Client(api_key="YOUR_API_KEY")
# Fast-fail non-retryable errors (400, 401)
def is_rate_limit_error(exc: BaseException) -> bool:
return isinstance(exc, errors.ClientError) and getattr(exc, "code", None) == 429
@retry(
retry=retry_if_exception_type(errors.ClientError),
wait=wait_random_exponential(min=2, max=60), # full jitter, 2s -> 60s ceiling
stop=stop_after_attempt(5), # give up after 5 tries
before_sleep=before_sleep_log(logger, logging.WARNING),
)
def generate_with_retry(prompt: str) -> str:
response = client.models.generate_content(
model="gemini-3.6-flash",
contents=prompt,
)
return response.text
if __name__ == "__main__":
result = generate_with_retry("Summarize the Q3 earnings report in 3 bullets.")
print(result)Fifteen minutes of setup eliminates the entire class of "one bad burst crashes the job" failures. But retrying after a 429 is still reactive. The real production fix is preventing the burst entirely.
3. Pre-Emptive Throttling with asyncio and aiolimiter
Retrying is damage control. Rate limiting is prevention. If your pipeline never exceeds 14 requests per minute in the first place, you never trigger a 429, eliminating wasted round-trip latency on rejected calls.
For bulk workloads — such as processing 500 documents — teams switching to proactive throttling typically observe 2–3x higher effective throughput.
Batch Prompts (500)
│
▼
[AsyncLimiter: Max 14 req/60s] ──► (Guards RPM Ceiling)
│
▼
[Semaphore: Max 5 Concurrent] ──► (Guards TPM / Gateway In-Flight)
│
▼
Call Gemini 3.6 Flash
├── [Success] ──► Store Output
└── [429 Error] ──► Tenacity Full-Jitter Retry ──► Re-enter Execution
Below is the complete async implementation combining aiolimiter for pacing and a Semaphore for concurrency control:
import asyncio
from aiolimiter import AsyncLimiter
from google import genai
from google.genai import errors
from tenacity import retry, retry_if_exception_type, wait_random_exponential, stop_after_attempt
client = genai.Client(api_key="YOUR_API_KEY")
# Set to 14 instead of 15 to account for clock drift
rate_limiter = AsyncLimiter(max_rate=14, time_period=60)
# Protects against TPM spikes and gateway connection exhaustion
concurrency_gate = asyncio.Semaphore(5)
@retry(
retry=retry_if_exception_type(errors.ClientError),
wait=wait_random_exponential(min=2, max=60),
stop=stop_after_attempt(4),
)
async def safe_generate(prompt: str) -> str:
async with rate_limiter:
async with concurrency_gate:
response = await client.aio.models.generate_content(
model="gemini-3.6-flash",
contents=prompt,
)
return response.text
async def run_batch(prompts: list[str]) -> list[str]:
tasks = [safe_generate(p) for p in prompts]
# return_exceptions=True prevents one failed prompt from crashing the batch
return await asyncio.gather(*tasks, return_exceptions=True)
async def main():
prompts = [f"Summarize document #{i}" for i in range(500)]
results = await run_batch(prompts)
failures = [r for r in results if isinstance(r, Exception)]
print(f"Completed: {len(results) - len(failures)} / {len(results)}")
if __name__ == "__main__":
asyncio.run(main())This layered defense creates an ultra-resilient pipeline: AsyncLimiter prevents quota spikes upfront, while tenacity handles unavoidable network fluctuations.
If you haven't initialized your SDK environment yet, check out our guide on setting up the Google GenAI SDK v1.0 client in Python for detailed setup and API key best practices.
4. Production Resilience: Fallback and Quota Upgrades
Sometimes 429 errors stem from hard daily quota limits (RPD) rather than momentary bursts. For mission-critical workflows, implement a Graceful Degradation route to fail over to a backup key or alternative model:
async def generate_with_fallback(prompt: str) -> str:
try:
return await safe_generate(prompt)
except errors.ClientError as exc:
if getattr(exc, "code", None) == 429:
# Primary quota exhausted — route to backup client / secondary project
return await backup_client_generate(prompt)
raiseIf Token-per-Minute (TPM) limits are your primary issue, prompt optimization will yield better results than retry logic alone. Refer to our guide on token cost optimization strategies for the Gemini API to implement context caching and compact payloads.
- Wrap API calls in a
tenacitydecorator with full-jitter exponential backoff to eliminate synchronized herd storms. - Incorporate
AsyncLimiterandasyncio.Semaphoreto enforce rate limits before sending requests. - Configure fallback failover logic for daily quota exhaustion and file quota requests before launch.
Encountering a specific bottleneck in your pipeline? Leave a comment below with your setup details!
Specializing in production LLM orchestration, async backend architectures, and API resilience engineering.
댓글
댓글 쓰기