On 13 March 2026, Anthropic made the 1M-token context window generally available for Claude Opus 4.6 and Sonnet 4.6. The headline change wasn’t the size of the window, since it had been in beta before. It was the price. There’s no longer a long-context premium: a 900K-token request is billed at the same per-token rate as a 9K one.
That removes a real barrier for anyone who wants to give a model a whole codebase, a long contract set or a stack of research papers. It also makes it easier to spend a lot of money without noticing. This post covers what changed, what it actually costs, and how to use a huge context window sensibly.
What changed in March 2026
From Anthropic’s announcement and the pricing documentation:
- Standard pricing across the full window. Opus 4.6 is $5 per million input tokens and $25 per million output tokens. Sonnet 4.6 is $3 and $15.
- No beta header. Requests over 200K tokens just work.
- Full rate limits at every length. Your normal account throughput applies to long requests too.
- More media per request. Up to 600 images or PDF pages, up from 100.
- Wide availability. The Claude API, Amazon Bedrock, Google Cloud Vertex AI and Microsoft Foundry, plus Claude Code for Max, Team and Enterprise users on Opus 4.6.
On quality, Anthropic reports that Opus 4.6 scores 78.3% on MRCR v2, a multi-needle retrieval benchmark, at that context length. That’s the vendor’s own number, so treat it as a useful signal rather than a guarantee for your workload. Retrieval over a million tokens is still harder for any model than retrieval over ten thousand.
What a full-context request actually costs
Flat pricing is simple, but large numbers add up fast. Here’s the maths for one request with 900,000 input tokens and 4,000 output tokens:
- Opus 4.6: 0.9 × $5 = $4.50 input, plus 0.004 × $25 = $0.10 output, so about $4.60 per request.
- Sonnet 4.6: 0.9 × $3 = $2.70 input, plus 0.004 × $15 = $0.06 output, so about $2.76 per request.
That’s fine for a one-off analysis. It’s not fine for an interactive chat where every follow-up question resends the same 900K tokens. Ten follow-ups on Opus would cost around $46 in input tokens alone. This is where prompt caching becomes essential.
Prompt caching changes the maths
With prompt caching, you mark a large, stable part of the prompt (say, your codebase) as cacheable. The first request writes it to the cache at a premium, and later requests within the cache lifetime read it at 10% of the normal input price. According to the pricing docs:
- a 5-minute cache write costs 1.25× the base input price,
- a 1-hour cache write costs 2× the base input price,
- a cache read costs 0.1× the base input price.
Redo the Opus example with a cached 900K-token prefix. The first request costs about $5.63 in input (1.25 × $4.50). Every follow-up within five minutes costs about $0.45 in input. After two or three questions, you’re well ahead. Here’s the shape of it in Python:
import anthropic
client = anthropic.Anthropic()
with open("codebase_dump.txt") as f:
codebase = f.read()
response = client.messages.create(
model="claude-opus-4-6", # check the docs for current model IDs
max_tokens=4000,
system=[
{"type": "text", "text": "You are reviewing this repository."},
{
"type": "text",
"text": codebase,
"cache_control": {"type": "ephemeral"} # cache the big, stable part
}
],
messages=[{"role": "user", "content": "Where is authentication handled, and what are its weak points?"}]
)
print(response.usage) # check cache_creation_input_tokens vs cache_read_input_tokensAlways look at the usage fields in the response. They tell you whether you actually hit the cache. A small change at the start of the cached block, even a timestamp, invalidates it.
For jobs that don’t need an immediate answer, the Batch API halves the price of both input and output, and caching discounts still apply on top.
Opus 4.6 or Sonnet 4.6 for long context?
Both models support the full window, so the choice is the usual one: capability against cost.
- Choose Opus 4.6 when the task needs deep reasoning across the whole context: tracing a bug through many layers of a codebase, finding contradictions across a set of legal documents, or planning a large refactor where missing one dependency is expensive.
- Choose Sonnet 4.6 for broad, repeated or high-volume work: summarising many documents, answering routine questions over a knowledge base, or running an agent that makes many calls. At 60% of Opus’s price, the savings add up quickly.
A common pattern is to use Sonnet for the wide first pass and hand the interesting parts to Opus.
When not to use the whole window
A 1M-token window is a tool, not a default. There are good reasons to keep prompts smaller:
- Relevance still matters. The more irrelevant material you include, the more chances the model has to latch onto the wrong thing. A focused 50K-token prompt often beats a sprawling 800K one.
- Latency grows with input. Processing a million tokens takes time, which matters for anything interactive.
- Retrieval is often cheaper. If your data changes constantly, or you only ever need a few relevant passages, a search or RAG step to pick the right chunks is usually cheaper and faster than sending everything every time.
- Long conversations drift. In agent sessions, context fills up with old tool output. Anthropic has introduced context management features, including compaction for Opus 4.6 that summarises older parts of a conversation, as InfoQ reported. Use them, or trim the history yourself.
Practical tips for long prompts
- Put stable content first and the question last. That’s better for caching, and models tend to handle instructions well when they come after the material.
- Add structure. Wrap files or documents in clear delimiters with their names, like
<file path="src/auth.ts">. It helps the model cite and navigate. - Ask for locations. Requests like “quote the relevant lines and give file paths” make answers easier to check and discourage vague summaries.
- Cut the obvious noise. Lock files, build output, minified bundles and vendored dependencies waste tokens and rarely help.
- Measure, don’t guess. Log token counts and costs per request type for a week before assuming long context is cheap or expensive for your use case.
The bottom line
Making the full 1M-token window standard price is a genuinely useful change. It removes a pricing cliff that used to make long-context work awkward to budget. But the economics still reward the same habits as before: cache what’s stable, send what’s relevant, and pick the cheaper model when it’s good enough. Used that way, a million tokens of context is one of the most practical capabilities available to developers in 2026.
