Anthropic Rate Limits: Claude API Tiers, TPM Caps, and Document Processing

Anthropic rate limits are throughput constraints enforced on API requests, measured in requests per minute (RPM) and tokens per minute (TPM) across account tiers from Build Tier 1 to Tier 4. According to Anthropic's rate limits documentation, the Messages API governs throughput through three distinct metrics: requests per minute (RPM), input tokens per minute (ITPM), and output tokens per minute (OTPM) applied separately across each model class. Understanding how these thresholds interact is essential for engineering teams deploying autonomous agents, batch data extraction, and document processing systems on Claude models.

When an application exceeds any of these thresholds, Anthropic returns an HTTP 429 status code indicating that the client has sent too many requests. Unlike simple request counters that reset on a fixed hourly or daily clock, Anthropic uses a token bucket algorithm to enforce throughput limits. Each organization receives a bucket of allowed requests and tokens that continuously replenishes at a steady rate up to the tier ceiling. This design accommodates modest bursts of activity while preventing sustained traffic spikes that could degrade shared infrastructure.

Requests per Minute and the Token Bucket Algorithm

The requests per minute (RPM) metric tracks the total number of distinct HTTP calls your application makes to the Messages API within a sixty-second rolling window. Under the token bucket implementation, RPM is not merely an end-of-minute aggregate. Anthropic enforces short-term rate smoothing: an account with an allowance of 60 requests per minute is evaluated roughly as 1 request per second. Sending twenty concurrent requests in a single second will immediately deplete your available bucket tokens and trigger rate limiting, even if your total request count for that minute sits far below 60.

Production applications must account for this sub-minute pacing. Dispatching parallel worker threads against the API without rate-limiting controls causes immediate 429 errors during burst phases. Clients must pace outgoing dispatches smoothly rather than firing batches in single unthrottled bursts.

Input Tokens per Minute vs Output Tokens per Minute

Anthropic splits token throughput into two distinct accounting streams: input tokens per minute (ITPM) and output tokens per minute (OTPM). This division reflects the different computational burdens that prompt ingestion and text generation place on model infrastructure.

Input tokens represent the prompt payload: system instructions, conversation history, context documents, schema definitions, and user instructions. Output tokens represent the text generated by the model in response. OTPM limits are evaluated in real time as tokens stream from the model. Specifying a large max_tokens parameter does not draw down your OTPM allowance in advance. Only the actual tokens generated count toward your OTPM rate limit.

ITPM limits, by contrast, are evaluated at the initiation of the request based on the size of the submitted prompt. For complex document workflows where prompts include complete PDF files or large codebases, ITPM is almost always the first ceiling that developers hit.

Acceleration Limits and Traffic Spikes

In addition to static RPM and TPM caps, Anthropic monitors traffic acceleration across organizations. If an account suddenly jumps from zero activity to thousands of requests within a few seconds, internal traffic management systems can return HTTP 429 errors even when total volume remains under nominal tier caps.

Anthropic platform documentation notes that organizations experiencing sharp usage increases may encounter acceleration limits. Engineering teams scaling automated workloads must warm up their request pipelines gradually, ramping up worker threads over several minutes to maintain predictable throughput.

• Anthropic Token Counter: Count Tokens with the Messages API and TokenizerAn Anthropic token counter calculates input token consumption for prompts, system instructions, documents, and tool...
• Claude Daily Limit: Usage Caps, Reset Times, and WorkaroundsClaude daily limits refer to the message and token caps imposed on Claude.ai accounts, which operate as fixed 24-hour...
• Claude 5-Hour Limit Explained: Reset Rules, Token Consumption, and WorkaroundsThe Claude 5 hour limit is Anthropic's rolling rate-limiting mechanism that dynamically restricts user message volume...
• Claude Code Usage Limits: Rate Windows, Plan Caps, and Token StrategiesClaude Code routinely consumes 10 to 100 times more tokens per interaction than a standard Claude.ai chat message,...
• Claude Code Rate Limits: 5-Hour Usage Caps, 429 Errors, and WorkaroundsClaude Code rate limits enforce execution thresholds across terminal requests, tokens per minute, and five-hour rolling...
• Anthropic Context Window: Claude Token Limits, Prompt Caching, and MCP WorkspacesThe Anthropic context window defines the active token capacity available across Claude models for system instructions,...

More on this subject: Claude and Claude Code (255 guides)

