Claude Opus 4.7

claude-opus-4-7

Opus 4.7 is the next-generation product in the Anthropic Opus series, built specifically for long-running asynchronous agents. It builds on the coding and agentic strengths of Opus 4.6, delivering stronger performance on complex multi-step tasks and more reliable agentic execution in extended workflows. It is particularly effective for asynchronous agent pipelines where tasks unfold over time — large codebases, multi-stage debugging, and end-to-end project orchestration. Beyond coding, Opus 4.7 also improves knowledge work capabilities — from drafting documents and building presentations to analyzing data. It maintains coherence across long outputs and extended sessions, making it the default choice for tasks that require persistence, judgment, and follow-through.

Context window1.0M

ProviderClaude

Released2026/04/17

Playground

Pricing

The same model is available through multiple service channels — choose based on latency, reliability and cost.

Prices in $ / 1M tokens

To pick a channel, add a provider field to the request body, for example "provider": { "channel": "direct" }. Valid values are direct / stable / economical; omit it to use the default channel.

Direct

Direct upstream connection — best when you need native behavior and the full context window.

Input	Output	Cache read	Cache write
5.00/M	25.00/M	0.50/M	6.25/M

Overview

Input

Text Image

Output

Text

Claude Opus 4.7 API: Built for Long-Horizon Asynchronous Agents

Claude Opus 4.7 is the previous-generation flagship of the Anthropic Opus series, built specifically for long-running asynchronous agents. Building on Opus 4.6's coding and agent strengths, it further improves performance on complex multi-step tasks and delivers more reliable execution in extra-long workflows.

Opus 4.7 is particularly well-suited for asynchronous pipelines where tasks unfold over time: large-scale codebase refactoring, multi-stage debugging, and end-to-end project orchestration. It is also the first model in the Claude series to support high-resolution vision.

SeaWhale AI provides Opus 4.7 through the Anthropic native Messages API, supporting adaptive thinking, five effort levels (including xhigh), task budget, and full tool calling.

Get API Key · Model ID: claude-opus-4-7

Why Choose Claude Opus 4.7

Strong model for asynchronous agents — maintains reliable execution when tasks unfold over long periods
First high-resolution vision Claude — up to 2576 pixels on the long edge, with coordinates mapped 1:1 to pixels
New xhigh effort level — sits between high and max, the optimal level for coding and agent tasks
1M token context — standard pricing, no long-context premium
Task budget — give the agent loop a token limit, letting it pace itself and wind down gracefully

Core Capabilities

01 Long-Horizon Asynchronous Agents

Opus 4.7 proactively drives the full execution of complex tasks: breaking down goals, planning steps, calling tools, checking intermediate results, and dynamically adjusting its path until delivery. The longer the task horizon, the more pronounced its advantage over the previous generation.

Large-scale codebase refactoring and multi-stage debugging
End-to-end project orchestration
Stable tool calling in long workflows

02 High-Resolution Vision

Opus 4.7 is the first Claude model to support high-resolution images, with the long-edge limit raised from 1568 to 2576 pixels. This is a substantial improvement for computer use, screenshot understanding, and document and chart analysis — the coordinates returned by the model correspond directly to real pixels, with no scaling conversion needed.

High-precision parsing of screenshots, charts, and technical drawings
Precise positioning and clicking in computer use
Understanding of scanned documents and complex layouts

03 Memory and Knowledge Work

Opus 4.7 is notably stronger at reading and writing filesystem-based memory, and also shows significant improvements on tasks that require visual verification of its own output — .docx revisions, .pptx editing, and programmatic chart analysis.

Cross-session memory writing and retrieval
Document revision and presentation editing
Pixel-level data transcription from charts

04 More Literal Instruction Following

Opus 4.7 interprets prompts more literally and explicitly than the previous generation. It won't silently generalize an instruction to other items, nor will it infer needs you didn't state. This leads to higher precision and less rework.

More predictable in structured extraction and pipeline scenarios
Well-tuned prompts yield greater benefits
Explicitly state the scope for instructions that should apply broadly

Best Use Cases

Use Case	Description
Asynchronous coding agents	Large-scale codebase refactoring with tasks unfolding over time
Computer use	Interface understanding, precise positioning, and multi-step automation
Vision-intensive work	Parsing screenshots, charts, scanned documents, and technical drawings
Structured extraction	Production pipelines that require predictable behavior
Knowledge work	Document revision, presentation editing, research synthesis
Memory-driven assistants	Maintaining project context across sessions

Claude Opus 4.7 vs. Opus 4.8 and Opus 4.6

Capability	Claude Opus 4.7	Claude Opus 4.6	Claude Opus 4.8
Model ID	`claude-opus-4-7`	`claude-opus-4-6`	`claude-opus-4-8`
Context window	1M tokens	1M tokens	1M tokens
Vision resolution	2576px (high-resolution)	1568px	2576px
Effort levels	low → max (including xhigh)	low → max	low → max
Thinking config	Adaptive only	Adaptive + budget (deprecated)	Adaptive only
Sampling parameters	Not supported	Supported	Not supported
Task budget	Supported	Not supported	Supported

Billing details are subject to the real-time price card at the top of the page.

How to Use the Claude Opus 4.7 API

1. Create a SeaWhale AI API key Generate a key in the console and top up your balance.

