Google Gemini Token Limits: 1M Context Windows, 65K Output Caps, and API Quotas

Input Context Windows Versus Output Generation Limits

The fundamental token boundary of any large language model is its context window. Google documentation states that the context window defines the combined limit of input and output tokens across an interaction. However, the input ceiling and the output cap operate under asymmetric constraints.

On current Gemini 3 and 2.5 models, the input context window reaches 1,048,576 tokens, accommodating extensive multi-file repositories or media recordings. In contrast, completion output is restricted to 65,536 tokens. A model cannot generate a response that matches the size of its maximum input.

This asymmetry shapes software architecture:

1. Asymmetric Payloads: You can supply a 900,000-token codebase to Gemini 3.8 Flash, but the model completion output reaches a maximum ceiling of 65,536 tokens of analysis or refactored code in a single API round-trip.
2. Context Exhaustion: In a multi-turn session, output tokens from turn one become input tokens for turn two, consuming both the 1,048,576 context window and rolling TPM allowances.
3. Finish Reasons: If a generation reaches the 65,536-token ceiling before the model concludes its reasoning, the API terminates the stream with a finish_reason of MAX_TOKENS, resulting in truncated text or malformed JSON payloads.

How Multimodal Data Converts to Gemini Tokens

In Google Gemini, non-text media files are converted directly into token representations within the neural network:

• Text and Source Code: For standard English text, Google documents that one token corresponds to approximately four characters, meaning 100 tokens equals roughly 60 to 80 English words. Source code and structured JSON exhibit higher token density due to indentation and symbols.
• Images: Images with dimensions of 384 pixels or smaller consume exactly 258 tokens. Larger images are divided into standardized 768 by 768 pixel tiles, with each tile consuming 258 tokens. An architectural blueprint with complex dimensions can consume numerous token tiles.
• Video Footage: The Gemini API samples video at one frame per second during static processing, with each second converting to approximately 263 tokens. A ten-minute video consumes roughly 157,800 input tokens.
• Audio Streams: Audio tracks tokenize at 32 tokens per second, which equals 1,920 tokens for every minute of recorded speech.
• PDF Documents: Text pages parse as text tokens, while embedded charts and scanned pages convert into image tiles at 258 tokens per tile.

Free Tier Limits Versus Paid Tier Quotas

The progression from evaluation sandbox to production deployment requires transitioning across Google AI Studio usage tiers:

• Free Tier: Available immediately upon creating a project in Google AI Studio. Flash-class models carry the highest free allowances, while Pro-class reasoning models and any experimental or preview model are restricted considerably more tightly. Free Tier inputs and outputs may be reviewed by human evaluators and used to train Google models.
• Tier 1 (Pay-as-You-Go): Activated immediately upon linking a valid Google Cloud billing account. Tier 1 raises per-minute request and token allowances across every model class and carries a $250 billing tier cap with a $10 spend rate limit per rolling ten minutes. Customer data is exempt from model training.
• Tier 2: Unlocked automatically after meeting initial cumulative spending thresholds on Google Cloud services and maintaining an active account following the first successful payment.
• Tier 3: Unlocked after meeting higher cumulative spending thresholds and maintaining an established operational history, providing maximum throughput for enterprise deployments.

Moving from the Free Tier to Tier 1 raises every per-minute ceiling, but any ceiling is easily exhausted when running automated agents across large document sets, because each agent turn re-transmits the whole corpus.

Rolling Spend Limits and Batch API Enqueued Tokens

In addition to RPM and TPM limits, Google enforces rolling spend-based rate limits across rolling ten-minute windows:

• Free Tier: Not applicable (unpaid evaluation).
• Tier 1: Entry spend rate limit per rolling ten-minute window.
• Tier 2: Intermediate spend rate limit per rolling ten-minute window.
• Tier 3: Highest standard spend rate limit per rolling ten-minute window for enterprise deployments.

If your application sends rapid bursts of high-token prompts, you can trigger an HTTP 429 response from spend velocity limits even when nominal RPM and TPM metrics appear healthy.

For high-volume offline workloads, Google provides the Batch API. The Batch API processes asynchronous jobs at a discounted rate compared to standard interactive pricing without drawing down real-time TPM allocations:

• Tier 1: Enqueues millions of tokens for Flash models and Pro reasoning variants.
• Tier 2: Significantly expands active enqueued token pools for production scale.
• Tier 3: Allocates maximum enqueued capacity for high-volume enterprise pipelines.

Batch API jobs accommodate large individual input files and extensive cumulative file storage across concurrent batch requests.

Decoding HTTP 429 and RESOURCE_EXHAUSTED Errors

When an HTTP 429 occurs, the response body provides critical diagnostic details that distinguish between request count exhaustion and token volume saturation:

