Rate Limits and Usage Tiers at Anthropic, OpenAI, and Google

Compare rate limits, spend caps, tier progression, header metadata, and error handling across Anthropic, OpenAI, and Google Gemini APIs.

By ailog · Published Oct 14, 2026 · 9 min read · How we work
In short
  • Anthropic separates rate limits into input tokens per minute (ITPM) and output tokens per minute (OTPM), excluding cached prompt reads from ITPM on modern models.
  • OpenAI couples request rates and token volumes into combined TPM ceilings while calculating limits based on the higher of max_tokens or estimated input characters.
  • Google enforces rolling 10-minute spend rate limits alongside standard RPM, TPM, and midnight Pacific RPD resets.
  • Provider tier progression is automated based on billing history, ranging from entry caps of $250 to $500 per month up to $200,000 per month for top tiers.
  • Traffic spikes trigger specialized throttling: OpenAI enforces a 50% increase limit every 15 minutes above 1 million TPM, while Anthropic flags burst acceleration.

Usage Tiers and Monthly Spend Caps Across Providers

Every major AI provider bounds infrastructure usage through a progression of usage tiers and spend caps. Rather than offering static allocations, Anthropic, OpenAI, and Google determine maximum allowable throughput based on customer account standing and cumulative spending. Transitioning through these tiers occurs automatically as accounts establish payment records, but each platform calculates thresholds and enforces ceilings differently.

Provider Tier Name Qualification Criteria Monthly Spend Cap / Usage Limit
Anthropic Start Default tier for standard funded accounts $500 USD
Anthropic Build Automatic account progression through usage history $1,000 USD
Anthropic Scale Automatic account progression through usage history $200,000 USD
OpenAI Free Account located in an allowed geography $100 / month
OpenAI Build $5 in total credit purchases $500 / month
OpenAI Launch $100 in total credit purchases $5,000 / month
OpenAI Grow $500 in total credit purchases $200,000 / month
Google Free Active Google Cloud project or trial N/A
Google Tier 1 Set up and link an active billing account $250
Google Tier 2 Paid $100 plus 3 days from first successful payment $2,000
Google Tier 3 Paid $1,000 plus 30 days from first successful payment $20,000 - $100,000+

Anthropic also provides an Evaluation tier with reduced allocations for initial verification, while enterprises on its Custom tier negotiate terms without standard monthly caps. For accounts hosted via Claude Platform on AWS, organizations start on the Start tier and advance through paid AWS Marketplace invoices without access to manual tier-request forms. On Google, moving from Free to Tier 1 happens instantly upon linking billing, whereas subsequent upgrades take effect within 10 minutes once criteria are reached. When planning budget ceilings, developers can evaluate baseline expenses with the LLM API cost calculator or explore governance patterns via per-run cost caps.

Token Accounting: How Caching and Request Shapes Affect Limits

A fundamental difference among the three providers lies in how tokens count toward throughput limits. Anthropic decouples token rate limits into input tokens per minute (ITPM) and output tokens per minute (OTPM). Crucially, Anthropic evaluates ITPM using cache-aware mechanics. Uncached input_tokens and newly generated cache_creation_input_tokens consume your ITPM allowance, while cache_read_input_tokens do not count against ITPM on modern architectures like Claude Opus 5.5, Claude Sonnet 5.5, and Claude Haiku 4.5. Claude Haiku 3.5 remains the exception, counting cached read tokens against its ITPM quota.

Because read tokens do not draw down ITPM, implementing prompt caching can drastically multiply effective throughput. For instance, on a 2,000,000 ITPM limit with an 80% cache hit rate, an application can process 10,000,000 total input tokens per minute (composed of 2M uncached and 8M cached tokens). Anthropic’s OTPM limits are evaluated dynamically in real time as generated tokens stream back. The max_tokens request parameter does not restrict Anthropic OTPM, meaning setting higher generation ceilings carries no rate-limiting penalty.

OpenAI adopts an entirely different token budgeting mechanism. For models such as Astra, Sol, Terra, and Luna, OpenAI measures combined tokens per minute (TPM). When processing an incoming call, OpenAI assesses the token footprint as the maximum value between the request’s max_tokens configuration and the estimated token count derived from character length. Specifying an unnecessarily large max_tokens ceiling on OpenAI can exhaust your minute-based token budget before requests even execute. To prevent premature throttling, clients must tighten max_tokens close to anticipated output volume.

