Anthropic charges for Claude API usage primarily by the number of input and output tokens processed. The rate depends on the model, while prompt caching, batch processing, inference geography, server-side tools, and managed-agent runtime can change the final bill.
The headline price per million tokens is therefore only the starting point. A useful estimate also needs the expected prompt and response sizes, cache behavior, tool calls, valid-result rate, and any retries.
This guide explains the current Claude API rates and calculates three example workloads. It also includes a standalone Python calculator for estimating a workload before deployment.
Quick Answer
Anthropic's standard first-party Claude API rates currently range from $0.10 per million input tokens and $0.50 per million output tokens for Claude Haiku 5.5 with prompts up to 100,000 tokens, to $10 per million input tokens and $50 per million output tokens for Claude Fable 5.1. Claude Sonnet 5.5 costs $2 per million input tokens and $10 per million output tokens, while Claude Opus 5.5 costs $4 and $20.
Those are standard global token rates before tax, negotiated discounts, caching, batch processing, data-residency adjustments, or tool charges. Claude Haiku 5.5 uses higher rates when a request's prompt exceeds 100,000 tokens.
Key Takeaways
- Anthropic bills input and output separately. Output tokens currently cost more than input tokens across the main Claude models.
- Claude app plans and API billing are different. Some current app plans list a fixed amount of monthly API credit, but that does not turn API usage into an unlimited subscription.
- Prompt caching can reduce the cost of repeated context. Cache writes cost more than ordinary input, while subsequent cache reads can be much cheaper.
- The Batch API discounts token charges by 50%. It fits asynchronous work that can wait, not an interactive response path.
- Tools can add more than tokens. Web search is billed per search as well as through the tokens added to the conversation; managed agents also incur running session-hour charges.
- Location can affect inference cost. Anthropic currently applies a 1.1x token-price multiplier to supported U.S.-only inference.
- Cost per accepted result matters more than cost per call. Retries, invalid outputs, and failed validation increase the number of billable attempts required to produce usable data.
Methodology and disclosure: Prices and rules were checked against Anthropic's official Claude Platform pricing documentation and Claude plan pricing on November 4, 2026. The examples below are calculations based on stated assumptions, not observations from a private Anthropic invoice. The Python calculator was syntax-checked and run locally but does not call the API or retrieve live prices. Verify the current documentation and your account terms before budgeting production usage.
Anthropic API Pricing at a Glance
The following table covers the main current models listed in Anthropic's first-party API pricing documentation.
| Claude model | Standard input per 1M tokens | Standard output per 1M tokens | Prompt condition | General positioning |
|---|---|---|---|---|
| Haiku 5.5 | $0.10 | $0.50 | Prompt up to 100,000 tokens | High-volume, latency-sensitive classification, extraction, and routing |
| Haiku 5.5 | $0.50 | $2.50 | Prompt over 100,000 tokens | Haiku workloads with long prompts |
| Sonnet 5.5 | $2 | $10 | Standard pricing across its documented context window | General production applications and agent workloads |
| Opus 5.5 | $4 | $20 | Standard pricing across its documented context window | Complex coding, knowledge work, and long-running agentic work |
| Fable 5.1 | $10 | $50 | Standard pricing across its documented context window | Demanding reasoning and long-horizon agentic work |
Source: Anthropic's model pricing table. Prices are in USD and were checked on November 4, 2026.
These prices do not prove which model will be cheapest for a particular application. A lower-priced model that repeatedly fails validation can cost more per accepted result than a stronger model that succeeds on its first attempt.
What Counts as an Input or Output Token?
Input tokens include the content sent to the model, such as:
- system instructions;
- user messages;
- conversation history;
- tool names, descriptions, and schemas;
- retrieved documents;
- tool results returned to the model;
- image input where applicable; and
- portions of the prompt written to or read from cache.
Output tokens include the model's generated response and billable thinking tokens where the selected feature and model use them. A short visible answer can therefore follow a larger amount of billable reasoning.
Token counts are not a permanent conversion from words or characters. Anthropic says the tokenizer used by Claude 4.7 and later models can produce approximately 30% more tokens for the same text than earlier models, with the exact difference depending on the content and workload. Count tokens using the exact model ID rather than assuming that a previous model's usage will remain unchanged.
How to Calculate Claude API Cost
For a basic request without caching or tools, use:
For a complete application estimate, add the applicable components:
Then account for any valid batch or geography modifiers. Do not apply every modifier blindly: Claude Managed Agents sessions, for example, do not support the Batch API discount.
Example: One Sonnet 5.5 Request
Assume one request uses:
- 5,000 uncached input tokens;
- 1,000 output tokens; and
- no tools, caching, or regional pricing adjustment.
The calculation is:
At 10,000 identical successful requests, that simplified workload costs $200. If only 90% of attempts produce an accepted result and failed attempts consume the same average tokens, producing 10,000 accepted results requires about 11,111 attempts and costs approximately $222.22 before tool or runtime fees.
Is Claude API Usage Included in a Claude Subscription?
Claude app plans and Claude Platform API usage should be budgeted separately. A subscription controls access and limits in Claude's web, desktop, and mobile applications. API requests are metered through Claude Platform.
The current plan page does list specific API-credit benefits for some subscriptions, so the answer is not simply that every subscription includes nothing.
| Claude plan category | Current API-credit treatment shown on the plan page |
|---|---|
| Free | No monthly API credit listed |
| Pro | No monthly API credit listed |
| Max | $100 in monthly API credits listed |
| Ultra | $200 in monthly API credits listed |
| Team | Up to $500 per month in pooled API credits listed |
| Enterprise | Seat price plus usage at API rates; account terms can vary |
Source: Claude's current plan page, checked November 4, 2026.
Treat these credits as a plan benefit with current terms, not as a promise of unlimited API use. Confirm eligibility, expiration, billing treatment, and account-level conditions in the live plan and console before relying on them.
How Prompt Caching Changes Anthropic API Pricing
Prompt caching is designed for content that repeats across requests, such as a long system prompt, policy document, tool definition set, or conversation prefix.
Anthropic currently documents these general multipliers relative to the model's base input rate:
| Cache operation | General multiplier | Cache duration |
|---|---|---|
| Five-minute cache write | 1.25x base input rate | Five minutes |
| One-hour cache write | 2x base input rate | One hour |
| Cache read | Normally 0.1x; selected current models have lower documented rates | Follows the preceding write duration and refresh behavior |
Current model-specific rates are:
| Model and prompt tier | 5-minute write per 1M tokens | 1-hour write per 1M tokens | Cache read per 1M tokens |
|---|---|---|---|
| Haiku 5.5, up to 100,000 prompt tokens | $0.125 | $0.20 | $0.01 |
| Haiku 5.5, over 100,000 prompt tokens | $0.625 | $1 | $0.05 |
| Sonnet 5.5 | $2.50 | $4 | $0.10 |
| Opus 5.5 | $5 | $8 | $0.20 |
| Fable 5.1 | $12.50 | $20 | $0.25 |
A cache write costs more than ordinary input, so caching does not automatically save money. The repeated prefix must be read again while the cache remains useful. Sparse traffic, unique prompts, or poor cache-key design can create write charges without enough subsequent reads.
Calculated Example: Cached Support Instructions
Assume 20,000 support-ticket requests use Sonnet 5.5. Each request has:
- 8,000 repeated policy and style tokens;
- 1,000 unique ticket tokens; and
- 600 output tokens.
Without caching:
For the cached calculation, assume the work runs in 20 sufficiently active bursts. Each burst makes one five-minute cache write and 999 cache reads. That produces 20 writes and 19,980 reads:
Under those assumptions, caching reduces the calculated total by $303.616, or approximately 63.3%. That is not a universal saving: it depends on the repeated prefix, request timing, cache-hit rate, and current model rates.
How Batch Processing Changes Claude API Cost
Anthropic's Batch API currently provides a 50% discount on input and output tokens for asynchronous processing. Anthropic also documents that caching and batch modifiers can be combined.
The current main-model batch rates are:
| Claude model | Batch input per 1M tokens | Batch output per 1M tokens |
|---|---|---|
| Haiku 5.5, prompt up to 100,000 tokens | $0.05 | $0.25 |
| Haiku 5.5, prompt over 100,000 tokens | $0.25 | $1.25 |
| Sonnet 5.5 | $1 | $5 |
| Opus 5.5 | $2 | $10 |
| Fable 5.1 | $5 | $25 |
Batch processing fits work such as:
- nightly extraction;
- classification;
- evaluation runs;
- dataset enrichment;
- document transformation; and
- other jobs that do not require an immediate response.
It is not a substitute for a synchronous customer-facing chat or interactive agent. Anthropic says batch requests may take up to 24 hours, and Claude Managed Agents sessions do not support the Batch API discount.
Other Charges That Can Affect a Claude Workload
U.S.-Only Inference
For Claude 4.6 and later models, Anthropic currently applies a 1.1x multiplier to supported U.S.-only inference. The multiplier applies to token-pricing categories, including input, output, cache writes, and cache reads. Global inference is the default at standard rates.
Partner-operated Amazon Bedrock and Google Cloud deployments can have their own regional pricing. Use the price sheet for the platform and region that will actually bill the account.
Web Search
Anthropic currently charges $10 per 1,000 successful web searches, or $0.01 per search, in addition to standard token costs for search-generated content. A tool error is not billed as a search, according to the current documentation.
One API turn can perform more than one search. Set and monitor the maximum number of tool uses rather than assuming one model request equals one search charge.
Web Fetch
Anthropic currently lists no separate web-fetch fee, but the fetched content that enters the conversation is billed as input. Its documentation gives illustrative content sizes of approximately:
- 2,500 tokens for an average 10 kB webpage;
- 25,000 tokens for a large 100 kB documentation page; and
- 125,000 tokens for a 500 kB research-paper PDF.
Actual token counts depend on the retrieved content and model. Use a content limit and count the resulting tokens rather than budgeting from file size alone.
Tool Definitions and Results
Tool names, descriptions, schemas, calls, and results can all add tokens. Anthropic also adds a model-specific tool-use system prompt when tools are present.
This matters most in long agent loops. A tool result returned on one turn becomes context on a later turn, so an expanding conversation can pay to process the same earlier material repeatedly unless context and caching are managed deliberately.
Browser and Computer Use
Browser and computer-use toolsets add definitions to the prompt. Screenshots, accessibility trees, page text, console information, and network results can add further billable input.
Budget from recorded usage rather than counting only the final text response. A browser task can consume far more context than its visible answer suggests.
Code Execution
Anthropic currently says code execution is free when used with supported web-search or web-fetch tools. When used separately, it has a five-minute minimum, an organization-level monthly free allowance, and a $0.05 per container-hour price above that allowance.
Do not subtract the full allowance independently for every project. Several workloads can share one organization's allowance. The calculator below therefore accepts only code-execution hours already determined to be billable.
Claude Managed Agents
Claude Managed Agents are billed for model tokens and running session time. The current runtime price is $0.08 per running session-hour. Time in documented idle, rescheduling, or terminated states is not counted as running time.
Managed-agent sessions can also incur web-search charges and applicable token multipliers. They cannot use the Batch API discount because the sessions are stateful and interactive.
Fast Mode
Anthropic currently lists premium fast-mode pricing for selected Opus models. This is a latency choice rather than a new token category: token charges use the fast-mode rates, while compatible cache and geography modifiers can still apply.
Because model support and fast-mode prices can change quickly, verify the current table before enabling it in a production cost estimate.
Calculated Workload 1: Structured Extraction
Assume a team needs 100,000 accepted document extractions. Each attempt uses:
- 2,500 uncached input tokens;
- 150 output tokens;
- no cache;
- no tools;
- global inference; and
- a 100% valid-result rate.
The calculated standard and batch totals are:
| Model | Standard token cost | Batch token cost |
|---|---|---|
| Haiku 5.5 | $32.50 | $16.25 |
| Sonnet 5.5 | $650 | $325 |
| Opus 5.5 | $1,300 | $650 |
| Fable 5.1 | $3,250 | $1,625 |
These values do not establish which model should be used. Evaluate representative documents and define an acceptance rule. If Haiku produces invalid fields that require repeated calls or manual review, its true cost includes that failure handling.
Calculated Workload 2: Support Drafting With Caching
Using the 20,000-ticket assumptions above, Sonnet 5.5 costs:
| Configuration | Calculated monthly token cost |
|---|---|
| Repeated 8,000-token prefix sent as ordinary input | $480.00 |
| Twenty cache writes and 19,980 cache reads | $176.384 |
This example shows why request timing matters. If the cache expires repeatedly between requests, the workload creates more writes and fewer reads than assumed here, increasing its cost.
Calculated Workload 3: Web-Research Agent
Assume a managed research workflow must produce 10,000 accepted results using Sonnet 5.5. Each attempt averages:
- 5,000 uncached input tokens;
- 1,000 output tokens;
- one successful Anthropic web search;
- no prompt cache;
- global inference; and
- a 90% valid-result rate.
Assume the managed sessions accumulate 400 running hours in total. To produce 10,000 accepted results at a 90% valid-result rate, the workload requires approximately 11,111 attempts.
| Cost component | Calculation | Calculated cost |
|---|---|---|
| Input | 11,111.11 x 5,000 / 1M x $2 | $111.11 |
| Output | 11,111.11 x 1,000 / 1M x $10 | $111.11 |
| Web search | 11,111.11 x $0.01 | $111.11 |
| Managed-agent runtime | 400 x $0.08 | $32.00 |
| Total | Sum of listed components | $365.33 |
| Cost per accepted result | $365.33 / 10,000 | Approximately $0.0365 |
The failed-attempt assumption is deliberately visible. If invalid attempts use fewer tokens or do not invoke web search, the actual total will be lower. If an agent loops through several searches or tool calls before failing, it can be higher.
Python Claude API Cost Calculator
The script below uses only Python's standard library. It was compiled and run with Python 3.11.2. It does not send an API request, read an Anthropic account, include taxes, or retrieve current prices. It calculates from hard-coded public rates checked on November 4, 2026.
Inputs are averages per attempt, except --agent-hours and --code-hours-over-free, which are workload totals. The success rate is:
For example, a 90% valid-result rate is entered as 0.90. The calculator assumes failed attempts consume the same average tokens and web searches as successful attempts. Split the workload into separate runs if that assumption is not appropriate.
Save the complete script as anthropic_api_cost.py:
Run the Web-Research Example
The tested output is:
What the Calculator Includes
The script supports:
- current standard rates for Haiku 5.5, Sonnet 5.5, Opus 5.5, and Fable 5.1;
- automatic Haiku short- versus long-prompt pricing based on the entered prompt-token categories;
- uncached input and output;
- five-minute and one-hour cache writes;
- cache reads;
- the Batch API token discount;
- the U.S.-only inference token multiplier;
- web-search fees;
- managed-agent running hours;
- code-execution hours already determined to be above the free allowance; and
- a valid-result rate for calculating expected attempts and cost per accepted result.
It deliberately rejects Batch API pricing combined with managed-agent runtime because Anthropic currently says managed sessions do not support batch mode.
What the Calculator Does Not Include
The script does not include:
- taxes;
- negotiated volume discounts;
- account-specific credits;
- partner-cloud pricing;
- fast-mode pricing;
- image-token calculations;
- storage or observability costs;
- a retry cap or variation between failed and successful attempts; or
- live price retrieval.
Update the RATES mapping and fixed feature prices whenever Anthropic changes its documentation.
How to Reduce Claude API Costs
Start With the Cheapest Model That Passes
Build a representative evaluation set and define what a valid result requires. Start with the lowest-cost model that might satisfy it, then move individual tasks to a stronger model only when the evidence warrants it.
Price the accepted result rather than the attempted call:
This catches the cost of retries, invalid JSON, missing fields, unsupported claims, and manual review.
Limit Output Deliberately
Output is currently the more expensive token category for the main models. Ask for only the fields or response length the application needs, use structured schemas where appropriate, and stop agent loops after a bounded number of iterations.
Cache Stable Prefixes
Cache long instructions, stable reference material, and repeated tool definitions when request timing makes a useful hit rate possible. Measure cache writes and reads separately; do not infer savings from the existence of a cache setting.
Batch Work That Can Wait
Use batch processing for offline jobs that can accept delayed results. Keep interactive requests on an appropriate synchronous path rather than delaying a user-facing workflow solely to obtain a discount.
Control Retrieved Content
Set content limits for web fetches, trim irrelevant HTML, and avoid sending the same full document on every turn. A large retrieved page can cost more in input tokens than the model's final answer.
Limit Tools and Agent Turns
Give the model only the tools needed for the task. Record searches, tool calls, tool-result sizes, loop iterations, and stop reasons. A low model rate cannot prevent a poorly bounded agent from repeatedly spending tokens and tool fees.
Track the Invoice Components Separately
At minimum, store:
- model ID;
- input tokens;
- output tokens;
- cache-write tokens;
- cache-read tokens;
- server-tool uses;
- running session time;
- accepted or rejected result;
- retry count; and
- task or customer identifier.
That makes it possible to investigate a higher bill without logging secrets or private prompt content unnecessarily.
Where Proxies Fit in a Claude-Powered Data Pipeline
Anthropic and Proxidize solve different layers. Claude performs model inference and offers managed AI tools. Proxidize provides the network route and exit IP for a scraper or browser that the customer operates.
| Architecture | Main cost components | Is a separate proxy inherently required? |
|---|---|---|
| Claude with Anthropic-managed web search or fetch | Claude tokens plus applicable Anthropic tool and runtime charges | No |
| Claude analyzing internal files or private application data | Claude tokens, application infrastructure, and data controls | No |
| An independently operated browser or scraper sending permitted public data to Claude | Collector compute, proxy traffic where needed, parsing, storage, retries, and Claude tokens | Sometimes |
| Location-specific public-web observations collected by your own system | Collector, suitable location routing, validation, storage, and Claude tokens | Often useful when the task requires that network location |
A proxy does not reduce Anthropic's token rate. It can be relevant when a team runs its own authorized browser or scraper and needs broad geographic routing, location-specific observations, or additional network paths.
Proxidize Residential Proxies provide global residential routing across supported countries, cities, and ISPs. Proxidize Mobile Proxies are relevant when the observation specifically requires a supported mobile-network context.
The collector still owns navigation, extraction, validation, scheduling, rate control, storage, and compliance. Customers are responsible for ensuring that web collection and automated access comply with applicable laws and third-party terms.
For a broader architectural comparison, see How AI Agents Access the Web. For proxy selection in an agent workflow, see Best Proxies for AI Agents and Claude Browser Use With Residential Proxies.
Final Verdict
Claude API cost is not one number. The model sets the base input and output rates, but the application determines how many tokens, cache operations, searches, tool results, retries, and running hours are actually consumed.
Start with representative tasks, record real usage, and calculate cost per accepted result. Use caching for genuinely repeated prefixes, batch processing for work that can wait, and strict limits for tools and agent loops. Recheck Anthropic's live documentation before every production budget or model migration.
If Claude analyzes data collected through an independently operated web pipeline, calculate the collection and inference layers separately. Proxies can support the network layer when the workflow needs them; they do not replace the scraper or change Claude's token prices.
Frequently asked questions
Anthropic charges primarily by input and output tokens, with rates determined by the Claude model. Current standard first-party rates range from $0.10 per million input tokens and $0.50 per million output tokens for Haiku 5.5 prompts up to 100,000 tokens, to $10 and $50 for Fable 5.1. Caching, batch processing, tools, inference geography, and managed-agent runtime can change the total.
It depends on the model and token category. Sonnet 5.5 currently costs $2 per million standard input tokens and $10 per million output tokens. Opus 5.5 costs $4 and $20. Haiku 5.5 and Fable 5.1 have different rates. Always identify whether a price refers to input, output, cache, batch, or another feature.
The current Claude pricing page does not list monthly API credits for Pro. API usage is metered through Claude Platform. Some other current Claude plans list fixed API-credit benefits, so check the live plan page and account terms rather than assuming every subscription behaves the same way.
Anthropic currently says new users receive a small amount of free credit for API testing. That is not the same as a permanent monthly free tier that a production workload can rely on. Confirm the credit and expiration shown in the account before budgeting.
Common causes include output tokens, thinking tokens, cache writes, tool definitions, tool results, web searches, repeated conversation context, retries, failed validation, U.S.-only inference, managed-agent runtime, and partner-platform pricing. Inspect the recorded usage fields and feature counts rather than estimating from the original user prompt alone.
No. Cache writes cost more than ordinary input. Savings require subsequent reads of the same eligible prefix while the cache remains useful. A workload with unique prompts or long gaps can pay for cache writes without generating enough discounted reads.
Anthropic currently documents a 50% discount on input and output token prices for eligible batch requests. It is intended for asynchronous work and can take up to 24 hours. Managed-agent sessions do not support the batch discount.
Yes. Anthropic currently charges $10 per 1,000 successful web searches, in addition to standard token costs for search-generated content. A single model request can perform multiple searches, so count actual search uses.
Anthropic currently lists no separate fee for web fetch, but fetched content is added to the model context and charged as input tokens. Large pages can therefore raise the token bill even without a separate fetch line item.
It can. Anthropic documents first-party API pricing and some Anthropic-managed marketplace billing, while partner-operated Bedrock and Google Cloud deployments can have separate regional and platform terms. Use the price sheet for the exact platform, model, and region that will invoice the account.
No. A proxy changes the network route used by a collector. It does not lower Anthropic's per-token rates. Proxy cost becomes a separate part of the architecture when a team operates its own authorized scraper or browser and sends the resulting data to Claude.