{
  "error": {
    "code": 429,
    "message": "Resource has been exhausted (e.g. check quota).",
    "status": "RESOURCE_EXHAUSTED",
    "details": [
      {
        "@type": "type.googleapis.com/google.rpc.QuotaFailure",
        "violations": [
          {
            "subject": "project:987654321098",
            "description": "Quota exceeded for quota metric 'Tokens per minute' and limit 'Tokens per minute per project' of service 'generativelanguage.googleapis.com'"
          }
        ]
      },
      {
        "@type": "type.googleapis.com/google.rpc.ErrorInfo",
        "reason": "RATE_LIMIT_EXHAUSTED",
        "domain": "googleapis.com",
        "metadata": {
          "consumer": "projects/987654321098",
          "quota_location": "global",
          "quota_metric": "generativelanguage.googleapis.com/generate_content_input_tokens",
          "quota_value": "1000000"
        }
      }
    ]
  }
}

In the payload above, inspecting quota_metric reveals that generate_content_input_tokens triggered the failure, and quota_value reports the exact per-minute input token ceiling that applied to the request.

Calculating Request Tokens and Implementing Exponential Backoff

To avoid unexpected 429 errors and context overflows, production applications must calculate prompt token counts before dispatching requests. In Python using the Google GenAI SDK:

import os
from google import genai

client = genai.Client(api_key=os.environ["GEMINI_API_KEY"])

prompt_text = "Analyze this quarterly report dataset..."

# count tokens prior to generation
token_count = client.models.count_tokens(
    model="gemini-3.8-flash",
    contents=prompt_text
)

print(f"Total input tokens: {token_count.total_tokens}")

if token_count.total_tokens > 950000:
    print("Warning: Approaching the per-minute token ceiling. Route to external retrieval.")

When unexpected HTTP 429 errors occur due to concurrent traffic spikes, client applications must implement exponential backoff with randomized jitter rather than retrying immediately:

import time
import random
from google.genai.errors import APIError

def execute_with_backoff(client, model, contents, max_retries=5):
    base_delay = 2.0
    for attempt in range(max_retries):
        try:
            return client.models.generate_content(
                model=model,
                contents=contents
            )
        except APIError as e:
            if e.code == 429 and attempt < max_retries - 1:
                # calculate backoff with full jitter
                sleep_time = (base_delay * (2 ** attempt)) + random.uniform(0.5, 1.5)
                time.sleep(sleep_time)
            else:
                raise e

While exponential backoff resolves transient RPM spikes, it cannot solve systemic TPM exhaustion caused by repetitive, oversized prompt payloads.

The Compounding Math of Multi-Turn Context Expansion

The primary trap of in-context document processing is multi-turn conversational expansion. In stateless API protocols, language models have no internal memory across independent calls. To maintain conversation context, client applications must append the entire conversation history, including all prior documents, instructions, and model replies, into every subsequent request.

Consider an autonomous document review assistant examining a 250,000-token legal agreement across four conversational turns:

• Turn 1: Client submits instructions (2,000 tokens), the document (250,000 tokens), and question 1 (500 tokens). Gemini processes 252,500 input tokens and generates 1,500 output tokens. Total turn tokens: 254,000 tokens.
• Turn 2: Client appends the document, question 1, answer 1, and question 2. Gemini processes 254,500 input tokens and generates 2,000 output tokens. Total turn tokens: 256,500 tokens. Cumulative tokens: 510,500 tokens.
• Turn 3: Client resends the full history and question 3. Gemini processes 257,000 input tokens and generates 1,800 output tokens. Total turn tokens: 258,800 tokens. Cumulative tokens: 769,300 tokens.
• Turn 4: Client resends the full history and question 4. Gemini processes 259,300 input tokens and generates 2,200 output tokens. Total turn tokens: 261,500 tokens. Cumulative tokens: 1,030,800 tokens.

Over four questions, that single session processed over one million tokens. On a Free tier project, the later turns fail with an HTTP 429 error. On a paid tier, running several concurrent users through this same workflow still exhausts the project's throughput allocation. Either way you are paying for and reprocessing the exact same 250,000 tokens four times in succession.

Latency Spikes, Attention Drift, and Context Caching Costs

Beyond throughput caps, massive prompts inflict severe performance penalties on application responsiveness and output quality:

Generation Latency Spikes

Processing prompt tokens requires computing the initial key-value (KV) attention cache across inference hardware before emitting the first response token. Time to First Token (TTFT) scales directly with input size. A prompt containing 5,000 tokens typically begins generating output within 800 milliseconds on Gemini 3.8 Flash. If you transmit an 800,000-token document collection, TTFT surges to 15 to 40 seconds. For autonomous agents running iterative tool loops, waiting half a minute for every turn paralyzes execution.

Attention Diffusion Across Dense Context

