Claude Opus 5 Pricing: Official Rates vs a 40% Route

Claude Opus 5 launched on July 24, 2026, at the same per-token price as Opus 4.8: $5 per million input tokens and $25 per million output tokens. What changed is everything around that number. Adjustable effort levels can push your bill up or down without touching the rate card, cache writes and reads are optional but turbocharge cost efficiency when used right, and fast mode doubles the rate for 2.5x output speed. The real story of Claude Opus 5 pricing is that the same sticker produces very different invoices depending on how you configure your calls.

This guide covers every rate on the official card, the hidden multipliers (thinking tokens, verbosity, regional surcharges), worked cost scenarios you can verify yourself, and the third-party route that runs Opus 5 at 40 % of the official price without sacrificing anything.

Claude Opus 5 Pricing: The Official Rate Card

The table below lists every pricing category Anthropic publishes for Opus 5, with the corresponding rate on OurToken (the unified API at 40 % of official pricing).

A few notes that matter for your budget:

Cache hits cost one‑tenth of standard input. This is the single biggest lever on the card. Repeat the same system prompt or repo context and the tenth call costs you $0.50/M instead of $5/M.

Binary is a flat 50 % off both input and output, but it is only available through Anthropic's own endpoint. If you route through a third‑party provider that supports batch, check whether the endpoint implements the /v1/messages?batch=true parameter.

Fast mode is a research preview shipping at 2x the standard rate for roughly 2.5x output speed. It is Anthropic‑first‑party only and does not combine with batch.

There is no long‑context premium. Every token inside the 1M context window bills at the same rate. A 100k prompt costs the same per token as a 500k prompt.

Where the rate card is misleading

The table above implies a linear model: send N tokens, get billed N × rate. In practice the final bill depends on three invisible factors that no rate card shows:

• Thinking tokens bill as output. Opus 5 enables adaptive thinking by default. The reasoning tokens the model generates internally before producing its visible answer are charged at the output rate. Two identical‑looking conversations can have very different thinking depths and therefore very different output token counts.

• Verbosity changes the token count, not the rate. Independent testing from Code Rabbit found Opus 5 consuming roughly 50 % more input tokens and 65 % more output tokens than GPT‑5.6 on identical code review work. The effective bill gap is wider than the $5‑vs‑$2 sticker suggests for tasks that encourage verbose reasoning.

• Fast mode and effort level are dials your engineers control. Flipping from medium to max effort is a single configuration flag that changes your unit economics, and no invoice line will tell you it happened.

Why Your Opus 5 Bill Is Not the Sticker Price

The simplest way to see the gap between sticker and bill is to compare the same task on two rate cards.

The numbers in each row are real (we work through the arithmetic below). The takeaway: even the most aggressive official configuration (cache + batch) can be undercut by a third‑party standard rate.

Thinking tokens are the hidden line item

When you call Opus 5 with the thinking parameter or when adaptive thinking is on, the model generates internal reasoning tokens that never appear in content[].text but do appear in usage.output_tokens. Those tokens bill at $25/M — the full output rate.

In practice, a 4k‑character visible answer can cost 8k–12k of billed output tokens once thinking is included. Always check the usage block in the response rather than guessing from visible output length.

Effort levels change the cost per completion

Opus 5 exposes an effort parameter (low, medium, high, max). Higher effort produces better answers on hard problems but uses significantly more thinking tokens. Anthropic's launch benchmarks plot performance per effort level for exactly this reason:

• low → minimal reasoning, fast, cheap, good for classification
• medium → default, balanced cost‑quality ratio
• high → deeper reasoning, useful for coding and planning
• max → frontier reasoning, expensive, use only for tasks that genuinely need it

The CLI argument or API parameter is one line of code; the cost difference between low and max on the same prompt can be 5–10x.

How to Cut Claude Opus 5 Costs

Cache the prefix

Any repeated prefix — system prompt, repo context, few‑shot examples — should be wrapped in cache_control. One cache write (at $6.25/M) saves you $4.50/M on every subsequent turn.

Practical rule: if the same text appears in three or more requests, cache it. The breakeven on a 5‑minute cache write is two reads (write $6.25 + two reads at $0.50 = $7.25 vs three standard inputs at $15.00 → $7.75 saved after three calls).

Batch what can wait

For classification, enrichment, evaluation, or any workload that tolerates asynchronous delivery, use Anthropic's Batch API. Batch is flat 50 % off and runs within 24 hours. Through a third‑party provider that does not offer batch, the standard rate may still match or beat Anthropic's batch price — run the arithmetic on your actual token mix.

Turn the effort dial down

Not every prompt needs frontier reasoning. Route summarization, extraction, and simple Q&A through Opus 5 at low or medium effort, or better yet through Claude Sonnet 5 ($2/$10 official, $0.80/$4.00 on OurToken).

Route routine work to a cheaper model

