Claude Haiku 5.5 Pricing: $0.10/$0.50 and a Cost-Per-Task Routing Test

Claude Haiku 5.5 costs $0.10 per million input tokens and $0.50 per million output tokens for prompts up to 100,000 tokens. Above that length the rates rise to $0.50 and $2.50. Anthropic announced it on 7 October 2026. The headline price is low, but your bill depends on prompt length, caching and how many tasks the small model gets right the first time.

This post prices three task shapes with the arithmetic shown, explains the 100,000-token threshold, compares Haiku 5.5 with Qwen3.8 Flash, and sets out a routing rule. Last verified 2026-11-09.

How much does Claude Haiku 5.5 cost?

Anthropic's launch page lists two prices for each line, split at a 100,000-token prompt. The first figure applies to prompts up to 100,000 tokens, and the second to longer prompts. Prices are US dollars per million tokens.

Anthropic's own wording is that Haiku 5.5 is "priced 90% lower than Claude Haiku 4.5 for requests up to 100,000 tokens", and "50% lower for requests over 100,000 tokens". The page adds that "on average, it now costs around 75% less to run". Anthropic says nine in ten Haiku 4.5 requests fell within the cheaper prompt tier, and that its estimate accounts for the new tokenizer using slightly more tokens. It does not publish enough detail for us to reproduce the average. Our arithmetic on the table matches the first two claims: $0.10 against $1.00 is 90% lower, and $0.50 against $1.00 is 50% lower.

Two more facts from Anthropic's pricing page. Batch processing is half price, so Haiku 5.5 batch rates are $0.05 input and $0.25 output up to 100,000 tokens. One-hour cache writes cost $0.20 up to the threshold, against $0.125 for five minutes. The API model ID is claude-haiku-5-5, and the launch page says it is "available now on all platforms, including Amazon Web Services, Google Cloud, and Microsoft Azure".

Anthropic also lists caveats worth keeping. The new tokenizer means Haiku 5.5 "uses slightly more tokens per task". And "Sonnet 5.5 and Opus 5.5 remain better choices for complex agentic coding tasks". Customer results on the page come from the companies' own early testing. The announcement gives no context window or maximum output figure, so we state none.

What changes at 100,000 tokens?

The price changes for the whole request, not just the tokens above the line. Anthropic's pricing page says the request's prompt length counts input tokens, cache reads and cache writes together. A request over 100,000 tokens "pays the higher prices" even when part of the prompt is a cache hit. Each request is priced on its own.

That creates a cliff. Our arithmetic, input only:

• A prompt of 100,000 tokens: 100,000 x $0.10 per million = $0.0100.
• A prompt of 100,001 tokens: 100,001 x $0.50 per million = $0.0500, five times the cost for one extra token.

Output tokens move from $0.50 to $2.50 per million as well, so the long request also pays five times as much for what it writes.

Compare that with the other Claude models on the same page. Sonnet 5.5 has one rate at $2 and $10. Anthropic's pricing page says Claude 4.6 and later models, except Haiku 5.5, include the full 1M context window at standard pricing. Haiku 5.5 is the exception. The long-prompt rate is still cheaper than Haiku 4.5, but the structure rewards short prompts.

Three practical consequences, labelled as our inference:

1. Count tokens before sending. If a prompt sits near 100,000 tokens, a small trim saves 80% of the input cost.
2. Do not pad. Adding retrieved documents to a prompt that was under the line can cross it.
3. Chunking can beat one long call, with a cost. Two requests of 75,000 tokens are priced at the low rate. Whether chunking works depends on whether the answer needs cross-chunk context. We show an example below.

What does a task cost? Three worked examples

Per-token price is the number on the rate card. Cost per task is what you pay for one finished piece of work. Our post on Opus 5.5 pricing explains the difference. These examples are illustrative: the token counts are our assumptions, not measurements, and tokenizers differ between vendors.

