Claude Haiku 5.5 Pricing: Script the Savings Math

By /
A hand holding a printed sheet on a desk, rows of blank entries above two bars, one short navy and one long amber, beside a coffee mug

7 min read · 1,701 words

This article was written with AI. It was drafted from the sources it cites and checked against the full text of those sources before publishing. How we make articles

Claude Haiku 5.5 pricing comes with three discount figures from Anthropic itself: the model “costs around 75% less to run” than Haiku 4.5 on average — a cut SiliconANGLE describes as “roughly a quarter of what Haiku 4.5 costs to run” (SiliconANGLE) — and the pricing footnote puts the cut at 90% for requests up to 100,000 tokens and 50% above that (Anthropic). The model was released on October 7, 2026 (9to5Mac). Which figure lands on your invoice depends on how your traffic splits across that line, and a short Python script can tell you before you migrate anything.

What You’ll Build

A dependency-free command-line script, haiku_price_check.py, that takes your monthly traffic as one or more segments (request count, prompt size, completion size, cached share) and prints the Haiku 4.5 bill, the Haiku 5.5 bill, the percentage saved, and how much of the old bill each segment was responsible for. Every output below comes from running the script as printed here on Python 3.12.

Prerequisites

  • Python 3.11 or newer (python3 --version to confirm). The script uses only the standard library.
  • Your traffic’s rough shape from your provider dashboard: requests per month, average input and output tokens, and the share of input tokens read from cache. If some prompts run past that line, count those requests separately.

Step 1: Encode the published price table

Anthropic’s table prices Haiku 5.5 in two tiers by prompt size, per million tokens. Up to 100,000 tokens, input is $0.10 and output $0.50; over that, $0.50 and $2.50. Cache reads are $0.01 in the lower tier and $0.05 in the upper. Haiku 4.5 has a single tier: $1.00 input, $5.00 output, $0.10 cache reads (Anthropic). Create haiku_price_check.py with those rows:

#!/usr/bin/env python3
"""Compare Claude Haiku 4.5 and Haiku 5.5 spend from Anthropic's published list prices."""
import argparse

TIER_TOKENS = 100_000  # Haiku 5.5 prices change above this prompt size

# dollars per million tokens
HAIKU_45 = {"input": 1.00, "output": 5.00, "cache_read": 0.10}
HAIKU_55 = {
    "under": {"input": 0.10, "output": 0.50, "cache_read": 0.01},
    "over": {"input": 0.50, "output": 2.50, "cache_read": 0.05},
}

Verify it works: run python3 -c "import haiku_price_check" from the file’s directory. No output and no traceback means the file is valid Python.

Step 2: Price one request on each model

Prompt size chooses the tier, so the Haiku 5.5 function has to pick a row before it multiplies. Add:

def request_cost(prices, in_tokens, out_tokens, cache_frac=0.0):
    cached = in_tokens * cache_frac
    fresh = in_tokens - cached
    return (fresh * prices["input"] + cached * prices["cache_read"]
            + out_tokens * prices["output"]) / 1_000_000


def haiku_45_cost(in_tokens, out_tokens, cache_frac=0.0):
    return request_cost(HAIKU_45, in_tokens, out_tokens, cache_frac)


def haiku_55_cost(in_tokens, out_tokens, cache_frac=0.0, inflation=1.0):
    in_tokens, out_tokens = in_tokens * inflation, out_tokens * inflation
    tier = "under" if in_tokens <= TIER_TOKENS else "over"
    return request_cost(HAIKU_55[tier], in_tokens, out_tokens, cache_frac)

Step 4 uses the inflation argument; leave it at 1.0 for now.

Verify it works:

python3 -c "from haiku_price_check import haiku_45_cost, haiku_55_cost; print(haiku_45_cost(2000, 500), haiku_55_cost(2000, 500))"

prints 0.0045 0.00045: a 2,000-token prompt with a 500-token reply costs under half a cent on Haiku 4.5 and a tenth of that on Haiku 5.5. To see the boundary, price a prompt of exactly that size and one a single token longer:

