Claude Sonnet 5's Price Didn't Change. Your Bill Just Did.

The headline that was true and the bill that wasn't

Anthropic's own launch documentation states it plainly: Claude Sonnet 5 is “a capability upgrade over Claude Sonnet 4.6 at the same price.” That sentence is accurate. The per-token rate really did not move.

Source: Anthropic, “What's new in Claude Sonnet 5,” June 30, 2026. Nominally, Sonnet 5 is still the budget model next to Opus 4.8, at 40% of Opus's per-token output rate. That is the number that made the launch headlines. It is also not the number that determines your invoice.

The number Anthropic didn't put in the headline

Buried in the same documentation is a second fact: Sonnet 5 runs on a new tokenizer. Anthropic's own words: “The same input text produces approximately 30% more tokens than on Claude Sonnet 4.6.” It is not a rounding error, and it is not uniform across content types.

This is not an API-breaking change. Requests, responses, and streaming events keep the same shape, no code changes required, which is exactly why it is easy to miss. But Anthropic's docs are explicit that it changes anything measured or billed in tokens: “Per-request cost: per-token pricing is unchanged, but because the same text produces more tokens, the cost of an equivalent request can differ from Claude Sonnet 4.6.” Independent AI commentator Simon Willison reached the same conclusion reviewing the same launch: the nominal price is flat, but “the same input text produces approximately 30% more tokens,” which he called, correctly, a hidden price increase.

You can measure the inflation on your own prompts with Anthropic's token counting endpoint, run once against each model and diff the two input_tokens fields:

# Run the same prompt through both endpoints and compare input_tokens.
# The delta on your own text is the real number that matters, not the
# 30% average Anthropic cites, since the ratio varies by content type.

$ curl https://api.anthropic.com/v1/messages/count_tokens \
    --header "x-api-key: $ANTHROPIC_API_KEY" \
    --header "anthropic-version: 2023-06-01" \
    --header "content-type: application/json" \
    --data '{
      "model": "claude-sonnet-4-6",
      "messages": [{"role": "user", "content": "<your actual prompt here>"}]
    }'
#   ✓ OK: run against claude-sonnet-4-6, note input_tokens

$ curl https://api.anthropic.com/v1/messages/count_tokens \
    --header "x-api-key: $ANTHROPIC_API_KEY" \
    --header "anthropic-version: 2023-06-01" \
    --header "content-type: application/json" \
    --data '{
      "model": "claude-sonnet-5",
      "messages": [{"role": "user", "content": "<your actual prompt here>"}]
    }'
#   ⚠ FIX: run the identical string against claude-sonnet-5, diff input_tokens

Anthropic's migration guide tells you to do exactly this before shipping: recount every prompt, and revisit any max_tokens budget sized close to your expected output length, because the same limit that fit on Sonnet 4.6 can now truncate equivalent output on Sonnet 5.

The coupon that hides the hike

Here is the part that did not make the launch headline either. Anthropic is not charging the full $3/$15 rate yet. Introductory pricing of $2 per million input tokens and $10 per million output tokens, roughly a third off, is in effect through August 31, 2026. Anthropic states the intent directly: the discount is sized so migration feels “cost-neutral” while it is live, despite the tokenizer change.

The coupon is temporary. The extra tokens are not. On September 1, whatever workload you migrated to Sonnet 5 keeps consuming 30 to 42% more tokens than it did on Sonnet 4.6, but at the full nominal rate instead of the discounted one. Anthropic even flags this for high-volume customers directly: “Enterprise customers running high-volume workloads will want to benchmark their specific use cases carefully before assuming their bills won't change,” reported by VentureBeat's coverage of the launch.

What Artificial Analysis actually measured

Tokenizer math tells you the input side is inflated. It does not tell you the whole story, because Sonnet 5 also behaves differently once it is running. Artificial Analysis, an independent benchmark firm, stopped measuring price per token for this release and measured price per finished task instead, using its Intelligence Index methodology.

Read the three bars in order. Sonnet 4.6 costs $1.15 to finish an average task. Sonnet 5 costs $2.29, roughly double its predecessor. And Opus 4.8, the model priced 67% higher per token at $5 and $25, costs $1.99 a task, less than Sonnet 5. The model marketed as the efficient tier now costs more, in real dollars, than the flagship it is supposed to be the budget option next to.

Artificial Analysis also reported Sonnet 5's Intelligence Index score at 53, tied with GPT-5.5 on high reasoning, so this is not a story about Sonnet 5 being a worse model. It is a better model that got meaningfully more expensive to run per completed task, in a launch that led with a price tag suggesting otherwise.

Where the extra money is going: the agentic loop tax

The tokenizer explains part of the gap. The rest comes from how Sonnet 5 behaves once you send it a task. Anthropic turned on adaptive thinking by default for Sonnet-class models for the first time, and removed manual control over how much the model reasons before answering, pushing every request toward more deliberate, multi-step execution.

