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.
- 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 |
| Free | Active Google Cloud project or trial | N/A | |
| Tier 1 | Set up and link an active billing account | $250 | |
| Tier 2 | Paid $100 plus 3 days from first successful payment | $2,000 | |
| 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_errorand aretry-afterheader specifying wait duration in seconds. - Anthropic Spend Caps: Returns HTTP 429 with error type
rate_limit_erroranderror.details.error_codeset toenforced_spend_limit_reached. This response omits theretry-afterheader 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_errorand error codeslow_down. Clients must reduce transmission speed and followRetry-After. - OpenAI System Overload: Returns HTTP 503 with error type
service_unavailable_errorand error codeserver_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_codeon Anthropic forenforced_spend_limit_reachedto avoid futile retries on monthly spend caps. On OpenAI, check forslow_downcodes to handle traffic ramp limits differently from model overload. - Inspect headers on retries: Always prioritize
Retry-Afterheaders when present, using them as the lower boundary for backoff, and combine them with randomized jitter. - Right-size OpenAI max_tokens: Configure
max_tokensclose 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_downthrottling. - 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.