The arithmetic for the first row on Haiku 5.5: 2,000 x $0.10 per million = $0.0002, plus 200 x $0.50 per million = $0.0001, so $0.0003. On Sonnet 5.5: $0.004 plus $0.002 is $0.006. That is a factor of 20.

The long-document row shows the cliff. At 150,000 tokens the prompt is over the line, so Haiku 5.5 charges $0.50 and $2.50: 150,000 x $0.50 per million = $0.075, plus 2,000 x $2.50 per million = $0.005, so $0.08. The gap to Sonnet 5.5 narrows from 20 times to 4 times. If the task splits into two 75,000-token calls of 1,000 output tokens each, the cost is 2 x ($0.0075 plus $0.0005) = $0.016, one fifth of the single call. That only works if each half can be answered alone.

Caching changes the picture for repeated prompts. Suppose the extraction task has a 6,000-token fixed instruction block and 2,000 tokens of new content. After the first call writes the cache, each later call costs 6,000 x $0.01 per million = $0.00006 for the cached part, plus 2,000 x $0.10 per million = $0.0002 for the new part, plus $0.0005 for 1,000 output tokens. That is $0.00076, against $0.0013 uncached. The write costs $0.125 per million against $0.10 uncached, a premium of $0.025 per million, and each read saves $0.09 per million, so one reuse pays the write back. That is our arithmetic on the rate card. Prompt caching has its own pricing rules by vendor, which we compare in prompt caching pricing compared.

One caution on all three rows. Haiku 5.5 uses a new tokenizer and Anthropic says it uses slightly more tokens per task. We have not applied an adjustment, because Anthropic gives no figure. Measure your own token counts.

Haiku 5.5 vs Qwen 3.8 Flash: cheaper per task?

On Alibaba's International (Singapore) Model Studio page, updated 7 November 2026, the qwen3.8-flash API model costs $0.15 per million input tokens and $0.47 per million output tokens, in a single tier up to 1 million tokens.

Read the table in two parts. Up to 100,000 tokens, Haiku 5.5 is cheaper on input and about the same on output. Our arithmetic gives $0.00030 against $0.00039 on the triage task, and $0.00130 against $0.00167 on extraction. Over 100,000 tokens, the Qwen model is cheaper on both lines: $0.02344 against $0.08 in the long-document case.

Three caveats stop this being a verdict. First, tokenizers differ, so 2,000 tokens for one model is not 2,000 for the other. Second, we found no published head-to-head quality comparison of these two models, so price per task says nothing about success per task. Anthropic's own benchmarks show where Haiku 5.5 stands against its siblings (vendor-reported): GDPval-AA v2.1 at 1620 against 1840 for Sonnet 5.5, and Terminal-Bench 4.0 at 39.2% against 70.6%. Third, Alibaba's page lists no batch label for these rows in Singapore, and its Context Cache page excludes qwen3.8-flash from the general 125% creation and 10% hit ratios, pointing to the console for actual prices. Cache prices for this model are not confirmed. Our Qwen 4 release post lists the rest of the Qwen API prices.

Our view: choose by measured success rate on your tasks, then by cost. At these prices the two are close enough that quality and data location decide.

How capable is Haiku 5.5 compared with its siblings?

Price only matters if the model can do the job. Anthropic's launch page prints benchmark results (vendor-reported, not independently reproduced) for Haiku 5.5, Haiku 4.5, OpenAI's GPT-6 Luna and Sonnet 5.5.

Read the pattern, not the decimals. Haiku 5.5 is far ahead of Haiku 4.5 and ahead of GPT-6 Luna on every row where Anthropic shows both. It trails Sonnet 5.5 everywhere, and the gap is widest on the terminal task. That fits Anthropic's own advice to use Sonnet 5.5 or Opus 5.5 for complex agentic coding. For your workload, the benchmark that counts is a replay of your own tasks.

When should you route to a small model?