Anthropic assigns rate limits based on an organization's account tier. Account tiers reflect deposit history, operational spend, and account verification status. Understanding where your organization sits in this hierarchy determines whether your application can process real-time user traffic or will frequently stall against API boundaries.

New accounts with limited operational history start in the Evaluation tier, which applies restrictive thresholds below standard production allowances to mitigate fraud and abuse. As an account deposits funds and builds consistent usage patterns, Anthropic moves the organization into higher tiers automatically.

Legacy Build Tiers and Deposit Requirements

In earlier platform documentation and legacy configurations, Anthropic organized self-service developers into four sequential tiers known as Build Tier 1 through Tier 4. Many third-party libraries, MCP tools, and tutorials still reference these historical deposit tiers:

Developers on Build Tier 1 face a narrow operational envelope: with 50 RPM and 40,000 TPM, sending even a single comprehensive document bundle can consume the entire minute's quota. Moving through the tiers requires making prepaid deposits or establishing payment history in the Claude Console.

Current Platform Tiers: Start, Build, Scale, and Custom

In the modern Claude Platform architecture, usage tiers are organized into Start, Build, Scale, and Custom tiers. Each of the Start, Build, and Scale tiers carries a monthly spend cap, which is the maximum your organization can spend on the API each calendar month. Each tier provides distinct throughput envelopes across model families:

Anthropic applies rate limits independently for each model family. Using your full token allocation on Claude Sonnet does not draw down your available rate limit pool for Claude Opus or Claude Haiku. Teams can distribute concurrent operations across model families to maximize aggregate system throughput.

Spend Caps vs Rate Limits: Detecting Enforced Spend Limit 429 Errors

A distinct operational difference lies between rate limits and spend caps. Rate limits restrict short-term velocity over seconds and minutes. Spend caps establish the absolute maximum monetary expenditure an organization can incur within a calendar month.

When your organization reaches its monthly spend cap, API operations pause until 00:00 UTC on the first day of the next calendar month unless you request an increase. When paused, the API returns HTTP 429, but with a notable difference: the response payload contains an error code of enforced_spend_limit_reached and does not provide a retry-after header. Standard retry logic with exponential backoff will continuously fail until the billing cycle resets or an administrator raises the spend limit in the Claude Console. Monitoring this specific error code in your client middleware prevents worker threads from entering infinite retry loops.

The primary reason developers encounter unexpected Anthropic rate limits is not high user concurrency. It is the document payload trap.

When building applications that process business records, research papers, legal agreements, or software codebases, naive architectures read entire files from disk and inject them directly into the messages array of the API request. While modern Claude models feature massive context windows supporting hundreds of thousands of tokens per request, developers frequently conflate context window capacity with rate limit throughput.

A model may possess the capability to process 200,000 tokens in a single inference call. However, if your organizational tier enforces an ITPM limit of 40,000 or even 500,000 tokens per minute, submitting two or three large document bundles concurrently will instantly trigger 429 throttling.

The Document Payload Trap and TPM Exhaustion

Consider an automated legal review agent instructed to analyze fifty vendor contracts, each averaging twenty pages. A twenty-page contract converted to text represents approximately 10,000 tokens. If the agent attaches four contracts to a single prompt to verify cross-agreement indemnification clauses, that single API call consumes 40,000 input tokens.

On Build Tier 1, this single request completely exhausts the organization's per-minute input token allowance. A second request dispatched thirty seconds later will immediately fail with HTTP 429, halting execution. Even on higher tiers, running five parallel agent threads against raw document payloads consumes millions of tokens in minutes, quickly bumping against ITPM limits and creating severe latency bottlenecks.

Claude Projects and the 50-File Boundary

This operational wall is familiar to users of Claude Projects in the web interface. Claude Projects provides project knowledge storage but enforces a strict limit of 50 project files per project. When engineering teams hit this 50-file boundary while attempting to analyze complete repositories or client file sets, their first instinct is to write custom Python or TypeScript scripts to send raw files directly through the API.

Without an intermediate retrieval architecture, these custom scripts immediately run into the API's token-per-minute ceiling. Instead of solving the 50-file constraint, teams simply shift the bottleneck from a UI file count limit to an API token throughput limit.

Why Prompt Caching Only Partially Solves Multi-File Ingestion

Anthropic offers prompt caching, a capability that allows developers to cache repetitive context blocks across requests. On supported models, cached input tokens do not count toward your active ITPM rate limit; only uncached input tokens and initial cache writes draw down your quota.

