Claude Haiku 5.5 Pricing: $0.10 per Million Input Tokens

Claude Haiku 5.5 pricing starts at $0.10 per million input tokens and $0.50 per million output tokens, a tenth of what Haiku 4.5 charges per token. The headline is true, and so is the fine print: a 100k-token pricing cliff, a heavier tokenizer and thinking that's on by default. This piece covers what Haiku 5.5 costs, where it fits next to Sonnet 5.5 and Opus 5.5, and what to test on Monday.

What Anthropic shipped

On October 7, Anthropic released Claude Haiku 5.5 (claude-haiku-5-5), pitched at summaries, compaction, database queries, classification and subagents. It's the first Haiku-class model with an adjustable effort setting. It's available on the Claude API, Amazon Bedrock, Google Cloud and Microsoft Foundry, with a 1M-token context window and up to 128K output tokens.

Claude Haiku 5.5 pricing, tier by tier

Prices per million tokens (MTok), from Anthropic's pricing page:

| Model | Input | Output | Cache read | | :-- | :-- | :-- | :-- | | Haiku 5.5, prompt up to 100k tokens | $0.10 | $0.50 | $0.01 | | Haiku 5.5, prompt over 100k tokens | $0.50 | $2.50 | $0.05 | | Haiku 4.5 | $1 | $5 | $0.10 | | Sonnet 5.5 | $2 | $10 | $0.10 | | Opus 5.5 | $4 | $20 | $0.20 |

The Batch API takes 50% off, so Haiku 5.5 batch is $0.05 input and $0.25 output for prompts up to 100k. At list price, Sonnet 5.5 costs 20x Haiku 5.5 per token on short prompts, and Opus 5.5 costs 40x. Anthropic also halved Sonnet 5.5's cache-read price to $0.10.

The 100k-token cliff

Haiku 5.5 is priced by prompt length. Once a request's prompt passes 100,000 tokens, that request is billed at the higher rates, and the length counts cache reads and cache writes too. So 100,000 input tokens cost $0.01 and 100,001 cost $0.05.

Even then it's 4x cheaper than Sonnet 5.5. But unlike Sonnet 5.5 and Opus 5.5, its 1M-token window isn't flat-priced.

The Haiku 5.5 tokenizer

Haiku 5.5 uses the same tokenizer as Claude 4.7 and later. The migration guide says the same text produces approximately 30% more tokens than on Haiku 4.5.

Do the arithmetic: 1.3 x $0.10 is $0.13 against $1.00, so identical text is roughly 87% cheaper on input before any thinking tokens. Anthropic's own figure is about 75% cheaper on average. The tokenizer also moves prompts: an 80k-token Haiku 4.5 prompt becomes roughly 104k, past the cliff.

Thinking tokens

Adaptive thinking is on by default at medium effort, and thinking tokens count toward max_tokens and are billed as output. Thinking blocks from earlier turns also stay in context as input, where Haiku 4.5 kept only the latest turn's. Long chats cost more than the tokenizer alone suggests.

Claude Haiku 5.5 vs Sonnet 5.5: where each fits

Anthropic's benchmarks are vendor-reported, so treat them as a prior, not a verdict. Sonnet 5.5 leads on every listed test:

• Terminal-Bench 4.0: 39.2% (Haiku) vs 70.6% (Sonnet)
• OSWorld 2.1 (offline): 72.4% vs 83.9%
• GDPval-AA v2.1: 1620 vs 1840 Elo
• FrontierCode 1.1: 46.4% vs 52.1% (Sonnet at Xhigh effort)

The gap is widest on terminal-style agentic work, and Anthropic says Sonnet 5.5 remains the pick for complex agentic coding. For Opus 5.5, the announcement describes it as a lead model with Haiku 5.5 as subagents, and gives no Opus figures.

So use Haiku 5.5 for high-volume work you can check cheaply: classification, extraction, summaries, compaction and subagent fan-out. Use Sonnet or Opus when one wrong step ruins a long task.

Effort is your second dial. Start at medium. low is cheapest, but the effort docs warn that in long agent prompts the model is more likely to skip a search, stop early or skip a check.

Caveats before you swap the model ID

• Remove temperature, top_p and top_k: values other than the defaults return a 400. Assistant prefill and thinking: {"type": "enabled", "budget_tokens": N} return a 400 too.
• Handle stop_reason: "refusal". Safety classifiers can decline a request, there's no server-side fallback, and the announcement says it still blocks penetration-testing-style requests.
• Priority Tier isn't supported.
• Bedrock and Google Cloud set their own regional pricing, and US-only inference on the Claude API adds a 1.1x multiplier.

Test it Monday: cost per successful task

Pick one high-volume task with a check you can automate. Run a few hundred real cases through Haiku 5.5 at low and medium and through Sonnet 5.5, then divide total spend by passes. The script reads token counts from usage, so it picks up the tokenizer change and the 100k tier on its own.

import anthropic

client = anthropic.Anthropic()

# USD per million tokens, from the official pricing page. Check it before you rely on it.
PRICES = {
    "claude-haiku-5-5": {
        "short": {"in": 0.10, "out": 0.50, "cache_read": 0.01, "cache_write": 0.125},
        "long": {"in": 0.50, "out": 2.50, "cache_read": 0.05, "cache_write": 0.625},
    },
    "claude-sonnet-5-5": {
        "short": {"in": 2.00, "out": 10.00, "cache_read": 0.10, "cache_write": 2.50},
    },
}


def request_cost(model, usage):
    read = usage.cache_read_input_tokens or 0
    write = usage.cache_creation_input_tokens or 0
    prompt_tokens = usage.input_tokens + read + write
    tiers = PRICES[model]
    p = tiers["long"] if prompt_tokens > 100_000 and "long" in tiers else tiers["short"]
    return (
        usage.input_tokens * p["in"]
        + read * p["cache_read"]
        + write * p["cache_write"]
        + usage.output_tokens * p["out"]
    ) / 1_000_000


def cost_per_success(model, effort, cases, passes):
    total, wins = 0.0, 0
    for case in cases:
        resp = client.messages.create(
            model=model,
            max_tokens=4096,
            output_config={"effort": effort},
            messages=[{"role": "user", "content": case["prompt"]}],
        )
        total += request_cost(model, resp.usage)
        text = next((b.text for b in resp.content if b.type == "text"), "")
        wins += int(resp.stop_reason != "refusal" and passes(case, text))
    return total / wins if wins else float("inf")


# CASES: your labelled examples. passes(case, text): your pass/fail check.
for model, effort in [
    ("claude-haiku-5-5", "low"),
    ("claude-haiku-5-5", "medium"),
    ("claude-sonnet-5-5", "medium"),
]:
    print(model, effort, cost_per_success(model, effort, CASES, passes))

CASES and passes are yours to supply. Cache writes are priced at the five-minute rate, and refusals and max_tokens cutoffs count as failures. If Haiku clears your bar, route that task to it and escalate the failures to Sonnet.

A 20x list-price gap only pays off if the cheaper model passes your checks, so measure cost per successful task before you reroute production traffic.