Route when most of your traffic is easy, a wrong answer is cheap to catch, and you can tell the difference. A small model is the default, and a larger one handles what the small one cannot.

Good first candidates, in our view:

• Classification and triage. Short prompts, a fixed set of labels, and easy checks.
• Field extraction. Outputs that validate against a schema.
• Summaries of short inputs. Where an occasional weaker summary costs little.
• First-pass drafts that a person reviews anyway.

Poor candidates are the long, multi-step agentic coding tasks where Anthropic itself says Sonnet 5.5 and Opus 5.5 remain better, and tasks where an unnoticed error is expensive.

The routing pattern has four parts:

1. Small model first. Send every request to Haiku 5.5, or a comparable small model.
2. Check the answer. Use a schema check, a confidence signal or a simple rule. Without a check, escalation is guesswork.
3. Escalate on failure. If the check fails, send the same request to a stronger model.
4. Fall back on errors. If a provider is down or rate limiting, a chain moves the request to another model.

For the broader pattern, see intelligent LLM routing.

What does routing save?

Take 100,000 triage requests a month at 2,000 input and 200 output tokens each. These are our assumptions.

• All on Sonnet 5.5: $0.006 per request, so 100,000 x $0.006 = $600.
• All on Haiku 5.5: $0.0003 per request, so 100,000 x $0.0003 = $30.
• Routed, with 15% escalating: every request pays Haiku first, $30, then 15,000 escalated requests pay Sonnet, 15,000 x $0.006 = $90. Total $120.

That is 80% lower than all-Sonnet. The 15% is an assumption, not a measurement. At 5% escalation the bill is $30 plus $30, or $60. At 30% it is $30 plus $180, or $210. An escalated request is paid for twice, once on the small model and once on the large one, and the arithmetic above includes both. Our arithmetic puts break-even against all-Sonnet at about 95% escalation for this task shape, because Haiku's first pass is so cheap.

Do not read $120 as a forecast. The result depends on two numbers you must measure: the share of requests the small model handles acceptably, and the cost of the ones it gets wrong and nobody catches. A failed first pass that is accepted is worse than a $0.006 escalation. Our post on why LLM prices are falling explains why the rate card keeps moving, and our post on hidden reasoning-token costs explains why token counts decide the rest.

A short method:

1. Pull 30 days of real prompts and split them by task type.
2. Replay 100 of each type on the small and the large model.
3. Score both against the answers you accept.
4. Price each result at the actual token counts.
5. Pick the lowest cost per accepted task, then set the escalation rule.

Where Swfte sits

The pattern in this post is a small default model with an escalation path. Swfte Connect offers one API across many providers, with smart routing that optimises cost and availability, and you can bring your own provider keys.

Connect supports per-workspace routing rules with a mandatory fallback chain, so a request can move to another model when the first fails. When a workspace reaches a usage cap, Connect moves its requests to a cheaper model. That second feature is a spending control, not a quality control, so it does not replace the escalation check described above.

We do not claim that Connect picks the right model for each task on its own. You define the rules, the check and the threshold. For a deeper look, see multi-provider routing with Swfte Connect.

The decision rule is plain. Send easy, checkable work to the small model, keep prompts under 100,000 tokens where you can, and let measured cost per accepted task, not the price per million, set your routing.

---

Related: Claude Opus 5.5 pricing and cost per task, Why LLM prices are falling, Prompt caching pricing compared, OpenAI API alternatives.

Sources: Anthropic, Claude Haiku 5.5, 7 October 2026 · Claude docs, Pricing · Alibaba Cloud, Model Studio pricing, updated 7 November 2026 · Alibaba Cloud, Context cache · accessed 9 November 2026.

Anthropic's benchmark figures are vendor-reported and not independently reproduced. Worked examples are our arithmetic on assumed token counts and an assumed escalation rate, not measurements. We found no head-to-head quality comparison of Haiku 5.5 and qwen3.8-flash.