While prompt caching provides relief for fixed system prompts and static tool definitions, it is not an all-in-one remedy for dynamic multi-file collections. Prompt caching requires identical, byte-for-byte prefix ordering. The moment an agent queries different subsets of files in changing orders, cache misses occur. Writing new document corpuses into the cache still consumes cache_creation_input_tokens, which count against ITPM limits during initial ingestion. To process massive, changing file collections without throttling, teams must decouple raw file storage from LLM prompt payloads.

Query document repositories without burning Claude token limits

Connect Claude to indexed workspaces over remote MCP to search multi-gigabyte archives without payload throttling. Every organization starts with a 14-day free trial, which requires a credit card.

Start 14-Day Trial

To solve the document ingestion bottleneck without hitting Anthropic rate limits, production systems separate storage and retrieval from prompt construction. Instead of shipping multi-megabyte document payloads into the Messages API, organizations store their corpus in Fast.io workspaces that index file contents in the cloud.

Fast.io provides a dedicated workspace platform built for autonomous agents and collaborative human teams. Rather than treating cloud storage as a passive bit bucket, Fast.io automatically indexes files for hybrid search upon arrival. When Claude needs factual context to answer a query or execute an action, it queries the workspace through the Model Context Protocol (MCP) and receives only the relevant text passages or structured records.

By replacing full-document attachments with targeted semantic retrieval, prompt token consumption drops from 50,000 tokens per request down to isolated excerpt tokens. An agent can inspect information across thousands of files without approaching Anthropic ITPM rate limits. Fast.io does not alter or raise Anthropic's vendor-enforced API quotas; rather, it drastically reduces the token footprint required to answer complex questions.

The Workspace Indexing Architecture

The workspace indexing workflow operates across four distinct stages:

• 1. Centralized Corpus Ingestion: Teams place project records, specifications, and client archives directly into a shared workspace. Files can be uploaded directly or imported from cloud providers. Fast.io supports one-way or two-way synchronization for Google Drive, Dropbox, Box, and Microsoft OneDrive. Files synchronize in the background without burning local machine resources or API tokens.
• 2. Automatic Intelligence Mode Indexing: In workspace settings, administrators enable Intelligence Mode. As files arrive, Fast.io parses formats including PDFs, Microsoft Word documents, presentations, spreadsheets, and scanned documents. The platform creates both full-text keyword indexes and semantic vector embeddings automatically, eliminating the need to configure and manage external vector databases or chunking pipelines.
• 3. Hybrid Search Retrieval: When querying the workspace, Fast.io executes hybrid search combining keyword matching, semantic vector similarity, and metadata filtering. This ensures that exact identifiers (such as part numbers, policy codes, or error strings) and conceptual inquiries are retrieved with equal precision.
• 4. Version History and Audit Tracking: Every document maintains full version history, allowing agents and humans to track modifications over time. The platform maintains an append-only audit log of all file reads, writes, and share operations, ensuring complete visibility across automated workflows.

Structuring Extraction with Metadata Views

For document-heavy workflows that require structured data rather than free-form conversational answers, teams use Metadata Views. Metadata Views turn unstructured document archives into live, queryable relational databases.

Users describe the target fields in natural language: contract effective dates, counterparties, governing law, invoice totals, or insurance policy limits. Fast.io designs a typed schema (supporting Text, Integer, Decimal, Boolean, URL, JSON, and Date & Time) and extracts the values across matching workspace documents without OCR templates or manual coordinate rules. Agents can inspect, query, and filter this structured table via MCP tool calls, retrieving exact fields in dozens of tokens rather than ingesting entire contract PDFs into Claude.

Configuring Remote MCP Access for Claude Desktop and Claude Code

Connecting Claude to a Fast.io workspace requires no local daemon, no Node.js scripts, and no npm packages. Fast.io provides a remote MCP server operating over Streamable HTTP at https://mcp.fast.io/mcp/tools for Claude applications and https://mcp.fast.io/mcp/code for coding agents like Claude Code. Complete setup steps are available at Fast.io MCP documentation. For developers configuring autonomous agent environments, review the storage for agents guide and onboarding documentation at fast.io/llms.txt.

Every organization begins with a 14-day free trial, which requires a credit card. Subscription plans on Fast.io pricing include Starter, Business, and Enterprise options tailored to different storage sizes and team seats.