Google divides Gemini API consumption across requests per minute (RPM), tokens per minute (TPM), and requests per day (RPD). While TPM applies strictly to incoming input tokens, Google also enforces spend-based rate limits evaluated across a rolling 10-minute window. Even if an application remains under standard RPM and TPM ceilings, expensive high-context calls can trigger a spend exhaustion failure if 10-minute cumulative charges exceed tier limits.

Standard Model Limits, Rolling Windows, and Ramp-Up Rules

Throughput quotas scale directly across usage tiers, but providers enforce distinct algorithms to throttle high-frequency traffic. Anthropic employs a token bucket algorithm that continuously replenishes allowances rather than resetting them at fixed intervals. However, Anthropic enforces limits over short slices; an allowance of 60 RPM can be metered as 1 request per second, which means immediate bursts can return errors.

Provider Tier Model Selection RPM Limit Token Limit (TPM or ITPM)
Anthropic Start Claude Opus 5.5, Sonnet 5.5, Haiku 4.5 1,000 2,000,000 ITPM
Anthropic Start Claude Fable 5.x 1,000 500,000 ITPM
Anthropic Build Claude Opus 5.5, Sonnet 5.5, Haiku 4.5 5,000 5,000,000 ITPM
Anthropic Build Claude Fable 5.x 2,000 1,500,000 ITPM
Anthropic Scale Claude Opus 5.5, Sonnet 5.5, Haiku 4.5 10,000 10,000,000 ITPM
OpenAI Build Astra, Sol, Terra 5,000 1,000,000 TPM
OpenAI Build Luna 5,000 2,000,000 TPM
OpenAI Launch Astra, Sol, Terra 10,000 4,000,000 TPM
OpenAI Launch Luna 10,000 10,000,000 TPM
OpenAI Grow Astra, Sol, Terra 15,000 40,000,000 TPM
OpenAI Grow Luna 30,000 180,000,000 TPM

Beyond steady-state limits, OpenAI enforces traffic acceleration constraints. When consumption reaches 1 million input TPM, systems should expand traffic volume by no more than 50% every 15 minutes. Attempting to jump instantly from baseline to peak volume triggers an error even if the organization operates well below its designated TPM ceiling. For stable large-scale workloads, OpenAI offers Scale Tier or Reserved Tier (for GPT-5.6 and subsequent releases). Google enforces fixed 10-minute spend caps ($10 in Tier 1, $50 in Tier 2, and $200 in Tier 3) and resets RPD metrics daily at midnight Pacific time. Priority inference on Gemini draws from interactive capacity at 0.3x standard limits.

Response Headers, Status Codes, and Retry Strategies

Differentiating temporary traffic saturation from permanent quota exhaustion requires inspecting HTTP status codes, payload structures, and response headers. Each platform signals throttling through distinct conventions, meaning generic retry loops can cause cascade failures.

  • Anthropic Rate Limits: Returns HTTP 429 with error type rate_limit_error and a retry-after header specifying wait duration in seconds.
  • Anthropic Spend Caps: Returns HTTP 429 with error type rate_limit_error and error.details.error_code set to enforced_spend_limit_reached. This response omits the retry-after header because access remains paused until 00:00 UTC on the first day of the next month.
  • Anthropic User Configured Limits: Hitting a self-configured organization or workspace spending limit returns HTTP 400 with invalid_request_error.
  • OpenAI Rapid Ramp-up: Returns HTTP 429 with error type rate_limit_error and error code slow_down. Clients must reduce transmission speed and follow Retry-After.
  • OpenAI System Overload: Returns HTTP 503 with error type service_unavailable_error and error code server_is_overloaded.
  • Google Spend Limits: Hitting rolling 10-minute spend limits yields HTTP 429 with status RESOURCE_EXHAUSTED.

OpenAI provides detailed diagnostic headers on successful and throttled calls alike, exposing x-ratelimit-remaining-requests, x-ratelimit-remaining-tokens, x-ratelimit-reset-requests, and x-ratelimit-reset-tokens. Project-scoped restrictions similarly expose x-ratelimit-remaining-project-tokens. When a Retry-After header is returned, clients must honor the server delay as a minimum baseline and append random jitter to prevent synchronized retry storms.