Artificial Analysis found Sonnet 5 burns roughly 40% more output tokens per task than Sonnet 4.6, and on agent-heavy benchmarks like AA-Briefcase and GDPval-AA it takes roughly three times as many turns, tool calls, self-checks, re-plans, to reach an answer. Push the new effort parameter to max and that climbs to six times the turns of the low-effort setting. Every one of those turns is a billed request. None of them are visible on a pricing page that only shows dollars per million tokens.

# What "more agentic" costs in practice, per completed task
# Sonnet 4.6: 1 turn baseline, ~500 output tokens
sonnet_46_cost = 1 * 500 * (15 / 1_000_000)          # = $0.0075 / turn-equivalent

# Sonnet 5 at default effort: 3x turns, 1.4x output tokens per turn
sonnet_5_cost  = 3 * (500 * 1.4) * (15 / 1_000_000)  # = $0.0315 / turn-equivalent
#   ⚠ FIX: 4.2x more per task before counting the tokenizer's input-side inflation

# Same math is why Artificial Analysis's task-level benchmark (which captures
# the full loop, not one call) shows ~2x on Sonnet 5 vs Sonnet 4.6, not a
# clean 1.3x you'd guess from the tokenizer number alone.

This isn't an Anthropic problem

The pattern generalizes. Per-token prices across the industry are flat or falling, release after release, that part of the story is real and it is why routing to cheaper models still matters. But tokens burned per completed task keep climbing alongside it, because “more agentic” means more tool calls and more self-correction before the model calls itself done, on every vendor's roadmap. OpenRouter's own June 2026 data shows DeepSeek V4 doubling its share of agentic token volume on the platform in six months, precisely because more of every task's token budget is now spent on multi-step tool use rather than a single completion.

Two trend lines, moving in opposite directions, rarely appear on the same chart because they come from different departments: pricing pages track dollars per token, and they are going down. Usage telemetry tracks tokens per task, and it is going up. Multiply them together and you get the number that actually lands on an invoice, and that number is not falling nearly as fast as the sticker price suggests.

How to actually measure it: cost per task, not cost per token

Cost per token was never the metric that protected a budget. It is the number a vendor can hold flat, or cut, while quietly changing what a token buys, through a tokenizer, a default reasoning mode, or an effort parameter defaulted to “on.” Cost per completed task is the only number immune to that move, because it is measured after all of those changes have already happened.

# task_cost_tracker.py — measure cost per completed task, not per call
import os
from openai import OpenAI

client = OpenAI(
    base_url=os.environ["MEGABRAIN_BASE_URL"],   # MegaBrain gateway: one endpoint, 500+ models
    api_key=os.environ["MEGABRAIN_API_KEY"],
)

def run_task_and_measure(task_id: str, model: str, messages: list) -> dict:
    total_input_tokens = 0
    total_output_tokens = 0
    turns = 0

    while not task_complete(task_id):
        resp = client.chat.completions.create(model=model, messages=messages)
        total_input_tokens += resp.usage.prompt_tokens
        total_output_tokens += resp.usage.completion_tokens
        turns += 1
        messages = advance_conversation(messages, resp)

    # MegaBrain reports zero-markup per-token cost for every call in the loop
    task_cost = megabrain_cost(model, total_input_tokens, total_output_tokens)

    return {
        "task_id": task_id,
        "model": model,
        "turns": turns,                       # ← the number the pricing page never shows
        "total_tokens": total_input_tokens + total_output_tokens,
        "cost_usd": task_cost,                # ← the number that actually matters
    }

# Compare models on cost PER TASK, not cost per token, before defaulting to one
for model in ["claude-sonnet-5", "claude-opus-4-8", "deepseek-v4-flash"]:
    result = run_task_and_measure("refactor-auth-module", model, messages)
    print(f"{model}: {result['turns']} turns, ${result['cost_usd']:.4f}/task")
#   ✓ OK: apples-to-apples comparison across the full agentic loop, not one call

The point is not that Sonnet 5 is a bad choice, it scores well and the frontier moves fast. The point is that no pricing page, from any vendor, currently reports the number that determines your bill. Only your own task-level telemetry does.

If you want to build this yourself

This is exactly the gap MegaBrain's gateway is built to close. Every request through MegaBrain, across all 500+ models including Claude Sonnet 5, Opus 4.8, and every open-weight alternative, is billed at zero markup with per-call token usage logged automatically, so a script like the one above needs no custom cost math per provider. Auto-routing can also send planning and orchestration calls to a frontier model while sub-calls that don't need Sonnet 5's adaptive thinking route to a cheaper model, cutting agentic-loop turns without cutting task quality.

For an always-on agent that runs this kind of loop continuously rather than on demand, BrainClawruns the same routing logic 24/7 on its own isolated VM, scheduling, memory, and shell access included, so the turn count that inflated Sonnet 5's bill gets routed intelligently instead of billed at the frontier rate by default.