Claude Haiku 5.5 API Costs: Budgeting Retries and Recovery
Estimate Claude Haiku 5.5 production workflow costs with explicit token, cache, retry, recovery, and context-tier assumptions.
Summary · TL;DR
An illustrative production workload of 100,000 jobs, including retries, recovery calls, and assumed cache writes, costs $149.59 at the cited official rates or $44.73 at the published OneMux rates. Actual costs depend on token usage, cache behavior, context tiers, and additional charges.
Key Takeaways
- Budget for API attempts, not just completed jobs: retries and recovery calls consume tokens too.
- At the cited entry-tier rates, a call with 8,000 input tokens, 80% cached input, and 2,000 output tokens costs $0.001224 before cache writes.
- The worked monthly estimate separates cache writes from cache reads and assumes their billed token volumes do not overlap.
- Prompts above 100,000 tokens use the higher rates in the supplied pricing source; measure the entire prompt, not just the latest user message.
- OneMux publishes a 0.29900000000000004 price ratio for this model in the dated catalogue snapshot; actual bills require validation against applicable terms and usage.
On this page (10)
The decision: budget attempts, not completed jobs
For a production workflow using Claude Haiku 5.5, start with the cost of an ordinary API attempt, then add retry attempts, recovery calls, and cache writes. A budget based only on successful jobs misses the calls most likely to increase during an incident.
In the illustrative workload below, 100,000 monthly jobs produce 112,000 API attempts. With the stated cache assumptions and a separate cache-write allowance, the estimate is $149.59 at the cited official rates or $44.73 at the published OneMux rates. These are token-cost estimates, not quotes or guarantees.
This is a cost guide from OneMux, the publisher and product discussed here. The arithmetic is useful whether you call the provider directly or use a model-access service.
Price snapshot and billing units
All prices below are USD per million tokens. The OneMux catalogue snapshot was captured on November 12, 2026; it is not a live price check. The supplied pricing review reports the official standard and cache rates, including a higher band for prompts above 100,000 input tokens. Check current terms before committing a budget.
| Prompt tier | Official input | Official output | OneMux input | OneMux output | Published OneMux-to-official price ratio |
|---|---|---|---|---|---|
| Up to 100K input tokens | $0.10 | $0.50 | $0.0299 | $0.1495 | 0.29900000000000004 |
| Above 100K input tokens | $0.50 | $2.50 | $0.1495 | $0.7475 | 0.29900000000000004 |
The ratio is a price multiplier, not a dollar amount. It is reproduced as published rather than rounded into a discount claim. The OneMux model page lists the model-specific rates.
Cache prices are separate from ordinary input and output prices:
| Prompt tier | Official cache read | Official cache write | OneMux cache read | OneMux cache write |
|---|---|---|---|---|
| Up to 100K input tokens | $0.01 | $0.125 | $0.00299 | $0.037375 |
| Above 100K input tokens | $0.05 | $0.625 | $0.01495 | $0.186875 |
The catalogue also lists a distinct one-hour cache-write rate: $0.20 official and $0.0598 OneMux per million tokens in the lower tier; $1.00 and $0.299 respectively in the higher tier. The example uses the standard write rate, not the one-hour rate. Regional processing, tools, and other applicable charges can add to the total. Cache eligibility, lifetime, and billing behavior should be verified for the endpoint and settings you use.
A reproducible monthly estimate
Assume a workflow classifies an operational event and returns a structured decision. The following numbers are illustrative, not measured performance or a recommendation to automate a particular decision.
| Assumption | Monthly or per-attempt amount |
|---|---|
| Original jobs | 100,000 per month |
| Extra retry attempts | 10,000 per month |
| Extra recovery calls | 2,000 per month |
| Input per attempt | 8,000 tokens |
| Input served as cache reads | 80% of input |
| Output per attempt | 2,000 tokens |
| Separately billed cache writes | 100 million tokens per month |
All attempts are assumed to have the same token shape and to remain in the lower prompt tier. The 100 million write tokens are a separate billing category: they are not also counted among the ordinary-input or cache-read tokens below. This simplifies the example; use actual billing-category counts when available.
Cost of one attempt
At the cited official lower-tier rates, split 8,000 input tokens into 1,600 ordinary input tokens and 6,400 cache-read tokens:
- Ordinary input: 1,600 ÷ 1,000,000 × $0.10 = $0.000160.
- Cache reads: 6,400 ÷ 1,000,000 × $0.01 = $0.000064.
- Output: 2,000 ÷ 1,000,000 × $0.50 = $0.001000.
- Total: $0.001224 per attempt, excluding cache writes.
That is $0.1224 per million total input and output tokens for this particular 4:1 input-to-output mix and 80% input cache-read assumption. It is not a universal blended rate: change the output length or cache-hit share and the result changes.
Add retries, recovery, and writes
The workload has 100,000 + 10,000 + 2,000 = 112,000 attempts. At $0.001224 each, those attempts cost $137.088 at official rates. The separately assumed 100 million cache-write tokens cost 100 × $0.125 = $12.50, for a total of $149.588, or $149.59 rounded to cents.
Using the published OneMux lower-tier rates for the same categories:
- One attempt: input $0.00004784 + cache reads $0.000019136 + output $0.000299 = $0.000365976.
- 112,000 attempts: $40.989312.
- 100 million standard cache-write tokens: $3.7375.
- Total: $44.726812, or $44.73 rounded to cents.
For a comparable operational unit, divide by the original 100,000 jobs: approximately $0.001496 per job at the cited official rates and $0.000447 per job at the published OneMux rates. These are costs per original job, including the assumed extra attempts and writes—not costs per successful job. If some jobs remain unresolved, cost per successful job will be higher.
Set retry and recovery rules before launch
A retry is another attempt at the same operation. A recovery call is a separate attempt to resolve an uncertain or invalid result. Their counts and token sizes should be recorded separately: a recovery prompt that includes an error transcript may be larger than the original prompt.
Use a bounded policy rather than retrying every failure:
- Classify the failure. Consider a limited retry for a transient transport failure or a rate-limit response, with backoff and jitter. Check the endpoint's documented response behavior and retry guidance.
- Set a maximum attempt count and deadline. Include the initial attempt in the limit. Send exhausted jobs to a queue or operator review instead of looping indefinitely.
- Handle ambiguous completion carefully. A timeout does not prove that the provider did no work or that an external action did not occur. Reconcile the result before repeating a side effect; use idempotency controls where the relevant systems support them.
- Treat invalid output as a separate recovery path. Validate the response against your application's required structure. If a repair call is allowed, cap it and define what happens if it also fails.
- Reserve an incident budget. Track attempts per original job, billed token categories, unresolved jobs, and cache-write volume. Alert on changes, not only on the final monthly bill.
Do not assume a failed or timed-out attempt is free. Record the usage and charges actually reported; where usage is unavailable, keep a conservative allowance until the bill can be reconciled.
Watch the 100K prompt boundary
The cited pricing review applies the higher context band when input per request exceeds 100,000 tokens. Count system instructions, tool definitions, conversation history, and retrieved material—not only the latest message. Under the listed rates, standard input, output, cache reads, and standard cache writes in the higher band each have five times the corresponding lower-band rate.
For example, 101,000 ordinary input tokens and 2,000 output tokens, with no cache use, cost $0.0555 at the higher official rates: $0.0505 input plus $0.005 output. A 100,000-token ordinary-input prompt with the same output costs $0.011 at the lower rates. This illustrates a tier boundary, not a claim about the distribution of real prompts.
Measure prompt size before calls, especially on retries that append history. Set a policy for trimming or routing oversized requests, and check current provider terms for how the tier is applied.
Before approving the budget
Replace the example's token counts with observed billed usage, then run a normal-month and incident-month scenario. Keep cache reads and writes distinct, verify the applicable tier per attempt, and add any non-token charges. OneMux provides access to models through one OpenAI-compatible API, but compatibility for a particular workflow depends on documented endpoint and parameter support; this example does not claim an integration was tested.
Sources
- LLMLearner: Claude Haiku 5.5 pricing — cited rate review, context-band conditions, and workload examples.
- OneMux: Claude Haiku 5.5 — model catalogue prices; snapshot captured November 12, 2026.
Published price snapshot
Captured 2026-11-12T22:00:06.144Z from the OneMux published catalogue. Prices retain website billing units; this is not a live benchmark. Tiered, cached or time-based billing may differ. Unknown values are not zero.
| Model | Official input | Official output | OneMux input | OneMux output | Published price ratio |
|---|---|---|---|---|---|
| Claude Haiku 5.5 | $0.1 | $0.5 | $0.0299 | $0.1495 | 0.29900000000000004 |
Current OneMux prices. Compare workload costs only when input/output and billing units match; see each model page for tier conditions.
FAQ
How much does Claude Haiku 5.5 cost per million tokens?
The supplied pricing review lists $0.10 per million ordinary input tokens and $0.50 per million output tokens for prompts up to 100,000 input tokens. Above that threshold, it lists $0.50 input and $2.50 output. Cache and other charges are separate.
Should retries be included in an API cost estimate?
Yes. Count the input and output of every attempt, including retries and recovery calls, using the billing categories and usage actually reported. A timeout does not establish that an attempt was free.
Does the example assume that every prompt is cached?
No. It assumes 80% of each attempt's input is billed as cache reads and 20% as ordinary input, plus a separate allowance of 100 million cache-write tokens per month. Actual cache behavior can differ.
What happens to the estimate when a prompt exceeds 100,000 input tokens?
The supplied pricing review says the higher context band applies. Under the listed rates, each corresponding standard input, output, cache-read, and standard cache-write price is five times its lower-tier price.
Related articles
Guides
Estimate MiniMax M3.1 Flash API Costs for Production Workflows
A reproducible MiniMax M3.1 Flash cost estimate for production workflows, with published OneMux rates, explicit assumptions, and practical retry and recovery rules.
Guides
GPT 6.2 Astra API costs for production workflows: a retry-aware estimate
Estimate GPT 6.2 Astra workflow costs using comparable token prices, explicit retry assumptions, and a reproducible monthly example.
Guides
Gemini 4 Carbon API Cost: A Retry-Aware Workload Estimate
Estimate Gemini 4 Carbon task costs with explicit token assumptions, retry rules, and a reproducible ledger.
Guides
GPT Image 2.6 Flare API Cost Estimation for Production Workflows
Estimate GPT Image 2.6 Flare workload costs with explicit token assumptions, comparable billing units, acceptance rates, and production retry rules. Includes the dated OneMux price snapshot and a reproducible budgeting method.