Claude Opus 5 is Anthropic's model for complex agentic coding and enterprise work, and its migration guide calls it a step-change improvement over Claude Opus 4.8 on deep reasoning, agentic and long-horizon tasks, and test-time compute scaling.
- Input
- text image $5/M
- Output
- text $25/M
- Cache read
- $0.5/M
- Context
- 1M
- Knowledge cutoff
- 2026-05
Benchmarks
Vendor-published: Alibaba (Qwen) Anthropic ByteDance DeepSeek Google MiniMax Moonshot OpenAI Tencent Z.ai
Price in context
Where the price sits among 65 comparable models
The bar shows how this model’s price compares with every other model of the same kind on Synthorai. The cheapest and the most expensive are named at each end. These are base rates; batch, region and cache-write discounts are on the pricing page.
Specs & limits
Tokens
| Context window (vendor spec) | 1,000,000 |
|---|---|
| Max output (vendor spec) | 128,000 |
| Knowledge cutoff | 2026-05 |
Prompt caching
| How it caches | explicit (opt-in) |
|---|---|
| Min prefix | 512 provider default is 1,024 |
| Lifetime | 5m default, 1h option |
| Write cost | 1.25x (5m) / 2x (1h) |
Thinking
| Vendor control | thinking.type + output_config.effort |
|---|---|
| Accepted values | thinking.type adaptive · disabled; effort low · medium · high · xhigh · max |
| Default | thinking on; effort high (Claude API and Claude Code) applied when the request sets nothing |
| Can be turned off | Yes |
| Thinking behaviour | Disabling thinking is accepted only at effort high or below, and thinking {"type": "disabled"} with xhigh or max returns a 400 error; display defaults to "omitted", so thinking blocks come back with an empty thinking field unless you set display "summarized". |
| Parameter | reasoning_effort |
| Values | minimal · low · medium · high the gateway's parameter surface - the vendor mapping above applies |
Model
| Modalities | text + image → text |
|---|
- 1M context is both the default and the maximum, with no smaller context variant
- minimum cacheable prompt lowered to 512 tokens
- high-resolution image input up to 2576 px on the long edge
- up to 300k output tokens on the Message Batches API with the output-300k-2026-03-24 beta header
- mid-conversation tool changes in beta
- fast mode is a research preview on the Claude API only
One prompt, measured through the gateway
Claude Opus 5 passed · 3 sentences
When reasoning is enabled, the model generates a hidden chain of "thinking" tokens before it writes the visible answer, and those internal tokens are billed at the output rate even though no one ever sees them — commonly 3–10x more tokens than the response itself. Because output tokens are priced several times higher than input tokens, that added volume hits us at our most expensive rate, which is why the bill roughly doubled while our request count stayed flat. The spend is controllable: we can cap the reasoning budget per call, route only genuinely hard requests to reasoning mode and cheaper models for the rest, and track cost per successfully completed task rather than cost per token, since a single correct answer usually beats three cheap retries plus human cleanup.
out 529 tok latency 9.0 s
Instruction following (exactly three sentences - countable), audience shaping (CFO register), and the hidden-thinking billing gap the token meters below expose.
Claude Opus 5 passed · 8/8 cases
## Fixed version ```python def longest_run(xs): if not xs: return 0 best = 1 cur = 1 for i in range(1, len(xs)): if xs[i] == xs[i - 1]: cur += 1 else: cur = 1 if cur > best: best = cur return best ``` ## The bug The counters were tracking the wrong quantity: `cur` counted *matching adjacent pairs* rather than *elements in the current run*, and both counters started at `0` instead of `1`. Since a run of length *n* contains only *n − 1* adjacent equal pairs, every result came back one too small — `[1, 1]` returned 1, `[3, 3, 3]` returned 2 — and a single-element list returned 0 because the loop body never executed and `best` kept its initial value of `0`. […]
out 1094 tok latency 16.1 s
Whether the fix is actually correct (runnable), explanation density, and token efficiency on a bounded task.
Claude Opus 5 passed · 5/5 fields, guidance "Withheld pending Q4 close"
```json { "company": "Meridian Robotics", "quarter": "Q3", "revenue_usd_m": 412, "growth_pct": 11, "guidance": "Withheld pending Q4 close" } ``` Notes on judgment calls: - **quarter**: "September quarter" is labeled Q3 because the text refers to an upcoming "Q4 close," implying a calendar-aligned fiscal year. No fiscal year is given. - **revenue_usd_m**: 412 is stated as constant-currency and hedged ("call it"), so it's approximate; the currency is not explicitly stated as USD. - **growth_pct**: "up eleven and change" means slightly more than 11, so 11 is a floor rather than an exact figure.
out 539 tok latency 7.6 s
Schema obedience (no invented fields), hallucination pressure (guidance is explicitly withheld), and structured-output path differences.
Claude Opus 5 passed · 123 words, 0 banned, 1 question
**Cross-Provider Prompt Caching** We're introducing Cross-Provider Prompt Caching in the API Gateway. Repeated system prompts, long documents, and few-shot examples are stored once at the gateway layer and reused across OpenAI, Anthropic, Google, and self-hosted models. Instead of paying full input token costs on every request, your application sends a cache reference, and the gateway rehydrates the context before forwarding it downstream. Why does that matter? Teams running high-volume agents and retrieval pipelines typically see input token spend fall 40 to 70 percent, with median latency dropping by several hundred milliseconds. Caches are scoped per project, encrypted at rest, and invalidated automatically when a prompt template changes. Enable it with a single header, and see the docs for TTL tuning and per-route controls.
out 1593 tok latency 19.1 s
Constraint obedience (word budget, banned-word list, the single question), style fingerprint, and length control.
Use Claude Opus 5 in 30 seconds
OpenAI-compatible: swap the base_url, keep your SDK. POST /v1/chat/completions
from openai import OpenAI
client = OpenAI(
base_url="https://synthorai.io/v1",
api_key="sk-syn-...",
)
resp = client.chat.completions.create(
model="claude-opus-5",
messages=[{"role": "user", "content": "Summarize this diff"}],
reasoning_effort="medium",
)
print(resp.choices[0].message.content)import OpenAI from "openai";
const client = new OpenAI({
baseURL: "https://synthorai.io/v1",
apiKey: "sk-syn-...",
});
const resp = await client.chat.completions.create({
model: "claude-opus-5",
messages: [{ role: "user", content: "Summarize this diff" }],
reasoning_effort: "medium",
});
console.log(resp.choices[0].message.content);curl https://synthorai.io/v1/chat/completions \
-H "Authorization: Bearer sk-syn-..." \
-H "Content-Type: application/json" \
-d '{
"model": "claude-opus-5",
"messages": [{"role": "user", "content": "Hello"}],
"reasoning_effort": "medium"
}'package main
import (
"context"
"fmt"
"github.com/openai/openai-go/v3"
"github.com/openai/openai-go/v3/option"
)
func main() {
client := openai.NewClient(
option.WithBaseURL("https://synthorai.io/v1"),
option.WithAPIKey("sk-syn-..."),
)
resp, _ := client.Chat.Completions.New(context.TODO(), openai.ChatCompletionNewParams{
Model: "claude-opus-5",
Messages: []openai.ChatCompletionMessageParamUnion{
openai.UserMessage("Summarize this diff"),
},
ReasoningEffort: openai.ReasoningEffortMedium,
})
fmt.Println(resp.Choices[0].Message.Content)
}import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.chat.completions.*;
import com.openai.models.ReasoningEffort;
OpenAIClient client = OpenAIOkHttpClient.builder()
.baseUrl("https://synthorai.io/v1")
.apiKey("sk-syn-...")
.build();
ChatCompletion resp = client.chat().completions().create(
ChatCompletionCreateParams.builder()
.model("claude-opus-5")
.addUserMessage("Summarize this diff")
.reasoningEffort(ReasoningEffort.MEDIUM)
.build());
System.out.println(resp.choices().get(0).message().content().orElse(""));About Claude Opus 5
- Anthropic's own selection guidance is to start here, reserving Claude Fable 5 for workloads that need the highest available capability.
- It is a drop-in upgrade at Opus 4.8's pricing of $5 and $25 per million input and output tokens, keeping the 1M-token context window as the default with no beta header, 128K max output, adaptive thinking, prompt caching, batch processing, the Files API, PDF support, and vision, with two documented gaps: the web fetch tool is unavailable and Priority Tier is unsupported.
- Two changes catch migrations.
- Thinking is on by default, so a request that omits the thinking field now reasons where it previously did not, and max_tokens still caps thinking and answer together.
- And thinking can be switched off only at effort high or below, because pairing disabled thinking with xhigh or max returns a 400.
- Effort runs low through max and defaults to high, prompt caching starts at a 512-token prefix rather than 1,024, fast mode is offered as a research preview, and the reliable knowledge cutoff is May 2026.
- Cybersecurity safety classifiers can decline a request, and Anthropic notes the model verifies its own work unprompted, so verification instructions carried over from older prompts now cause over-verification.
- Synthorai serves Claude Opus 5 through its OpenAI-compatible chat endpoint.
FAQ
Is the Claude Opus 5 API free to try?
Yes: new accounts get 10 trial calls and up to $1 in free credit, no card required. At $5/M input tokens, that credit alone covers roughly 24 requests of ~8K tokens against Claude Opus 5.
What is Claude Opus 5 best at?
Built for complex agentic coding and enterprise work; step-change over Opus 4.8 on deep reasoning and long-horizon tasks; thinking on by default, disabled only at effort high or below. See the About section for the full picture from the vendor's own release notes.
How much does Claude Opus 5 cost?
Claude Opus 5 costs $5 per million input tokens and $25 per million output tokens on Synthorai. That is the provider's list price, with no platform markup. Cached input tokens bill at $0.5/M.
Does Claude Opus 5 support prompt caching?
Yes, via opt-in: mark stable prefixes with cache_control breakpoints. Cached input tokens bill at $0.5/M vs $5/M uncached; prompts need a 512-token stable prefix to cache (TTL 5m default, 1h option). Prompt caching guide →
How do I get access to Claude Opus 5?
Point your existing OpenAI SDK at base_url="https://synthorai.io/v1", set model="claude-opus-5", and you're done. One API key covers every model on the gateway.
What is Claude Opus 5's knowledge cutoff?
Claude Opus 5's knowledge cutoff is 2026-05, per the vendor's official documentation (as of 2026-07-28).
Related models
Compare
Every value on this page is transcribed from the vendor's own documentation, linked above, and carries the date it was checked. Prices are compared across the catalogue; specification values that vendors define differently are shown with the difference stated rather than charted. Nothing here is measured by us, and nothing is scored.