Claude Opus 5 launched on July 24, 2026 at $5 per million input tokens and $25 per million output tokens—the same rate as Opus 4.8 and half the price of Fable 5. However, your actual invoice also depends on cache writes and hits, Batch API rates, fast mode, regional multipliers, and behavior changes that increase token usage. Use the calculations below to estimate costs before shipping, then verify them against real traffic by sending requests from Apidog and inspecting each response’s usage object.
The full Claude Opus 5 price table
Every rate below comes from Anthropic’s pricing documentation and applies to the claude-opus-5 model ID.
| Token category | Price per million tokens |
|---|---|
| Input (standard) | $5.00 |
| Output (standard) | $25.00 |
| Prompt cache write, 5 minute TTL | $6.25 |
| Prompt cache write, 1 hour TTL | $10.00 |
| Cache hits and refreshes | $0.50 |
| Batch API input | $2.50 |
| Batch API output | $12.50 |
| Fast mode input | $10.00 |
| Fast mode output | $50.00 |
Key pricing rules:
- Cache hits cost one tenth of standard input. Reused prompt prefixes are the largest direct cost lever.
- Cache writes have a premium. A 5-minute write is 1.25× standard input; a 1-hour write is 2×.
- Batch API pricing is 50% lower for both input and output.
- Fast mode is 2× standard pricing for 2.5× output speed. It is a research preview, available only through the first-party API—not Bedrock, Google Cloud, or Microsoft Foundry—and cannot be combined with Batch API.
- There is no long-context premium. The 1M-token context window is both the default and maximum window. Tokens are billed at the same $5 input rate regardless of context length.
That means a maximum-sized Messages API request has a defined ceiling:
1,000,000 input tokens × $5 / 1M = $5.00
128,000 output tokens × $25 / 1M = $3.20
---------------------------------------------
Maximum standard request cost $8.20
On the Batch API, the output-300k-2026-03-24 beta header raises maximum output to 300,000 tokens. At Batch output pricing, that output portion caps at $3.75.
Opus 5 vs. Opus 4.8, Fable 5, and Sonnet 5
| Model | Input / MTok | Output / MTok |
|---|---|---|
| Claude Opus 5 | $5.00 | $25.00 |
| Claude Opus 4.8 | $5.00 | $25.00 |
| Claude Fable 5 | $10.00 | $50.00 |
| Claude Sonnet 5 (intro, through Aug 31 2026) | $2.00 | $10.00 |
| Claude Sonnet 5 (from Sep 1 2026) | $3.00 | $15.00 |
Two implications matter for implementation:
Moving from Opus 4.8 to Opus 5 does not change your per-token rate. The model ID changes, but input and output unit prices do not. Your total spend can still change if Opus 5 produces more thinking tokens, longer responses, or more subagent work. The Opus 4.8 pricing breakdown still applies to the older model ID.
Opus 5 is half the per-token price of Fable 5. Anthropic claims Opus 5 is within 0.5% of Fable 5’s peak on CursorBench 3.2 and surpasses it on OSWorld 2.0 at roughly one third of the cost per task. These are vendor-run figures from the Opus 5 launch post, not independently reproduced results as of July 25, 2026. Treat them as claims and evaluate them against your own workloads.
For model-specific comparisons, see the Opus 5 vs. Fable 5 comparison and the Fable 5 pricing page.
Worked example 1: calculate a single request cost
Suppose a summarization request has:
- 8,000 input tokens
- 1,200 output tokens
Calculate each side independently:
Input: 8,000 / 1,000,000 × $5.00 = $0.040
Output: 1,200 / 1,000,000 × $25.00 = $0.030
--------------------------------------------
Total per request $0.070
At 10,000 calls per month:
10,000 × $0.070 = $700/month
For the same token volume:
- Fable 5:
$0.140per call, or$1,400/month - Sonnet 5 introductory pricing:
$0.028per call, or$280/month
Even though this request has nearly seven times more input tokens than output tokens, output represents 43% of the bill. Output costs five times more than input, so reducing output volume often matters more than reducing small input fields.
This is especially important on Opus 5 because thinking tokens are billed as output and adaptive thinking is enabled by default.
Worked example 2: reduce agent-session costs with prompt caching
Consider a coding agent with:
- 120,000-token system prompt and repository context
- 40 turns
- 1,500 new input tokens per turn
- 2,500 output tokens per turn
Without prompt caching
If you resend the entire context on every turn:
| Line item | Tokens | Rate | Cost |
|---|---|---|---|
Input: (120,000 × 40) + 60,000
|
4,860,000 | $5.00 | $24.30 |
Output: 2,500 × 40
|
100,000 | $25.00 | $2.50 |
| Total | $26.80 |
With a 5-minute prompt cache
Cache the stable 120,000-token prefix once, then pay cache-hit pricing for subsequent turns:
| Line item | Tokens | Rate | Cost |
|---|---|---|---|
| Cache write, once | 120,000 | $6.25 | $0.75 |
| Cache reads, 39 turns | 4,680,000 | $0.50 | $2.34 |
New input: 1,500 × 40
|
60,000 | $5.00 | $0.30 |
Output: 2,500 × 40
|
100,000 | $25.00 | $2.50 |
| Total | $5.89 |
That is a 78% reduction:
($26.80 - $5.89) / $26.80 = 78%
After caching, output becomes 42% of the total bill instead of 9%. Once your prompt cache is working, optimize output length and thinking-token volume next.
The 5-minute TTL is refreshed by cache reads. If turns arrive less than five minutes apart, one cache write can cover the entire session. If the agent may idle longer, use the 1-hour cache:
120,000 tokens × $10 / 1M = $1.20 cache write
Total session cost = $6.34
That is still 76% lower than the uncached run.
Worked example 3: use Batch API for asynchronous workloads
For non-interactive jobs, Batch API cuts input and output costs by 50%.
Assume you process 50,000 documents, each with:
- 1,200 input tokens
- 150 output tokens
| Path | Input cost | Output cost | Total |
|---|---|---|---|
| Standard | 60 MTok × $5.00 = $300.00 |
7.5 MTok × $25.00 = $187.50 |
$487.50 |
| Batch | 60 MTok × $2.50 = $150.00 |
7.5 MTok × $12.50 = $93.75 |
$243.75 |
The token volume and model output are unchanged. The Batch API saves $243.75 because the workload accepts asynchronous delivery.
Use Batch API for workloads such as:
- Evaluation runs
- Data backfills
- Nightly summaries
- Content classification
- Document enrichment
- Offline extraction pipelines
If the user does not need an immediate response, the standard endpoint costs twice as much.
Worked example 4: decide when fast mode is worth it
Fast mode doubles prices to $10 / MTok input and $50 / MTok output for roughly 2.5× output speed.
Using the 8,000-input, 1,200-output request from example 1:
Input: 8,000 / 1,000,000 × $10.00 = $0.080
Output: 1,200 / 1,000,000 × $50.00 = $0.060
---------------------------------------------
Total per request $0.140
That is exactly double the standard Opus 5 cost.
Fast mode is useful when users are actively waiting for generated output. It is difficult to justify for background jobs, especially because it cannot be combined with Batch API.
The four levers that move your Opus 5 bill
1. Cache prompt prefixes of 512 tokens or more
Opus 5 lowers the minimum cacheable prompt size to 512 tokens. Opus 4.8 required 1,024 tokens.
Add cache control to stable prompt prefixes, such as:
- System prompts
- Tool instructions
- Repository context
- Policy documents
- Reused few-shot examples
- Static retrieval context
Caching breaks even quickly:
- 5-minute TTL: ahead from the second request
- 1-hour TTL: ahead from the third request
For example, reuse a 700-token system prompt across 1,000 calls:
Uncached:
700,000 tokens × $5 / 1M = $3.50
Cached with 5-minute TTL:
Write: 700 × $6.25 / 1M = $0.0044
Reads: 699,300 × $0.50 / 1M = $0.3497
Total = $0.3541
That is roughly a 90% reduction for a prompt that could not be cached on Opus 4.8.
2. Route asynchronous work to Batch API
Batch is a direct 50% discount. Audit every workflow and ask whether the result must be synchronous.
A practical routing rule:
User is waiting for the response? Standard API or Fast mode
Result can arrive later? Batch API
Do not use fast mode for batch-style jobs: the two options cannot be combined.
3. Sweep output_config.effort against your own evals
output_config.effort controls how much the model thinks. Thinking tokens are billed as output tokens at $25 / MTok.
Opus 5 recalibrates low and medium, which Anthropic says are stronger than comparable settings on earlier Opus models.
Recommended starting points:
- Use
xhighfor coding and agentic work. - Test
high,medium, andlowwhere latency and cost matter. - Select the lowest effort level that passes your task-specific evals.
For example, if a task uses 8,000 thinking tokens at xhigh but 1,500 at low:
Tokens saved: 8,000 - 1,500 = 6,500
Cost saved: 6,500 × $25 / 1M = $0.1625 per task
At 100,000 tasks, that is $16,250 saved.
These numbers are illustrative. Run a fresh effort sweep instead of reusing Opus 4.8 settings. The effort parameter guide covers that process.
Important: lowering effort reduces thinking-token volume, not necessarily visible response length. If you need shorter answers, explicitly constrain the output:
Return no more than 5 bullet points.
Keep the response under 200 words.
Output JSON only.
4. Account for tool-use system prompt overhead
Tool definitions add system prompt tokens that you pay for.
On Opus 5, tool-use overhead is:
286 tokens for tool_choice: "auto" or "none"
That compares with:
- 290 tokens on Opus 4.8
- 675 tokens on Opus 4.7
The difference from Opus 4.8 is negligible:
4 tokens × $5 / 1M × 1,000,000 requests = $20
The difference from Opus 4.7 is larger:
389 tokens × $5 / 1M = $0.001945 per request
1,000,000 requests = $1,945
For more general optimization techniques, see the guide to cutting your Claude API bill.
Two line items that are easy to miss
inference_geo: "us" applies a 1.1× multiplier
Pinning inference to US-only infrastructure for compliance or residency multiplies every token category by 1.1.
| Category | Standard | With inference_geo: "us"
|
|---|---|---|
| Input | $5.00 | $5.50 |
| Output | $25.00 | $27.50 |
| Cache hits | $0.50 | $0.55 |
| Batch input | $2.50 | $2.75 |
| Batch output | $12.50 | $13.75 |
For the 10,000-call monthly workload from example 1:
Standard: $700/month
US pin: $770/month
On a $50,000 monthly bill, the multiplier adds $5,000. Set the pin only when your compliance requirements need it.
Priority Tier is not available on Opus 5
Opus 4.8 supports Priority Tier, but Opus 5 does not. If your capacity planning depends on Priority Tier commitments, evaluate this constraint before migrating.
See the Opus 4.8 to Opus 5 migration guide for this and other API changes.
Behavior changes that can increase token volume
Per-token pricing is only half the cost equation. Opus 5 behavior can increase the number of billed tokens if you keep existing request patterns unchanged.
Thinking is enabled by default.
On Opus 4.8, requests without athinkingfield did not use thinking. On Opus 5, the same request uses adaptive thinking. Those tokens are billed as output. Sincemax_tokenscaps thinking and visible output together, existing requests can also begin truncating.Opus 5 may delegate to subagents more readily.
Each subagent generates separately billed tokens. Put limits around delegation for cost-sensitive workflows.Opus 5 may verify work without being prompted.
If you carry forward instructions such as “double-check your work,” remove them where they are redundant. Anthropic’s prompting guide specifically recommends avoiding unnecessary verification instructions.
None of these change the unit price. All of them can change the invoice.
Confirm real spend with Apidog
The fastest way to validate estimates is to inspect the usage object from every response. It separates:
input_tokensoutput_tokenscache_creation_input_tokenscache_read_input_tokens
Use Apidog to send a request to the Messages endpoint with:
{
"model": "claude-opus-5"
}
Then add these checks to your request workflow:
- Duplicate a saved request for each effort level and compare thinking-token usage using identical prompts.
- Assert that
usage.cache_read_input_tokensis greater than zero. A broken cache should fail a test rather than appear as an unexpected invoice. - Store API keys in environment variables instead of request bodies. This prevents development requests from accidentally using production credentials.
- Watch the SSE stream during long generations to identify where output tokens are being spent.
Download Apidog to run these tests alongside the walkthrough in the Opus 5 API guide.
What you are buying at $5 / $25
Opus 5 offers frontier-class capability at half the per-token price of Fable 5, but it is not the top of the Claude stack.
Anthropic states that:
- Fable 5 is its most capable widely released model.
- Opus 5 trails Mythos 5 on cybersecurity exploitation and autonomous biology research.
The practical decision is usually not “Opus 5 or the highest tier?” It is whether the workload needs Opus at all.
For many teams, Sonnet 5 may be sufficient at $2 / $10 through August 31, 2026, increasing to $3 / $15 on September 1, 2026. Run both models against your own evaluation set before finalizing a budget.
For additional context, see the Claude Opus 5 overview, the Mythos-class explainer, and Anthropic’s canonical models overview.
FAQ
How much does Claude Opus 5 cost?
The standard API costs $5 per million input tokens and $25 per million output tokens. Cache hits cost $0.50 per million tokens, Batch API pricing is $2.50 / $12.50, and fast mode is $10 / $50.
Is Claude Opus 5 more expensive than Opus 4.8?
No, not per token. Rates are identical. Your total bill can still increase because thinking is enabled by default and responses may be longer. Measure real token usage before assuming costs are unchanged.
Is there a long-context surcharge on the 1M-token window?
No. The 1M-token context window is both the default and maximum, with no higher pricing tier for long inputs.
What is the cheapest way to run Claude Opus 5?
Cache reused prefixes of at least 512 tokens, route non-urgent jobs through Batch API, and test lower effort levels against your own evals. See the free and cheapest-path guide for more options.
Does the regional pin cost extra?
Yes. Setting inference_geo: "us" applies a 1.1× multiplier to all token categories, including cache hits and Batch API usage.
Top comments (0)