What Is Claude Opus 4.7? Features, Benchmarks, Pricing, and Everything You Need to Know

TL;DR

Claude Opus 4.7 is Anthropic’s most capable generally available model, released April 16, 2026. It introduces high-resolution vision (up to 3.75 megapixels), a new xhigh effort level, task budgets for agentic loops, and a new tokenizer. It keeps the 1M token context window and $5/$25 per million token pricing from Opus 4.6 but ships several breaking API changes, including the removal of extended thinking budgets and sampling parameters.

Introduction

Anthropic released Claude Opus 4.7 on April 16, 2026. It replaces Opus 4.6 as the top-tier model in the Claude lineup and targets developers building autonomous agents, knowledge-work assistants, and vision-heavy applications.

The release matters for three reasons. First, it’s the first Claude model with high-resolution image support, more than tripling the pixel budget from 1.15 MP to 3.75 MP. Second, it introduces task budgets, a way to give the model a token allowance for an entire agentic loop rather than a single turn. Third, it ships breaking changes that require code updates if you’re migrating from Opus 4.6.

Core Specifications

Opus 4.7 uses a new tokenizer that may produce up to 35% more tokens for the same text compared to Opus 4.6. The per-token price is unchanged, but your effective cost per request may increase depending on the content.

What’s New in Claude Opus 4.7

High-Resolution Image Support

This is the headline addition. Previous Claude models capped image input at 1,568 pixels on the long edge (about 1.15 megapixels). Opus 4.7 raises that to 2,576 pixels on the long edge (about 3.75 megapixels).

The practical impact: screenshots, design mockups, documents, and photographs come through at much higher fidelity. Coordinate mapping is now 1:1 with actual pixels, eliminating the scale-factor math that computer-use workflows previously required.

Opus 4.7 also improves on specific vision subtasks:

• Low-level perception: pointing, measuring, and counting tasks are more accurate
• Image localization: bounding-box detection and natural-image localization show clear gains

Higher resolution means more tokens per image. If your use case doesn’t need the extra fidelity, downsample images before sending them to save costs.

New xhigh Effort Level

The effort parameter controls how much reasoning Claude invests in a response. Opus 4.7 adds xhigh above the existing high, medium, and low levels.

Use xhigh for coding and agentic tasks where quality matters more than latency. At this level, the model spends significantly more tokens on internal reasoning, resulting in better outputs for complex problems. Use high as the minimum for intelligence-sensitive work. Lower levels trade accuracy for speed and cost savings.

Task Budgets (Beta)

Task budgets solve a problem that anyone building agents has hit: how do you prevent a multi-turn agentic loop from consuming an unbounded number of tokens?

With task budgets, you give Claude a rough token target for the entire loop, including thinking, tool calls, tool results, and final output. The model sees a running countdown and uses it to prioritize work, skip low-value steps, and finish gracefully as the budget runs out.

Key details:

• Minimum task budget is 20,000 tokens
• It’s advisory, not a hard cap. Claude tries to stay within it but may overshoot
• It’s different from max_tokens, which is a hard per-request ceiling that the model doesn’t see
• Requires the beta header task-budgets-2026-03-13

For open-ended agentic tasks where quality matters most, skip the task budget and let the model run. Reserve task budgets for workloads where you need to control total spend.

Adaptive Thinking as the Only Thinking Mode

Extended thinking (where you set a fixed budget_tokens) is removed. Attempting to set thinking: {"type": "enabled", "budget_tokens": N} returns a 400 error.

Adaptive thinking is the sole thinking-on mode. In Anthropic’s internal evaluations, it consistently outperformed the fixed-budget approach because the model allocates reasoning tokens dynamically based on task difficulty.

Important: adaptive thinking is off by default. You must explicitly set thinking: {"type": "adaptive"} to enable it.

By default, thinking content is also omitted from responses. If you need to see the model’s reasoning (e.g., for streaming progress to users), set display: "summarized" in the thinking config.

Improved Memory

Opus 4.7 is better at writing to and reading from file-system-based memory. If your agent maintains a scratchpad, notes file, or structured memory store across turns, it will do a better job of updating and referencing those notes.

This matters for long-running coding agents, research assistants, and any workflow where context carries across sessions.

Knowledge Work Improvements

Specific gains on real-world knowledge tasks:

• Document redlining: better at producing and self-checking tracked changes in .docx files
• Slide editing: improved accuracy when generating and validating .pptx layouts
• Chart analysis: better at using image-processing libraries (like PIL) to analyze charts at the pixel level and transcribe data from figures

