# Gemini CLI Rate Limits: Quotas, 429 Errors, and Terminal Workarounds

Gemini CLI rate limits enforce strict per-minute and per-day caps that trigger 429 Resource Exhausted errors during automated terminal tasks. Understanding how quotas differ between Google account logins and Gemini API keys allows developers to configure effective fallbacks. Offloading large project files to indexed external workspaces prevents prompt bloat and keeps CLI commands well within token thresholds.

Source: https://fast.io/resources/gemini-cli-rate-limit/
Author: [Derek Labian](https://fast.io/authors/derek-labian/)
Last reviewed: 2026-10-26

## What Are the Gemini CLI Rate Limits Across Authentication Modes?

Terminal automation pipelines that rely on Gemini CLI fail abruptly when execution exceeds the 1,000 maximum model requests per user per day enforced on standard personal Google logins. When developers hook terminal tools into continuous scripts, git hooks, or batch code review loops, hitting operational ceilings is common.

Gemini CLI rate limits are per-minute (RPM) and per-day (RPD) request and token caps imposed by the underlying Gemini API when executing commands or piping data in the terminal.

According to [Gemini API documentation](https://ai.google.dev/gemini-api/docs/rate-limits), rate limits regulate traffic across three operational metrics:
- **Requests Per Minute (RPM):** The frequency ceiling for API calls within any rolling sixty-second window.
- **Tokens Per Minute (TPM):** The total volume of input and output tokens processed in sixty seconds, including system instructions, attached code, and piped files.
- **Requests Per Day (RPD):** The total request allowance allotted per calendar day, resetting at midnight Pacific Time.

Rate limits are evaluated at the project level rather than per individual API key. If multiple terminal sessions or automated jobs connect to the same Google Cloud project, they consume the same pool of requests.

The exact rate limit applied to your terminal session depends on the authentication method chosen during CLI initialization. Official [Gemini CLI documentation](https://geminicli.com/docs/resources/quota-and-pricing/) outlines four primary access tiers:

| Authentication Method | Account Tier | Request Limit (RPM) | Token Limit (TPM) | Daily Quota (RPD) | Model Access |
|---|---|---|---|---|---|
| Personal Google Account | Gemini Code Assist (Individual) | 60 RPM burst limit | Standard interactive TPM | 1,000 requests / day | Dynamic Flash and Pro models |
| Personal Google Account | Google AI Pro or Ultra | 60 RPM burst limit | Priority interactive TPM | 1,500 to 2,000 requests / day | Priority Flash and Pro models |
| Gemini API Key | Free Tier (Unpaid AI Studio) | 15 RPM | 1,000,000 TPM (Flash) | 250 requests / day | Flash models only |
| Gemini API Key | Pay-as-you-go (Paid Tier 1-3) | Up to 2,000 RPM | 2,000,000 to 4,000,000+ TPM | 10,000+ requests / day | All Gemini models |
| Google Workspace | Code Assist Enterprise | 60 RPM burst limit | Enterprise interactive TPM | 2,000 requests / day | Enterprise Gemini models |

Developers authenticating via individual Google accounts receive 1,000 requests per day without entering billing details. However, running unpaid Gemini API keys restricts daily volume to 250 requests and limits queries to Flash models only. Understanding which credential your terminal environment loads is the first step in avoiding unexpected service cutoffs.

## Why Gemini CLI Returns 429 Resource Exhausted Errors

The standard response code for a rate limit breach is `429 RESOURCE_EXHAUSTED`. In the terminal, this error manifests either as an outright script failure, a warning that model throughput has dropped, or an alert stating that response times are slow and forcing an automated downgrade to Flash models.

Five execution patterns trigger 429 errors in terminal environments:

### 1. Burst Frequency Overruns (RPM Limits)
Running rapid, repeated commands in shell scripts is the fastest path to a 429 error. On unpaid Gemini API keys, the ceiling is 15 RPM. A bash script processing twenty files in a tight loop breaches this threshold within seconds. Even on interactive Google logins with a 60 RPM burst allowance, submitting concurrent queries from multi-pane terminal multiplexers like tmux will saturate the queue.

### 2. Context Floods and Tokens Per Minute (TPM)
Piping large source files or build logs directly into Gemini CLI consumes input tokens at an aggressive pace. Commands such as `cat bundle.js | gemini "find syntax bugs"` force the CLI to package the entire text payload into the prompt. If the input exceeds the model's Tokens Per Minute ceiling, the Gemini API refuses the request with a resource exhaustion error, even if you made only one request that minute.

### 3. Exhausting the Daily Ceiling (RPD)
Automated agent loops that generate code, run test suites, and prompt the CLI for iterative fixes consume daily allowances rapidly. On individual accounts, reaching 1,000 requests locks the CLI out until quotas reset at midnight Pacific Time. Once the daily budget is gone, no amount of backoff will restore service until the reset window passes.

### 4. Rolling Ten-Minute Spend Limits on Paid Keys
On pay-as-you-go accounts, Google enforces rolling spend-rate caps evaluated across ten-minute intervals to prevent unexpected charges across billing tiers. Rapid high-token completions generated by parallel agent scripts can trigger a spend-based 429 error even when RPM and TPM metrics appear healthy.

### 5. Shared Project Quota Depletion
Because rate limits bind to the Google Cloud project ID, multiple team members or automated CI runners using credentials tied to the same project compete for the same quota pool. One developer running a local benchmark script can starve teammates of terminal access.

### Diagnosing Rate Limits in the Terminal
Gemini CLI includes internal diagnostics to verify consumption before and after errors occur:
- Run `/stats model` inside an active interactive session to inspect your current session token usage and verify the quota rules governing your session.
- Review the summary printed to standard error upon exiting a session, which records total input and output tokens consumed.
- Check active rate limits directly in [Google AI Studio](https://aistudio.google.com/) to verify whether your project has hit RPM, TPM, or spend limits.

## How to Resolve 429 Errors with Terminal Pacing and Model Fallbacks

Resolving 429 errors requires managing pacing, setting up fallback models, and upgrading account tiers when automation requires sustained throughput.

### Implement Exponential Backoff and Pacing in Bash
Automated pipelines should never make consecutive CLI calls without error handling. When wrapping Gemini CLI in shell scripts, intercept non-zero exit codes and inspect error output for rate limit indicators.

Here is a practical bash wrapper script demonstrating exponential backoff with jitter:

```bash
#!/usr/bin/env bash
MAX_RETRIES=5
BASE_DELAY=2
INPUT_PROMPT="${1:-}"
for ((attempt=1; attempt<=MAX_RETRIES; attempt++)); do
  RESPONSE=$(gemini "$INPUT_PROMPT" 2>&1)
  STATUS=$?
  if [ $STATUS -eq 0 ]; then
    echo "$RESPONSE"
    exit 0
  fi
  if echo "$RESPONSE" | grep -qiE "429|RESOURCE_EXHAUSTED|rate limit"; then
    DELAY=$(( BASE_DELAY * (2 ** (attempt - 1)) + (RANDOM % 2) ))
    echo "Rate limit reached. Retrying in ${DELAY}s (Attempt ${attempt}/${MAX_RETRIES})..." >&2
    sleep "$DELAY"
  else
    echo "Command failed with error: $RESPONSE" >&2
    exit $STATUS
  fi
done
echo "Exceeded maximum retry attempts." >&2
exit 1
```

### Route Non-Critical Queries to Flash Models
Pro models carry lower rate limits and consume token budgets faster than lightweight alternatives. When executing automated tasks that do not require deep reasoning, configure the CLI to invoke Flash models. In interactive sessions or script configuration, specify the Flash model to maintain higher request thresholds and avoid depleting Pro quotas needed for architectural review.

### Upgrade to Pay-As-You-Go in Google AI Studio
If individual Google account quotas are insufficient for your development volume, switch from Google login to a paid Gemini API key:
1. Open Google AI Studio and view the Rate Limits dashboard.
2. Link an active Google Cloud billing account to your project.
3. Once billing is linked, your project enters Tier 1, raising throughput caps above unpaid tiers.
4. Export the API key in your terminal environment:

```bash
export GEMINI_API_KEY="your-api-key-here"
```

As your cumulative spend increases and payments clear, your project automatically progresses to Tier 2 and Tier 3, raising per-minute quotas to 2,000 RPM.

## How to Offload Large Project Files to Fast.io MCP

A primary reason terminal agents exceed Gemini CLI rate limits is prompt bloat. When developers need the CLI to analyze project architecture, documentation, or legal agreements, the instinctive approach is piping raw files into the standard input:

```bash
cat docs/*.md src/*.ts | gemini "Audit this codebase for authentication flaws"
```

This pattern floods the model's Tokens Per Minute (TPM) allowance. Processing tens of thousands of tokens per command exhausts rate limits within a handful of prompts. Re-sending the same static context on every prompt also wastes token allowances.

The sustainable architecture decouples file persistence from prompt context. Instead of forcing the CLI to ingest entire directory trees, store project assets in an external intelligent workspace and query them through the Model Context Protocol (MCP). Teams can review [storage for agents](/storage-for-agents/) to understand how external storage interfaces with coding tools.

### Connecting Gemini CLI to Fast.io via Streamable HTTP
Fast.io provides shared cloud workspaces for agentic teams. When files are uploaded to an [intelligent workspace](/product/workspaces/), Intelligence Mode indexes their contents automatically for full-text and semantic search. Rather than stuffing hundreds of files into your terminal prompt, your terminal assistant connects to the Fast.io MCP server and retrieves only the exact paragraphs relevant to your inquiry.

To connect Gemini CLI to Fast.io, edit your client configuration in `~/.gemini/settings.json` or your project settings file:

```json
{
  "mcpServers": {
    "fast-io": {
      "httpUrl": "https://mcp.fast.io/mcp/code"
    }
  }
}
```

Two technical details are critical when configuring Gemini CLI:
1. **Use `httpUrl`, not `url`:** In Gemini CLI and forks like Qwen Code, the `"url"` property selects the legacy Server-Sent Events (SSE) transport. Fast.io serves MCP over modern Streamable HTTP, which requires the `"httpUrl"` key.
2. **Coding Agent Endpoint:** Use the dedicated coding agent address `https://mcp.fast.io/mcp/code`. Setup instructions for human developers and credentials are documented at the [Fast.io MCP setup guide](https://mcp.fast.io/docs).

### Authenticating the MCP Connection
Once your configuration is saved, open Gemini CLI and authenticate the connection:

```bash
/mcp auth fast-io
```

This command initiates OAuth authentication in your browser. Review the permission screen to grant read or read-and-write access to your designated Fast.io workspaces.

### Preserving Rate Limits with Semantic Search
With Fast.io connected, the CLI no longer requires file dumps in its prompt. When you ask a question about your project, the assistant calls the Fast.io MCP tools to search the workspace index. The tool returns targeted snippets with citations, reducing input token consumption from thousands of tokens down to a few paragraphs.

A search query consuming 400 tokens replaces a 40,000-token file attachment. This token reduction prevents TPM exhaustion, preserves daily request headroom, and keeps automated terminal pipelines running smoothly without hitting 429 errors.

Fast.io provides persistent workspaces with per-file version history and a detailed activity log tracking changes made by humans and agents. Monthly plans start with a 14-day free trial, which requires a credit card. Plans are Starter at `$9.99/mo` (`3` seats, `250 GB`, `5` workspaces, `100,000` credits a month), Business at `$49.99/mo` (`10` seats, `5 TB`, `50` workspaces, `600,000` credits a month), and Enterprise at `$199.99/mo` (`30` seats included, `25 TB`, `200` workspaces, `3,000,000` credits a month). Review details on [Fast.io pricing](/pricing/).

## Production Steps for Terminal Pipelines and CI/CD Automation

Scaling terminal automation across teams and automated build environments requires deliberate architectural boundaries to prevent quota starvation.

### Separate Environments Across Distinct Google Cloud Projects
Because Gemini API rate limits are enforced per project, never share a single project ID between interactive developer machines and unattended CI/CD runners. 
- Create a dedicated Google Cloud project for automated test runners and build scripts.
- Assign separate projects to individual developer machines.
- This separation prevents a rogue automated test loop from consuming your team's interactive terminal quota during workday hours.

### Use the Batch API for Asynchronous Jobs
If your automation involves non-interactive operations, such as overnight repository analysis or bulk code translation, avoid the interactive chat endpoints. The Gemini Batch API provides dedicated queues for large jobs. Batch processing runs at reduced token rates and is subject to distinct token queues, leaving your interactive terminal limits untouched.

### Monitor Account Health in Google AI Studio
Track API performance metrics through the Google AI Studio dashboard. Monitor rolling spend graphs, request latency, and quota consumption. When team activity consistently approaches high percentages of daily or per-minute ceilings, submit a quota increase request through the Google Cloud Console before your pipelines experience service interruptions.

### Maintain Shared Workspace Hygiene
When collaborating on codebases with multiple terminal agents, manage shared project files within organized workspaces. Cloud Sync connects Google Drive, Dropbox, Box, and OneDrive folders to a workspace, one-way or two-way, on a schedule or on demand. This keeps documentation and reference materials current across agent sessions while eliminating redundant file copies and reducing unnecessary token queries across your developer team. Learn more about dedicated [AI storage](/product/ai-storage/) architecture for multi-agent workflows.

## Frequently asked questions

### What are the rate limits for the Gemini CLI?

Gemini CLI rate limits depend on your authentication method. Users authenticating with a personal Google account receive a 60 RPM burst limit and 1,000 requests per day through Gemini Code Assist for individuals. Google AI Pro and Ultra subscriptions expand daily allowances to 1,500 and 2,000 requests per day. Unpaid Gemini API keys provide standard free tier request rates on Flash models, while pay-as-you-go accounts provide higher per-minute throughput across paid tiers.

### Why does Gemini CLI return 429 Resource Exhausted?

A 429 Resource Exhausted error occurs when your session exceeds per-minute request limits (RPM), per-minute token limits (TPM), daily request allowances (RPD), or rolling 10-minute spend caps. In terminal pipelines, piping large files into the CLI or running rapid automated loops without sleep intervals are the primary causes of this error.

### How do I increase my Gemini CLI rate limit?

To increase rate limits, switch from an unpaid credential to a paid Gemini API key linked to a Google Cloud billing account in Google AI Studio. Linking billing places your account in Tier 1 and substantially raises RPM and TPM caps. As your account establishes payment history and cumulative spend, limits automatically upgrade to Tier 2 and Tier 3.

### What is the difference between RPM and TPM in Gemini CLI?

RPM (Requests Per Minute) measures the number of distinct API calls sent to Gemini within a sixty-second window. TPM (Tokens Per Minute) measures the combined volume of prompt input tokens and generated output tokens processed during that same window. Exceeding either limit triggers an immediate 429 error.

### How do I check my current Gemini CLI token and request usage?

Inside an interactive Gemini CLI session, type `/stats model` to view your current token consumption and applicable quota rules. Exiting a session also displays a summary of model usage in the terminal. For API keys, detailed usage and real-time quota graphs can be reviewed in the Google AI Studio Rate Limits dashboard.

## Sources

- [Gemini CLI Documentation: Quotas and Pricing](https://geminicli.com/docs/resources/quota-and-pricing/): Google account users accessing Gemini Code Assist for individuals have a cap of 1,000 maximum model requests per user per day.
- [Google AI for Developers: Rate Limits](https://ai.google.dev/gemini-api/docs/rate-limits): Gemini API rate limits apply at the project level rather than per individual API key.

## About Fast.io

Fast.io provides shared workspaces where people and AI agents work on the same files, with built-in semantic search and citation-backed chat over what they hold. Agents reach it through a remote MCP server, a REST API at https://api.fast.io/current/, and a command line client published on npm as @vividengine/fastio-cli. MCP setup is at https://mcp.fast.io/docs: Claude and most MCP clients connect to https://mcp.fast.io/mcp/tools, ChatGPT to https://mcp.fast.io/mcp/operations, and coding agents to https://mcp.fast.io/mcp/code.