import random
import time
import openai
from openai import OpenAI

client = OpenAI()

def retry_with_exponential_backoff(
    func,
    initial_delay: float = 1,
    exponential_base: float = 2,
    jitter: bool = True,
    max_retries: int = 10,
    errors: tuple = (openai.RateLimitError,),
):
    def wrapper(*args, **kwargs):
        num_retries = 0
        delay = initial_delay
        while True:
            try:
                return func(*args, **kwargs)
            except errors:
                num_retries += 1
                if num_retries > max_retries:
                    raise Exception("Maximum number of retries exceeded.")
                delay *= exponential_base * (1 + jitter * random.random())
                time.sleep(delay)
            except Exception:
                raise
    return wrapper

Batch API Limits and Queue Throughput

When workloads do not require interactive response times, asynchronous batch endpoints provide an isolated processing path with dedicated rate quotas. Using batch processing helps prevent background jobs from cannibalizing live interactive limits. Teams considering this architectural shift can review structural patterns in batch API discounts and scheduling.

On Anthropic, the Message Batches API enforces an overall requests-per-minute ceiling on batch endpoints alongside a concurrency cap on the number of batch requests in the processing queue. A batch request remains inside the queue until fully executed. OpenAI structures batch capacity around queued token volume per model. Unprocessed input tokens in pending jobs consume queue capacity; once a batch job finishes, its tokens are released from that model’s batch allocation.

Google establishes rigorous batch boundaries across its usage tiers. The Gemini Batch API enforces a universal ceiling of 100 concurrent batch requests, a maximum input file size of 2GB, and a total file storage ceiling of 20GB. Enqueued token volumes scale extensively across tiers:

Model Name Tier 1 Enqueued Tokens Tier 2 Enqueued Tokens Tier 3 Enqueued Tokens
Gemini 3.1 Pro Preview 5,000,000 500,000,000 1,000,000,000
Gemini 3.8 Flash 3,000,000 400,000,000 1,000,000,000
Gemini 3.5 Flash-Lite 10,000,000 500,000,000 1,000,000,000
Gemini 2.5 Pro 5,000,000 500,000,000 1,000,000,000
Gemini 2.5 Flash 3,000,000 400,000,000 1,000,000,000
Gemini 2.5 Flash Lite 10,000,000 500,000,000 1,000,000,000
Gemini Embedding 500,000 5,000,000 10,000,000

Production Checklist for Multi-Provider Rate Limit Management

Building production software that connects to Anthropic, OpenAI, or Google requires defensive network wrappers tailored to each provider’s error states, replenishment cycles, and header formats. Review this checklist before deploying high-volume inference jobs.

  • Differentiate 429 error bodies: Check error.details.error_code on Anthropic for enforced_spend_limit_reached to avoid futile retries on monthly spend caps. On OpenAI, check for slow_down codes to handle traffic ramp limits differently from model overload.
  • Inspect headers on retries: Always prioritize Retry-After headers when present, using them as the lower boundary for backoff, and combine them with randomized jitter.
  • Right-size OpenAI max_tokens: Configure max_tokens close to realistic generation sizes to prevent OpenAI’s pre-request token estimators from consuming excessive TPM allowance.
  • Leverage prompt caching: Structure system prompts, large contexts, and documentation with cache breakpoints to take advantage of Anthropic’s zero-ITPM cache read policy.
  • Throttle ramp-ups on high volume: When OpenAI traffic exceeds 1 million input TPM, restrict traffic increases to 50% per 15-minute window to avoid slow_down throttling.
  • Monitor Google spend rate limits: Space out large-context batch calls on Gemini to prevent exhausting the rolling 10-minute spend caps ($10 for Tier 1, $50 for Tier 2, $200 for Tier 3).
  • Separate interactive and batch queues: Offload bulk jobs to provider Batch APIs to access separate concurrency queues and keep user-facing RPM buffers intact.
Sources
  1. Rate limits
  2. Rate limits
  3. https://ai.google.dev/gemini-api/docs/rate-limits

Related