2. Note the API changes Opus 4.7 no longer accepts temperature / top_p / top_k or budget_tokens; use output_config.effort to control reasoning depth.

3. Make a request

curl -X POST https://api.seawhaleai.com/v1/messages \
  -H 'Authorization: Bearer YOUR_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{
    "model": "claude-opus-4-7",
    "max_tokens": 64000,
    "thinking": {"type": "adaptive"},
    "output_config": {"effort": "xhigh"},
    "stream": true,
    "messages": [
      {"role": "user", "content": "Analyze this architecture document, identify scalability bottlenecks, and provide a refactoring path."}
    ]
  }'

At the xhigh or max effort levels, set a larger max_tokens (recommended starting at 64K) and use streaming.

FAQ

Is Opus 4.7 still worth using? Yes. It remains strong for asynchronous long-horizon agent and high-resolution vision tasks, its price tier is the same as 4.8, and existing prompts tuned for 4.7 can continue to be used.

Why does passing temperature cause an error? Opus 4.7 removed temperature, top_p, and top_k. For more determinism, use a lower effort with stricter prompts; for creative variation, steer with prompts.

What if I can't see the thinking content? Opus 4.7 defaults to display: "omitted", so the thinking block body is empty. To show it to users, set thinking.display to "summarized".

Why is token count different from 4.6? Opus 4.7 uses a new tokenizer, so the same text will use more tokens than 4.6. Use count_tokens to re-baseline your typical prompts and leave headroom in max_tokens.

How to choose between xhigh and max? Prefer xhigh for coding and agent tasks; only use max when correctness matters far more than cost, as it can sometimes overthink simple tasks.

What is the task budget? It gives the agent loop a total token limit. The model can see the countdown and prioritize accordingly, winding down gracefully. It's a suggested value; max_tokens remains the hard limit.

Why Choose SeaWhale AI for the Claude Opus 4.7 API

Full capability passthrough — Effort, task budget, high-resolution vision, and prompt caching are all available
Stable direct connection — no need to build your own proxy; latency and availability are guaranteed by the platform
Pay-as-you-go billing — no minimum spend; pay only for what you use
Multiple tiers coexist — shares one set of API keys with Opus 4.8, Fable 5, and Sonnet 5, routing by task value

API

API integration

Model IDUse this value as the model in inference requests

claude-opus-4-7

API KeyBearer token used to authenticate inference requests

Manage API keys

Base URLOpenAI compatible · /chat/completions

https://api.seawhaleai.com/v2/

provider OptionalSelects a service channel; omit it and the system picks the default

"provider": { "channel": "direct" }

claude-opus-4-7 usage examples

SeaWhale AI is compatible with the OpenAI API protocol, so you can call it with the OpenAI SDK or plain HTTP requests. Streaming is enabled by default.

About the provider parameter (optional, a SeaWhale AI extension): most models are served over several channels that differ slightly in price and reliability. Add a provider field to the request body to pick one; omit it and the system selects the default channel — normal calls are unaffected.

provider is not part of the official OpenAI protocol — it is a SeaWhale AI extension that only takes effect on this platform. The OpenAI SDK allows custom fields like this to pass through; see the examples below.

Value	Channel	Best for
`direct`	Direct	The official upstream link, for native behavior and the full context window
`stable`	Preferred	Balanced availability and speed — a good default for production traffic
`economical`	Economy	Cost first, well suited to batch processing and price-sensitive workloads

Available channels and their prices are listed under "Pricing" above (channels vary by model). Additional notes:

Syntax: "provider": { "channel": "direct" }.
If the requested channel is not enabled for that model, the request automatically falls back to the default channel and returns normally — it does not error.
With the official SDKs: in Python pass it via extra_body; in Node.js put it directly on the request object and it passes through. In TypeScript projects, add a // @ts-expect-error line to skip the type check.

cURLPythonNode.js

curl https://api.seawhaleai.com/v2/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer <API_KEY>" \
  -d '{
    "model": "claude-opus-4-7",
    "messages": [
      {"role": "system", "content": "You are a helpful assistant."},
      {"role": "user", "content": "Hello!"}
    ],
    "provider": { "channel": "direct" },
    "stream": true
  }'
# provider is optional — remove this line to use the default channel

from openai import OpenAI

client = OpenAI(
    base_url="https://api.seawhaleai.com/v2",
    api_key="<API_KEY>",
)

stream = client.chat.completions.create(
    model="claude-opus-4-7",
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "Hello!"},
    ],
    stream=True,
    # Optional: pick a service channel; omit to use the default
    extra_body={"provider": {"channel": "direct"}},
)

for chunk in stream:
    if chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="", flush=True)

import OpenAI from 'openai'

const client = new OpenAI({
  baseURL: 'https://api.seawhaleai.com/v2',
  apiKey: '<API_KEY>',
})

const stream = await client.chat.completions.create({
  model: 'claude-opus-4-7',
  messages: [
    { role: 'system', content: 'You are a helpful assistant.' },
    { role: 'user', content: 'Hello!' },
  ],
  stream: true,
  // Optional: pick a service channel; omit to use the default
  // @ts-expect-error provider is a SeaWhale AI extension, not in the OpenAI SDK types
  provider: { channel: 'direct' },
})

for await (const chunk of stream) {
  process.stdout.write(chunk.choices[0]?.delta?.content ?? '')
}