python3 -c "from haiku_price_check import haiku_55_cost; print(haiku_55_cost(100000, 500), haiku_55_cost(100001, 500))"

That prints 0.01025 0.0512505. One extra token makes the request five times as expensive, because the upper-tier rates apply to the whole request in this model of the table.

Step 3: Compare a month of traffic

Add the comparison and the command line:

def compare(segments, inflation=1.0):
    """Old bill, new bill and percent saved for (requests, in, out, cache_frac) segments."""
    old = sum(n * haiku_45_cost(i, o, c) for n, i, o, c in segments)
    new = sum(n * haiku_55_cost(i, o, c, inflation) for n, i, o, c in segments)
    return old, new, 100.0 * (1.0 - new / old)


def parse_segment(text):
    parts = text.split(":")
    if len(parts) not in (3, 4):
        raise argparse.ArgumentTypeError("use REQUESTS:IN_TOKENS:OUT_TOKENS[:CACHE_FRAC]")
    cache = float(parts[3]) if len(parts) == 4 else 0.0
    return int(parts[0]), int(parts[1]), int(parts[2]), cache


if __name__ == "__main__":
    p = argparse.ArgumentParser(description=__doc__)
    p.add_argument("--segment", type=parse_segment, action="append",
                   help="REQUESTS:IN_TOKENS:OUT_TOKENS[:CACHE_FRAC], repeatable")
    p.add_argument("--inflation", type=float, default=1.0,
                   help="Haiku 5.5 tokens per Haiku 4.5 token for the same text")
    a = p.parse_args()
    segments = a.segment or [(1_000_000, 2_000, 500, 0.0)]

    old, new, saved = compare(segments, a.inflation)
    print(f"Haiku 4.5 monthly: ${old:,.2f}")
    print(f"Haiku 5.5 monthly: ${new:,.2f}")
    print(f"Saving: {saved:.1f}%")
    if len(segments) > 1:
        for n, i, o, c in segments:
            share = 100.0 * n * haiku_45_cost(i, o, c) / old
            print(f"  {n:,} requests of {i:,} tokens in: {share:.1f}% of the Haiku 4.5 bill")

Run it with no arguments for the default workload, one million requests of 2,000 tokens in and 500 out:

python3 haiku_price_check.py

Haiku 4.5 monthly: $4,500.00
Haiku 5.5 monthly: $450.00
Saving: 90.0%

That is the 90% Decrypt calculated for the lower tier, a rate it notes matches what OpenAI set for GPT-6 Luna (Decrypt). Caching does not change the percentage, because the cache-read price fell by the same factor of ten. With 80% of input read from cache:

python3 haiku_price_check.py --segment 1000000:2000:500:0.8

Haiku 4.5 monthly: $3,060.00
Haiku 5.5 monthly: $306.00
Saving: 90.0%

Now push the prompt past the boundary with --segment 1000000:250000:500. The script prints Saving: 50.0%.

Verify it works: the three runs print 90.0%, 90.0% and 50.0%. If the first number is off, a price in Step 1 was mistyped.

Step 4: Find out which discount your mix gets

Anthropic’s footnote explains where 75% comes from: 90% of requests to Haiku 4.5 were at or under the line, and the figure also accounts for an updated tokenizer that “uses slightly more tokens per task” (Anthropic). A share of requests is not a share of the bill, though. Model a month where nine requests in ten are short and the tenth carries a 150,000-token prompt:

python3 haiku_price_check.py --segment 900000:2000:500 --segment 100000:150000:1000

Haiku 4.5 monthly: $19,550.00
Haiku 5.5 monthly: $8,155.00
Saving: 58.3%
  900,000 requests of 2,000 tokens in: 20.7% of the Haiku 4.5 bill
  100,000 requests of 150,000 tokens in: 79.3% of the Haiku 4.5 bill

