Google AI Studio Rate Limits for Gemini 3, 2.5, and Gemma Models: Complete 2025 Guide

Google AI Studio enforces three distinct rate limit tiers across its model families: Gemini 3 and 2.5 series models cap daily requests at 20-500 per day with high token throughput (up to 250,000 tokens/minute), while Gemma 3 models offer significantly higher daily volumes (14,400 requests/day) but lower token throughput (15,000 tokens/minute).

The open-source repository cheahjs/free-llm-api-resources maintains programmatically extracted rate limit data for Google AI Studio's free tier, capturing the exact quotas developers must respect when building applications against the Gemini and Gemma APIs.

Gemini vs. Gemma: Rate Limit Architecture

Google AI Studio applies per-model rate limits that vary by computational cost and model generation. The limits are defined across three dimensions: token throughput per minute, daily request quota, and per-minute request capacity. According to the repository's README.md (lines 88-100), these quotas differ substantially between flagship Gemini models and open-weights Gemma variants.

Gemini 3 Series Limits

The Gemini 3 family represents Google's latest flagship models with the highest token throughput but strict request throttling:

• Gemini 3 Flash: 250,000 tokens/minute, 20 requests/day, 5 requests/minute
• Gemini 3.1 Flash-Lite: 250,000 tokens/minute, 500 requests/day, 15 requests/minute

Gemini 2.5 Series Limits

Gemini 2.5 models maintain similar token throughput but introduce specialized audio capabilities with reduced limits:

• Gemini 2.5 Flash: 250,000 tokens/minute, 20 requests/day, 5 requests/minute
• Gemini 2.5 Flash-Lite: 250,000 tokens/minute, 20 requests/day, 10 requests/minute
• Gemini 3.1 Flash TTS / Gemini 2.5 Flash TTS: 10,000 tokens/minute, 10 requests/day, 3 requests/minute

The TTS (Text-to-Speech) variants demonstrate significantly reduced throughput—only 10,000 tokens per minute—reflecting the higher computational cost of audio generation, as documented in src/pull_available_models.py around lines 423-754.

Gemma 3 Model Limits

All Gemma 3 variants (1B, 4B, 12B, and 27B Instruct) share uniform quotas, indicating they run on shared infrastructure within Google AI Studio:

• Token throughput: 15,000 tokens/minute
• Daily quota: 14,400 requests/day
• Per-minute limit: 30 requests/minute

This represents a 720x higher daily request allowance compared to standard Gemini 3 Flash models, making Gemma更适合 high-volume applications requiring lower latency.

Why Rate Limits Vary by Model Family

Compute cost drives quota allocation. Larger, newer Gemini models (Gemini 3 Flash) receive higher token-throughput limits (250,000 tokens/minute) to support complex reasoning tasks, but strict daily caps (20-500 requests) prevent service overload. Conversely, Gemma models—while smaller—prioritize volume over throughput, offering thousands of daily requests suitable for chatbot or classification workloads.

Specialized capabilities trigger stricter throttling. The TTS-focused models (Gemini 3.1 Flash TTS and Gemini 2.5 Flash TTS) reduce token throughput by 96% compared to standard Flash models because audio synthesis requires substantially more GPU resources per token processed.

Implementing Rate Limit Compliance in Python

Exceeding any quota results in HTTP 429 "Too Many Requests" responses. The following patterns demonstrate how to enforce both per-minute and daily limits when calling the Google AI Studio REST API.

REST API Wrapper with Exponential Backoff

This implementation tracks local counters aligned with the Gemini 3 Flash limits (5 requests/minute, 20/day):

import time
import requests
from urllib.parse import urljoin

BASE_URL = "https://generativelanguage.googleapis.com/v1beta/models/"
MODEL = "gemini-3-flash"
API_KEY = os.getenv("GOOGLE_API_KEY")

# Gemini 3 Flash limits

MAX_REQS_PER_MIN = 5
MAX_REQS_PER_DAY = 20

reqs_this_min = 0
reqs_today = 0
minute_start = time.time()
day_start = time.time()

def wait_for_quota():
    global reqs_this_min, reqs_today, minute_start, day_start
    now = time.time()
    
    # Reset sliding windows

    if now - minute_start > 60:
        minute_start = now
        reqs_this_min = 0
    if now - day_start > 86400:
        day_start = now
        reqs_today = 0
        
    # Enforce throttling

    if reqs_this_min >= MAX_REQS_PER_MIN:
        sleep = 60 - (now - minute_start) + 0.1
        time.sleep(sleep)
        wait_for_quota()
    if reqs_today >= MAX_REQS_PER_DAY:
        raise RuntimeError("Daily quota exhausted")

