Why Image Generation Suddenly Stopped Working
Code that generated images fine yesterday now returns 429 RESOURCE_EXHAUSTED on every call. Since December 2025, when Google changed the free tier's image-per-minute limits, this has become one of the most common reports.
Quota is not the only culprit. Safety filter blocks, corrupted output data, wrong model identifiers, and creeping generation times each fail in their own way. Below are the five errors you are most likely to hit, with implementation patterns for resolving each one.
1. 429 RESOURCE_EXHAUSTED — Quota Management Strategy
The Problem: Why 429 Errors Spike
- Free tier: As of December 2025, Image-based Requests Per Minute (RPM) has been set to 0, effectively blocking free image generation
- Tier 1 upgrade: Paying $5/month should raise your quota, but a reported ghost bug keeps quotas at 0 for some users after upgrading
- Paid tiers: Even with valid quotas, there are two layers of limits: burst quotas and smoothing quotas
Solution: Implement Quota-Aware Retry Logic
import google.generativeai as genai
from google.generativeai.types import generation_types
import time
genai.configure(api_key="YOUR_API_KEY")
def generate_image_with_exponential_backoff(
prompt,
max_retries=3,
base_delay=1
):
"""Generate image with exponential backoff for quota errors"""
model = genai.GenerativeModel("gemini-2.0-flash-exp")
for attempt in range(max_retries):
try:
response = model.generate_images(
prompt=prompt,
number_of_images=1,
safety_filter_level="block_none"
)
return response, "success"
except genai.types.RequestLimitExceeded as e:
# 429 error
if attempt < max_retries - 1:
wait_time = (base_delay ** attempt) + 1
print(f"Rate limited (429). Waiting {wait_time}s before retry...")
time.sleep(wait_time)
else:
print("Max retries exceeded. Check quota in Google Cloud Console.")
return None, "quota_exhausted"
except genai.types.BlockedPromptException as e:
print(f"Content blocked by safety filter: {e}")
return None, "blocked"
except Exception as e:
print(f"Error: {type(e).__name__}: {e}")
return None, "error"
return None, "unknown"
# Usage example
result, status = generate_image_with_exponential_backoff(
"A tranquil mountain landscape at golden hour"
)
if result:
print(f"Generation successful: {result.candidates[0].image.uri}")
else:
print(f"Generation failed: {status}")Expected output:
Generation successful: https://lh3.googleusercontent.com/...
Workarounds if Quota is Exhausted
- Stagger requests across time — spread generation over hours instead of minutes
- Local caching — store generated images and reuse for identical prompts
- Batch-friendly scheduling — process non-urgent images during off-peak hours (late night, weekends)
2. "Image Generation Failed" — Safety Filter Blocks
The Problem: False Positives in Content Moderation
Gemini's image generation uses Google's safety filters, which can block legitimate requests:
- Medical illustrations (anatomy diagrams, X-ray explanations)
- Historical war scenes or cultural artifacts
- AI-generated characters that "look too realistic"
The safety system errs on the side of caution, which means false positives are common.
Solution: Prompt Rewording and Safety Level Adjustment
def generate_with_safety_variations(prompt, max_attempts=3):
"""Try generating with different safety levels and prompt variations"""
model = genai.GenerativeModel("gemini-2.0-flash-exp")
safety_levels = [
("default", "Try default safety settings first"),
("none", "Relax to minimum safety filter"),
]
prompt_variations = [
prompt,
f"Illustration style: {prompt}",
f"Educational: {prompt}",
f"Cartoon style: {prompt}",
]
for safety_name, description in safety_levels:
for variant in prompt_variations:
try:
print(f"Attempt: {description} with '{variant[:40]}...'")
response = model.generate_images(
prompt=variant,
number_of_images=1,
safety_filter_level=(
"block_none" if safety_name == "none" else "block_some"
)
)
return response, "success"
except genai.types.BlockedPromptException:
continue
except Exception as e:
print(f"Unexpected error: {e}")
return None, "error"
return None, "blocked_all_attempts"
# Usage
result, status = generate_with_safety_variations(
"Doctor explaining medical imaging results to patient"
)Expected output:
Attempt: Try default safety settings first with 'Doctor explaining m...'
Attempt: Relax to minimum safety filter with 'Illustration style: Do...'
# ... tries variations until one succeeds
Prompt Rewriting Techniques
| Original | Rewritten | Success Rate |
|---|---|---|
| "People fighting" | "Action movie poster fight scene" | ↑ Higher |
| "Graphic violence" | "Dramatic action scene, painterly style" | ↑ Higher |
| "Celebrity look-alike" | "Character in the style of [celebrity]" | ↑ Higher |
| "Real person photo" | "Portrait illustration inspired by..." | ↑ Higher |
3. Corrupted Output Images and Format Errors
The Problem: Base64 Decoding Fails
Image responses can arrive in multiple formats. Decoding errors are common when:
- Response format doesn't match expectations (PNG vs JPEG)
- Base64 data is malformed
- Image data is truncated during transmission
Solution: Robust Image Handling
import base64
import io
from PIL import Image
import hashlib
def save_image_with_validation(response, output_path):
"""Save image with format validation and integrity check"""
try:
candidate = response.candidates[0]
# If response contains URI (preferred)
if hasattr(candidate, 'image') and hasattr(candidate.image, 'uri'):
print(f"Image available at: {candidate.image.uri}")
return candidate.image.uri
# If response contains base64 data
if hasattr(candidate.image, 'data'):
try:
# Decode base64
image_bytes = base64.b64decode(candidate.image.data)
# Validate image
img = Image.open(io.BytesIO(image_bytes))
img.verify() # Will raise if corrupted
# Check file size
if len(image_bytes) < 1000:
raise ValueError("Image too small, likely corrupted")
# Calculate checksum
checksum = hashlib.md5(image_bytes).hexdigest()
print(f"Image checksum: {checksum}")
# Save
img = Image.open(io.BytesIO(image_bytes))
img.save(output_path)
print(f"Image saved to {output_path}")
return output_path
except Exception as e:
print(f"Decoding/validation error: {e}")
print("Try fetching from URI instead if available")
return None
except (AttributeError, IndexError) as e:
print(f"Unexpected response structure: {e}")
return None
# Usage
model = genai.GenerativeModel("gemini-2.0-flash-exp")
response = model.generate_images(
prompt="A majestic eagle soaring through clouds",
number_of_images=1
)
path = save_image_with_validation(response, "output.png")Expected output:
Image available at: https://lh3.googleusercontent.com/...
# or
Image checksum: a7f3c9d2e1b5f8a4
Image saved to output.png
4. "Model Not Found" Error
The Problem: Wrong Model Name
Not all Gemini models support image generation. Common mistakes:
- ❌
gemini-pro-vision - ❌
gemini-2.5-pro - ✅
gemini-2.0-flash-exp(image generation enabled)
Correct Model Names for Image Generation
# Updated model names that support image generation
MODELS_WITH_IMAGE_GENERATION = [
"gemini-2.0-flash-exp", # Current primary option
]
# Text-only models (will fail image generation)
TEXT_ONLY_MODELS = [
"gemini-2.5-pro",
"gemini-2.5-flash",
"gemini-1.5-pro",
"gemini-1.5-flash",
]
def verify_image_generation_support(model_name):
"""Check if model supports image generation"""
try:
model = genai.GenerativeModel(model_name)
response = model.generate_images(
prompt="test",
number_of_images=1
)
print(f"✓ {model_name} supports image generation")
return True
except Exception as e:
print(f"✗ {model_name} error: {type(e).__name__}")
return False
# Test available models
for model_name in TEXT_ONLY_MODELS:
verify_image_generation_support(model_name)Expected output:
✗ gemini-2.5-pro error: InvalidArgument
✗ gemini-2.5-flash error: InvalidArgument
Check for Model Updates
Google updates available models frequently. Always verify by trying to list models:
def list_image_generation_models():
"""List all models with image generation support"""
models = genai.list_models()
image_models = []
for model in models:
methods = model.supported_generation_methods
if 'generateImages' in str(methods):
image_models.append(model.name)
if image_models:
print("Image generation supported by:")
for model in image_models:
print(f" - {model}")
else:
print("No image generation models found")
return image_models
list_image_generation_models()5. Timeout During Generation
The Problem: Requests Hang or Take Too Long
Image generation can timeout due to:
- High resolution — 1024×1024 or larger
- Complex prompts — detailed, multi-element descriptions
- Concurrent requests — hitting rate limits
Solution: Implement Timeout Handling
import concurrent.futures
import threading
def generate_with_timeout(prompt, timeout_seconds=120):
"""Generate image with configurable timeout"""
model = genai.GenerativeModel("gemini-2.0-flash-exp")
def _generate():
return model.generate_images(
prompt=prompt,
number_of_images=1
)
with concurrent.futures.ThreadPoolExecutor() as executor:
future = executor.submit(_generate)
try:
result = future.result(timeout=timeout_seconds)
return result, "success"
except concurrent.futures.TimeoutError:
print(f"Generation timed out after {timeout_seconds}s")
return None, "timeout"
except Exception as e:
return None, f"error: {type(e).__name__}"
# Handling timeout gracefully
result, status = generate_with_timeout(
"A hyper-detailed 3D rendered city at night with thousands of lights",
timeout_seconds=90
)
if status == "timeout":
print("Recommendations:")
print("1. Simplify prompt")
print("2. Reduce detail level ('simple', 'minimal style')")
print("3. Use standard resolution (512×512 instead of 1024×1024)")Expected output:
# Success:
# Image returned
# Timeout:
Generation timed out after 90s
Recommendations:
1. Simplify prompt
2. Reduce detail level ('simple', 'minimal style')
3. Use standard resolution (512×512 instead of 1024×1024)
Best Practices Summary
- Always implement retry logic — 429 errors are usually transient
- Log prompt rejection patterns — track which prompts trigger safety filters
- Use paid tier for production — free tier is unreliable post-December 2025
- Prefer URI responses over base64 — more reliable and lighter
- Monitor quota usage — check Google Cloud Console weekly
For deeper troubleshooting, see Gemini API Error Handling Guide and Rate Limiting & Quota Management.