Opus 5 is for deep reasoning, long‑horizon agentic tasks, and complex software engineering. Day‑to‑day chat, classification, and lightweight generation belong on Sonnet 5. A model‑routing layer that sends cheap work to the cheap model and expensive work to Opus 5 can cut your blended rate by 50–70 % without users noticing the difference. LLM model routing covers the implementation in detail.

Worked Claude Opus 5 Cost Scenarios

Each scenario below shows the arithmetic on both rate cards so you can verify every number.

Scenario 1: a single summarization request (8k in / 1.2k out)

A simple document summarization call with 8,000 input tokens and 1,200 output tokens.

At 10,000 calls per month:

• Official: $700.00
• OurToken: $280.00
• Savings: $420.00 (60 %)

Scenario 2: a 40‑turn agent session with prompt caching

A coding agent maintains a 120,000‑token system prompt plus repo context and runs 40 turns. Each turn adds 1,500 new conversation tokens and produces 2,500 output tokens.

Without cache (official): 40 turns resend the full prefix each time.

With 5‑minute cache (official): one cache write, then 39 cache reads.

With cache (OurToken): same token counts at 40 % of each official rate.

Per‑session comparison:

• Official uncached: $26.80
• Official cached: $5.89
• OurToken cached: $2.36
• OurToken cached is 60 % cheaper than official cached and 91 % cheaper than official uncached.

Scenario 3: a batch enrichment job (60M in / 7.5M out)

Process 50,000 documents, each requiring 1,200 input tokens and 150 output tokens. Total volume: 60,000,000 input tokens (60 MTok) and 7,500,000 output tokens (7.5 MTok).

OurToken's standard rate ($195.00) is already 20 % cheaper than Anthropic's batch rate ($243.75), with no latency trade‑off.

Monthly rollup: the same workload on two rate cards

Combine the three scenarios into a typical team's monthly spend.

Verification: $2,365.50 − $947.00 = $1,418.50. $1,418.50 / $2,365.50 = 0.5997 ≈ 60.0 %.

Running Opus 5 Through One Compatible Endpoint

You do not need separate routing code for every provider. A unified API endpoint accepts the same messages payload, the same Model ID claude-opus-5, and the same cache_control markers while billing at 40 % of the official rate.

┌──────────────────────┐
│ Your Application     │
│ (SDK, cURL, Python)  │
└──────┬───────────────┘
       │ POST /v1/messages
       │ Authorization: Bearer YOUR_API_KEY
       │ {"model":"claude-opus-5",...}
       ▼
┌──────────────────────────────────┐
│ api.ourtoken.ai/v1/messages      │
│ Base URL: https://api.ourtoken.ai/v1
│ Model ID: claude-opus-5          │
│ Pricing: 40 % of official        │
└──────────────────────────────────┘

cURL smoke test

curl https://api.ourtoken.ai/v1/messages \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $OURTOKEN_API_KEY" \
  -d '{
  "model": "claude-opus-5",
  "max_tokens": 256,
  "messages": [
    {"role": "user", "content": "Estimate the cost of 8k in / 1.2k out tokens on Opus 5."}
  ]
}'

The response includes a usage object with input_tokens, output_tokens, cache_creation_input_tokens, and cache_read_input_tokens. Multiply by your rate and log every call for budget tracking.

Python: estimate cost before you ship

"""Cost estimator for Claude Opus 5 — official vs third‑party rates."""

RATES = {
    "official": {
        "input": 5.00, "output": 25.00,
        "cache_write": 6.25, "cache_read": 0.50,
    },
    "ourtoken": {
        "input": 2.00, "output": 10.00,
        "cache_write": 2.50, "cache_read": 0.20,
    },
}


def estimate_cost(
    input_tokens: int,
    output_tokens: int,
    cache_write_tokens: int = 0,
    cache_read_tokens: int = 0,
    calls: int = 1,
    rate_card: str = "official",
) -> float:
    r = RATES[rate_card]
    per_call = (
        input_tokens / 1_000_000 * r["input"]
        + output_tokens / 1_000_000 * r["output"]
        + cache_write_tokens / 1_000_000 * r["cache_write"]
        + cache_read_tokens / 1_000_000 * r["cache_read"]
    )
    return round(per_call * calls, 4)


if __name__ == "__main__":
    # Scenario 1 — single call
    off = estimate_cost(8000, 1200, rate_card="official")
    ot = estimate_cost(8000, 1200, rate_card="ourtoken")
    print(f"Single call — official: ${off:.4f}, ourtoken: ${ot:.4f}")

    # Scenario 2 — agent session with cache
    off2 = estimate_cost(60000, 100000, cache_write_tokens=120000,
                         cache_read_tokens=4680000, rate_card="official")
    ot2 = estimate_cost(60000, 100000, cache_write_tokens=120000,
                        cache_read_tokens=4680000, rate_card="ourtoken")
    print(f"Agent session — official: ${off2:.2f}, ourtoken: ${ot2:.2f}")

    # Scenario 3 — batch-equivalent
    off3 = estimate_cost(60_000_000, 7_500_000, rate_card="official")
    ot3 = estimate_cost(60_000_000, 7_500_000, rate_card="ourtoken")
    print(f"Enrichment job — official: ${off3:.2f}, ourtoken: ${ot3:.2f}")