On this article’s arithmetic, a 90/10 split by request count saves 58.3% at these sizes, because the long tenth was 79.3% of the old spend and only gets the 50% cut. These sizes are an example, not Anthropic’s traffic. The same script shows how few long requests it takes to land on the headline figure:

python3 haiku_price_check.py --segment 900000:2000:500 --segment 15677:150000:1000

Haiku 4.5 monthly: $6,479.93
Haiku 5.5 monthly: $1,619.97
Saving: 75.0%
  900,000 requests of 2,000 tokens in: 62.5% of the Haiku 4.5 bill
  15,677 requests of 150,000 tokens in: 37.5% of the Haiku 4.5 bill

In this run the 15,677 long requests are a sliver beside the 900,000 short ones, and the saving is already 75.0%. Anthropic’s own 75% also includes the tokenizer change, so this is not a reconstruction of its number; it shows how sensitive the result is to long prompts.

--inflation multiplies Haiku 5.5’s token counts so you can enter what you measure on your own prompts. With an assumed 10%, which is this article’s placeholder and not a published number:

python3 haiku_price_check.py --inflation 1.1

Haiku 4.5 monthly: $4,500.00
Haiku 5.5 monthly: $495.00
Saving: 89.0%

Verify it works: the two-segment runs print 58.3% and 75.0%, each followed by one line per segment, and the inflation run prints 89.0%.

Common Pitfalls

  • A malformed segment stops the run. --segment 10:20 exits with error: argument --segment: use REQUESTS:IN_TOKENS:OUT_TOKENS[:CACHE_FRAC]. Each segment needs three or four colon-separated values.
  • One average across both tiers gives a wrong answer. The first Step 4 run blends to 16,800 input tokens and 550 output tokens per request. Entered as a single segment (--segment 1000000:16800:550), that average sits under the boundary and the script reports 90.0%; the two-segment run of the same traffic reports 58.3%. Enter long prompts as their own segment.
  • Inflation can move a request across the line. The script applies --inflation before choosing the tier, so a 95,000-token prompt at 1.1 is priced at the upper-tier rates: haiku_55_cost(95000, 500, 0, 1.1) returns about $0.054 against $0.00975 without it.

When the cheaper model is the wrong model

Price is one input to routing. On Terminal-Bench 4.0, the agentic coding row of Anthropic’s benchmark table, Haiku 5.5 scores 39.2% against 70.6% for Sonnet 5.5, and Anthropic says Sonnet 5.5 and Opus 5.5 “remain better choices for complex agentic coding tasks,” with Haiku 5.5 “best suited to more narrowly scoped tasks” such as compaction, summarization and subagent work (Anthropic). Sonnet 5.5’s own costs moved in the same launch: its cache-read price was halved to $0.10 per million tokens, which Anthropic says makes it around 20% cheaper on most agentic tasks (Anthropic). That is the case for staying put on capability.

Terminal-Bench 4.0 scores (Anthropic's benchmark table reports these scores on Terminal-Bench 4.0, its agentic coding row, for the two Claude models.): Haiku 5.5 39.2%; Sonnet 5.5 70.6%.
Drawn by Decoded AI.

For high-volume work where latency counts, the customer reports point the other way. Asana tested the model before release on the evaluations for its AI Teammates agent and reported task completions more than 30% quicker than on the model it runs now, with inference on each agent turn up to 2.5 times as fast. “It’s a noticeably snappier experience,” said Aaron Vinh, a staff software engineer at Asana (SiliconANGLE).

One policy note belongs in the same decision, for security teams: the model’s safeguards allow more defensive security work than Sonnet 5.5’s, and still block penetration testing (SiliconANGLE).

What’s Next

Replace the example segments with a month of real counts and run the script once per product surface. If the result sits well under 90%, the per-segment lines show which traffic to look at first: shortening or splitting prompts that sit just over the line moves them to rates five times lower. When you switch, the model ID is claude-haiku-5-5 (Anthropic). Keep the price rows in one place, so the next repricing is a two-line edit.

References

Leave a Comment

Scroll to Top