For Claude (web, desktop, mobile): open Customize, then Connectors; add a custom connector and paste https://mcp.fast.io/mcp/tools; select Connect and sign in to Fastio in the window that opens; in a chat, turn Fastio on from the + menu under Connectors.

For developers deploying the Claude Code terminal agent, configure the server directly using the command line interface:

claude mcp add --transport http fastio https://mcp.fast.io/mcp/code

Then run /mcp inside Claude Code to sign in. A project .mcp.json entry needs "type": "http" and "url".

Once connected, Claude gains direct access to workspace search and retrieval tools. When asked to evaluate an issue across your archives, the assistant executes a targeted search, retrieves relevant citations, and synthesizes answers while consuming a tiny fraction of your Anthropic token rate limit.

Even with an optimized retrieval architecture, high-concurrency production systems will occasionally encounter transient rate limits during peak workloads. Handling these events cleanly requires inspecting Anthropic response headers, implementing jittered exponential backoff, and leveraging asynchronous batch processing for non-interactive tasks.

Inspecting Anthropic Rate Limit Response Headers

Every response from the Messages API includes standard HTTP headers detailing your organization's real-time rate limit status. Inspecting these headers in your application monitoring layer allows you to track headroom and throttle requests proactively before errors occur:

• retry-after: Returned when an HTTP 429 error occurs. Specifies the integer number of seconds your client must wait before retrying the request.
• anthropic-ratelimit-requests-limit: The total requests per minute allowed for the target model.
• anthropic-ratelimit-requests-remaining: The number of requests remaining in your token bucket for the current period.
• anthropic-ratelimit-requests-reset: The exact RFC 3339 timestamp when your request bucket will be fully replenished.
• anthropic-ratelimit-input-tokens-limit: The maximum input tokens per minute (ITPM) permitted.
• anthropic-ratelimit-input-tokens-remaining: The number of input tokens remaining (rounded to the nearest thousand).
• anthropic-ratelimit-input-tokens-reset: The RFC 3339 timestamp when the input token quota replenishes.
• anthropic-ratelimit-output-tokens-limit: The maximum output tokens per minute (OTPM) permitted.
• anthropic-ratelimit-output-tokens-remaining: Output tokens remaining before throttling.
• anthropic-ratelimit-output-tokens-reset: The replenishment timestamp for output tokens.

Implementing Jittered Exponential Backoff

When a request receives a 429 status code, client code must not immediately retry. Firing immediate retries will worsen server load and deplete replenishing bucket tokens.

Instead, inspect the retry-after header. If present, sleep for the specified duration plus a small randomized jitter (such as 100 to 500 milliseconds) to prevent synchronized retry waves across worker threads. If the header is missing, implement exponential backoff:

// Exponential backoff retry handler with randomized jitter
async function executeWithRetry<T>(
  apiCall: () => Promise<T>,
  maxRetries = 5,
  baseDelayMs = 1000
): Promise<T> {
  for (let attempt = 0; attempt < maxRetries; attempt++) {
    try {
      return await apiCall();
    } catch (error: any) {
      if (attempt === maxRetries - 1 || error?.status !== 429) {
        throw error;
      }
      const retryAfterSec = error?.headers?.get("retry-after");
      const delayMs = retryAfterSec
        ? parseFloat(retryAfterSec) * 1000 + Math.random() * 500
        : baseDelayMs * Math.pow(2, attempt) + Math.random() * 1000;
      await new Promise((resolve) => setTimeout(resolve, delayMs));
    }
  }
  throw new Error("Maximum retry attempts exceeded");
}

Anthropic's official client SDKs in Python and TypeScript include automatic retry logic by default. However, verifying that your custom worker loops do not bypass SDK retry handlers is critical for maintaining stability.

Asynchronous Batch Processing with the Message Batches API

For operations that do not require real-time streaming responses, such as nighttime document classification, bulk translation, or historical archive enrichment, developers should use the Message Batches API.

The Message Batches API provides dedicated throughput queues that operate completely independently from standard Messages API limits. Batch requests run asynchronously, completing within 24 hours at half the cost of on-demand pricing.

The Message Batches API supports up to 1,000 requests per minute to batch endpoints on Start, Build, and Scale tiers, with a processing queue capacity of up to 200,000 batch requests. Offloading heavy background extraction jobs to batch queues preserves your interactive Messages API rate limits for live user interactions.