What Changed from Opus 4.6

Breaking API Changes

These apply to the Messages API. If you use Claude Managed Agents, there are no breaking changes.

Behavior Changes

These aren’t API-breaking but may affect your prompts:

• More literal instruction following. The model won’t silently generalize instructions from one item to another
• Response length scales with task complexity instead of defaulting to a fixed verbosity
• Fewer tool calls by default, preferring reasoning over action. Raise effort to increase tool usage
• More direct, opinionated tone with less emoji and less validation-forward phrasing
• Fewer subagents spawned by default in agentic workflows

If you’ve built prompting scaffolding to force Claude into specific behaviors (like “double-check the slide layout” or “give status updates”), try removing it. Opus 4.7 handles many of these patterns natively.

Pricing Breakdown

Opus 4.7 maintains the same per-token pricing as Opus 4.6 and 4.5:

The new tokenizer is the cost variable to watch. Because it may produce up to 35% more tokens for the same input text, your effective cost per request could increase even though the per-token price hasn’t changed. Test with the /v1/messages/count_tokens endpoint to measure the impact on your specific prompts.

The 1M context window has no long-context premium. A 900K-token request costs the same per-token rate as a 9K-token request.

Where to Use Opus 4.7

Strong Use Cases

• Autonomous coding agents: the xhigh effort level + task budgets give you fine-grained control over agent behavior and cost
• Computer use: 1:1 pixel coordinate mapping and 3.75 MP vision make screen interaction significantly more reliable
• Document processing: improved .docx, .pptx, and chart analysis for knowledge-work automation
• Long-context retrieval: 1M token window at standard pricing for large codebases, legal documents, or research papers
• Multi-session agents: better file-based memory for workflows that span many conversations

When Opus 4.7 May Be Overkill

• Simple Q&A or classification tasks: Haiku 4.5 ($1/$5 per MTok) or Sonnet 4.6 ($3/$15 per MTok) deliver strong results at a fraction of the cost
• Low-latency chatbot flows: the overhead of adaptive thinking and high effort levels adds latency
• Batch analytics on structured data: the Batch API with Sonnet is typically more cost-effective

How to Test Your Claude Opus 4.7 Integration with Apidog

Switching your model ID from claude-opus-4-6 to claude-opus-4-7 is the easy part. The harder part is validating that your existing prompts, tool definitions, and error handling still work correctly after the breaking changes.

Apidog makes this straightforward:

Import your API schema. Drop in your OpenAPI spec or manually define your Claude API endpoints. Apidog auto-generates request templates for the Messages API.

Create test scenarios. Set up multi-turn conversations that test your specific tool-use patterns. Apidog lets you chain requests, pass context between turns, and validate response schemas.

Compare model versions. Run the same test scenarios against claude-opus-4-6 and claude-opus-4-7 side by side. Check for differences in token counts, response structure, and output quality.

Validate breaking changes. Confirm that your updated thinking config works, that removed sampling parameters don’t sneak back in, and that the new tokenizer doesn’t blow past your max_tokens limits.

Debug tool-use payloads. Inspect the full request and response bodies for multi-turn tool-use conversations. Apidog’s visual interface makes it easy to spot malformed tool results or missing tool_use_id references.

Migration Checklist

If you’re upgrading from Opus 4.6:

• [ ] Update your model ID to claude-opus-4-7
• [ ] Replace thinking: {"type": "enabled", "budget_tokens": N} with thinking: {"type": "adaptive"}
• [ ] Remove temperature, top_p, and top_k parameters (or set to defaults)
• [ ] If streaming thinking to users, add display: "summarized" to your thinking config
• [ ] Increase max_tokens headroom to account for the new tokenizer (up to 35% more tokens)
• [ ] Test prompt caching — token counts will differ
• [ ] Remove prompt scaffolding for behaviors Opus 4.7 handles natively (status updates, self-checking)
• [ ] Run your test suite with Apidog to validate end-to-end behavior

Conclusion

Claude Opus 4.7 is Anthropic’s strongest generally available model. The high-resolution vision, task budgets, and xhigh effort level push it further into autonomous agent territory. The breaking changes (no more extended thinking budgets, no sampling parameters) require code updates, but the migration path is clear.

The new tokenizer is the main cost consideration. Per-token prices are flat, but the same prompt may cost more due to higher token counts. Test your workloads before switching production traffic.

For developers building API integrations, Apidog provides the testing and debugging environment you need to validate your migration and compare model performance across versions.