GuidesOneMux

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.

AI

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 tierOfficial inputOfficial outputOneMux inputOneMux outputPublished OneMux-to-official price ratio
Up to 100K input tokens$0.10$0.50$0.0299$0.14950.29900000000000004
Above 100K input tokens$0.50$2.50$0.1495$0.74750.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 tierOfficial cache readOfficial cache writeOneMux cache readOneMux 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.

AssumptionMonthly or per-attempt amount
Original jobs100,000 per month
Extra retry attempts10,000 per month
Extra recovery calls2,000 per month
Input per attempt8,000 tokens
Input served as cache reads80% of input
Output per attempt2,000 tokens
Separately billed cache writes100 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:

  1. 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.
  2. 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.
  3. 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.
  4. 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.
  5. 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

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.

ModelOfficial inputOfficial outputOneMux inputOneMux outputPublished price ratio
Claude Haiku 5.5$0.1$0.5$0.0299$0.14950.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