Claude Opus 5 Max Output Tokens: The Long-Form Limit That Matters

Claude Opus 5 API is Anthropic's flagship reasoning model — released July 24, 2026, per Artificial Analysis — and its max output token cap is the API setting most teams budget wrong. The million-token context window gets the headlines, but output is where the money, the truncation risk, and the real design decisions live; Claude Opus 5 carries the live spec sheet, and this is the straight-talk version of what the limit means for long-form work.

The arithmetic that changes everything: output costs five times as much as input. Anthropic's published API list price — verified by OrcaRouter on August 18, 2026 — is $5.00 per million input tokens and $25.00 per million output tokens. Because Opus 5 reasons before it answers, a meaningful share of that output budget is spent on thinking the model will never show you. Understand the cap and you control both the cost and the reliability of every long generation; ignore it and your reports arrive truncated and your bills arrive high.

What the max output cap actually is

A max output token cap is a ceiling on how many tokens a single response may contain. The model stops writing when it hits it, and whatever was unfinished simply does not exist. On Opus 5 that cap is a vendor API setting rather than a headline spec, so check the API docs — our reference is the official limit — rather than trusting a number a third party may have quoted against an older configuration. We are deliberately not repeating one here.

The classic confusion is mixing the cap up with the context window. Opus 5's context window is 1,000,000 tokens, per Artificial Analysis's independent model card — but that is the envelope the model reads from, not a budget it writes into. Input and output are separate ledgers, and a prompt that consumes most of the window leaves the response almost no room, even though the window itself never shrinks. A prompt pushing toward the million-token limit all but guarantees a short answer whether you want one or not.

Output is the expensive direction

Five-to-one is not a rounding error; it is the single biggest driver of Opus 5 costs. At $25.00 per million output tokens (Anthropic's list price, verified by OrcaRouter), a 4,000-token code diff costs about $0.10, a 20,000-token report about $0.50, and a long agent session that emits 100,000 output tokens around $2.50. Cached input, at $0.50 per million, is an 80% reduction on Anthropic's published rate card — which is why the cheapest thing you can do is keep your prompt stable and pay once for the parts that never change.

Independent testers see the same asymmetry. On Artificial Analysis's board (checked August 22, 2026), Opus 5 cost $2.34 per Intelligence Index task, and evaluating the full index cost $3,836.05 — driven by the roughly 100 million output tokens the model consumed to complete it, against a median tier of 72 million. That is the output-heavy workload in miniature: cheap to start, expensive to finish, and every token of reasoning billed at the output rate.

Scenario	Output tokens	Cost at Anthropic's $25.00/1M list rate
Single-file code diff	4,000	~$0.10
Chapter-length report	20,000	~$0.50
Long agent session, including reasoning	100,000	~$2.50

Reasoning tokens come out of the output budget

Opus 5 uses what Anthropic calls Adaptive Reasoning, which Artificial Analysis configures at four effort levels — max, xhigh, high, and medium. Thinking tokens are output tokens: the budget the model spends working through the problem comes out of the same $25.00-per-million ledger as the answer you actually read. On a genuinely hard task at max effort, the hidden reasoning can exceed the visible answer several times over — you are paying output rates for the thinking and the writing together.

OrcaRouter's own production telemetry shows why this matters in practice: p50 time-to-first-token of 7.34 seconds and p95 of 10.00 seconds over a seven-day window, across 491.5 million tokens of traffic. The flagship thinks before it answers, and it thinks in billable tokens. This is an output-quality model, not a latency model — which is exactly why the cap, and how much of it effort burns, deserves planning before you build anything on top of it.

The effort dial trades directly against output length

Effort buys quality, and quality costs output tokens. On Artificial Analysis's independent index, the same model scores 63.05 at max effort — the #1 result across 185 models on the current board — then 62.52 at xhigh, 61.48 at high, and 58.64 at medium (readings from August 22, 2026). The gap between max and medium is more than four points and is real, but so is the token cost of earning it. For a long deliverable you are choosing between two failure modes: max effort and a response that truncates at the cap, or medium effort and a full-length answer that is slightly weaker.

Two more numbers shape the decision. Opus 5's median output speed is 61.8 tokens per second (Artificial Analysis) — slower than several smaller models on the same board — so a long answer is also a slow one in wall-clock time, not just in dollars. And the answer's length is fixed by the cap regardless of effort. Pick the lowest effort level that still hits your quality bar, and treat the difference as output headroom for the answer itself.

Practical chunking and streaming strategies

For long-form work on Opus 5, four habits repay their setup cost quickly:

• Keep the stable part of your prompt cacheable. Repository, style guide, prior context — byte-identical between calls — rides the $0.50-per-million cached rate (an 80% reduction on Anthropic's published rate card) instead of the $5.00 input rate. Variable instruction last.

• Stream everything. At 61.8 tokens per second you can watch a long generation arrive, kill it early on a wrong turn, and avoid paying output rates for a full-length but useless response.

• Chunk generation, don't stretch it. For a long report, generate section by section with self-contained prompts and stitch afterwards; each chunk stays comfortably under the cap, and a failed chunk is cheap to retry. For code, emit and verify per-file or per-module diffs rather than one massive patch.

• Budget reasoning explicitly. Count the expected thinking tokens at your chosen effort level against the cap before you start — not after the response comes back truncated.

Finally, the failure-mode argument for a router. Very long generations are where timeouts and provider hiccups concentrate — the longer the stream, the more surface area for something to break. Whether you call Opus 5 through the vendor's own API or several third-party platforms, a router with automatic failover turns a stalled 20-minute generation into a retry rather than an incident. OrcaRouter passes Opus 5's list price through at 0% markup and carries alternatives behind the same key; that sentence stays true whether or not you use one — it is simply what a router is for.

The takeaway

Claude Opus 5's max output cap is the constraint that shapes everything the model is good at. For code generation, multi-file agent runs, and long reports, the winning pattern is the same: check the official limit in the API docs, price the output side at $25.00 per million before you commit, choose the lowest effort level that meets your quality bar, stream and chunk so a bad generation is cheap, and keep the stable part of the prompt in cache at $0.50. Skip any of that and the model still works — you just get truncated reports, five-to-one billing surprises, and 7.34-second waits for answers that never arrive. Budget the output and Opus 5 earns its flagship label; ignore it and it becomes the most expensive way to discover truncation.

Sourcing note: Release date, context window, effort ladder, per-task and full-index cost, and output speed are Artificial Analysis readings (board checked August 22, 2026). Prices are Anthropic's published API list rate, verified by OrcaRouter on August 18, 2026. Time-to-first-token and traffic figures are OrcaRouter's own seven-day production telemetry. The exact max output-token cap is a vendor API setting; refer to the official API documentation.