Claude Haiku 5.5: Preis sprunghaft fuenffach hoeher ab 100.001 Prompt-Tokens
Ein Request mit 100.000 Tokens Prompt und 2.000 Output-Tokens kostet 0,011 Dollar, ein einziges Token mehr im Prompt 0,055 Dollar. Der Sprung ergibt sich allein aus der Staffelung in der Preisliste von Anthropic.
Veröffentlicht am 8. Oktober • Zuerst erschienen auf importstatic.com • KI-unterstützt
Eine Anfrage an Claude Haiku 5.5 mit einem Prompt von 100.000 Tokens und 2.000 Tokens an Ausgabe kostet 0,011 $. Fügt man dem Prompt ein einziges Token hinzu, kostet dieselbe Anfrage 0,055 $. Alles andere blieb unverändert; man hat eine Grenze in der Preisliste überschritten.
Anthropic hat Haiku 5.5 am 7. Oktober 2026 veröffentlicht, und seit dem 8. Oktober ist das Modell über die Claude API, Amazon Bedrock, Google Cloud, Microsoft Foundry und Claude Platform on AWS unter der ID claude-haiku-5-5 verfügbar (auf Bedrock anthropic.claude-haiku-5-5).
Die Schlagzeile ist der Preis: 0,10 $ pro Million Input-Tokens gegenüber 1 $ bei Haiku 4.5. Der Haken daran: Der günstige Satz gilt für „Prompts bis 100.000 Tokens“, während das Modell Prompts von der zehnfachen Größe verarbeitet. In einer Hacker-News-Diskussion zur Veröffentlichung wurde hin und her debattiert, ob Agent-Workloads unter dieser Grenze bleiben können, ohne dass eine Klärung erreicht wurde.
Also haben wir die Rechnung mit einem kleinen Go-Programm nachgestellt. Für diesen Durchlauf hatten wir keinen API-Schlüssel, daher wurde nichts davon an das Modell gesendet: Die Preise stammen aus Anthropics Dokumentation, und die Kosten wurden daraus berechnet.
Die Preisseite führt für Haiku 5.5 zwei Zeilen auf, eine „für Prompts bis 100.000 Tokens“ und eine „für Prompts über 100.000 Tokens“. Jeweils pro Million Tokens:
Jeder Satz in der zweiten Spalte ist fünfeinhalb Mal so hoch wie der erste. Das gilt auch für die Ausgabe, was vielen entgeht: Die Länge dessen, was man sendet, bestimmt den Preis dessen, was zurückkommt.
Das ist keine Randstufe wie bei der Einkommensteuer, bei der nur der übersteigende Teil den höheren Satz zahlt. Die Zeile wird pro Prompt gewählt und gilt für die gesamte Anfrage. Sie ist auch im aktuellen Modellangebot einmalig. Für die anderen Modelle mit 1M-Kontext heißt dieselbe Seite: „Eine Anfrage mit 900k Tokens wird zum selben Preis pro Token abgerechnet wie eine Anfrage mit 9k Tokens“, und nennt Haiku 5.5 als Ausnahme.
Der Begriff „Prompt“ leistet in dieser Tabelle Schwerstarbeit, und die Dokumentation definiert ihn nicht als Formel über die Usage-Felder. Hier ist, was sie tatsächlich sagt.
Mit aktiviertem Prompt Caching verteilt sich der Input auf input_tokens, cache_creation_input_tokens und cache_read_input_tokens. Die Seite zu den Kontextfenstern ist bei gecachten Token deutlich: „Prompt Caching ändert, wofür Sie bei diesen Token bezahlen, nicht ob sie zählen.“ Wir betrachten den Prompt daher als Summe aller drei Werte, also die Lesart, bei der ein 100.000-Token-Cache-Präfix plus eine 50-Token-Frage in der teuren Stufe landet. Das ist unsere Interpretation, keine zitierte Regel. Wenn Ihre Rechnung davon abhängt, prüfen Sie eine echte Rechnung gegen eine Anfrage, deren Größe Sie kennen.
Haiku 5.5 verwendet den neueren Tokenizer, und der Migrationsleitfaden sagt, dass derselbe Text „etwa 30 % mehr Tokens erzeugt“ als bei Haiku 4.5. Wenn Sie Ihre Prompt-Größen in Haiku-4.5-Tokens kennen, liegt die Schwelle für Sie nicht bei 100.000, sondern bei etwa 76.900.
Und die Vorabprüfung ist nur eine Näherung. Der Token-Counting-Endpunkt ist kostenlos und nimmt denselben Body wie eine Message-Anfrage entgegen, aber die Dokumentation bezeichnet sein Ergebnis als Schätzung, die „um einen kleinen Betrag abweichen kann“. Routen Sie nicht auf <= 100000. Lassen Sie Puffer.
curl https://api.anthropic.com/v1/messages/count_tokens \ -H "x-api-key: $ANTHROPIC_API_KEY " \ -H "content-type: application/json" \ -H "anthropic-version: 2023-06-01" \ -d '{"model": "claude-haiku-5-5", "messages": [{"role": "user", "content": "..."}]}' Das ist die dokumentierte Anfrage mit ausgetauschtem Modell; wir haben sie nicht gesendet. Übergeben Sie claude-haiku-5-5 und nicht Ihr altes Modell, sonst erhalten Sie die Zählung des alten Tokenizers.
Der Rechner ist eine einzige Funktion. Er bildet das Usage-Objekt ab, wählt anhand der Prompt-Länge eine Stufe und wendet diese Stufe auf alles an:
type Usage struct { InputTokens int `json:"input_tokens"` CacheCreationInputTokens int `json:"cache_creation_input_tokens"` CacheReadInputTokens int `json:"cache_read_input_tokens"` OutputTokens int `json:"output_tokens"` } // Die Sätze sind US-Dollar pro Million Tokens. type Rates struct { Input, CacheWrite5m, CacheRead, Output float64 } var ( Haiku55Short = Rates { Input: 0.10, CacheWrite5m: 0.125, CacheRead: 0.01, Output: 0.50 } Haiku55Long = Rates { Input: 0.50, CacheWrite5m: 0.625, CacheRead: 0.05, Output: 2.50 } Haiku45 = Rates { Input: 1.00, CacheWrite5m: 1.25, CacheRead: 0.10, Output: 5.00 } ) const Haiku55Threshold = 100 _000 func ( u Usage ) PromptTokens () int { return u. InputTokens + u. CacheCreationInputTokens + u.
CacheReadInputTokens } func ( u Usage ) at ( r Rates ) float64 { return ( float64 ( u. InputTokens ) * r. Input + float64 ( u.
CacheCreationInputTokens ) * r. CacheWrite5m + float64 ( u. CacheReadInputTokens ) * r.
CacheRead + float64 ( u. OutputTokens ) * r. Output ) / 1e6 } func Haiku55Cost ( u Usage ) ( dollars float64, long bool ) { if u.
PromptTokens () > Haiku55Threshold { return u. at ( Haiku55Long ), true } return u. at ( Haiku55Short ), false } Gibt man ihm zwei Anfragen, die sich um ein Token unterscheiden, und dann einen 150.000-Token-Prompt gegen dasselbe Material in zwei Hälften (jeweils 1.000 Ausgabe-Tokens), ergibt sich:
prompt 100000 + 2000 out $0.011000 long=false prompt 100001 + 2000 out $0.055001 long=true one request $0.0775 two requests $0.0160 Das zweite Paar ist das praktisch relevante. Die Zusammenfassung eines langen Dokuments in zwei Aufrufen mit je 75.000 Tokens kostet ein Fünftel dessen, was ein einzelner Aufruf kostet, und man kann einen dritten Aufruf zum Zusammenführen der Hälften hinzunehmen und liegt trotzdem weit vorne. Für Extraktion und Klassifikation über große Inputs, wofür dieses Modell verkauft wird, ist Chunking damit neben einer Qualitätsfrage nun auch eine Preisentscheidung.
Sind 100.000 Token viel? Für einen einzelnen Klassifikationsaufruf sind es enorm viele. Für einen Tool-Calling-Agent, der jedes Ergebnis an die Konversation anhängt, sind sie es nicht.
Wir haben eine Schleife mit aktiviertem Prompt Caching modelliert: ein 8.000-Token-Präfix aus Systemprompt und Tool-Definitionen, wobei jeder Zug ein 5.000-Token-Tool-Ergebnis und eine 500-Token-Antwort hinzufügt. Diese Größen sind plausibel gewählt. Es ist ein Modell der Abrechnung, und Ihr Agent wird andere Zahlen haben.
turn 16: prompt 95500 $0.00184 long=false turn 17: prompt 101000 $0.00946 long=true append only $0.3267 (first long-tier turn: 17) compact before 100k $0.0623 (first long-tier turn: 0, compactions: 2) Zug 17 kostet das Fünffache von Zug 16 für fast dieselbe Arbeit, und jeder spätere Zug bleibt in der teuren Stufe, weil die Historie nur wächst. Über 40 Züge kostet die Append-Only-Schleife 0,33 $. Die zweite Variante ersetzt die Historie durch eine 3.000-Token-Zusammenfassung, sobald der nächste Prompt 100.000 überschreiten würde, zahlt für das Schreiben dieser Zusammenfassung und kommt auf 0,06 $. Ob eine Zusammenfassung für Ihre Aufgabe ausreicht, ist eine separate Frage, die keine Preistabelle beantwortet.
In der naheliegenden Lösung lauert eine Falle. Die Threshold Compaction der API, als Beta gelistet und laut Angaben mit Haiku 5.5 unterstützt, fasst alte Züge serverseitig zusammen, sobald der Input einen Schwellenwert erreicht. Der Standard-Schwellenwert liegt bei 150.000 Input-Tokens. Bei jedem anderen Modell ist das eine sinnvolle Voreinstellung. Bei diesem Modell bedeutet es, dass die Compaction 50.000 Tokens nach der Preiserhöhung einspringt. Stellen Sie ihn selbst ein; das Minimum liegt bei 50.000:
{ "model": "claude-haiku-5-5", "max_tokens": 4096, "context_management": { "edits": [ { "type": "compact_20260112", "trigger": { "type": "input_tokens", "value": 80000 } } ] }, "messages": [{ "role": "user", "content": "..." }] } Dieser Body ist aus dem dokumentierten Beispiel abgeleitet und gehört zum Header anthropic-beta: compact-2026-01-12. Auch ihn haben wir nicht gesendet.
Kürzen Sie die Historie nicht von Hand, ohne vorher den Migrationsleitfaden zu lesen. Haiku 5.5 denkt standardmäßig, und eine Anfrage, die nach einer Änderung früherer Nachrichten einen Thinking-Block zurücksendet, kann mit einem 400-Fehler abgewiesen werden (der Leitfaden sagt, welche Konten die Prüfung erhalten). Seine Anweisung lautet, Konversationen append-only zu halten, was genau das nicht tut, was eine selbstgebaute Schleife nach dem Motto „die ältesten Tool-Ergebnisse entfernen“ macht.
Nichts davon macht Haiku 5.5 zu einem schlechten Angebot. Die lange Stufe liegt bei der Hälfte des Token-Preises von Haiku 4.5 und bei einem Viertel des Input-Satzes von 2 $ bei Sonnet 5.5.
Der Tokenizer frisst diesen Vorteil allerdings teilweise auf. Preis man denselben Text auf beiden Modellen ab, mit Haiku 5.5s um die dokumentierten 30 % erhöhten Zählungen:
threshold in Haiku 4.5 tokens: 76923 4.5: 10000 in $0.0150 | 5.5: 13000 in $0.0019 long=false | saving 87% 4.5: 50000 in $0.0550 | 5.5: 65000 in $0.0072 long=false | saving 87% 4.5: 76000 in $0.0810 | 5.5: 98800 in $0.0105 long=false | saving 87% 4.5: 78000 in $0.0830 | 5.5: 101400 in $0.0539 long=true | saving 35% 4.5: 150000 in $0.1550 | 5.5: 195000 in $0.1008 long=true | saving 35% Ergebnis: 87 % günstiger für denselben Text unterhalb der Grenze, 35 % günstiger oberhalb davon. Anthropics Ankündigung sagt, Prompts bis 100.000 Tokens „machen rund 90 % der Anfragen an unser vorheriges Haiku-Modell aus“. Das ist ein Anteil an Anfragen, und lange Anfragen tragen jeweils mehr Tokens, sodass der Anteil Ihrer Ausgaben, der in die lange Stufe fällt, deutlich höher sein kann als einer von zehn.
Der Wechsel ist nicht nur eine Preisänderung. Manuelles budget_tokens-Denken, eine nicht standardmäßige Temperatur und Assistant-Prefill führen bei Haiku 5.5 alle zu 400-Fehlern, ganz ähnlich den Änderungen, die wir für Claude Sonnet 5.5 aufgelistet haben. Und wenn Ihre langen Prompts wegen Tool-Definitionen lang sind, messen Sie diese zuerst; sie stehen in jeder Anfrage.
Unser Rat ist kurz. Setzen Sie ein Budget von 90.000 gezählten Token auf alles, was Sie an Haiku 5.5 senden, legen Sie den Komprimierungstrigger darunter an und protokollieren Sie die Nutzung pro Anfrage, damit Sie sehen können, wie viele Aufrufe darüber hinausgehen. Wenn eine Workload nicht hineinpasst, teilen Sie sie auf. Wenn sie sich nicht aufteilen lässt, führen Sie sie trotzdem aus und wissen Sie, dass dies der 35-prozentige Rabatt ist, den Sie erhalten.
Mit Vorlagen lassen sich FAQs schnell beantworten oder Snippets zur Wiederverwendung speichern.
Sind Sie sicher, dass Sie diesen Kommentar ausblenden möchten? Er wird in Ihrem Beitrag verborgen, bleibt aber über den Permalink des Kommentars sichtbar.
Für weitere Maßnahmen können Sie diese Person blockieren und/oder einen Missbrauchsfall melden.
Automatisch übersetzt. Das Original auf Englisch ist unten aufklappbar.
Original (Englisch) anzeigen
Posted on Oct 8 • Originally published at importstatic.com • AI-assisted
A request to Claude Haiku 5.5 with a 100,000-token prompt and 2,000 tokens of output costs $0.011. Add one token to the prompt and the same request costs $0.055. Nothing else changed; you crossed a line in the price list.
Anthropic released Haiku 5.5 on October 7, 2026, and as of October 8 it's available on the Claude API, Amazon Bedrock, Google Cloud, Microsoft Foundry and Claude Platform on AWS under the ID claude-haiku-5-5 ( anthropic.claude-haiku-5-5 on Bedrock). The headline is the price: $0.10 per million input tokens against $1 for Haiku 4.5. The catch is that the cheap rate is for "prompts up to 100,000 tokens", and the model takes prompts ten times that size. A Hacker News discussion of the release went back and forth on whether agent workloads can stay under the line and didn't settle it. So we did the arithmetic with a small Go program. We had no API key in this run, so nothing below was sent to the model: the prices come from Anthropic's documentation and the costs are computed from them.
The pricing page gives Haiku 5.5 two rows, one "for prompts up to 100,000 tokens" and one "for prompts over 100,000 tokens". Per million tokens:
Every rate in the second column is five times the first. That includes output, which is the part people miss: the length of what you send decides the price of what comes back.
This isn't a marginal bracket like income tax, where only the excess pays the higher rate. The row is chosen per prompt and applies to the whole request. It's also unique in the current lineup. For the other 1M-context models the same page says "A 900k-token request is billed at the same per-token rate as a 9k-token request", and it names Haiku 5.5 as the exception.
"Prompt" is doing a lot of work in that table, and the documentation doesn't define it as a formula over the usage fields. Here's what it does say.
With prompt caching on, the input is split across input_tokens, cache_creation_input_tokens and cache_read_input_tokens. The context windows page is blunt about cached tokens: "prompt caching changes what you pay for those tokens, not whether they count." So we treat the prompt as the sum of all three, which is the reading where a 100,000-token cached prefix plus a 50-token question lands in the expensive tier. That's our reading, not a quoted rule. If your bill depends on it, check a real invoice against a request you know the size of.
Haiku 5.5 uses the newer tokenizer, and the migration guide says the same text "produces approximately 30% more tokens" than on Haiku 4.5. If you know your prompt sizes in Haiku 4.5 tokens, the threshold isn't 100,000 for you. It's about 76,900.
And the pre-flight check is approximate. The token counting endpoint is free and takes the same body as a message request, but the docs call its result an estimate that "might differ by a small amount". Don't route on <= 100000. Leave headroom.
curl https://api.anthropic.com/v1/messages/count_tokens \ -H "x-api-key: $ANTHROPIC_API_KEY " \ -H "content-type: application/json" \ -H "anthropic-version: 2023-06-01" \ -d '{"model": "claude-haiku-5-5", "messages": [{"role": "user", "content": "..."}]}' Enter fullscreen mode Exit fullscreen mode That's the documented request with the model swapped in; we didn't send it. Pass claude-haiku-5-5 and not your old model, or you'll get the old tokenizer's count.
The calculator is one function. It mirrors the usage object, picks a tier from the prompt length and applies that tier to everything:
type Usage struct { InputTokens int `json:"input_tokens"` CacheCreationInputTokens int `json:"cache_creation_input_tokens"` CacheReadInputTokens int `json:"cache_read_input_tokens"` OutputTokens int `json:"output_tokens"` } // Rates are US dollars per million tokens. type Rates struct { Input, CacheWrite5m, CacheRead, Output float64 } var ( Haiku55Short = Rates { Input: 0.10, CacheWrite5m: 0.125, CacheRead: 0.01, Output: 0.50 } Haiku55Long = Rates { Input: 0.50, CacheWrite5m: 0.625, CacheRead: 0.05, Output: 2.50 } Haiku45 = Rates { Input: 1.00, CacheWrite5m: 1.25, CacheRead: 0.10, Output: 5.00 } ) const Haiku55Threshold = 100 _000 func ( u Usage ) PromptTokens () int { return u. InputTokens + u. CacheCreationInputTokens + u.
CacheReadInputTokens } func ( u Usage ) at ( r Rates ) float64 { return ( float64 ( u. InputTokens ) * r. Input + float64 ( u.
CacheCreationInputTokens ) * r. CacheWrite5m + float64 ( u. CacheReadInputTokens ) * r.
CacheRead + float64 ( u. OutputTokens ) * r. Output ) / 1e6 } func Haiku55Cost ( u Usage ) ( dollars float64, long bool ) { if u.
PromptTokens () > Haiku55Threshold { return u. at ( Haiku55Long ), true } return u. at ( Haiku55Short ), false } Enter fullscreen mode Exit fullscreen mode Feed it two requests that differ by one token, then one 150,000-token prompt against the same material in two halves (1,000 output tokens each):
prompt 100000 + 2000 out $0.011000 long=false prompt 100001 + 2000 out $0.055001 long=true one request $0.0775 two requests $0.0160 Enter fullscreen mode Exit fullscreen mode The second pair is the practical one. Summarising a long document in two 75,000-token calls costs a fifth of doing it in one, and you can add a third call to merge the halves and still be far ahead. For extraction and classification over big inputs, which is what this model is sold for, chunking just became a pricing decision as well as a quality one.
Is 100,000 tokens a lot? For a single classification call, it's enormous. For a tool-calling agent that appends every result to the conversation, it isn't.
We modelled a loop with prompt caching on: an 8,000-token prefix of system prompt and tool definitions, and each turn adding a 5,000-token tool result and a 500-token reply. Those sizes are made up to be plausible. This is a model of the billing, and your agent will have different numbers.
turn 16: prompt 95500 $0.00184 long=false turn 17: prompt 101000 $0.00946 long=true append only $0.3267 (first long-tier turn: 17) compact before 100k $0.0623 (first long-tier turn: 0, compactions: 2) Enter fullscreen mode Exit fullscreen mode Turn 17 costs five times turn 16 for almost the same work, and every later turn stays in the expensive tier because the history only grows. Over 40 turns the append-only loop costs $0.33. The second line replaces the history with a 3,000-token summary whenever the next prompt would cross 100,000, pays for writing that summary, and comes to $0.06. Whether a summary is good enough for your task is a separate question that no price table answers.
There's a trap in the obvious fix. The API's threshold compaction, in beta and listed as supporting Haiku 5.5, summarises old turns on the server once the input reaches a trigger. The default trigger is 150,000 input tokens. On every other model that's a sensible default. On this one it means compaction switches on 50,000 tokens after the price went up. Set it yourself; the minimum is 50,000:
{ "model": "claude-haiku-5-5", "max_tokens": 4096, "context_management": { "edits": [ { "type": "compact_20260112", "trigger": { "type": "input_tokens", "value": 80000 } } ] }, "messages": [{ "role": "user", "content": "..." }] } Enter fullscreen mode Exit fullscreen mode That body is adapted from the documented example and goes with the anthropic-beta: compact-2026-01-12 header. We didn't send it either.
Don't trim the history by hand without reading the migration guide first. Haiku 5.5 thinks by default, and a request that sends a thinking block back after earlier messages changed can come back as a 400 error (the guide says which accounts get the check). Its instruction is to keep conversations append-only, which is exactly what a hand-rolled "drop the oldest tool results" loop doesn't do.
None of this makes Haiku 5.5 a bad deal. The long tier is half of Haiku 4.5's per-token price, and a quarter of Sonnet 5.5's $2 input rate.
The tokenizer eats into that, though. Pricing the same text on both models, with Haiku 5.5's counts inflated by the documented 30%:
threshold in Haiku 4.5 tokens: 76923 4.5: 10000 in $0.0150 | 5.5: 13000 in $0.0019 long=false | saving 87% 4.5: 50000 in $0.0550 | 5.5: 65000 in $0.0072 long=false | saving 87% 4.5: 76000 in $0.0810 | 5.5: 98800 in $0.0105 long=false | saving 87% 4.5: 78000 in $0.0830 | 5.5: 101400 in $0.0539 long=true | saving 35% 4.5: 150000 in $0.1550 | 5.5: 195000 in $0.1008 long=true | saving 35% Enter fullscreen mode Exit fullscreen mode So: 87% cheaper for the same text under the line, 35% cheaper above it. Anthropic's announcement says prompts up to 100,000 tokens "make up around 90% of requests to our previous Haiku model". That's a share of requests, and long requests carry more tokens each, so the share of your spend that lands in the long tier can be a good deal higher than one in ten.
The switch isn't only a price change. Manual budget_tokens thinking, non-default temperature, and assistant prefill all return 400 errors on Haiku 5.5, much like the changes we listed for Claude Sonnet 5.5. And if your long prompts are long because of tool definitions, measure those first; they're in every request.
Our advice is short. Put a budget of 90,000 counted tokens on anything you send to Haiku 5.5, set the compaction trigger below it, and log usage per request so you can see how many calls go over. If a workload can't fit, split it. If it can't be split, run it anyway, and know that it's the 35% discount you're getting.