Claude Opus 4.8 is Anthropic's Opus release for complex agentic coding and enterprise work, building directly on Opus 4.7.
- Input
- text image $5/M
- Output
- text $25/M
- Cache read
- $0.5/M
- Context
- 1M
- Knowledge cutoff
- 2026-01
Benchmarks
Vendor-published: Alibaba (Qwen) Anthropic ByteDance DeepSeek Google MiniMax Moonshot OpenAI Tencent Z.ai
Price in context
Where the price sits among 60 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-01 |
Prompt caching
| How it caches | explicit (opt-in) |
|---|---|
| Min prefix | 1,024 |
| Lifetime | 5m default, 1h option |
| Write cost | 1.25x (5m) / 2x (1h) |
Thinking
| Vendor control | thinking.type "adaptive" + output_config.effort |
|---|---|
| Accepted values | thinking.type adaptive · disabled; effort low · medium · high · xhigh · max; "enabled" returns 400 |
| Default | thinking off; effort high applied when the request sets nothing |
| Can be turned off | Yes |
| Thinking behaviour | Reasoning between tool calls always appears in thinking blocks with no beta header; display defaults to "omitted", so thinking blocks come back with an empty thinking field unless you set display "summarized"; earlier turns' thinking blocks are kept in context and billed as input. |
| 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 by default
- effort defaults to high
- fast mode available as research preview
- mid-conversation system messages
- min cacheable prompt lowered to 1,024 tokens
- high-res image input
One prompt, measured through the gateway
Claude Opus 4.8 passed · 3 sentences
Reasoning models generate a hidden "thinking" phase before producing their final answer, and we're billed for every one of those internal tokens even though they never appear in the user-facing output. Because this deliberation often runs several times longer than the answer itself, our token consumption per request grew substantially even though our request volume stayed flat. The upside is that this trade buys us materially higher accuracy on complex tasks, so the right question isn't just cost but whether the improved output quality justifies the per-query premium for each use case.
out 162 tok latency 4.2 s
Instruction following (exactly three sentences - countable), audience shaping (CFO register), and the hidden-thinking billing gap the token meters below expose.
Claude Opus 4.8 passed · 8/8 cases
## Fixed Function ```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 best = max(best, cur) return best ``` ## Explanation of the Bug The original code counted **transitions between equal adjacent elements** rather than the **length of the run** itself. It initialized `best` and `cur` to `0` and incremented `cur` only when a match was found, so a run of length *N* recorded a count of *N-1* (e.g., a single element `[5]` never enters the loop and returns `0` instead of `1`, and `[5, 5]` returns `1` instead of `2`)—this is the off-by-one. […]
out 495 tok latency 9.2 s
Whether the fix is actually correct (runnable), explanation density, and token efficiency on a bounded task.
Claude Opus 4.8 passed · 5/5 fields, guidance null
```json { "company": "Meridian Robotics", "quarter": "Q3", "revenue_usd_m": 412, "growth_pct": 11, "guidance": null } ```
out 72 tok latency 1.8 s
Schema obedience (no invented fields), hallucination pressure (guidance is explicitly withheld), and structured-output path differences.
Claude Opus 4.8 passed · 121 words, 0 banned, 1 question
**Introducing Cross-Provider Prompt Caching** Today we're launching prompt caching directly within our API gateway, designed to cut latency and reduce your inference costs. When identical or overlapping prompts hit the gateway, cached responses are served instantly instead of being routed to the underlying model provider again. What makes this different from provider-specific caching? Our system works across OpenAI, Anthropic, Google, and any custom endpoint you configure, so you maintain one consistent cache regardless of which model handles a request. You control cache duration, invalidation rules, and scope through simple configuration settings. Teams running high-volume workloads can expect meaningful savings on repeated queries and faster response times for end users. Cross-provider prompt caching is available now for all customers on paid plans.
out 258 tok latency 5.3 s
Constraint obedience (word budget, banned-word list, the single question), style fingerprint, and length control.
Use Claude Opus 4.8 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-4-8",
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-4-8",
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-4-8",
"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-4-8",
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-4-8")
.addUserMessage("Summarize this diff")
.reasoningEffort(ReasoningEffort.MEDIUM)
.build());
System.out.println(resp.choices().get(0).message().content().orElse(""));About Claude Opus 4.8
- The official what's-new page highlights better long-horizon agentic coding with improved compaction recovery, more reliable reasoning-effort calibration, and fewer skipped tool calls; Anthropic also describes it as a more effective collaborator that fixes the comment-verbosity and tool-calling issues seen on 4.7.
- New at launch: mid-conversation system messages that preserve prompt-cache hits, a lower 1,024-token cache minimum (down from 2,048), and a fast-mode research preview with up to 2.5x higher output speed at a premium rate.
- It carries a 1M-token context window, 128K output, adaptive thinking, and vision, plus computer use and the high-resolution image input introduced on 4.7.
- Adaptive thinking is off unless requested but triggers reasoning only where a turn needs it, which Anthropic says wastes fewer thinking tokens than 4.7 at the same effort level; effort defaults to high on every surface and reaches xhigh and max, with xhigh recommended for coding and high-autonomy work.
- The refusal object it documents returns a category and a human-readable explanation, so applications can route different classes of refusal differently.
- Anthropic now lists it among legacy models behind the Opus 5 generation.
- Synthorai offers it through the OpenAI-compatible endpoint developers already use.
FAQ
Is the Claude Opus 4.8 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 4.8.
What is Claude Opus 4.8 best at?
Better long-horizon coding with compaction recovery; mid-conversation system messages preserve cache hits; fast-mode preview with 2.5x output speed. See the About section for the full picture from the vendor's own release notes.
How much does Claude Opus 4.8 cost?
Claude Opus 4.8 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 4.8 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 1,024-token stable prefix to cache (TTL 5m default, 1h option). Claude Opus 4.8 caching guide →
How do I get access to Claude Opus 4.8?
Point your existing OpenAI SDK at base_url="https://synthorai.io/v1", set model="claude-opus-4-8", and you're done. One API key covers every model on the gateway.
What is Claude Opus 4.8's knowledge cutoff?
Claude Opus 4.8's knowledge cutoff is 2026-01, per the vendor's official documentation (as of 2026-07-09).
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.