def call_gemini(prompt: str) -> dict:
    wait_for_quota()
    payload = {"contents": [{"role": "user", "parts": [{"text": prompt}]}]}
    url = urljoin(BASE_URL, f"{MODEL}:generateContent")
    
    resp = requests.post(url, json=payload, params={"key": API_KEY}, timeout=30)
    
    # Exponential backoff on 429

    retries = 0
    while resp.status_code == 429 and retries < 5:
        backoff = 2 ** retries
        time.sleep(backoff)
        resp = requests.post(url, json=payload, params={"key": API_KEY})
        retries += 1
        
    resp.raise_for_status()
    reqs_this_min += 1
    reqs_today += 1
    return resp.json()

Google Generative AI Client Library with Throttling

When using the official google-generativeai library, implement custom throttling to match Gemma's higher throughput (30 requests/minute):

import os
import time
import google.generativeai as genai

genai.configure(api_key=os.getenv("GOOGLE_API_KEY"))
model = genai.GenerativeModel("gemma-3-12b-it")

# Gemma 3 limits: 30 req/min, 14,400 req/day

MAX_REQS_PER_MIN = 30
MAX_REQS_PER_DAY = 14_400

_requests_min = 0
_requests_day = 0
_min_start = time.time()
_day_start = time.time()

def _throttle():
    global _requests_min, _requests_day, _min_start, _day_start
    now = time.time()
    
    if now - _min_start > 60:
        _min_start = now
        _requests_min = 0
    if now - _day_start > 86400:
        _day_start = now
        _requests_day = 0
    if _requests_min >= MAX_REQS_PER_MIN:
        time.sleep(60 - (now - _min_start) + 0.1)
        _throttle()
    if _requests_day >= MAX_REQS_PER_DAY:
        raise RuntimeError("Gemma daily quota exceeded")
        
    _requests_min += 1
    _requests_day += 1

def generate_gemma(prompt: str) -> str:
    _throttle()
    response = model.generate_content(prompt)
    return response.text

The official client library does not enforce rate limits automatically, making manual throttling essential to avoid service interruptions.

Source Files and Maintenance

The rate limit data originates from automated scraping of Google's public documentation via src/pull_available_models.py, which writes validated quotas to README.md. Key source locations include:

• README.md (lines 88-100): Human-readable table documenting token-per-minute, daily request, and per-minute request limits for all Gemini and Gemma variants.

• src/pull_available_models.py (lines 423-754): Python script containing the extraction logic for Gemini and Gemma rate limits, parsing the official Google AI Studio documentation to generate the repository's data structures.

• src/data.py: Central mapping of model identifiers (e.g., google/gemma-3-12b-it:free) to friendly names and limit categories used throughout the codebase.

Summary

• Gemini 3/2.5 Flash models offer high token throughput (250,000 tokens/minute) but restrict daily usage to 20-500 requests, suitable for low-volume, high-complexity tasks.
• Gemma 3 models provide uniform, generous daily quotas (14,400 requests/day) with moderate token limits (15,000 tokens/minute), optimal for high-frequency applications.
• TTS-specialized models impose strict limits (10 requests/day, 10,000 tokens/minute) due to audio generation costs.
• Always implement dual-threshold tracking (per-minute and per-day) with exponential backoff to handle HTTP 429 responses gracefully.

Frequently Asked Questions

How do Google AI Studio rate limits differ between Gemini 3 Flash and Gemma 3?

Gemini 3 Flash allows 250,000 tokens per minute but only 20 requests per day and 5 requests per minute. Gemma 3 models (all sizes) permit 14,400 requests per day and 30 requests per minute, but limit throughput to 15,000 tokens per minute. This makes Gemma更适合 applications requiring many small, frequent calls, while Gemini suits intensive, complex generation tasks.

What happens if I exceed the daily request quota in Google AI Studio?

The API returns HTTP 429 "Too Many Requests" responses for all subsequent calls until the daily window resets (based on a 24-hour sliding window). You must implement client-side tracking of request counts against the specific model's daily limit—14,400 for Gemma or 20-500 for Gemini variants—to prevent application failures.

Why do Gemini TTS models have lower token throughput than standard Flash models?

Audio synthesis requires significantly more computational resources per token than text generation. Consequently, Gemini 3.1 Flash TTS and Gemini 2.5 Flash TTS models are restricted to 10,000 tokens per minute and 10 requests per day, compared to 250,000 tokens per minute for standard Flash models.

Where can I find the most current rate limits for Google AI Studio models?

The cheahjs/free-llm-api-resources repository maintains automatically updated limits in README.md (lines 88-100), populated by the src/pull_available_models.py script which scrapes Google's official documentation daily. Always reference this repository rather than hardcoding limits, as Google periodically adjusts quotas without deprecation notices.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}