While synthetic benchmark evaluations demonstrate clean retrieval in isolated tests, real-world technical and legal documents behave differently. Transformer attention mechanisms tend to prioritize tokens situated near the very beginning of the prompt (system instructions) and the very end (the latest user prompt). When hundreds of pages of complex specifications are stuffed into the middle of a 700,000-token context payload, models experience attention diffusion. Minor qualification clauses, cross-file variable references, and conflicting policy exceptions buried in the middle region are frequently overlooked.

Limitations of Context Caching

Google offers context caching to reduce input token billing on prompts that exceed 32,768 tokens. When caching is active, Gemini caches the precomputed KV state for a minimum of one hour. However, context caching introduces rigid operational constraints:

• Minimum Threshold: Caching requires at least 32,768 tokens; smaller prompt segments cannot benefit.
• Storage Time-to-Live Fees: Cached tokens incur an hourly storage charge per million tokens in addition to invocation costs.
• Prefix Sensitivity: The cached tokens must sit at the exact beginning of the prompt. Any modification to system instructions or early text invalidates the entire cache, forcing a full re-computation.
• Volatile File Sets: In collaborative team environments where files are actively edited or versioned throughout the day, maintaining valid static caches becomes impractical.

Decoupling File Ingestion from Prompt Context with Fast.io MCP

Fast.io provides a consolidated Model Context Protocol (MCP) server that connects Gemini agents directly to shared workspace files. The remote MCP server operates over Streamable HTTP at https://mcp.fast.io/mcp (or https://mcp.fast.io/mcp/key when using bearer token authentication), with a legacy SSE transport available at https://mcp.fast.io/sse.

Setting up external file retrieval follows four straightforward steps:

1. Centralize Documents in an Org-Owned Workspace: Create a shared workspace in Fast.io. You can upload large files directly using chunked uploads or import existing archives from Google Drive, Dropbox, Box, or OneDrive. Fast.io supports one-time cloud import for Google Drive today, with active sync coming soon.
2. Enable Intelligence Mode for Automatic Indexing: Turn on Intelligence Mode in the workspace settings. Fast.io automatically indexes all incoming documents for hybrid search, combining full-text lexical search with semantic vector search. No external vector database, embedding model, or chunking script is required.
3. Connect Gemini via the Remote MCP Server: Register Fast.io's remote MCP endpoint in your agent configuration, IDE, or desktop assistant.
4. Retrieve Precise Passages on Demand: When a user asks a question, the assistant calls the Fast.io MCP search tool to query the workspace. Instead of transmitting 400,000 document tokens, the assistant retrieves only the top three relevant paragraphs with source citations, inserting just 1,500 tokens into Gemini's context window.

Below is an MCP client configuration example for connecting an assistant runtime to Fast.io:

{
  "mcpServers": {
    "fastio": {
      "url": "https://mcp.fast.io/mcp/key",
      "headers": {
        "Authorization": "Bearer YOUR_FASTIO_API_KEY"
      }
    }
  }
}

By retrieving only 1,500 to 3,000 tokens per turn instead of 300,000 tokens, your application preserves nearly all of its rolling TPM quota, slashes generation latency from thirty seconds to sub-second responses, and eliminates HTTP 429 throttling.

Extracting Structured Document Records with Metadata Views

Unstructured conversational search solves half the file problem. The other half involves extracting structured business intelligence from documents, such as contract renewal dates, indemnification limits, invoice totals, or technical parameters.

Rather than writing custom prompt-engineering scripts that burn thousands of tokens asking Gemini to output JSON schemas, teams use Metadata Views. Metadata Views turn documents into a live, queryable database without requiring OCR rules or rigid templates.

Users describe the fields they want extracted in natural language, and Fast.io builds a typed schema matching files in the workspace:

• Text: Vendor names, jurisdiction clauses, software package identifiers.
• Integer and Decimal: Line item quantities, invoice totals, rate limits, latency metrics.
• Boolean: Exclusivity clauses, compliance indicators, active status flags.
• URL and JSON: API endpoints, structured configuration objects, reference links.
• Date and Time: Effective dates, expiration deadlines, milestone timestamps.

Metadata Views work across PDFs, spreadsheets, presentations, scanned pages, and images. When new columns are added to a view, Fast.io updates the schema without requiring manual reprocessing. AI assistants can create views, trigger extraction, and query structured records directly through Fast.io MCP tools.

While Intelligence Mode handles semantic search and summarization across unstructured text, Metadata Views serve as the structured data extraction layer. Combined with per-file version history, an append-only audit log, Collaborative Notes, and agent-to-human ownership transfer, Fast.io provides the persistent coordination substrate for multi-agent workflows.

Every organization starts with a 14-day free trial, which requires a credit card. Subscription plans are Starter at $9.99/mo, Business at $49.99/mo, and Enterprise at $199.99/mo on Fast.io pricing. For developers building agent integrations, documentation and tool references are available in Fast.io storage for agents, with technical schema details at https://mcp.fast.io/skill.md and onboarding guides at https://fast.io/llms.txt.