Claude Haiku 5.5: Benchmarks, API Pricing and Agent Costs

AWS’s US East (N. Virginia) price list, checked October 8, quotes Global Standard at $0.10 input / $0.50 output per million tokens through 100K prompt tokens, and $0.50 / $2.50 for longer prompts. The non-Global rates are $0.11 / $0.55 and $0.55 / $2.75: a 10% premium. Global cache reads and five-minute writes start at $0.01 and $0.125 per million tokens; above 100K they cost $0.05 and $0.625. Non-Global cache rates also carry the premium.

For Global cross-Region inference on bedrock-runtime, select global.anthropic.claude-haiku-5-5 explicitly; the US, EU, AU and JP profiles use the corresponding prefix. Global routing is a choice, not an automatic default. For example, us-east-1 supports Global and geographic routing, but not direct In-Region inference for this model. AWS lists Standard only, so the Claude API Batch discount does not apply here. Model charges appear on the AWS bill under the provider through AWS Marketplace.

At the ≤100K prompt tier, cache reads cost $0.01 per million tokens, five-minute writes $0.125, and one-hour writes $0.20. Above 100K prompt tokens, the respective rates are $0.05, $0.625 and $1.00. Cache-write and cache-read usage have their own prices; do not count them again as ordinary uncached input.

Claude Code’s cache lifetime depends on billing and request type. Main-conversation requests within a Claude subscription use one hour by default; API-key, cloud-provider and usage-credit requests default to five minutes, with configurable TTL. Use the cache-write lifetime in your actual request usage when applying these rates.

Suppose five requests within the five-minute cache lifetime share an eligible 20,000-token prefix, each adding 1,000 uncached input tokens and generating 500 output tokens. The first request costs $0.00285: $0.0025 for the prefix write, $0.0001 for new input and $0.00025 for output. Each of four cache-hit requests costs $0.00055. The complete five-request example totals $0.00505, versus $0.01175 if all input is uncached. These calculated savings assume identical reusable prefixes and four actual hits; record cache_creation_input_tokens and cache_read_input_tokens from usage to check your bill.

For eligible asynchronous Batch API requests, Anthropic lists a 50% input/output discount. The uncached 20K-input/2K-output example becomes $0.0015; the >100K example with 120K input and 10K output becomes $0.0425. Those examples apply the Batch discount to uncached input and output only. Compare the delivery path with your latency requirement, and use the documented cache billing rules for requests that combine features.

A cheaper request can still produce a more expensive task if it needs extra attempts. Sum every attempt and tool charge, then divide by accepted outcomes.

Artificial Analysis reports an Intelligence Index score of 43 at max effort and 38 at high. The corresponding average output use is about 162K and 55K tokens per task. These are aggregate evaluation-task figures, rather than a single standard API response limit. Higher effort can improve measured quality while using substantially more output tokens.

Its AutomationBench-AA score is 35%. AA attributes part of the result to excessive safety refusals during prerelease testing and says it plans to rerun the evaluation after a fix. The linked October 7 article still describes that rerun as pending. Keep the observed score and that limitation together rather than treating an expected improvement as a completed result.

AA’s article also says its provisional task-cost figures omit the fivefold input/output rate increase above 100K prompt tokens. Use them as evaluation evidence, rather than a final all-tier bill. AA reports 33% on Terminal-Bench 4.0; Anthropic’s 39.2% comes from its own setup. Keep the harnesses separate when comparing coding results.

Cursor’s published coding evaluation reports Haiku 5.5 at 30.9% and $0.08 per task on low effort, 36.9%/$0.17 on medium, 42.3%/$0.32 on high, 44.3%/$0.56 on xhigh, and 48.4%/$1.12 on max. These are average task costs in Cursor’s agent and evaluation harness, rather than universal prices for fixing a bug.

Within that evaluation, max improves the pass rate over medium while raising average spend by about 6.6 times. Start a recurring workflow at medium, which is Haiku’s default, and test whether additional effort resolves the errors you actually see. Escalating only the failed or ambiguous cases can make a different tradeoff from running every request at max.

Product Compass’s Bug Hunt covers 105 bugs across two repositories. Haiku max repairs an average of 21.5 bugs at an estimated $5.83 for the complete two-repository run across two runs. High repairs 16 at $3.56 across two runs; xhigh repairs 18.3 at $4.80 across three. These are repaired-bug counts, not percentages, and the costs are list-price estimates rather than invoices or per-bug fees.

In the same published dataset, Sonnet xhigh repairs 36 bugs at $42.86 and high repairs 34.3 at $19.85. Those Sonnet estimates use the September 28, 2026 price table, including $0.20 per million cache-read tokens. Sonnet’s current cache-read rate is $0.10; the published Bug Hunt costs have not been recalculated at that rate, so they are historical run estimates rather than a current-price Haiku/Sonnet cost comparison. Luna max repairs 18.3 at $0.52 across three runs, but its cost estimate omits the long-context surcharge and is a lower bound. Claude Code and Codex CLI use different harnesses. The useful question is which configuration yields enough accepted fixes for the complete budget.

Plotly’s private 43-question data-analysis evaluation reports Haiku 5.5 at 37 correct, $0.38 for the round and a median 14 seconds per question. Haiku 4.5 scores 27 at $3.27 and 17 seconds; Luna scores 38 at $0.13. Effort and repeated-run counts are not disclosed. This is evidence about that small analytics task set, rather than a general ranking of coding or reasoning ability.

Choose Haiku for frequent classification, extraction and bounded subagent steps. Use Sonnet for everyday coding and agent work where stronger reasoning saves repair turns. Both accept text and images, with 1M context and up to 128K output tokens. Haiku defaults to medium effort; Sonnet defaults to high. Set effort explicitly when comparing the same task.