Python: call the API with retry, timeout, and usage logging

import json
import os
import time
import urllib.error
import urllib.request


LOG_SESSION: list[dict] = []


def call_opus_5(prompt: str, max_tokens: int = 1024,
                retries: int = 3, timeout: float = 60.0) -> dict:
    api_key = os.environ.get("OURTOKEN_API_KEY")
    if not api_key:
        raise RuntimeError("Set the OURTOKEN_API_KEY environment variable")

    headers = {
        "Content-Type": "application/json",
        "Authorization": f"Bearer {api_key}",
    }
    body = json.dumps({
        "model": "claude-opus-5",
        "max_tokens": max_tokens,
        "messages": [{"role": "user", "content": prompt}],
    }).encode()

    for attempt in range(retries):
        req = urllib.request.Request(
            "https://api.ourtoken.ai/v1/messages",
            data=body, headers=headers, method="POST",
        )
        try:
            with urllib.request.urlopen(req, timeout=timeout) as resp:
                resp_data = json.loads(resp.read().decode())
                usage = resp_data.get("usage", {})
                LOG_SESSION.append({
                    "model": "claude-opus-5",
                    "input_tokens": usage.get("input_tokens", 0),
                    "output_tokens": usage.get("output_tokens", 0),
                    "cache_read": usage.get("cache_read_input_tokens", 0),
                    "cache_write": usage.get("cache_creation_input_tokens", 0),
                })
                return resp_data
        except urllib.error.HTTPError as exc:
            if exc.code in (429, 502, 503) and attempt < retries - 1:
                time.sleep(2 ** attempt)
                continue
            raise
        except urllib.error.URLError:
            if attempt < retries - 1:
                time.sleep(2 ** attempt)
                continue
            raise
    raise RuntimeError("Max retries exceeded")


if __name__ == "__main__":
    result = call_opus_5("What is the cost of 8k input tokens on Opus 5?")
    print(json.dumps(LOG_SESSION, indent=2))

Troubleshooting

Conclusion

Claude Opus 5 pricing is straightforward to read and easy to mis‑budget. The official rate card says $5/$25, but the real cost per completion depends on effort level, thinking depth, cache configuration, and whether you batch. The most expensive way to use Opus 5 is to call each turn without caching at max effort. The cheapest official way combines prompt caching and batch — but even that can be undercut by a unified API that charges 40 % of the official rate.

If your team already writes to the messages endpoint, switching the base URL from https://api.anthropic.com/v1 to https://api.ourtoken.ai/v1 is a one‑line change that drops your Opus 5 bill by 60 %. The same model ID, the same cache_control markers, the same usage response structure. You keep every data integrity check you already have. Get a free key with $5 in initial credit to verify the math against your own traffic.

FAQ

Q: What is the exact price of Claude Opus 5 per million tokens?

A: $5.00 per million input tokens and $25.00 per million output tokens on the official rate card. Cache reads cost $0.50/M, cache writes cost $6.25/M (5‑minute TTL) or $10.00/M (1‑hour TTL). Batch API prices are $2.50/M and $12.50/M.

Q: How does OurToken's Opus 5 price compare to Anthropic's?

A: OurToken charges $2.00/M input and $10.00/M output — exactly 40 % of the official rate. Cache reads are $0.20/M, cache writes $2.50/M. No minimum, no commitment.

Q: Does Opus 5 cost more than Opus 4.8?

A: No, the per‑token rate is identical ($5/$25). Opus 5 may produce more output tokens per completion because of adaptive thinking, but the rate per million tokens on the invoice is unchanged.

Q: What is Opus 5 batch pricing?

A: Anthropic's Batch API cuts the standard rate in half: $2.50/M input and $12.50/M output. Through OurToken, the standard rate ($2/$10) is already below Anthropic's batch price — you save without sacrificing synchronous response time.

Q: Does prompt caching actually reduce the bill?

A: Yes. A cache read costs $0.50/M instead of $5.00/M, a 90 % discount on every cached input token. In agentic sessions that repeat the same system prompt across multiple turns, prompt caching can cut the cost by 70–80 %. See the prompt caching guide for implementation patterns.

Q: What is the cheapest way to use Claude Opus 5?

A: Combine prompt caching for repeated prefixes, batch for asynchronous jobs, set effort to medium by default (raise to max only on hard problems), and route through a 40 % provider. The cheapest arch is also the simplest: one endpoint, one API key, one rate card.

Q: Can I use Opus 5 for real‑time user‑facing applications?

A: Yes. Opus 5 standard mode delivers the first token in under one second for most prompt shapes. Fast mode (2x the standard rate at roughly 2.5x output speed) is available through Anthropic's first‑party API but not through third‑party endpoints. Standard mode is fast enough for chat, code review, and interactive agentic sessions.