At standard Claude API rates checked October 8, Sonnet costs $2 input and $10 output per million tokens across its 1M window. Haiku costs $0.10 / $0.50 through 100K prompt tokens and $0.50 / $2.50 above that boundary. Sonnet’s uncached input/output rates are therefore 20 times Haiku’s short-prompt rates and four times its long-prompt rates. For the same assumed 20K input and 2K output, the bill is $0.06 on Sonnet and $0.003 on Haiku; at 120K input and 10K output, it is $0.34 versus $0.085.

Those examples hold billed token counts constant. For actual agent work, compare accepted fixes, all attempts and elapsed time. The Bug Hunt evaluation provides useful repair counts, but their historical Sonnet cost estimates use the old cache-read rate; current Sonnet cache reads cost $0.10 per million tokens. Anthropic labels Haiku Fastest and Sonnet Fast in its standard model comparison, which does not measure time to a passing patch.

Use Haiku as a candidate for frequent extraction, routing and bounded subagent steps; compare Opus on the difficult coding and knowledge-work cases that need more capable reasoning. Both accept text and images, offer 1M context and normally generate up to 128K output tokens. Both default to medium effort, with low, high, xhigh and max also available.

Standard Claude API pricing, checked October 8, is $0.10 input / $0.50 output per million tokens for Haiku prompts through 100K, rising to $0.50 / $2.50 for the whole request above that boundary. Opus costs $4 / $20 throughout its 1M context. The uncached token-rate ratio is therefore 40 times for short prompts and eight times for long prompts. Cache reads cost $0.01 or $0.05 for Haiku and $0.20 for Opus. Those ratios describe billed tokens, not the cost of successful work.

For equal assumed uncached usage of 20K input and 2K output, Haiku costs $0.003 and Opus $0.12. At 120K input and 10K output, they cost $0.085 and $0.68. Real tasks can consume different token totals: include rejected attempts, cache writes, reasoning and tool charges before dividing by accepted outcomes.

Artificial Analysis’s October 8 comparison labels both configurations High, with Opus using Default Fallback. It reports Intelligence Index 38 for Haiku and 54 for Opus, and weighted Index task costs of $0.08 and $1.82. The associated output use is about 55K versus 36K tokens per task. Compare the actual output usage as well as effort labels; AA’s Haiku cost caveat about the over-100K rate step still matters.

The same comparison snapshot lists output generation at 178 versus 76 tokens per second and time to the first answer token at 26.69 versus 37.62 seconds. These are AA’s API measurements, not time to an accepted code patch. Its Time per Task is a decode estimate and its end-to-end figure models a 500-token response; neither substitutes for an agent run with tool execution and retries.

Opus always thinks and rejects forced tool use. Haiku supports forced tool choice, with no thinking on that forced-tool response. Preserve these differences when moving a workflow; compare both at an explicit effort and with the same acceptance checks.

Luna 6 refers here to OpenAI’s GPT-6 Luna, API ID gpt-6-luna. Anthropic Haiku 5.5 and GPT-6 Luna both fit focused, high-volume text work. Start by comparing a task both can finish: extraction, a reply grounded in retrieved material, or a bounded agent step with a clear acceptance rule.

GPT-6 Luna pricing is $0.10 per million standard input tokens and $0.50 per million output tokens for prompts up to 272K input tokens. Cached input is $0.01 and cache writes $0.125. Above 272K, input and cache rates double and output rates rise by 50% for the full request; regional processing can add 10%. Haiku has the same starting input/output pair, but its fivefold tier starts above 100K prompt tokens. The table uses equal billed token counts, not a claim that identical text tokenizes equally.

In Artificial Analysis’s same Intelligence Index framework, Haiku at high scores 38 with about 55K output tokens per task, while Luna at max scores 38 with about 50K. At max, Haiku scores 43 and uses about 162K output tokens per task. Those effort-specific aggregate results show a quality/token tradeoff; neither is a measurement of Haiku’s default medium setting. AA’s provisional Haiku costs omit its >100K rate step, so they do not settle the full task bill.

Plotly’s same private 43-question analytics test reports Haiku at 37 correct, $0.38 per full run and median 14 seconds per question; Luna scores 38, costs $0.13 and takes about 18 seconds. Effort and repeated-run counts are undisclosed. The result favors different choices for latency and run cost on that test. Bug Hunt adds repair evidence, but its Claude Code/Codex CLI harnesses differ and the Luna estimate omits a long-context surcharge.

BrenBuilds’s October 7 test puts that choice into a small TypeScript app. Across three bug-hunt runs, Haiku and Luna repaired medians of 19 and 18 of 20 planted bugs at medium effort. At xhigh, both medians were 20, with Haiku’s individual scores 20/20/19 and Luna’s 20/20/20. Adding the bug-hunt and three-ticket task medians gives 4.9 versus 3.0 minutes at medium, and 9.6 versus 13.1 at xhigh. The shared app and hidden checks ran through different harnesses: Claude Code 2.1.284 and Codex CLI 0.159.0.

Luna’s estimated costs were lower in those runs. The published ranges bound incomplete token logs, rather than fluctuations in paid invoices; Haiku cache writes in this dataset use the one-hour rate. Bren’s output-speed test separately requested at least 600 words. Its shorter explanation timings use six successful samples per combination, excluding one failed Luna-medium attempt. Compare visible output speed, accepted-task time and cost separately when selecting your coding workflow.

Choose with the complete workload: default medium first, then raise effort or escalate failed cases. Record accepted outcomes, all input/output/cache tokens, tool fees, retries and time to the accepted answer. Luna’s Responses API offers built-in tools and function calling; use the endpoint that supplies your workflow’s tools. Decisions is a separate input-only endpoint using Luna, useful for fixed-choice routing rather than generated replies.