DEV Community: Hassann

Claude Haiku 5.5 vs GPT-6 Luna

Hassann — Thu, 08 Oct 2026 04:15:41 +0000

Claude Haiku 5.5 and GPT-6 Luna share a list price: $0.10/$0.50 per million input/output tokens for Haiku prompts up to 100K tokens, with $0.01 cache reads and $0.125 cache writes on both. The difference is where that price ends. Haiku 5.5 moves to $0.50/$2.50 over 100K tokens; Luna holds its base rate until 272K input tokens, then charges 2x input and 1.5x output. On Anthropic’s launch table, Haiku 5.5 scores higher on every shared row. On Anthropic’s own cost charts, Luna is cheaper per task at every GDPval-AA effort level and at four of five on OSWorld; at OSWorld medium, Haiku 5.5 is marginally cheaper.

Try Apidog today

This guide compares price, specs, shared benchmarks, per-effort cost curves, and workload routing. For individual model details, see what is Claude Haiku 5.5 and what is GPT-6 Luna. The implementation section sends the same prompt to both models in Apidog.

Price side by side

Per 1M tokens	Claude Haiku 5.5	GPT-6 Luna
Input, base tier	$0.10 (prompts up to 100K tokens)	$0.10 (up to 272K input tokens)
Output, base tier	$0.50	$0.50
Cache read, base tier	$0.01	$0.01
Cache write, base tier	$0.125 (5-minute)	$0.125
Higher tier, input / output	$0.50 / $2.50 (over 100K)	$0.20 / $0.75 (over 272K)
Higher tier, cache read / write	$0.05 / $0.625	2x cache rates
Batch	$0.05 / $0.25 up to 100K; $0.25 / $1.25 over	50% of Standard rates (Batch and Flex)

Sources: Anthropic’s pricing docs and OpenAI’s GPT-6 Luna model page.

OpenAI reprices “the full request” above 272K. Anthropic says “a prompt of over 100,000 tokens pays higher prices,” charged per request by prompt length.

Apply the pricing thresholds

Measure the input token count for each request.
If prompts stay below 100K tokens, the listed input and output rates are identical.
For prompts between 100K and 272K tokens, Haiku 5.5 costs 5x more for both input and output.
Above 272K tokens, both models use higher-tier pricing, but Luna remains cheaper.

Two examples, counted in each vendor’s own tokens:

150K-token prompt, 2K output
- Haiku 5.5: 0.15 × $0.50 + 0.002 × $2.50 = $0.080
- Luna: 0.15 × $0.10 + 0.002 × $0.50 = $0.016
300K-token prompt, 2K output
- Haiku 5.5: 0.30 × $0.50 + 0.002 × $2.50 = $0.155
- Luna: 0.30 × $0.20 + 0.002 × $0.75 = $0.0615

Anthropic says prompts up to 100K tokens made up around 90% of Haiku 4.5 requests. If your traffic has a similar distribution, most calls cost the same on either model. See Claude Haiku 5.5 pricing for more calculations.

Tokenizers move the threshold

Do not compare raw token counts without measuring both APIs. A token on one model is not necessarily a token on the other.

Haiku 5.5’s updated tokenizer produces about 30% more tokens than Haiku 4.5 for the same text, according to Anthropic. In the Hacker News launch thread, one commenter estimated that “modern Claude’s 100K tokens are about ~60-65K modern GPT tokens.” That is a community estimate, not a vendor figure.

For production routing:

Send representative prompts to both APIs.
Record each response’s usage object.
Compare input-token counts, output-token counts, latency, and cost.
Set routing thresholds from measured usage rather than character counts.

Specs

	Claude Haiku 5.5	GPT-6 Luna
API model ID	`claude-haiku-5-5`	`gpt-6-luna`
Context window	1M tokens	1,050,000 tokens
Max output	128K tokens (300K on Batch with a beta header)	128,000 tokens
Knowledge cutoff	June 2026	May 18, 2026
Effort levels	low, medium (default), high, xhigh, max	none, low, medium (default), high, xhigh, max
Thinking off	`thinking: {"type": "disabled"}` at high effort or below	`none` reasoning effort
Free chat access	Free Claude.ai users can select it	Free and Go users in the ChatGPT desktop app

Both models default to medium.

On Haiku 5.5, configure effort with output_config.effort.
On Luna, configure effort with reasoning.effort.
Neither free chat route provides an API key, so neither can run a script, CI job, or agent.

See Claude Haiku 5.5 for free and GPT-6 Luna for free.

One caching difference matters for multi-step loops: on Haiku 5.5, changing top-level effort between requests invalidates the prompt cache. OpenAI says changing reasoning effort no longer breaks the cache on GPT-6 models. See GPT-6 prompt caching.

Benchmarks: Anthropic’s table and who ran each Luna cell

Every number below comes from Anthropic’s launch post and its system card. Anthropic compiled the table, but different parties ran different rows. Haiku 5.5 results are at max effort, mostly averaged over five trials.

Benchmark	Haiku 5.5	GPT-6 Luna	How the Luna cell was sourced
GDPval-AA v2.1 (Elo)	1620	1437	Run independently by Artificial Analysis
AA-Briefcase v1.1 (Elo)	1578	1336	Run independently by Artificial Analysis
OSWorld 2.1, offline subset	72.4%	48.9%	Run by Anthropic on the same 82 tasks via OpenAI’s API
Terminal-Bench 4.0	39.2%	16.4%	Public leaderboard, Codex CLI at max effort
FrontierCode 1.1 (Main)	46.4%	42.4%	Run by Cognition (Claude in Claude Code, GPT in Codex)
Chartography, no tools	46.4%	29.1%	As publicly reported by Surge AI

The rows share a benchmark name, not a single harness:

Terminal-Bench uses Haiku 5.5 in Claude Code and Luna in the Codex CLI.
OSWorld is the closest to a controlled comparison because Anthropic ran both models on the same tasks.
OSWorld is still one vendor running a rival’s model.

No independent head-to-head exists yet. As of October 8, 2026, Artificial Analysis has no Haiku 5.5 page, and no Haiku 5.5 result was found on Vals, LMArena, SWE-bench, or Aider. AA’s leaderboard that day lists GPT-6 Luna (max) at an Intelligence Index of 38 and 129 output tokens per second.

For the full set of Haiku 5.5 results, see Claude Haiku 5.5 benchmarks.

Cost per attempt at each effort level

The launch table shows each model at max effort. Anthropic’s launch page also plots effort level against cost, including Luna on two charts.

OSWorld 2.1: offline subset

Partial-credit score / cost per attempt:

Effort	Haiku 5.5	GPT-6 Luna
Low	42.0% / $0.0695	19.2% / $0.038
Medium	53.3% / $0.1257	37.5% / $0.1261
High	61.3% / $0.1827	42.3% / $0.1435
Xhigh	67.6% / $0.2792	44.8% / $0.1672
Max	72.4% / $0.6111	48.9% / $0.205

GDPval-AA v2.1

Elo / cost per task:

Effort	Haiku 5.5	GPT-6 Luna
Low	1125 / $0.01167	1036 / $0.0038
Medium	1277 / $0.03042	1262 / $0.02
High	1420 / $0.08938	1344 / $0.03
Xhigh	1513 / $0.26725	1364 / $0.05
Max	1620 / $0.86593	1437 / $0.09

Luna costs less at every effort level on GDPval-AA and at low, high, xhigh, and max on OSWorld. At OSWorld medium, Haiku 5.5 is marginally cheaper: $0.1257 versus $0.1261.

Haiku 5.5 scores higher at every level. Compare models at matched spend instead of only comparing maximum scores:

OSWorld: Haiku 5.5 at medium costs $0.1257 per attempt versus Luna’s $0.1261, while scoring 53.3% versus 37.5%. Haiku at medium also beats Luna at max (48.9%) for less money.
GDPval-AA: Luna at max (1437, $0.09) and Haiku 5.5 at high (1420, $0.08938) cost about the same and are 17 Elo apart.

For computer-use workflows, Haiku 5.5 buys more score per dollar in Anthropic’s run. For knowledge work, the models are close at similar spend, while Luna’s lower floor is useful when good-enough output is the goal.

Routing: which model for which workload

Anthropic positions Haiku 5.5 for “narrowly scoped tasks” and says Sonnet 5.5 and Opus 5.5 “remain better choices for complex agentic coding tasks.” Both models here are built for volume.

Workload	Start with	Why
Classification, routing, extraction under 100K tokens	Either; test both	Identical price; choose based on accuracy for your labels
Long-document Q&A, 100K to 272K tokens	GPT-6 Luna	Base rate holds to 272K; Haiku 5.5 is 5x above 100K
Browser and desktop automation	Claude Haiku 5.5	Higher OSWorld score at matched cost
Subagents under Opus 5.5 or Sonnet 5.5	Claude Haiku 5.5	Claude Code `model: haiku` frontmatter uses Haiku 5.5 on the Anthropic API
Lowest cost per call	GPT-6 Luna	Cheapest floor: $0.038 on OSWorld and $0.0038 on GDPval-AA at low
Knowledge-work drafting at high effort	Either; test both	Within 17 Elo at matched spend on GDPval-AA

See Claude Haiku 5.5 in Claude Code for subagents and GPT-6 Luna for high-volume API workloads for high-QPS pipelines.

Coming from Haiku 4.5? Haiku 5.5 vs Haiku 4.5 lists the five new 400 errors.

Test both side by side in Apidog

The comparison that matters runs on your prompts. In Apidog, create one project with two requests that use the same prompt.

Store ANTHROPIC_API_KEY and your OpenAI key as environment variables.
Add the Haiku 5.5 request below, then add the Luna request using the same prompt and effort.
Assert that Haiku’s stop_reason is not "refusal" because there is no server-side fallback.
Add a token-budget assertion based on the response usage.
Run both models at low, medium, and high effort.
Save responses and compare token usage, latency, cost, and output quality.

curl https://api.anthropic.com/v1/messages \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "content-type: application/json" \
  -d '{
    "model": "claude-haiku-5-5",
    "max_tokens": 2048,
    "thinking": {"type": "adaptive"},
    "output_config": {"effort": "medium"},
    "messages": [
      {
        "role": "user",
        "content": "Classify this support ticket as billing, bug, or feature request: The export button returns a 500 error since this morning."
      }
    ]
  }'

Leave out temperature, top_p, and top_k: non-default values return a 400 on Haiku 5.5.

For a walkthrough, see how to use the Claude Haiku 5.5 API. For eval sets, see testing LLM applications.

FAQ

Are Claude Haiku 5.5 and GPT-6 Luna the same price?

Yes, for Haiku prompts up to 100K tokens: $0.10/$0.50, $0.01 cache reads, and $0.125 cache writes. Above that, Haiku 5.5 costs $0.50/$2.50, while Luna stays at base pricing until 272K.

Which model scores higher?

Haiku 5.5 scores higher on every shared row of Anthropic’s launch table. Anthropic compiled that table, and no independent head-to-head exists yet.

Which is cheaper per task?

Usually Luna: it costs less at every effort level on Anthropic’s GDPval-AA chart and at four of five effort levels on OSWorld. At OSWorld medium, Haiku 5.5 is $0.0004 cheaper. At matched spend, Haiku 5.5 leads on OSWorld, while GDPval-AA is close.

Is either one free?

Only in chat interfaces. Free Claude.ai users can select Haiku 5.5, and Free and Go users get Luna in the ChatGPT desktop app. Neither provides an API key. See Claude Haiku 5.5 for free.

Pick by prompt length, then test

Start with prompt length:

Under 100K tokens: price is a tie. Test accuracy on your real tasks.
From 100K to 272K tokens: Luna’s threshold saves money on every call.
Over 272K tokens: Luna remains cheaper at the higher tier.

Then test both models on production-like requests at two or three effort levels. Download Apidog, put both requests in one project, and use the returned usage values to make the routing decision.

Claude Haiku 5.5 Benchmarks

Hassann — Thu, 08 Oct 2026 04:12:41 +0000

Claude Haiku 5.5 scores 72.4% on OSWorld 2.1, 1620 on GDPval-AA v2.1, 46.4% on FrontierCode 1.1, and 39.2% on Terminal-Bench 4.0. Haiku 4.5 scored 15.7%, 735, and 0.0% on three of those. These are max-effort numbers; at the default medium effort, GDPval-AA drops to 1277. No independent lab has published Haiku 5.5 results yet.

Try Apidog today

This guide breaks down every published Claude Haiku 5.5 benchmark, identifies who ran each test, shows how effort changes score and cost, and provides a practical workflow for testing the model against your own traffic in Apidog. For specifications and pricing context, start with What Is Claude Haiku 5.5.

The launch table

Every Haiku 5.5 result below uses adaptive thinking at max effort, usually averaged across five trials. Terminal-Bench used 10 trials per task. “n/r” means no published result.

Benchmark	Haiku 5.5	Haiku 4.5	GPT-6 Luna	Sonnet 5.5
GDPval-AA v2.1 (Elo)	1620	735	1437	1840
AA-Briefcase v1.1 (Elo)	1578	614	1336	1824
OSWorld 2.1, offline subset	72.4%	15.7%	48.9%	83.9%
Humanity’s Last Exam, no tools	45.9%	10.2%	n/r	56.9%
Humanity’s Last Exam, with tools	57.4%	18.7%	n/r	64.5%
Terminal-Bench 4.0	39.2%	0.0%	16.4%	70.6%
FrontierCode 1.1 (Main)	46.4%	n/r	42.4%	52.1% (xhigh)
Chartography, no tools	46.4%	6.4%	29.1%	61.6%

Who ran each benchmark

Treat cross-vendor comparisons carefully: sharing a benchmark name does not guarantee identical harnesses, prompts, or effort settings.

Benchmark	Who ran it	Conditions
GDPval-AA v2.1, AA-Briefcase v1.1	Artificial Analysis, independently	GDPval-AA: 220 tasks across 44 occupations; Elo anchored to DeepSeek V4.1 Flash (max) at 1600. Briefcase uses multi-week projects.
FrontierCode 1.1	Cognition	Claude ran in Claude Code; GPT ran in Codex. Main is the hardest 100 of 150 tasks.
Chartography	Anthropic, using Surge AI’s benchmark	Gemini 3.5 Flash grader; Luna score supplied by Surge AI.
Terminal-Bench 4.0	Anthropic	Claude Code `--bare`, 66 tasks, 10 trials per task, safeguards enabled.
OSWorld 2.1	Anthropic	82 of 108 tasks, 1080p resolution, up to 500 steps.
Humanity’s Last Exam	Anthropic	980K-token task budget; Opus 4.6 grader.

Two GPT-6 Luna values need additional context:

Anthropic ran Luna’s OSWorld score through OpenAI’s API on the same 82 tasks.
Luna’s 16.4% Terminal-Bench score comes from the public leaderboard using Codex CLI at max effort.
On Terminal-Bench, safeguards stopped 1.8% of Haiku 5.5 trials—12 of 660—and each stopped trial counted as a failure.

The FrontierCode comparison trap

The launch table compares Haiku 5.5 at max effort with Sonnet 5.5 at xhigh, which is Sonnet’s best published setting. The system card provides the matched-effort comparison.

FrontierCode 1.1	Main	Extended
Haiku 5.5, max	46.4%	58.4%
Haiku 5.5, xhigh	45.8%	n/r
Sonnet 5.5, max	46.2%	59.1%
Sonnet 5.5, xhigh	52.1%	64.4%

At matched max effort, Haiku 5.5 narrowly leads Sonnet 5.5 on FrontierCode Main: 46.4% versus 46.2%.

At each model’s best setting, Sonnet leads by 5.7 percentage points. When reporting FrontierCode results, always include the effort setting.

Additional system card benchmarks

The system card includes benchmarks omitted from the launch post. All values use max effort unless stated otherwise.

Benchmark	Haiku 5.5	Haiku 4.5	Sonnet 5.5
SWE-Bench Pro	64.8	n/r	81.3
SWE-bench Multilingual	83.7	67.4	90.3
SWE-bench Multimodal	30.7	19.8	54.3
OSWorld 2.1, strict pass rate	37.1%	n/r	48.8%
Chartography, with tools	86.2%	8.8%	90.2%
OfficeQA / OfficeQA Pro	73.5% / 60.3%	63.0% / 47.1%	76.9% / 65.6%
HealthBench Professional, length-adjusted	64.8%	32.2%	69.2%

Two implementation takeaways stand out:

The 72.4% OSWorld result is partial credit. The strict pass rate is only 37.1%.
Chartography rises from 46.4% without tools to 86.2% with tools. For chart-related workflows, give Haiku 5.5 access to the required tools rather than relying on text-only reasoning.

Default effort scores lower

Haiku 5.5 defaults to medium effort in the Claude API and Claude Code. Do not expect max-effort benchmark results unless you explicitly configure the model.

Benchmark	Medium (default)	Max	Note
GDPval-AA v2.1	1277	1620	Medium used about one tenth of max’s output tokens.
AA-Briefcase v1.1	1372	1578	Medium used under one quarter of max’s output tokens.
HealthBench Professional	59.9%	64.8%	Low: 57.9%; high: 61.3%.

If you omit output_config.effort, expect the medium column. See the Claude effort documentation for all five levels.

Score and cost by effort

The following launch-chart values pair score with cost. OSWorld and Terminal-Bench costs are per attempt; GDPval-AA costs are per task.

Model	Low	Medium	High	Xhigh	Max
OSWorld 2.1
Haiku 5.5	42.0% ($0.07)	53.3% ($0.13)	61.3% ($0.18)	67.6% ($0.28)	72.4% ($0.61)
Sonnet 5.5	57.9% ($0.68)	66.0% ($0.93)	73.2% ($1.38)	81.1% ($2.22)	83.9% ($5.73)
GPT-6 Luna	19.2% ($0.04)	37.5% ($0.13)	42.3% ($0.14)	44.8% ($0.17)	48.9% ($0.21)
GDPval-AA v2.1
Haiku 5.5	1125 ($0.012)	1277 ($0.030)	1420 ($0.089)	1513 ($0.27)	1620 ($0.87)
Sonnet 5.5	1179 ($0.22)	1324 ($0.27)	1551 ($0.62)	1731 ($1.88)	1840 ($6.78)
GPT-6 Luna	1036 ($0.004)	1262 ($0.02)	1344 ($0.03)	1364 ($0.05)	1437 ($0.09)
Terminal-Bench 4.0
Haiku 5.5	12.7% ($0.42)	20.3% ($0.68)	24.8% ($1.04)	31.5% ($1.75)	39.2% ($2.64)
Sonnet 5.5	20.0% ($0.62)	28.8% ($0.68)	43.0% ($1.46)	61.5% ($4.34)	70.6% ($10.44)

Use this table to choose an initial production setting:

Start with medium. On GDPval-AA, moving from medium to max costs roughly 28x more for 343 additional Elo points.
Validate the final increments. On OSWorld, moving from xhigh to max more than doubles cost for a 4.8-point gain.
Compare equivalent budgets, not just effort labels. Haiku 5.5 at medium beats Luna at max on OSWorld: 53.3% for $0.13 versus 48.9% for $0.21.
Use Sonnet for demanding terminal tasks. Sonnet 5.5 at high scores 43.0% on Terminal-Bench for $1.46, exceeding Haiku 5.5 at max—39.2% for $2.64.

Luna costs less at every other matching level, although at medium the two models cost about the same. See Claude Haiku 5.5 vs GPT-6 Luna.

Costs use list prices: $0.10/$0.50 per million tokens for prompts up to 100K tokens, with higher pricing above that threshold. See the Claude Haiku 5.5 pricing breakdown.

Where Haiku 5.5 still trails

Sonnet 5.5 leads every launch-table row. Haiku 5.5’s only direct win is FrontierCode at matched max effort.

The largest gap is Terminal-Bench 4.0:

Haiku 5.5: 39.2%
Sonnet 5.5: 70.6%

The same pattern appears in SWE-Bench Pro—64.8 versus 81.3—and SWE-bench Multimodal—30.7 versus 54.3.

Anthropic states that Sonnet 5.5 and Opus 5.5 remain better choices for complex agentic coding work. Haiku 5.5 is more appropriate for narrowly scoped tasks such as:

Context compaction
Summarization
Classification
Browser use
Subagents coordinated by a larger model

For a practical subagent setup, see Haiku 5.5 in Claude Code.

Independent results: none yet

As of October 8, 2026, no independent lab has published Haiku 5.5 benchmark results.

Artificial Analysis’s Haiku 5.5 page returns a 404, and its leaderboard lists only Claude 4.5 Haiku. Vals, LMArena, SWE-bench, and Aider did not show results either.

There is also no third-party speed figure. Anthropic calls Haiku 5.5 its “fastest model to date” at standard speed, while noting that it is slower than Opus in Fast Mode.

The closest external result comes from Cursor. Its Claude Haiku 5.5 model documentation reports:

48.4% on CursorBench at max effort
30.9% at low effort
With thinking disabled, 22.1% to 26.2% across the same effort levels
With thinking enabled, 30.9% to 42.3% across those levels

What customers report

The following claims come from Anthropic’s launch post and have not been independently verified:

HubSpot: 92.8% averaged across three runs on its simulated CRM portal suite, its best result on that suite.
AlphaSense: 0.84 versus Haiku 4.5’s 0.76 on 400 Ask in Document queries, described as statistically significant.
Box: 11 points higher than Haiku 4.5 at about half the latency in early testing.
Asana: Over 30% lower latency for task completions compared with its current model.
Cognition: Devin Fusion retains a FrontierCode score of 66.2 using Haiku 5.5 as a sidekick and Opus 5.5 as lead. This is a two-model system, not a Haiku-only result.

Run your own eval

Benchmarks are useful for model selection, but they are not representative of your production traffic. Anthropic’s prompting guide recommends using xhigh or max only when your own evaluations demonstrate a meaningful gain.

Build a repeatable eval collection in Apidog:

Store ANTHROPIC_API_KEY as an environment variable.
Create 20 to 50 Messages API requests from real prompts, sanitized production incidents, or representative fixtures.
Add assertions for:
- HTTP status 200
- A stop_reason other than "max_tokens" or "refusal"
- Required answer properties, such as a valid classification, JSON field, or expected phrase
Run the same collection at low, medium, and high effort.
Record pass rate and values from usage.
Duplicate the collection, replace the model with claude-sonnet-5-5, and compare results in the same project.

Changing effort invalidates the prompt cache, so evaluate each effort level independently.

curl https://api.anthropic.com/v1/messages \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "content-type: application/json" \
  -d '{
    "model": "claude-haiku-5-5",
    "max_tokens": 8000,
    "thinking": {"type": "adaptive"},
    "output_config": {"effort": "medium"},
    "messages": [
      {
        "role": "user",
        "content": "Classify this support ticket as billing, bug or feature request: ..."
      }
    ]
  }'

When implementing the response parser, select blocks by type. A thinking block can appear before the final content block.

Also note these Haiku 5.5 API constraints:

Do not send temperature.
Do not send top_p.
Do not send top_k.
Do not send an assistant prefill.

Each of these returns a 400 response on Haiku 5.5.

For implementation details, see the Claude Haiku 5.5 API guide and Testing LLM Applications.

FAQ

Is Claude Haiku 5.5 better than Sonnet 5.5?

Not according to Anthropic’s published numbers. Sonnet 5.5 leads every launch-table row. Haiku only edges it on FrontierCode when both run at max: 46.4% versus 46.2%. See Haiku 5.5 vs Haiku 4.5 for the upgrade comparison.

What is Haiku 5.5’s SWE-bench score?

It scores 64.8 on SWE-Bench Pro, 83.7 on SWE-bench Multilingual, and 30.7 on SWE-bench Multimodal. All results use max effort.

What effort were the benchmarks run at?

Most published results use max effort and are averaged over five trials. The API default is medium, where GDPval-AA scores 1277 instead of 1620.

Are there independent Haiku 5.5 benchmarks?

Not yet. Artificial Analysis independently ran GDPval-AA and AA-Briefcase, but Anthropic published those scores. Artificial Analysis does not currently have a Haiku 5.5 page.

Is GPT-6 Luna cheaper?

Usually. Luna costs less at every GDPval-AA effort level and every OSWorld level except medium, where the models cost about the same. Haiku 5.5 scores higher on both benchmarks.

Next step

Start at medium, measure pass rate and token usage on your own requests, then increase effort only when the pass-rate improvement justifies the cost.

Download Apidog, build the evaluation collection, and keep the results in Apidog next to your Sonnet 5.5 baseline before routing production traffic.

Claude Haiku 5.5 vs Haiku 4.5: What Changed and the Breaking Changes to Fix First

Hassann — Thu, 08 Oct 2026 04:11:25 +0000

Claude Haiku 5.5 (claude-haiku-5-5, released October 7, 2026) costs 90% less than Haiku 4.5 for prompts up to 100K tokens: $0.10/$0.50 per million input/output tokens versus $1/$5. It also expands the context window from 200K to 1M tokens and scores higher on every launch benchmark that lists both models. However, five request shapes that worked on 4.5 now return HTTP 400 errors, while several other changes affect responses and costs without errors.

Try Apidog today

This guide covers the migration differences, before/after request bodies, silent behavior changes, and a practical Apidog test plan. For the complete specification, see What is Claude Haiku 5.5. If you still use the previous model, see the Claude Haiku 4.5 API guide.

Haiku 4.5 vs. Haiku 5.5 at a glance

	Claude Haiku 4.5	Claude Haiku 5.5
Model ID (Claude API)	`claude-haiku-4-5-20251001`	`claude-haiku-5-5`
Context / max output	200K / 64K	1M / 128K
Input / output per MTok	$1 / $5	$0.10 / $0.50 up to 100K tokens; $0.50 / $2.50 over
Cache read / 5m write per MTok	$0.10 / $1.25	$0.01 / $0.125 up to 100K; $0.05 / $0.625 over
Batch input / output per MTok	$0.50 / $2.50	$0.05 / $0.25 up to 100K; $0.25 / $1.25 over
Thinking	Manual `budget_tokens`	Adaptive only, enabled by default
Effort levels	None	`low`, `medium` (default), `high`, `xhigh`, `max`
Minimum cacheable prompt	4,096 tokens	512 tokens
Tokenizer	Older	About 30% more tokens for the same text
Non-default sampling params / prefill	Accepted	HTTP 400
Priority Tier	Supported	Not supported
Status	Active; retirement not sooner than Oct. 15, 2026	Active; retirement not sooner than Oct. 7, 2027

Haiku 4.5 is not deprecated. The model deprecations page lists it as Active with no deprecation date, so you can migrate on your own schedule. Rate limits are the same for both models.

The five breaking changes

Each of the following request patterns returns HTTP 400 on Haiku 5.5 even though it works on Haiku 4.5. See Anthropic's Haiku 5.5 migration guide for the complete reference.

1. Replace manual thinking budgets

Haiku 5.5 supports adaptive thinking only. Requests with a fixed budget_tokens value are rejected.

// Before: Haiku 4.5
{
  "model": "claude-haiku-4-5-20251001",
  "max_tokens": 16000,
  "thinking": { "type": "enabled", "budget_tokens": 8000 },
  "messages": [
    { "role": "user", "content": "Classify this ticket." }
  ]
}

// After: Haiku 5.5
{
  "model": "claude-haiku-5-5",
  "max_tokens": 16000,
  "thinking": { "type": "adaptive" },
  "output_config": { "effort": "medium" },
  "messages": [
    { "role": "user", "content": "Classify this ticket." }
  ]
}

Use effort as your new control:

Use low or medium where you previously used a small thinking budget.
Use high, xhigh, or max only when the task needs more reasoning.
You can disable thinking with thinking: { "type": "disabled" }, but only at high effort or below. Disabling it at xhigh or max returns HTTP 400.

2. Remove sampling parameters

Remove temperature, top_p, and top_k from Haiku 5.5 requests.

The only accepted explicit values are:

temperature: 1
top_p: 0.99

Any other value returns HTTP 400. This includes top_p: 1, all top_k values, and sending temperature and top_p together.

// Before: Haiku 4.5
{
  "model": "claude-haiku-4-5-20251001",
  "max_tokens": 1024,
  "temperature": 0.2,
  "top_k": 40,
  "messages": [
    { "role": "user", "content": "Extract the order ID." }
  ]
}

// After: Haiku 5.5
{
  "model": "claude-haiku-5-5",
  "max_tokens": 1024,
  "messages": [
    { "role": "user", "content": "Extract the order ID." }
  ]
}

If you used low temperature to make output consistent, express the constraint in the prompt instead. For example: “Return exactly one order ID and no additional text.”

3. Remove assistant prefills

Haiku 5.5 rejects a final assistant message used as a prefill, including when thinking is disabled. Your messages array must end with a user turn.

// Before: Haiku 4.5
{
  "model": "claude-haiku-4-5-20251001",
  "max_tokens": 1024,
  "messages": [
    { "role": "user", "content": "Return the sentiment as JSON." },
    { "role": "assistant", "content": "{\"sentiment\": \"" }
  ]
}

// After: Haiku 5.5
{
  "model": "claude-haiku-5-5",
  "max_tokens": 1024,
  "system": "Reply with only a JSON object. No preamble.",
  "messages": [
    { "role": "user", "content": "Return the sentiment as JSON." }
  ]
}

For strict output formats, use structured outputs or a tool with enum fields for classification.

4. Migrate computer use to the new toolset

For the Claude API and Google Cloud, Haiku 5.5 supports computer use through computer_toolset_20260801.

Also remove these beta headers:

computer-use-2025-01-24
fine-grained-tool-streaming-2025-05-14

The fine-grained tool streaming header returns HTTP 400 when sent alongside a toolset.

// Before: Haiku 4.5
// Header: anthropic-beta: computer-use-2025-01-24
{
  "model": "claude-haiku-4-5-20251001",
  "max_tokens": 4096,
  "tools": [
    {
      "type": "computer_20250124",
      "name": "computer",
      "display_width_px": 1280,
      "display_height_px": 800
    }
  ],
  "messages": [
    { "role": "user", "content": "Open the settings page." }
  ]
}

// After: Haiku 5.5
// No beta header
{
  "model": "claude-haiku-5-5",
  "max_tokens": 4096,
  "tools": [
    { "type": "computer_toolset_20260801" }
  ],
  "messages": [
    { "role": "user", "content": "Open the settings page." }
  ]
}

Update your agent loop too:

Dispatch each tool_use block using its name and toolset_name.
Do not dispatch based on input.action.
Include toolset_name when sending tool results.

Haiku 5.5 also supports browser use through browser_toolset_20260801; Haiku 4.5 does not. See Claude Code computer use for more context.

5. Do not edit earlier turns before replaying thinking blocks

A Haiku 5.5 thinking block remains valid only when all earlier request content is unchanged. If you modify system, tools, or an earlier message and then replay the thinking block, the API returns HTTP 400.

Haiku 4.5 did not enforce this validation.

// Invalid: edited system + replayed thinking block = HTTP 400
{
  "model": "claude-haiku-5-5",
  "max_tokens": 4096,
  "system": "You are a billing agent. Be brief.",
  "messages": [
    { "role": "user", "content": "Why was I charged twice?" },
    {
      "role": "assistant",
      "content": [
        {
          "type": "thinking",
          "thinking": "",
          "signature": "<from turn 1>"
        },
        { "type": "text", "text": "Checking." }
      ]
    },
    { "role": "user", "content": "Order 4412." }
  ]
}

// Valid: preserve earlier content and append the new instruction
{
  "model": "claude-haiku-5-5",
  "max_tokens": 4096,
  "system": "You are a billing agent.",
  "messages": [
    { "role": "user", "content": "Why was I charged twice?" },
    {
      "role": "assistant",
      "content": [
        {
          "type": "thinking",
          "thinking": "",
          "signature": "<from turn 1>"
        },
        { "type": "text", "text": "Checking." }
      ]
    },
    { "role": "user", "content": "Order 4412. Be brief." }
  ]
}

For accounts created before August 31, 2026 at 00:00 UTC, this error appears only when requests set thinking.block_binding.prefix_mismatch_behavior.

Silent changes that will not throw an error

These behavior changes require application-level tests because the request can still return HTTP 200.

Thinking content is empty by default. Each thinking block includes an empty thinking field and a signature. Haiku 4.5 returned summarized thinking. If you log or display it, set:

  {
    "thinking": {
      "type": "adaptive",
      "display": "summarized"
    }
  }

Responses can begin with thinking. Adaptive thinking is enabled even if you omit it. Select content blocks by type, not by array index.
The tokenizer uses about 30% more tokens. Recount your prompts and account for thinking tokens in max_tokens. A small max_tokens value can produce stop_reason: "max_tokens" before the model returns text.
Forced tool_choice skips thinking. tool_choice: { "type": "any" } or a named tool still works, but the response starts with a tool call and has no thinking block. Use tool_choice: { "type": "auto" } and prompt the model to call the tool when appropriate if you want reasoning first.
Safety refusals have no fallback. Haiku 5.5 uses safety classifiers for cyber, frontier_llm, bio, and general_harms. These can return stop_reason: "refusal". There is no server-side fallback, and retries usually return the same refusal.
Priority Tier is unavailable. If you have a Priority Tier commitment for Haiku 4.5, plan Haiku 5.5 capacity separately.
Thinking blocks are account-bound. A thinking block works only in the account that produced it or a linked account. Replaying stored conversations through another account does not preserve that reasoning.
Short prompts can now benefit from caching. The minimum cacheable prompt drops from 4,096 tokens to 512 tokens, so short system prompts that did not cache on Haiku 4.5 may cache on Haiku 5.5.

What got better

The following are Anthropic-reported numbers for Haiku 5.5 at maximum effort. Artificial Analysis independently ran GDPval-AA and AA-Briefcase.

Benchmark	Haiku 4.5	Haiku 5.5
GDPval-AA v2.1 (Elo)	735	1620
AA-Briefcase v1.1 (Elo)	614	1578
OSWorld 2.1, offline subset	15.7%	72.4%
Humanity’s Last Exam, with tools	18.7%	57.4%
Terminal-Bench 4.0	0.0%	39.2%
SWE-bench Multilingual	67.4%	83.7%
Chartography, no tools	6.4%	46.4%

Haiku 4.5’s Terminal-Bench run used a fixed 63,999-token thinking budget. At default medium effort, Haiku 5.5 scored 1277 on GDPval-AA, still well above Haiku 4.5. Box reported scores 11 points higher than Haiku 4.5 at about half the latency.

See the full results in Claude Haiku 5.5 benchmarks.

Anthropic still positions Sonnet 5.5 and Opus 5.5 as better options for complex agentic coding. Haiku 5.5 targets classification, extraction, summarization, compaction, subagents, and browser use.

On cost, Anthropic says Haiku 5.5 is around 75% cheaper on average. This combines the 90% lower price below 100K tokens with the 50% lower price above that threshold, while accounting for the new tokenizer. The tool-use system prompt also decreased from 496 to 286 tokens with auto tool choice.

See worked cost examples in Claude Haiku 5.5 pricing.

Test the migration in Apidog

In Apidog, create a project with three saved requests targeting:

https://api.anthropic.com/v1/messages

Create these requests:

Baseline

Save your existing Haiku 4.5 request body and assert status 200.
Old body, new model

Change only the model value to claude-haiku-5-5. Assert status 400. Keep a separate failing request for every breaking change your application uses.
Migrated

Save the corrected Haiku 5.5 request. Assert:
- Status is 200
- stop_reason is not refusal
- stop_reason is not max_tokens
- A text block exists by checking content[*].type === "text"

Store ANTHROPIC_API_KEY as an environment variable and reference it in the x-api-key header:

{{ANTHROPIC_API_KEY}}

Also include:

anthropic-version: 2023-06-01

Compare usage.input_tokens between the baseline and migrated requests to measure the tokenizer change using your real prompts.

Save the requests as a test scenario. That way, if a teammate reintroduces temperature, the test run fails before the change reaches production. For request setup details, see how to use the Claude Haiku 5.5 API.

If you work in Claude Code, run:

/claude-api migrate this project to claude-haiku-5-5

This applies the model ID and parameter fixes, then provides a checklist. Note that the haiku alias resolves to Haiku 5.5 only on the Anthropic API. See Claude Haiku 5.5 in Claude Code.

FAQ

Is Claude Haiku 4.5 deprecated?

No. It is listed as Active with no deprecation date, and its retirement is not sooner than October 15, 2026.

Why does my Haiku 4.5 request return HTTP 400 on Haiku 5.5?

Check for budget_tokens, temperature, top_p, top_k, an assistant prefill, computer_20250124, or edits to earlier turns before replaying a thinking block. These are the five breaking changes.

Is Haiku 5.5 cheaper than Haiku 4.5 for long prompts?

Yes. Above 100K tokens, Haiku 5.5 costs $0.50/$2.50 per million input/output tokens, half of Haiku 4.5’s $1/$5 pricing. Haiku 4.5 cannot accept prompts beyond 200K tokens.

Should I switch every workload to Haiku 5.5?

For classification, extraction, and subagent workloads, test it first and then migrate. Compare it with its closest rival in Haiku 5.5 vs GPT-6 Luna.

Next step

Save your Haiku 4.5 request beside its Haiku 5.5 equivalent, confirm the expected HTTP 400, fix each incompatible field, and move traffic only after the migrated request passes. Download Apidog to build the test pair.

Claude Haiku 5.5 Pricing

Hassann — Thu, 08 Oct 2026 04:09:50 +0000

Claude Haiku 5.5 costs $0.10 per million input tokens and $0.50 per million output tokens for prompts up to 100K tokens. A prompt of over 100,000 tokens pays higher prices: $0.50 input and $2.50 output. Cache reads start at $0.01, the Batch API halves every rate, and Anthropic says the model costs “around 75% less to run” than Haiku 4.5 on average.

Try Apidog today

This guide covers every line item, the math behind that 75%, three worked examples (one crossing 100K), cost per effort level, and how Haiku 5.5 compares with Haiku 4.5, GPT-6 Luna and Sonnet 5.5. New to the model? Start with what Claude Haiku 5.5 is. To check the numbers on your own traffic, send requests from Apidog and read each response’s usage block.

Claude Haiku 5.5 API pricing table

Prices per million tokens (MTok), from Anthropic’s pricing docs:

Line item	Prompts up to 100K tokens	Prompts over 100K tokens
Input	$0.10	$0.50
Output	$0.50	$2.50
5-minute cache write	$0.125	$0.625
1-hour cache write	$0.20	$1.00
Cache read (hits and refreshes)	$0.01	$0.05
Batch input	$0.05	$0.25
Batch output	$0.25	$1.25

The docs put it plainly: “a prompt of over 100,000 tokens pays higher prices.” Other Claude models from 4.6 onward bill the full 1M window at one rate; Haiku 5.5 is the exception.

Also account for the following before estimating production cost:

US-only inference. US-only routing via inference_geo costs 1.1x on every token category on the Claude API and Claude Platform on AWS: $0.11 input and $0.55 output under 100K.
A new tokenizer. The same text produces about 30% more tokens than on Haiku 4.5.
Smaller tool overhead. The tool-use system prompt is 286 tokens (auto/none), down from 496 on Haiku 4.5.
No Priority Tier and no fast mode.

Where “around 75% less” comes from

Haiku 5.5 is priced 90% lower than Haiku 4.5 up to 100,000 tokens and 50% lower above. Anthropic says 90% of Haiku 4.5 requests fell under 100K, and its estimate also accounts for the new tokenizer.

A rough reconstruction:

Weight the reduction by request count:

   0.9 × 90% + 0.1 × 50% = 86% lower

Account for approximately 30% more tokens:

   Remaining cost: 14%
   Tokenizer-adjusted cost: 14% × 1.3 = 18.2%
   Savings: about 82%

Anthropic’s figure is lower again. It does not publish the weighting, and long prompts likely represent more spend than request count alone suggests. Treat 75% as an average; your own usage data is the real answer.

Cost per attempt at each effort level

Haiku 5.5 is the first Haiku with effort levels: low through max, with medium as the API default. Effort can affect your bill more than the base rate card.

These figures come from the launch post’s per-effort charts. Anthropic ran OSWorld and Terminal-Bench; Artificial Analysis ran GDPval-AA.

Effort	OSWorld 2.1 (score, $/attempt)	GDPval-AA v2.1 (Elo, $/task)	Terminal-Bench 4.0 (score, $/attempt)
low	42.0%, $0.0695	1125, $0.0117	12.7%, $0.424
medium	53.3%, $0.1257	1277, $0.0304	20.3%, $0.6798
high	61.3%, $0.1827	1420, $0.0894	24.8%, $1.0372
xhigh	67.6%, $0.2792	1513, $0.2673	31.5%, $1.7545
max	72.4%, $0.6111	1620, $0.8659	39.2%, $2.6433

Use the table to select effort based on the task, not just benchmark scores:

Max costs 4.9x medium on OSWorld ($0.6111 ÷ $0.1257) and 28.5x medium on GDPval-AA ($0.86593 ÷ $0.03042).
Launch-table scores are max effort. At the default medium, GDPval-AA is 1277, not 1620.
For agentic coding, check Sonnet. On Terminal-Bench, Sonnet 5.5 at low with $0.10 cache reads scored 20% for $0.6205. Haiku 5.5 at medium scored 20.3% for $0.6798. Anthropic says Sonnet and Opus “remain better choices for complex agentic coding tasks.” See the full benchmarks breakdown.

How Haiku 5.5 compares on price

Model	Input / output per MTok	Cache read	5m cache write	Long-prompt rule
Claude Haiku 5.5	$0.10 / $0.50 up to 100K	$0.01	$0.125	Over 100K: $0.50 / $2.50
GPT-6 Luna	$0.10 / $0.50	$0.01	$0.125	Over 272K input: 2x input and cache, 1.5x output ($0.20 / $0.75)
Claude Haiku 4.5	$1 / $5	$0.10	$1.25	One rate (200K context)
Claude Sonnet 5.5	$2 / $10	$0.10	$2.50	One rate across 1M

GPT-6 Luna matches Haiku 5.5 up to 100K, but the long-context threshold differs. Per OpenAI’s model page, the Luna surcharge starts above 272K and applies “for the full request.”

For example, a request with 150,000 input tokens and 2,000 output tokens stays on Luna’s base rate:

(150,000 × $0.10 + 2,000 × $0.50) ÷ 1,000,000 = $0.016

The same request costs $0.08 on Haiku 5.5 because it crosses Haiku’s 100K threshold.

Tokenizers differ too: one Hacker News commenter estimated 100K Claude tokens at about 60–65K GPT tokens. On Anthropic’s OSWorld chart, Haiku 5.5 at medium (53.3%, $0.1257) beat Luna at max (48.9%, $0.205). See Claude Haiku 5.5 vs GPT-6 Luna for more detail.

Sonnet 5.5 cut cache reads from $0.20 to $0.10 the same day, making it about 20% cheaper on most agentic work per Anthropic. The Sonnet 5.5 pricing guide predates the cut.

Haiku 4.5 is not deprecated. Review Haiku 5.5 vs Haiku 4.5 for breaking changes before migrating.

API credits and consumer plans

Max and Team API credits. Max 5x gets $100 a month in Claude Platform credits, Max 20x gets $200, and Team gets $20 per Standard seat and $100 per Premium seat, pooled and capped at $500. Free, Pro, and Enterprise are not eligible.

Per the API credits docs, credits cover the Claude API, not Claude Code or cloud providers, and they do not roll over.

At $0.10 per MTok, $100 buys 1 billion input tokens, or about 220,000 Example 1 requests:

$100 ÷ $0.000455 ≈ 220,000

Consumer plans. According to claude.com/pricing, Free ($0), Pro, Max, Team, and Enterprise users can select Haiku 5.5 on Claude.ai on web, iOS, and Android. Pro is $17/month billed annually or $20 monthly; Max starts at $100/month.

Free has no Claude Code, and a chat plan cannot drive a script or CI job. See how to use Claude Haiku 5.5 for free for the remaining options.

Clouds. Bedrock, Google Cloud, and Foundry bill Haiku 5.5 through their own price pages.

Track cost per request in Apidog

Every Messages response returns a usage object. You can use it to calculate per-request cost in Apidog.

Store your key as an ANTHROPIC_API_KEY environment variable.
Save one request per effort level—low, medium, and high—while keeping the prompt constant.

curl https://api.anthropic.com/v1/messages \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "content-type: application/json" \
  -d '{
    "model": "claude-haiku-5-5",
    "max_tokens": 4000,
    "thinking": {"type": "adaptive"},
    "output_config": {"effort": "medium"},
    "messages": [{"role": "user", "content": "Classify this support ticket: ..."}]
  }'

Add a post-processor that selects the correct pricing tier and saves the request cost. This assumes no caching, so input_tokens represents the prompt length.

const body = pm.response.json();
const u = body.usage;

const long = u.input_tokens > 100000;
const rateIn = long ? 0.50 : 0.10;
const rateOut = long ? 2.50 : 0.50;

const cost = (u.input_tokens * rateIn + u.output_tokens * rateOut) / 1e6;

pm.environment.set("haiku_call_usd", cost.toFixed(6));

pm.test("not a refusal", () => {
  pm.expect(body.stop_reason).to.not.eql("refusal");
});

Run all three saved requests and compare output tokens and cost side by side.

The refusal check matters because Haiku 5.5’s safety classifiers have no server-side fallback. See how to use the Claude Haiku 5.5 API for the full walkthrough.

FAQ

How much does Claude Haiku 5.5 cost per million tokens?

$0.10 input and $0.50 output for prompts up to 100K tokens; $0.50 input and $2.50 output above 100K.

Is Haiku 5.5 cheaper than Haiku 4.5?

Yes. It is 90% cheaper per token up to 100K, 50% cheaper above 100K, and around 75% cheaper on average per Anthropic.

Is Haiku 5.5 the same price as GPT-6 Luna?

Up to 100K, yes. Above that, Haiku 5.5 rises 5x, while Luna stays flat until 272K. See the GPT-6 Luna overview for details.

Do Max plan credits work in Claude Code?

No. They cover the Claude Platform API, not Claude Code. See Claude Haiku 5.5 in Claude Code for plan access there.

Next step: price your own workload

Pull your three most common request shapes, check how many cross 100K, and run each at low and medium. Multiply the returned usage values by the pricing table to estimate your real savings.

Download Apidog to keep those requests and the cost script in one project.

How to Use the Claude Haiku 5.5 API ?

Hassann — Thu, 08 Oct 2026 04:06:42 +0000

To use the Claude Haiku 5.5 API, send a POST request to https://api.anthropic.com/v1/messages with "model": "claude-haiku-5-5", your key in the x-api-key header, and anthropic-version: 2023-06-01. It costs $0.10/$0.50 per million input/output tokens for prompts up to 100K tokens ($0.50/$2.50 above that), reads up to 1M tokens of context, writes up to 128K, and defaults to medium effort with adaptive thinking enabled.

Try Apidog today

Anthropic released Haiku 5.5 on October 7, 2026. It is the first Haiku model with effort levels. What is Claude Haiku 5.5 covers its specs and positioning.

This guide shows how to make a first request with curl, Python, and TypeScript, then configure effort, thinking, caching, batches, refusal handling, and agent toolsets. You can save and assert every request in Apidog.

Claude Haiku 5.5 API at a glance

Parameter	Haiku 5.5 behavior
Model ID	`claude-haiku-5-5` (Bedrock: `anthropic.claude-haiku-5-5`); no separate alias
Price per MTok, prompts up to 100K tokens	$0.10 input, $0.50 output, $0.01 cache reads
Price per MTok, prompts over 100K tokens	$0.50 input, $2.50 output, $0.05 cache reads
Context / max output	1M / 128K; 300K on Batch with the `output-300k-2026-03-24` beta header
`output_config.effort`	`low`, `medium` (default), `high`, `xhigh`, `max`
`thinking`	`adaptive` by default; `disabled` only at `high` effort or below
`thinking.display`	Empty `thinking` field by default; `summarized` returns readable text
`temperature`, `top_p`, `top_k`	Non-default values return 400
Assistant prefill	Returns 400, even with thinking off
Minimum cacheable prompt	512 tokens (4,096 on Haiku 4.5)

Sources: the Haiku 5.5 model page and the Claude API pricing docs.

Your first Claude Haiku 5.5 API call

Create a key in the Claude Console and export it as ANTHROPIC_API_KEY. The Anthropic API key guide walks through the setup.

Never hard-code the key or commit it to source control.

curl

curl https://api.anthropic.com/v1/messages \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "content-type: application/json" \
  -d '{
    "model": "claude-haiku-5-5",
    "max_tokens": 4096,
    "output_config": {"effort": "medium"},
    "thinking": {"type": "adaptive", "display": "summarized"},
    "messages": [{
      "role": "user",
      "content": "Classify this ticket as billing, bug, or feature request: The export button times out on large projects."
    }]
  }'

Python

The Python SDK reads ANTHROPIC_API_KEY from your environment.

import anthropic

client = anthropic.Anthropic()

response = client.messages.create(
    model="claude-haiku-5-5",
    max_tokens=4096,
    output_config={"effort": "medium"},
    thinking={"type": "adaptive", "display": "summarized"},
    messages=[{
        "role": "user",
        "content": "Classify this ticket as billing, bug, or feature request: The export button times out on large projects.",
    }],
)

for block in response.content:
    if block.type == "thinking":
        print("[thinking]", block.thinking)
    elif block.type == "text":
        print(block.text)

print(response.stop_reason, response.usage)

TypeScript

import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic();

const response = await client.messages.create({
  model: "claude-haiku-5-5",
  max_tokens: 4096,
  output_config: { effort: "medium" },
  thinking: { type: "adaptive", display: "summarized" },
  messages: [
    {
      role: "user",
      content:
        "Classify this ticket as billing, bug, or feature request: The export button times out on large projects.",
    },
  ],
});

for (const block of response.content) {
  if (block.type === "text") {
    console.log(block.text);
  }
}

console.log(response.stop_reason, response.usage);

Follow these implementation rules:

Read content blocks by type. A response can start with a thinking block, so content[0].text is not safe.
Leave output headroom. Thinking tokens count against max_tokens.
Do not send unsupported sampling fields. Non-default temperature, top_p, top_k, budget_tokens, and assistant prefills return 400 errors.

If you are migrating existing code, see Haiku 5.5 vs Haiku 4.5 for before-and-after request JSON.

Pick an effort level

Use output_config.effort as the primary quality, latency, and cost control.

The prompting guide recommends these starting points:

low: Fastest and cheapest. Use it for chat, short tool tasks, and simple high-volume workloads.
medium: Default setting. Start here for most workloads, including agentic coding.
high: Use for knowledge work, longer agent tasks, and strict instruction following.
xhigh and max: Use only when your evaluations demonstrate a meaningful gain. Anthropic recommends comparing the same evaluations with Claude Sonnet 5.5.

Anthropic's OSWorld 2.1 offline-subset launch results show the tradeoff:

Effort	Score	Cost per attempt
`low`	42.0%	$0.0695
`medium`	53.3%	$0.1257
`high`	61.3%	$0.1827
`xhigh`	67.6%	$0.2792
`max`	72.4%	$0.6111

Moving from xhigh to max more than doubles cost for fewer than five score points. See the Haiku 5.5 benchmarks breakdown for the remaining per-effort charts.

At xhigh, multi-turn chats can occasionally put the complete answer in thinking and return no visible text. Validate that a text block exists before rendering a reply to a user.

Control thinking

Adaptive thinking is enabled by default.

By default, each thinking block contains an empty thinking field and a signature. To return readable thinking summaries for logs or a UI, set:

{
  "thinking": {
    "type": "adaptive",
    "display": "summarized"
  }
}

To reduce thinking, lower the effort level. Prompting the model to answer directly did not stop thinking in Anthropic's testing.

You can disable thinking only when effort is high or lower:

{
  "model": "claude-haiku-5-5",
  "max_tokens": 1024,
  "thinking": {"type": "disabled"},
  "output_config": {"effort": "low"},
  "messages": [{
    "role": "user",
    "content": "Extract the invoice number from: INV-2291, due Nov 3."
  }]
}

The same request with xhigh or max returns a 400 error.

A forced tool_choice (any or a named tool) is accepted, but the response begins with the tool call and has no thinking block.

For multi-turn conversations and agent loops:

Return every thinking block unchanged.
Keep message history append-only.
Do not modify system, tools, or earlier messages before a returned thinking block.

Changing prior request context can return a 400. Thinking blocks also work only in the account that produced them, or an account linked to it.

Cache prompts and batch jobs

Prompt caching can significantly reduce input costs. For prompts up to 100K tokens:

Fresh input: $0.10 per MTok
Cache read: $0.01 per MTok
5-minute cache write: $0.125 per MTok
1-hour cache write: $0.20 per MTok

Haiku 5.5 has a 512-token minimum cacheable prompt, down from 4,096 tokens on Haiku 4.5. This makes short system prompts and stable tool definitions cacheable.

Mark stable prompt prefixes with cache_control:

{
  "model": "claude-haiku-5-5",
  "max_tokens": 1024,
  "system": [{
    "type": "text",
    "text": "You are a support triage assistant. <long, stable policy text here>",
    "cache_control": {"type": "ephemeral"}
  }],
  "messages": [{
    "role": "user",
    "content": "Ticket: refund not received after 10 days."
  }]
}

Changing top-level effort between requests invalidates the cache. Per-message effort, available with the mid-conversation-output-config-2026-07-01 beta header on the Claude API and Google Cloud, preserves it.

See the prompt caching docs for TTL behavior, or read this prompt caching explainer.

For asynchronous jobs, the Message Batches API reduces input and output pricing by 50%:

Up to 100K-token prompts: $0.05 input / $0.25 output per MTok
Over 100K-token prompts: $0.25 input / $1.25 output per MTok

Batch is also the only route to 300K output tokens. Include the output-300k-2026-03-24 beta header.

Watch the 100K-token threshold: prompts over 100,000 tokens use higher prices. The Haiku 5.5 pricing guide includes examples on both sides of that threshold.

Handle `stop_reason: "refusal"`

Haiku 5.5 safety classifiers can decline requests, and there is no server-side fallback.

A declined request returns:

{
  "stop_reason": "refusal"
}

Possible categories are:

cyber
frontier_llm
bio
general_harms

Do not blindly retry a refusal. The same request will usually be declined again.

def run(client, messages):
    response = client.messages.create(
        model="claude-haiku-5-5",
        max_tokens=4096,
        messages=messages,
    )

    if response.stop_reason == "refusal":
        details = getattr(response, "stop_details", None)
        category = getattr(details, "category", "unknown")

        log_refusal(category, messages)  # your logging
        return {"status": "refused", "category": category}

    text = "".join(
        block.text
        for block in response.content
        if block.type == "text"
    )

    return {"status": "ok", "text": text}

Check stop_reason before reading content. Route refusals to a human workflow or another model in your own application logic.

Teams doing legitimate security or life-sciences work that are blocked by cyber or bio classifiers can apply to Anthropic's Cyber Verification Program or Life Sciences Verification Program.

Computer use and browser use

On the Claude API and Google Cloud, Haiku 5.5 supports computer use through the computer_toolset_20260801 toolset. It does not require a beta header.

Do not declare computer_20250124; it returns a 400 error.

Browser use is available through browser_toolset_20260801, which Haiku 4.5 does not support. Python and TypeScript SDK beta classes for both toolsets were added on launch day.

See the computer use tool docs for the available tools.

Rate limits

Haiku 5.5 uses the same rate limits as Haiku 4.5:

Tier	Requests/minute	Input tokens/minute	Output tokens/minute
Start	1,000	2M	400K
Scale	10,000	10M	2M

Priority Tier is not supported.

For 429 handling patterns, see the rate limit exceeded guide.

Test the Claude Haiku 5.5 API in Apidog

Saved requests make effort comparisons, caching checks, and refusal debugging repeatable. Set up a collection in Apidog:

Create an environment and add ANTHROPIC_API_KEY as a secret variable.
Set the x-api-key header to {{ANTHROPIC_API_KEY}}.
Add these headers:
- anthropic-version: 2023-06-01
- content-type: application/json
Create a POST request to https://api.anthropic.com/v1/messages.
Paste the first-call request body and save it.
Add assertions:
- Status equals 200
- $.stop_reason equals end_turn
- $.usage.output_tokens is greater than 0
- $.content[*].type contains text
Duplicate the request for low, high, xhigh, and max, then run the folder to compare usage across effort levels.
Add a cached-system-prompt version and assert that $.usage.cache_read_input_tokens is greater than 0 on the second run.

These assertions catch refusals and empty xhigh replies before they reach production.

For more testing patterns, see testing LLM applications.

FAQ

What is the Claude Haiku 5.5 model ID?

claude-haiku-5-5, with no date suffix and no separate alias, on the Claude API, Google Cloud, Microsoft Foundry, and Claude Platform on AWS. On Amazon Bedrock, use anthropic.claude-haiku-5-5.

Is there a free Claude Haiku 5.5 API?

There is no ongoing free tier, but new API users receive a small amount of free credit for testing. Free Claude.ai users can select Haiku 5.5 in chat, but that does not provide an API key. Max and Team plans include monthly API credits. See the free access guide for details.

Why does my Haiku 4.5 request return 400?

Check for:

budget_tokens
Non-default temperature
Non-default top_p
Any top_k
Assistant prefill
The old computer_20250124 tool

These are the common causes.

Can I use Haiku 5.5 in Claude Code?

Yes, from v2.1.293. On the Anthropic API, the haiku alias resolves to Haiku 5.5. See Claude Haiku 5.5 in Claude Code.

Should I use Haiku 5.5 or Sonnet 5.5 for agentic coding?

Anthropic says Sonnet 5.5 and Opus 5.5 remain better choices for complex agentic coding tasks. Use Haiku 5.5 for narrowly scoped work such as classification, summarization, compaction, subagents, and browser use.

Next step

Run the first request at medium, then rerun the same prompt at low and high. Compare answer quality and usage.output_tokens using a prompt from your own workload.

Download Apidog to save the requests and assertions, so testing the next model release becomes a one-field change.

How to Use Claude Haiku 5.5 for Free ?

Hassann — Thu, 08 Oct 2026 04:05:57 +0000

Yes, you can use Claude Haiku 5.5 for free—but only in chat. Anthropic says Free plan users can select Haiku 5.5 on Claude.ai, including web, iOS, and Android. The Claude API has no ongoing free tier: new users receive only a small test credit, Claude Code is not included with Free, and a free chat account does not provide an API key. To call claude-haiku-5-5 from code, you pay per token, starting at $0.10 per million input tokens and $0.50 per million output tokens for prompts up to 100K tokens.

Try Apidog today

Haiku 5.5 shipped on October 7, 2026. This guide shows the free chat option, explains why there is no permanently free Haiku 5.5 API, clarifies paid-plan credits, and identifies offers that do not apply. For model details, read what Claude Haiku 5.5 is. For Claude generally, see the free Claude guide. When you move to the API, Apidog lets you send and inspect a Haiku 5.5 request before wiring it into your application.

Every route at a glance

Route	Free?	What you get	The catch
Claude.ai Free plan	Yes	Select Haiku 5.5 in chat on web, iOS, and Android	Chat only: no API key or Claude Code
Claude API	No	`claude-haiku-5-5` at $0.10/$0.50 per 1M tokens for prompts up to 100K	Only a small test credit for new users; prompts over 100K cost $0.50/$2.50
Max and Team monthly API credits	No, paid-plan perk	$100/month (Max 5x), $200 (Max 20x), up to $500 pooled (Team)	Not available for Free, Pro, or Enterprise; not usable in Claude Code or cloud platforms
Claude Code	No	Haiku 5.5 in v2.1.293 or later	Not available on Free
Vercel AI Gateway	Unconfirmed	$5 credit every 30 days for accounts that have not paid	Vercel does not confirm that the credit covers Haiku 5.5
Google Cloud $300 trial	No	Nothing for Claude	Excludes partner models offered as managed APIs
Azure $200 credit	No	Nothing for Claude	Excludes third-party branded products
OpenRouter, GitHub Copilot	No	Not listed as of October 8, 2026	Haiku 4.5 only

Route 1: Use the Claude.ai Free plan

This is the simplest free route. Sign up at claude.ai or install the iOS or Android app. Then open the model picker and select Haiku 5.5. Anthropic’s pricing page lists Haiku as included with Free; Opus is not.

Free users can select Haiku 5.5. Anthropic does not state that it is the default Free-plan model, so verify the selected model before starting a long conversation.

Anthropic’s Claude.ai system prompt describes Haiku 5.5 as “the fastest model for quick questions.” Use it for:

Short, repeatable tasks: summaries, rewrites, classification, and quick lookups.
Long content, cautiously: the API supports a 1M-token context window, but Anthropic has not published a Free-plan chat context limit.
Complex work elsewhere: Anthropic positions Sonnet 5.5 and Opus 5.5 for more complex agentic coding. See the free Sonnet 5.5 guide.

A Claude.ai chat entitlement cannot run Claude Code, create an API key, power a script, or run in CI.

Is there a free Claude Haiku 5.5 API?

Not on an ongoing basis. Anthropic says new users receive “a small amount of free credits to test the API,” but there is no permanent free tier or official free Haiku 5.5 API offer.

Every claude-haiku-5-5 API request is billed by token.

Max and Team monthly API credits: paid, not free

Anthropic introduced monthly API credits for Max and Team subscribers. These are subscription benefits, not free API access.

Plan	Monthly API credit
Max 5x	$100
Max 20x	$200
Team	$20 per Standard seat, $100 per Premium seat, pooled and capped at $500
Free, Pro, Enterprise	Not eligible

The credits apply to models on the Claude Platform, including Haiku 5.5, across:

Messages API
Message Batches
Managed Agents
Agent SDK
Console Playground

They do not cover interactive Claude Code, additional Claude app usage, or Claude through Bedrock, Google Cloud, Microsoft Foundry, or Claude Platform on AWS.

Credits expire at the end of each billing cycle and do not roll over. New subscribers can claim them after seven days. Link one Console organization from Claude.ai billing settings; you cannot change that organization yourself. When credits are exhausted and no other balance exists, API requests stop until the next billing period. Review the Help Center claim instructions for the exact process.

Vercel AI Gateway: unconfirmed

Vercel lists Haiku 5.5 as anthropic/claude-haiku-5.5. Its model page says that users who have not made a payment receive $5 in credits every 30 days.

However, Vercel does not explicitly confirm that this credit applies to Haiku 5.5. Treat it as unconfirmed until you successfully send a request from an account that has never paid.

At the up-to-100K pricing tier, $5 would cover approximately:

50M input tokens, or
10M output tokens

The cheapest paid path

Without Max or Team credits, create a Console key and pay list prices. The Anthropic API key guide walks through key creation.

Haiku 5.5, per 1M tokens	Input	Output	Cache read	Batch input / output
Prompts up to 100K tokens	$0.10	$0.50	$0.01	$0.05 / $0.25
Prompts over 100K tokens	$0.50	$2.50	$0.05	$0.25 / $1.25

For example, a request with 2,000 input tokens and 500 output tokens costs approximately:

Input:  2,000 × $0.10 / 1,000,000 = $0.00020
Output:   500 × $0.50 / 1,000,000 = $0.00025
Total:                               $0.00045

Two cost caveats apply:

The new tokenizer produces about 30% more tokens for the same text than Haiku 4.5.
A prompt over 100,000 tokens uses the higher price tier.

See the Haiku 5.5 pricing breakdown for more examples.

To stretch a small API budget:

Set lower effort. output_config.effort accepts low, medium (default), high, xhigh, and max. Anthropic describes low as the fastest and cheapest option.
Disable thinking when you do not need it. Use thinking: {"type": "disabled"} with high effort or lower. Thinking tokens count toward max_tokens.
Cache repeated prompt prefixes. Haiku 5.5 requires at least 512 tokens for a cacheable prompt. At the lower tier, cache reads cost $0.01 per million tokens. See the prompt caching explainer.
Use batches for non-interactive jobs. The Batch API halves input and output prices.

What is not free

These options often appear in searches for “free Haiku 5.5,” but they do not provide free access.

Claude Code on Free. Claude Code is not available on Free, and Max and Team API credits do not pay for it. Haiku 5.5 requires version 2.1.293 or later. See the Haiku 5.5 Claude Code guide.

API access through Pro. Pro is not eligible for the monthly API credit. Pro subscribers pay per token for API requests.

Google Cloud’s $300 trial. Google states that trial credits cannot be used for generative AI partner models delivered as managed APIs. Free-trial accounts also cannot use third-party generative AI models until upgraded.

Azure’s $200 credit. Microsoft’s offer terms exclude third-party branded products and Azure Marketplace products. Claude is a third-party branded model.

AWS Free Tier. AWS offers eligible new accounts up to $200 in credits, but Bedrock bills Haiku 5.5 through AWS Marketplace. No AWS documentation confirms that Free Tier credits apply, so assume they do not.

OpenRouter. As of October 8, 2026, OpenRouter has no Haiku 5.5 entry. It lists Haiku 4.5 at $1/$5 and no :free variant.

GitHub Copilot. GitHub has not announced Haiku 5.5. Its supported-models page lists Haiku 4.5 only.

Cursor Hobby. Haiku 5.5 is billed from Cursor’s “Other Models” pool, which is included with Pro, Pro Plus, and Ultra. There is no official confirmation that Hobby users can access it.

Third-party “Haiku 5.5” chatbots. One chatbot aggregator listing was created by an unrelated user and ran on a different company’s model. Use Claude.ai and official Anthropic apps instead.

Test your first Haiku 5.5 request in Apidog

Once you have an API key, validate the request before adding it to your application. In Apidog, store ANTHROPIC_API_KEY as an environment variable so the secret never appears in a shared request.

Import this cURL command into Apidog, then replace $ANTHROPIC_API_KEY with {{ANTHROPIC_API_KEY}}:

curl https://api.anthropic.com/v1/messages \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "content-type: application/json" \
  -d '{
    "model": "claude-haiku-5-5",
    "max_tokens": 1024,
    "thinking": {"type": "disabled"},
    "output_config": {"effort": "low"},
    "messages": [
      {
        "role": "user",
        "content": "Classify this ticket as billing, bug, or feature request: The export button returns a 500 error."
      }
    ]
  }'

After sending the request, inspect the usage object to confirm billed token counts. Save the request with assertions for:

stop_reason, not just HTTP status. Haiku 5.5 can decline a request with stop_reason: "refusal" because it runs safety classifiers. This behavior is new for developers coming from Haiku 4.5.
usage within budget. Rerun the request after changing the prompt or effort setting and compare token usage.

If you are migrating an old Haiku 4.5 request, remove:

temperature
top_p
top_k
budget_tokens
assistant prefill

Each can cause a 400 response with Haiku 5.5. See the Haiku 5.5 vs Haiku 4.5 guide for breaking changes, and the Haiku 5.5 API guide for effort, thinking, and caching details.

FAQ

Is Claude Haiku 5.5 free?

Yes, in chat. Free-plan users can select Haiku 5.5 on Claude.ai, including web, iOS, and Android. The API and Claude Code are paid.

Is Haiku 5.5 the default model on Claude’s Free plan?

Anthropic has not said that it is. It only states that Free users can select Haiku 5.5, so check the model picker.

Can I get a free Claude Haiku 5.5 API key?

Not permanently. New API users receive only a small test credit, and a chat plan does not include an API key. Max and Team subscribers receive monthly API credits, but those credits are part of paid plans.

Do Max and Team API credits work in Claude Code?

No. They apply to the Claude API, Message Batches, Managed Agents, Agent SDK, and Console Playground—not interactive Claude Code or cloud platforms.

Is GPT-6 Luna a free alternative?

GPT-6 Luna has the same $0.10/$0.50 list price for short prompts, and OpenAI lets Free and Go users access it in the desktop app, not in Chat. See the GPT-6 Luna free guide and the Haiku 5.5 vs GPT-6 Luna comparison.

Start in chat, then pay pennies for the API

Start with claude.ai or the mobile app and select Haiku 5.5 for quick, repeatable work. When you need the model in a script, CI job, or agent, first check whether you have Max or Team API credits. Otherwise, a small Console balance can go far at $0.10/$0.50 per million tokens for prompts up to 100K tokens.

Download Apidog to send your first claude-haiku-5-5 request, assert on stop_reason and usage, and keep API keys in environment variables from day one.

How to Use Claude Haiku 5.5 in Claude Code (and as Your Subagent Model)

Hassann — Thu, 08 Oct 2026 04:03:52 +0000

To use Claude Haiku 5.5 in Claude Code, update to v2.1.293 or later with claude update. Then start a session with claude --model claude-haiku-5-5, or switch models inside a session with /model claude-haiku-5-5. For most coding workflows, use Haiku as a subagent: configure model: haiku in a subagent file and let Sonnet 5.5 or Opus 5.5 delegate searches, test runs, and summaries. With an API key, pricing is $0.10/$0.50 per million input/output tokens for prompts up to 100K tokens, and $0.50/$2.50 above that threshold.

Try Apidog today

This guide covers setup, the haiku alias behavior, effort levels, subagent configuration, the 100K pricing threshold, and when Sonnet or Opus should remain the lead model. For model details, see what Claude Haiku 5.5 is. If your code calls APIs, Apidog can store the test scenarios a Haiku subagent runs.

Claude Haiku 5.5 in Claude Code at a glance

Setting	Haiku 5.5
Minimum version	v2.1.293 (`claude update`)
Model ID	`claude-haiku-5-5`
`haiku` alias	Haiku 5.5 on the Anthropic API only
Context	1M native on every plan; no `[1m]` suffix
Auto-compaction	About 967K tokens by default
Default effort	`medium` (`low` through `max`)
Thinking	Always on; cannot be disabled
API price	$0.10/$0.50 up to 100K prompt tokens; $0.50/$2.50 over 100K
Plans	Pro, Max, Team, Enterprise, or an API key; not Free

Step 1: Update Claude Code

Haiku 5.5 requires Claude Code v2.1.293 or newer. The changelog describes it as “now the default Haiku model on the Anthropic API.”

claude update

Claude Code is not available on the Free plan. Free users can select Haiku 5.5 in the Claude.ai apps, but Claude Code requires Pro, Max, Team, Enterprise, or an Anthropic API key.

According to claude.com/pricing, Pro costs $17/month when billed annually or $20/month, while Max starts at $100/month.

Step 2: Select Haiku 5.5 as the main model

Start Claude Code with the full model ID:

claude --model claude-haiku-5-5

Inside an existing session, run:

/model claude-haiku-5-5

If your saved model setting is haiku, a session previously saved on Haiku 4.5 resumes on Haiku 5.5 when using the Anthropic API.

The `haiku` alias only means Haiku 5.5 on the Anthropic API

Provider	`haiku` resolves to
Anthropic API	Haiku 5.5
Claude Platform on AWS	Haiku 4.5
Amazon Bedrock	Haiku 4.5
Google Cloud’s Agent Platform	Haiku 4.5
Microsoft Foundry	Haiku 4.5

On cloud providers, /model haiku and model: haiku in a subagent file select Haiku 4.5.

To use Haiku 5.5, pin the provider-specific model identifier:

Google Cloud and Claude Platform on AWS: claude-haiku-5-5
Microsoft Foundry: your deployment name
Amazon Bedrock: an inference profile ID such as us.anthropic.claude-haiku-5-5

You can also point the haiku alias to the desired model with ANTHROPIC_DEFAULT_HAIKU_MODEL, covered in Step 5.

Step 3: Pick an effort level

Haiku 5.5 is the first Haiku model with effort control:

low
medium
high
xhigh
max

Claude Code defaults to medium.

claude --model claude-haiku-5-5 --effort high

Inside a session, set an effort level with:

/effort low

That setting is saved for the current model.

Use the levels pragmatically:

Use low for short tool calls, codebase searches, and high-volume tasks.
Use medium for most development work.
Use high for longer agent tasks.
Use xhigh and max only when your evaluations show a measurable benefit.

Thinking is always enabled for Haiku 5.5 in Claude Code. Neither alwaysThinkingEnabled: false nor MAX_THINKING_TOKENS=0 disables it. The raw Messages API can disable thinking at high effort or lower, but Claude Code cannot. To reduce thinking tokens in Claude Code, lower the effort level.

Step 4: Run Haiku 5.5 as a subagent

Anthropic says Haiku 5.5 “pairs well with Opus 5.5 and Sonnet 5.5 as a subagent on coding work.”

Subagents are Markdown files with YAML frontmatter:

Project scope: .claude/agents/
User scope: ~/.claude/agents/

Only name and description are required. The subagent docs support sonnet, opus, haiku, fable, a full model ID, or inherit in the model field.

For more on scopes and tools, see the Claude Code subagent guide.

Replace Explore with a cheaper explorer

The built-in Explore subagent runs on the main conversation model. If your session uses Opus 5.5, every Explore search also uses Opus.

Create a user or project subagent named Explore to override the built-in one and assign it a separate model:

---
name: Explore
description: Fast read-only codebase search. Use to find files, symbols and call sites without editing anything.
tools: Read, Grep, Glob
model: haiku
effort: low
---

You search the codebase and report what you find. Return file paths with line
numbers and a short summary of each match. Never edit files.

Save the file as:

.claude/agents/Explore.md

Use /tasks while it runs to confirm the selected model.

On a cloud provider, replace haiku with the full Haiku 5.5 model ID from Step 2.

Force every subagent onto Haiku

To force every subagent, including Explore, to use Haiku, add both variables to a settings file:

{
  "env": {
    "CLAUDE_CODE_SUBAGENT_MODEL": "haiku",
    "CLAUDE_CODE_SUBAGENT_MODEL_FORCE": "1"
  }
}

CLAUDE_CODE_SUBAGENT_MODEL by itself only sets a default. A subagent’s own model field still takes priority, and the built-in Explore agent does not move.

Step 5: Point background work at Haiku 5.5

ANTHROPIC_DEFAULT_HAIKU_MODEL configures the model used for haiku and background functionality, including summarizing prior sessions for claude --resume.

The older ANTHROPIC_SMALL_FAST_MODEL variable is deprecated according to the environment variable reference. Replace it if it is still set in your shell profile.

On the Anthropic API, no configuration is necessary. On cloud providers, background tasks may default to Sonnet or the primary model. Once Haiku 5.5 is enabled for your account, pin it explicitly:

# Google Cloud's Agent Platform
export ANTHROPIC_DEFAULT_HAIKU_MODEL=claude-haiku-5-5

# Amazon Bedrock (inference profile ID)
export ANTHROPIC_DEFAULT_HAIKU_MODEL=us.anthropic.claude-haiku-5-5

The 100K price step in long sessions

Haiku 5.5 pricing depends on prompt length. Claude Code sends the conversation as the prompt on every turn.

After a session exceeds 100K tokens of context, each request is billed at:

Input: $0.50 per million tokens instead of $0.10
Output: $2.50 per million tokens instead of $0.50

That is five times the short-prompt rate.

The documentation does not specify whether cached tokens count toward the threshold, so budget as though they do.

Auto-compaction does not prevent this by default. Haiku 5.5 compacts at roughly 967K tokens, leaving plenty of room to cross the 100K pricing threshold first.

If you pay per token, use these two practices:

Compact earlier. Run /autocompact 100k, the lowest context window Claude Code accepts, to compact near the threshold rather than near 1M tokens.
Move bulky work into subagents. Each subagent has its own context, so test logs, search results, and generated reports stay out of the lead conversation.

Even above 100K tokens, Haiku’s $0.50/$2.50 pricing is one quarter of Sonnet 5.5’s $2/$10 rate.

On paid plans, sessions consume usage limits rather than direct token billing. Anthropic has not published how Haiku 5.5 counts against those limits. The Haiku 5.5 pricing breakdown walks through the cost arithmetic.

Max and Team subscribers should also note that monthly API credits do not cover interactive Claude Code usage. Anthropic’s API credits documentation lists $100 for Max 5x, $200 for Max 20x, and up to $500 pooled for Team.

When Sonnet 5.5 or Opus 5.5 should remain the lead

Anthropic says Sonnet 5.5 and Opus 5.5 “remain better choices for complex agentic coding tasks.”

On Terminal-Bench 4.0, run by Anthropic in Claude Code at max effort, Haiku 5.5 scored 39.2% compared with Sonnet 5.5 at 70.6%.

Effort	Haiku 5.5	Sonnet 5.5
`medium`	20.3% at $0.68	28.8% at $0.68
`high`	24.8% at $1.04	43% at $1.46
`max`	39.2% at $2.64	70.6% at $10.44

At medium, both models cost about the same per attempt, but Sonnet scores higher. Haiku’s lower token price does not automatically make it the better lead model for difficult shell-heavy coding sessions.

Computer use shows a different tradeoff. On OSWorld 2.1:

Haiku 5.5 at medium: 53.3% at $0.13 per attempt
Sonnet 5.5 at low: 57.9% at $0.68 per attempt

See the full Haiku 5.5 benchmarks breakdown and the Sonnet 5.5 Claude Code guide.

A practical setup is:

Lead model: Sonnet 5.5 or Opus 5.5
Haiku 5.5 subagents: Explore, test runners, log readers, and documentation fetchers

Example: A Haiku subagent that runs Apidog tests

Test runs are verbose and repetitive, which makes them a good Haiku workload.

The Apidog CLI runs saved Apidog test scenarios from the terminal. A subagent can execute the relevant scenario and return a concise report without adding full test output to the lead model’s context.

---
name: api-test-runner
description: Runs the project's Apidog test scenarios with the Apidog CLI after an API endpoint changes, then reports pass and fail counts with the failing requests.
tools: Bash, Read
model: haiku
effort: low
---

Run the Apidog CLI test command documented in this repo's README for the
scenario that covers the changed endpoint. Report the pass and fail counts.
For each failure, give the request name, the expected result and the actual
result. Don't edit code. Don't retry a failed run more than once.

For CLI setup, authentication, and the run command, see Apidog CLI in Claude Code. Download Apidog to create the scenarios the subagent runs.

Migrating an app from Haiku 4.5

If your app calls Haiku 4.5 through the API, start the migration from Claude Code:

/claude-api migrate this project to claude-haiku-5-5

Expect breaking changes. Haiku 5.5 returns a 400 error for:

Manual budget_tokens thinking
Non-default temperature
Non-default top_p
Any top_k
Assistant prefill

The Haiku 5.5 vs. Haiku 4.5 guide lists each required fix.

After updating your code:

Save the old and new API requests as a pair in Apidog.
Store ANTHROPIC_API_KEY as an environment variable.
Assert on stop_reason and usage.
Fail tests when a new refusal stop reason appears or token usage jumps unexpectedly.

That turns model behavior changes into test failures instead of production issues.

FAQ

Is Haiku 5.5 the default model in Claude Code?

No. It is the default Haiku model on the Anthropic API, so the haiku alias points to it there. Select it as the main model with --model or /model.

Can I use Haiku 5.5 in Claude Code on the Free plan?

No. Claude Code requires a paid plan or an API key. Free users can choose Haiku 5.5 in the Claude.ai apps. See how to use Claude Haiku 5.5 for free.

Why does model: haiku give me Haiku 4.5?

You are using Bedrock, Google Cloud, Foundry, Claude Platform on AWS, or a Claude Code version older than v2.1.293. Pin the full model ID or configure ANTHROPIC_DEFAULT_HAIKU_MODEL.

Can I turn off thinking to save tokens?

Not in Claude Code. Lower the effort level instead; low is the cheapest setting.

Your next step

Run:

claude update

Then add the Haiku-powered Explore override and keep your current lead model for a week. If your project has APIs, add the test-runner subagent next.

To call the model from your own code, start with the Haiku 5.5 API guide. Apidog is free to start and provides real API scenarios for the subagent to run.

What Is Claude Haiku 5.5?

Hassann — Thu, 08 Oct 2026 04:03:19 +0000

Claude Haiku 5.5 is Anthropic’s smallest and fastest current model, released on October 7, 2026, with the API ID claude-haiku-5-5. It costs $0.10 per million input tokens and $0.50 per million output tokens for prompts up to 100K tokens, and $0.50/$2.50 for prompts over 100K. In its launch post, Anthropic says it costs “around 75% less to run” than Haiku 4.5 on average and calls it “our fastest model to date.” It is also the first Haiku with an effort setting and a 1M-token context window.

Try Apidog today

This guide covers the specs, two-tier pricing, migration changes from Haiku 4.5, benchmarks, availability, and when to switch. For more pricing detail, see the Haiku 5.5 pricing breakdown. To call the model while you read, Apidog can send the Messages request, keep your key in an environment variable, and show the response alongside token usage.

Claude Haiku 5.5 specs at a glance

Spec	Claude Haiku 5.5
Release date	October 7, 2026
Model ID (Claude API, Google Cloud, Microsoft Foundry, Claude Platform on AWS)	`claude-haiku-5-5` (fixed ID, no date suffix)
Model ID (Amazon Bedrock)	`anthropic.claude-haiku-5-5`
Context window	1M tokens (Haiku 4.5: 200K)
Max output	128K (Haiku 4.5: 64K); 300K on the Batch API with the `output-300k-2026-03-24` beta header
Thinking	Adaptive only
Effort levels	`low`, `medium` (default), `high`, `xhigh`, `max`
Knowledge cutoff	June 2026
Price per MTok, prompts up to 100K tokens	$0.10 input, $0.50 output
Price per MTok, prompts over 100K tokens	$0.50 input, $2.50 output
Retirement	Not sooner than October 7, 2027

Where Haiku 5.5 sits in the Claude lineup

Model	Input / output per MTok	Default effort	Latency
Claude Fable 5.1	$10 / $50	high	Slower
Claude Opus 5.5	$4 / $20	medium	Moderate
Claude Sonnet 5.5	$2 / $10	high	Fast
Claude Haiku 5.5	$0.10 / $0.50 for prompts up to 100K tokens	medium	Fastest

All four share a 1M context window, 128K max output, and a June 2026 cutoff. Anthropic built Haiku 5.5 for high-volume, latency-sensitive work such as classification, extraction, routing, summaries, live support, browser use, and subagent tasks under Opus 5.5 or Sonnet 5.5.

The speed claim has an important caveat: it is the fastest model “at each model’s standard speed,” but slower than Opus in Fast Mode. Anthropic does not publish a tokens-per-second figure.

Claude Haiku 5.5 pricing

Pricing depends on prompt length. Once a prompt exceeds 100,000 tokens, every input and output token uses the higher rate.

Source: Claude API pricing.

The “around 75% less” figure is an average:

Up to 100K tokens: 90% cheaper than Haiku 4.5.
Over 100K tokens: 50% cheaper than Haiku 4.5.
Anthropic says 90% of Haiku 4.5 requests are below the 100K-token threshold.

The comparison already accounts for the new tokenizer, which produces approximately 30% more tokens for the same text.

US-only inference (inference_geo) costs 1.1x for every token category. The minimum cacheable prompt is also lower: 512 tokens instead of 4,096 for Haiku 4.5.

For prompts under 100K tokens, Haiku 5.5 matches GPT-6 Luna’s listed price: $0.10 input, $0.50 output, $0.01 cache read, and $0.125 cache write per MTok. The thresholds differ: Luna’s surcharge begins above 272K input tokens. See the Haiku 5.5 vs GPT-6 Luna comparison and the pricing guide for worked cost examples.

What changed from Haiku 4.5

Haiku 5.5 increases the context window by 5x, doubles maximum output, and adds effort control. However, the migration guide warns that some Haiku 4.5 request formats return 400 errors.

Fix these breaking changes

Replace manual thinking budgets

This Haiku 4.5 configuration fails:

   {
     "thinking": {
       "type": "enabled",
       "budget_tokens": 2000
     }
   }

Use adaptive thinking with effort instead:

   {
     "thinking": {
       "type": "adaptive"
     },
     "output_config": {
       "effort": "medium"
     }
   }

Remove sampling parameters

Do not send temperature, top_p, or top_k.

A non-default temperature or top_p fails. Any top_k fails. Sending both temperature and top_p also fails.

Remove assistant prefills

Assistant-prefilled messages are rejected, including when thinking is disabled.

Update the computer-use tool

On the Claude API and Google Cloud, use:

   {
     "type": "computer_toolset_20260801"
   }

The older computer_20250124 tool fails.

Keep message history append-only

Do not modify system, tools, or earlier messages before a returned thinking block. Those edits fail validation.

Account for behavioral changes

These changes do not necessarily return errors, but they can change output, token usage, and application logic:

Thinking display: Thinking blocks are empty by default except for a signature. Use "display": "summarized" to receive summaries.
Token counts: The tokenizer can produce roughly 30% more tokens for the same text. max_tokens includes thinking tokens.
Forced tool use: tool_choice with any or a named tool still works, but the response does not include a thinking block.
Refusals: Safety classifiers can return stop_reason: "refusal" without a server-side fallback.
Priority Tier: Haiku 5.5 does not support Priority Tier.

Thinking can be disabled at high effort or below. Disabling thinking at xhigh or max returns a 400 error.

Haiku 4.5 is not deprecated and remains active. For before-and-after payloads, see the Haiku 5.5 vs Haiku 4.5 guide.

Claude Haiku 5.5 benchmarks

Haiku 5.5 benchmark scores use max effort and are mostly averaged across five trials. Artificial Analysis ran GDPval-AA and AA-Briefcase, Cognition ran FrontierCode, and Anthropic graded Chartography, a Surge AI benchmark, with its own implementation.

Read several comparisons carefully:

FrontierCode compares Haiku at max with Sonnet 5.5 at xhigh. At max, Sonnet scored 46.2%, below Haiku’s 46.4%.
Anthropic ran Luna’s OSWorld score through OpenAI’s API.
Luna’s Terminal-Bench score came from the public leaderboard using Codex CLI.
At default medium effort, Haiku 5.5 scored 1277 on GDPval-AA and 1372 on AA-Briefcase.

Anthropic says Sonnet 5.5 and Opus 5.5 remain better choices for complex agentic coding tasks. No independent leaderboard had a Haiku 5.5 result as of October 8, 2026. Cursor reports 48.4% on its own CursorBench at max effort.

For per-effort scores and cost comparisons, see the benchmarks deep dive.

Where you can use Claude Haiku 5.5

Surface	Access	Notes
Claude API	`claude-haiku-5-5`	Pay per token
Amazon Bedrock	`anthropic.claude-haiku-5-5`	Billed through AWS Marketplace
Google Cloud, Microsoft Foundry, Claude Platform on AWS	`claude-haiku-5-5`	Same ID as the Claude API
Claude.ai (web, iOS, Android)	Model picker	Free, Pro, Max, Team, and Enterprise users can select it
Claude Code	`/model claude-haiku-5-5`	v2.1.293 or later; paid plans
Vercel AI Gateway	`anthropic/claude-haiku-5.5`	From $0.10 / $0.50
Cursor	`claude-haiku-5-5`	Other Models pool

As of October 8, 2026, Haiku 5.5 was not available on OpenRouter or announced for GitHub Copilot.

Chat access on the Free plan does not provide an API key. The API is pay-as-you-go beyond the small free credit Anthropic gives new users for testing. Max and Team plans include monthly API credits:

Max 5x: $100
Max 20x: $200
Team: up to $500 pooled

These credits do not cover Claude Code. See the free access guide for the available free options.

In Claude Code, the haiku alias means Haiku 5.5 only when using the Anthropic API. Elsewhere, it still means Haiku 4.5. See Haiku 5.5 in Claude Code for subagent setups.

Who should switch to Haiku 5.5

You run Haiku 4.5: Switch after fixing the five breaking changes. Haiku 5.5 beats Haiku 4.5 on every launch-table row where both models have a score, at a lower listed price.
You use Sonnet or Opus for simple repeated tasks: Test Haiku 5.5 for classification, extraction, summaries, routing, and subagent work. Keep larger models for complex agentic coding.
Your prompts often exceed 100K tokens: Model the two pricing tiers before migrating. Above the threshold, input tokens cost 5x more.
You do security work: Haiku 5.5’s cyber safeguards still block penetration testing.

In Anthropic’s launch post, Asana reports more than 30% lower latency on task completions, while Box reports a score 11 points above Haiku 4.5 at about half the latency. These are customer claims, not independent tests.

The system card notes that Haiku 5.5 over-refused more than any other model in Anthropic’s automated audit. Measure refusal rates against your own production prompts.

Send your first Haiku 5.5 request

Start with a minimal Messages API request:

curl https://api.anthropic.com/v1/messages \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "content-type: application/json" \
  -d '{
    "model": "claude-haiku-5-5",
    "max_tokens": 4000,
    "thinking": {"type": "adaptive", "display": "summarized"},
    "output_config": {"effort": "low"},
    "messages": [
      {
        "role": "user",
        "content": "Classify this support ticket as billing, bug, or feature request: The export button returns a 500 error."
      }
    ]
  }'

Implementation checklist:

Do not send sampling parameters or assistant prefills.
Parse response content blocks by type, because the response can start with a thinking block.
Check stop_reason and handle refusal and max_tokens.
Run the same workload with low and medium effort.
Compare usage across effort levels before setting a production default.

In Apidog, import the cURL command as a new request and store the key in an ANTHROPIC_API_KEY environment variable. Add assertions that stop_reason is not refusal or max_tokens, then duplicate the request to compare effort settings and token usage.

For caching, batch processing, and streaming, see the Haiku 5.5 API guide. If you need credentials, use the Anthropic API key guide.

FAQ

When was Claude Haiku 5.5 released?

October 7, 2026, nine days after Sonnet 5.5.

Is Claude Haiku 5.5 free?

In the Claude.ai chat app, Free users can select it. The API is paid except for small test credits for new users. See every free route.

What is the Claude Haiku 5.5 context window?

1M tokens, with 128K maximum output on the Messages API.

Is Haiku 4.5 being retired?

Not yet. It remains listed as active, with retirement not sooner than October 15, 2026.

Next step

Pick one high-volume task you run today, such as ticket triage or document summarization. Send it to claude-haiku-5-5 at low and medium effort, validate the output, and compare usage against your current model.

Download Apidog to keep requests and assertions in one project, then use the pricing guide to turn token counts into a monthly cost estimate.

How to Use the Nano Banana 2.1 API

Hassann — Tue, 06 Oct 2026 17:22:55 +0000

Google launched Nano Banana 2.1 on October 6, 2026. It is available through the Gemini API as gemini-nano-banana-2.1. The model updates Nano Banana 2 (Gemini 3.1 Flash Image) with improved visual quality, mask-style editing, and stronger multi-turn character consistency. At shared resolutions, it costs half as much per generated image as Nano Banana 2.

Try Apidog today

This guide goes from an empty terminal to a saved image, then covers aspect ratios, 2K and 4K output, edits, multi-turn workflows, reference images, Search grounding, testing, and cost. Save each request in Apidog to compare Nano Banana 2.1 with the model you use today.

Want the background first? Read What Is Nano Banana 2.1 for what changed and what Google has not published yet.

What you need

Item	Value
Base URL	`https://generativelanguage.googleapis.com/v1beta`
Auth header	`x-goog-api-key: $GEMINI_API_KEY`
Model ID	`gemini-nano-banana-2.1`
Endpoint	`POST /v1beta/interactions`
Resolutions	1K (default), 2K, 4K
Inputs	Text, images (up to 14 references), video
Python SDK	`pip install google-genai`
JavaScript SDK	`npm install @google/genai`

All examples use the Interactions API, which is the API Google documents for Nano Banana 2.1 image generation.

Step 1: Get a Gemini API key

Open Google AI Studio and sign in.
Select Get API key and create a key in a Google Cloud project.
Enable billing for that project. Google lists the Nano Banana 2.1 API free tier as “Not available,” so API requests require a paid project.
Export the key in your shell:

export GEMINI_API_KEY="your-key-here"

Google links 2.1 to the AI Studio playground for prompt testing, but it has not published how much a free account can generate there. See how to use Nano Banana 2.1 for free and getting a Gemini API key for additional setup guidance.

Step 2: Generate your first image

Call the API with cURL

Send a text prompt to the Interactions endpoint:

curl -s -X POST "https://generativelanguage.googleapis.com/v1beta/interactions" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gemini-nano-banana-2.1",
    "input": [
      {
        "type": "text",
        "text": "Create a picture of a nano banana dish in a fancy restaurant with a Gemini theme"
      }
    ]
  }'

The API returns JSON. Generated image data is base64-encoded in an image content block, so use an SDK or script to decode and save it.

Save the result with Python

Install the SDK:

pip install google-genai

Then create an image and write it to disk:

from google import genai
import base64

client = genai.Client()  # Reads GEMINI_API_KEY

interaction = client.interactions.create(
    model="gemini-nano-banana-2.1",
    input="Create a picture of a nano banana dish in a fancy restaurant with a Gemini theme",
)

with open("generated_image.png", "wb") as f:
    f.write(base64.b64decode(interaction.output_image.data))

interaction.output_image returns the last generated image block. Its data field is base64, so decode it before writing the file.

Save the result with JavaScript

Install the SDK:

npm install @google/genai

Create and save the image:

import { GoogleGenAI } from "@google/genai";
import * as fs from "node:fs";

const ai = new GoogleGenAI({});

const interaction = await ai.interactions.create({
  model: "gemini-nano-banana-2.1",
  input: "Create a picture of a nano banana dish in a fancy restaurant with a Gemini theme",
});

const image = interaction.output_image;

if (image) {
  fs.writeFileSync("nano-banana.png", Buffer.from(image.data, "base64"));
}

Gemini 3 image models think before generating. Nano Banana 2.1 may produce up to two interim “thought images” while planning composition. These are not billed, and API users cannot disable thinking.

Step 3: Set aspect ratio, resolution, and image-only output

Use response_format to control the generated output. Setting "type": "image" returns only an image and omits conversational text, reducing response size and simplifying parsing.

interaction = client.interactions.create(
    model="gemini-nano-banana-2.1",
    input="A product shot of a matte black coffee grinder on a marble counter",
    response_format={
        "type": "image",
        "mime_type": "image/png",
        "aspect_ratio": "16:9",
        "image_size": "2K",
    },
)

Key details:

image_size accepts 1K, 2K, and 4K. Use an uppercase K; 2k is rejected.
Nano Banana 2.1 does not have a 512px tier. That option belongs to Nano Banana 2.
Supported aspect ratios include 1:1, 2:3, 3:2, 3:4, 4:3, 4:5, 5:4, 9:16, 16:9, 21:9, 1:4, 4:1, 1:8, and 8:1.
A 16:9 image at 2K is 2752x1536. At 4K, it is 5504x3072.
To request both text and an image, pass a list:

response_format=[
    {"type": "text"},
    {"type": "image"},
]

Step 4: Edit an existing image

To edit an image, send a base64 image block alongside a text instruction.

with open("living_room.png", "rb") as f:
    image_b64 = base64.b64encode(f.read()).decode("utf-8")

interaction = client.interactions.create(
    model="gemini-nano-banana-2.1",
    input=[
        {
            "type": "text",
            "text": (
                "Using the provided image of a living room, change only the "
                "blue sofa to be a vintage, brown leather chesterfield sofa. "
                "Keep the rest of the room, including the pillows on the sofa "
                "and the lighting, unchanged."
            ),
        },
        {
            "type": "image",
            "data": image_b64,
            "mime_type": "image/png",
        },
    ],
)

Mask-style inpainting without a mask file

Nano Banana 2.1 does not use a separate mask upload. Instead, define the edit region with your prompt.

Using the provided image, change only the [specific element] to [new element/description]. Keep everything else in the image exactly the same, preserving the original style, lighting, and composition.

For reliable edits:

Name one specific element.
Describe the replacement concretely.
Explicitly state which visual properties must remain unchanged.

For example, “make the sofa nicer” can cause a full-room redraw. “Change only the blue sofa to a brown leather chesterfield; keep pillows, lighting, walls, and composition unchanged” constrains the edit.

Step 5: Iterate with multi-turn editing

For successive edits, pass the previous interaction ID as previous_interaction_id. Send only the next requested change.

interaction_2 = client.interactions.create(
    model="gemini-nano-banana-2.1",
    input="Update this infographic to be in Spanish. Do not change any other elements of the image.",
    previous_interaction_id=interaction.id,
    response_format={
        "type": "image",
        "mime_type": "image/png",
        "aspect_ratio": "16:9",
        "image_size": "2K",
    },
)

With REST, include the same field in the request body:

{
  "previous_interaction_id": "<PREVIOUS_INTERACTION_ID>"
}

This workflow benefits from Nano Banana 2.1’s improved multi-turn character consistency: characters and products should remain recognizable over several edit rounds.

Step 6: Combine up to 14 reference images

Add additional image blocks to the input array. For Nano Banana 2.1, Google documents support for up to:

10 high-fidelity object images
4 character images
14 reference images total

interaction = client.interactions.create(
    model="gemini-nano-banana-2.1",
    input=[
        {
            "type": "text",
            "text": "An office group photo of these people, they are making funny faces.",
        },
        {"type": "image", "data": person_1_b64, "mime_type": "image/png"},
        {"type": "image", "data": person_2_b64, "mime_type": "image/png"},
        {"type": "image", "data": person_3_b64, "mime_type": "image/png"},
    ],
    response_format={
        "type": "image",
        "aspect_ratio": "5:4",
        "image_size": "2K",
    },
)

Reference images count as input tokens. Nano Banana 2.1 input costs three times as much as Nano Banana 2 input, so measure reference-heavy workflows before migrating.

Step 7: Ground images with Google Search

For prompts that depend on current information, such as recent events or weather data, add the Google Search tool.

interaction = client.interactions.create(
    model="gemini-nano-banana-2.1",
    input="A detailed painting of a Timareta butterfly resting on a flower",
    tools=[
        {
            "type": "google_search",
            "search_types": ["web_search", "image_search"],
        }
    ],
)

Using only this tool configuration enables web search:

{"type": "google_search"}

Adding image_search allows the model to use web images as visual context. This is supported by Nano Banana 2.1 and Nano Banana 2.

Important constraints:

Grounding cannot use real-world images of people from Search.
If you display grounded output to users, Google requires displaying the search_suggestions returned in the google_search_result step.

Step 8: Test the request in Apidog

Scripts are useful for generation, but saved requests are faster for validating prompts, credentials, and model behavior. In Apidog:

Create an environment and add a GEMINI_API_KEY variable.
Create a request:

   POST https://generativelanguage.googleapis.com/v1beta/interactions

Add this header:

   x-goog-api-key: {{GEMINI_API_KEY}}

Add a JSON request body containing model, input, and response_format.
Click Send.
Add this post-response script to verify both the status code and image output:

pm.test("status is 200", () => {
  pm.response.to.have.status(200);
});

pm.test("response contains an image block", () => {
  const steps = pm.response.json().steps || [];

  const hasImage = steps.some((s) =>
    s.type === "model_output" &&
    (s.content || []).some((c) => c.type === "image" && c.data)
  );

  pm.expect(hasImage).to.be.true;
});

Duplicate the request and change the model ID to gemini-3.1-flash-image.
Send both requests with the same prompt.

You now have a repeatable side-by-side comparison of Nano Banana 2.1 and Nano Banana 2, including status, timing, and response size. For a broader comparison, see Nano Banana 2.1 vs Nano Banana 2 vs Pro.

What it costs

Paid-tier pricing from Google’s pricing page on October 7, 2026:

Model	Input / 1M	1K image	2K image	4K image	Batch 1K
Nano Banana 2.1	$1.50	$0.0336	$0.0504	$0.0756	$0.0168
Nano Banana 2	$0.50	$0.067	$0.101	$0.151	$0.034
Nano Banana Pro	$2.00	$0.134	$0.134	$0.24	$0.067

For Nano Banana 2.1:

Image output costs $30 per 1M tokens.
A 1K image uses 1,120 tokens.
A 2K image uses 1,680 tokens.
A 4K image uses 2,520 tokens.
Text and thinking output costs $7.50 per 1M tokens.
Search grounding includes 5,000 free monthly requests shared across Gemini 3.x models, then costs $14 per 1,000 requests.

Worked example: 1,000 product images at 2K

Assume short prompts of about 100 input tokens each.

Output: 1,000 × $0.0504 = $50.40
Input: 100,000 × $1.50 / 1,000,000 = $0.15
Total: approximately $50.55, plus any thinking-text tokens

The same job on Nano Banana 2 costs about $101.

With the Batch API, Nano Banana 2.1’s 2K price drops to $0.0252 per image. The output cost for 1,000 images drops to $25.20 if you can wait. Batch jobs trade turnaround times of up to 24 hours for higher rate limits.

For more detail, see the Nano Banana 2 API pricing breakdown.

Common errors

These are generic Gemini API behaviors, not Nano Banana 2.1-specific errors.

Error	Likely cause	Fix
`400 INVALID_ARGUMENT`	Lowercase `image_size`, unsupported ratio, malformed `input`	Use `2K`, not `2k`; validate the ratio and request shape
`403 PERMISSION_DENIED`	Invalid key or billing is not enabled	Check the key and enable billing
`404 NOT_FOUND`	Incorrect model ID	Use `gemini-nano-banana-2.1` exactly
`429 RESOURCE_EXHAUSTED`	Rate limit reached	Use backoff and retry, or use Batch
`500` / `503`	Temporary server issue	Retry with exponential backoff
`200` but no image	Prompt blocked or text-only output	Set `"type": "image"` and rephrase the prompt

FAQ

Is there a free tier for the Nano Banana 2.1 API?

No. Google lists the API free tier as “Not available.” The AI Studio playground links to 2.1, but Google has not published a free limit for it.

Is Nano Banana 2.1 a drop-in replacement for Nano Banana 2?

Mostly. Change the model ID to gemini-nano-banana-2.1. However, 2.1 removes the 512px tier and has higher input-token pricing, so evaluate reference-heavy edit workflows before switching.

Do generated images carry a watermark?

Yes. All outputs include a SynthID watermark.

Can I generate an image from a video?

Yes. Nano Banana 2.1 accepts a video input block, such as a YouTube URL, alongside the text prompt.

Does the old Nano Banana 2 API guide still apply?

The core concepts still apply. See the Nano Banana 2 API guide for the earlier model.

Wrap-up

Nano Banana 2.1 promises improved images at half of Nano Banana 2’s per-image price while retaining the same Interactions API shape.

Start with a billed Gemini API key, generate one image, and save the request in Apidog with status and image assertions. Then duplicate the request, switch to the older model ID, and compare both models using the same prompts.

Nano Banana 2.1 vs Nano Banana 2 vs Nano Banana Pro: Which Should You Use?

Hassann — Tue, 06 Oct 2026 17:22:13 +0000

Google now sells four Nano Banana image models through the Gemini API. The newest model, Nano Banana 2.1, launched on October 6, 2026 at half the per-image price of the model it replaces. That makes it the default for most teams, but not every workload.

Try Apidog today

This guide compares Nano Banana 2.1, Nano Banana 2, Nano Banana Pro, and Nano Banana 2 Lite. Prices and limits below come from Google’s image generation documentation and pricing page as of October 7, 2026.

Quick verdict

Default to Nano Banana 2.1 (gemini-nano-banana-2.1) for new projects. Google recommends it for new projects, and it costs half as much as Nano Banana 2 at 1K, 2K, and 4K.
Keep Nano Banana 2 (gemini-3.1-flash-image) if you need 0.5K (512px) output. Nano Banana 2.1 does not support that size.
Use Nano Banana 2 Lite (gemini-3.1-flash-lite-image) for high-volume 1K generation when you do not need grounding or many reference images. It has the same 1K image price as 2.1 with cheaper input tokens.
Use Nano Banana Pro (gemini-3-pro-image) for workloads that need Google’s premium tier for professional asset production and can justify roughly four times the 1K image cost.

One caveat: Google has not published benchmarks for Nano Banana 2.1. Its launch announcement says 2.1 “outperforms our previous models across the board,” but provides no side-by-side measurements. Test your own prompts before making quality claims or migrating production traffic.

Side-by-side specs

	Nano Banana 2.1	Nano Banana 2	Nano Banana Pro
API model ID	`gemini-nano-banana-2.1`	`gemini-3.1-flash-image`	`gemini-3-pro-image`
Google’s positioning	Primary high-efficiency workhorse	Previous-generation workhorse	Premium choice for complex visual tasks
Resolutions	1K, 2K, 4K	0.5K, 1K, 2K, 4K	1K, 2K, 4K
Input price per 1M tokens	$1.50	$0.50	$2.00
Image output price per 1M tokens	$30	$60	$120
Per image at 0.5K	n/a	$0.045	n/a
Per image at 1K	$0.0336	$0.067	$0.134
Per image at 2K	$0.0504	$0.101	$0.134
Per image at 4K	$0.0756	$0.151	$0.24
Batch price per image at 1K	$0.0168	$0.034	$0.067
Google Search grounding	Web Search + Image Search	Web Search + Image Search	Web Search
Reference images	Up to 14: up to 10 objects, 4 characters	Up to 14: up to 10 objects, 4 characters	Up to 14: up to 6 objects, 5 characters
Video input	Yes	Yes	No
Free API tier	No; test in AI Studio	No	No

Key details behind the table:

Output token math: A 1K image uses 1,120 output tokens, 2K uses 1,680, and 4K uses 2,520 for both 2.1 and Nano Banana 2. The token counts are the same, but 2.1 has half the output-token rate.
Batch pricing: Nano Banana 2.1 batch prices are $0.0168 at 1K, $0.0252 at 2K, and $0.0378 at 4K.
Thinking: Gemini 3 image models think by default, and the API does not let you disable it. Up to two interim “thought images” can be generated without charge. Text and thinking output on 2.1 costs $7.50 per 1M tokens, compared with $3 on Nano Banana 2.
Grounding: The Gemini 3.x models share 5,000 free search requests per month. After that, search costs $14 per 1,000 requests.

Cost per 1,000 images

The following prices are output-only, standard non-batch API, paid tier.

Model	0.5K	1K	2K	4K
Nano Banana 2.1	n/a	$33.60	$50.40	$75.60
Nano Banana 2	$45.00	$67.00	$101.00	$151.00
Nano Banana 2 Lite	n/a	$33.60	n/a	n/a
Nano Banana Pro	n/a	$134.00	$134.00	$240.00

With the Batch API, Nano Banana 2.1 drops to:

$16.80 per 1,000 images at 1K
$25.20 per 1,000 images at 2K
$37.80 per 1,000 images at 4K

Two comparisons are especially useful when choosing a model:

A 4K image from 2.1 costs $0.0756, which is less than a 1K Pro image at $0.134.
A 1K image from 2.1 costs $0.0336, less than Nano Banana 2’s 512px tier at $0.045. Keep Nano Banana 2 only when you specifically need 0.5K output.

When input-heavy editing changes the math

Image output is not the entire bill. Nano Banana 2.1 charges $1.50 per 1M input tokens, three times Nano Banana 2’s $0.50 per 1M input tokens.

This matters for image-editing workflows that attach many reference images or send long multi-turn histories.

According to Google’s Vertex AI model page, each input image uses 1,120 tokens.

Example: 14 reference images plus a 500-token prompt

Assume a product-shot pipeline sends 14 reference images, a 500-token prompt, and requests one 1K image.

	Nano Banana 2.1	Nano Banana 2
Input tokens: `14 × 1,120 + 500`	16,180	16,180
Input cost	$0.0243	$0.0081
1K output	$0.0336	$0.0670
Total per request	$0.0579	$0.0751
Per 1,000 requests	$57.90	$75.10

Even at the 14-image limit, Nano Banana 2.1 is still cheaper. However, the savings shrink from 50% for output alone to roughly 23% for this input-heavy request.

Calculate the break-even point

For the same request:

Nano Banana 2.1 costs $0.000001 more per input token than Nano Banana 2.
Its output savings are:
- $0.0334 at 1K
- $0.0506 at 2K
- $0.0754 at 4K

That means 2.1 becomes more expensive only above approximately:

Output size	Approximate input-token break-even point
1K	33,400 input tokens
2K	50,600 input tokens
4K	75,400 input tokens

Fourteen reference images alone do not reach those limits. However, two patterns can get closer:

Long multi-turn edit sessions

If you chain edits with previous_interaction_id, inspect the usage data returned for every response. Earlier turns can add context tokens that you pay for. A ten-turn session that repeatedly includes full references can cross the 1K break-even point.
Thinking and text output

Nano Banana 2.1 charges $7.50 per 1M thinking and text-output tokens, compared with $3 for Nano Banana 2. You cannot disable thinking, so prompts that trigger more reasoning narrow 2.1’s cost advantage.

For long-history 1K editing, run real production-like requests through both models and compare total usage rather than image-output price alone.

Where Nano Banana 2 Lite fits

Nano Banana 2 Lite is the budget model. Google describes it as “the fastest and cheapest Gemini image model.”

Its pricing is:

$0.25 per 1M input tokens
$0.0336 per 1K generated image

That gives Lite the same 1K output cost as Nano Banana 2.1 with input tokens that cost one-sixth as much.

Use Lite when your workload is straightforward:

Plain 1K text-to-image generation
High-volume generation
Few or no reference images
No Google Search grounding
No multi-turn editing requirement

Lite only generates 1K output, does not support Google Search grounding, and Google says it is “not optimized” for multiple reference inputs or multi-turn editing.

Once you need 2K, 4K, grounding, or iterative editing, move to Nano Banana 2.1.

Google also recommends Lite as the migration path for the original Nano Banana model, gemini-2.5-flash-image, which is now legacy. See our Nano Banana 1 vs Nano Banana 2 comparison for the earlier migration.

Where Nano Banana Pro still makes sense

Google describes Pro as “the premium choice for the most complex visual tasks.” It positions Pro for professional asset production, the highest level of world knowledge, advanced localization, accurate brand consistency, and precision creative control.

Google’s prompting guide also recommends Pro for professional text-heavy assets.

Those are positioning statements, not published comparative measurements. Use them as a starting point, then validate the choice with your own prompts.

Choose Pro if your existing Pro workflows already meet your quality bar or you depend on its five-character consistency limit.
Test 2.1 first for volume work. At 4K, 2.1 costs about one-third as much as Pro: $0.0756 versus $0.24. At 1K, it costs about one-quarter as much.
Account for capability differences: Pro does not support Image Search grounding or video input.

For the full Pro request format, see the Nano Banana Pro API guide.

Migration notes: Nano Banana 2 to 2.1

For most API calls, migration is a one-line model change.

The endpoint, response_format, and google_search tool remain the same:

curl -s -X POST "https://generativelanguage.googleapis.com/v1beta/interactions" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gemini-nano-banana-2.1",
    "input": [
      {
        "type": "text",
        "text": "A studio product photo of a ceramic mug on a walnut desk"
      }
    ],
    "response_format": {
      "type": "image",
      "mime_type": "image/png",
      "aspect_ratio": "16:9",
      "image_size": "2K"
    }
  }'

Before sending production traffic to 2.1, check the following.

1. Find 512px calls

If your code sends:

{
  "image_size": "512px"
}

or requests 0.5K output, keep those requests on:

gemini-3.1-flash-image

Nano Banana 2.1 does not support that size.

2. Use uppercase `K`

Use:

{
  "image_size": "2K"
}

Do not use:

{
  "image_size": "2k"
}

Lowercase k is rejected on every model.

3. Configure Image Search grounding correctly

To enable both Web Search and Image Search, include:

{
  "google_search": {
    "search_types": ["web_search", "image_search"]
  }
}

Google requires you to display the returned search suggestions.

4. Update budget assumptions

For equivalent requests:

Your input-token line item can roughly triple when moving from Nano Banana 2 to 2.1.
Your image-output line item is cut roughly in half at 1K, 2K, and 4K.

Track both values in your billing and observability pipeline.

5. Plan for paid API usage

None of these models has a free Gemini API tier. See how to use Nano Banana 2.1 for free for testing options.

For a full walkthrough covering multi-turn editing and grounding, see the Nano Banana 2.1 API guide. For the release changes, see the Nano Banana 2.1 overview.

How to A/B test the three models in Apidog

Without published benchmarks, the useful comparison is your own prompt set, references, and acceptance criteria. Apidog lets you run the same API request against all three models without building a separate test harness.

1. Create a reusable request

Create:

POST https://generativelanguage.googleapis.com/v1beta/interactions

Store your API key in an environment variable and set:

x-goog-api-key: {{GEMINI_API_KEY}}

Start with the request body from the migration example. For reference images, add image parts like:

{
  "type": "image",
  "mime_type": "image/jpeg",
  "data": "<BASE64>"
}

2. Duplicate the request for each model

Create three copies and change only the model field:

gemini-nano-banana-2.1
gemini-3.1-flash-image
gemini-3-pro-image

Keep everything else identical:

Prompt
Reference images
Aspect ratio
image_size
Grounding configuration

This ensures the model is the only variable.

3. Send requests and compare responses

For every request, capture:

HTTP status
Latency
Response size
Usage data
Generated base64 image

Decode the returned images and review them side by side against the same acceptance criteria.

4. Turn it into a regression test

Add checks for:

A 200 status
A non-empty generated image
Expected response fields

Group the requests into a test scenario and rerun it when Google updates a model or when your prompting pipeline changes.

Run at least 10 to 20 real prompts, not one example. Then multiply each model’s measured per-request cost by your actual monthly volume. Download Apidog free to follow along.

FAQ

Is Nano Banana 2.1 better than Nano Banana 2?

Google says 2.1 “outperforms our previous models across the board,” citing visual design, mask-based editing, subject consistency, and more natural-looking images. Google has not published benchmarks, so verify this with your own prompts.

Is Nano Banana 2.1 cheaper than Nano Banana 2?

For image output, yes. It costs half as much at 1K, 2K, and 4K. For input tokens, no: 2.1 costs $1.50 per 1M tokens versus $0.50 for Nano Banana 2. For most workloads, output savings still win.

Should I replace Nano Banana Pro with 2.1?

Test first. Nano Banana 2.1 costs about one-quarter of Pro at 1K, but Google still positions Pro as its premium model.

Can I use Nano Banana 2.1 for free?

Not through the Gemini API. Google’s pricing page lists no free API tier for any Nano Banana model, though you can test 2.1 in Google AI Studio.

How many reference images can I send?

All three models support up to 14 reference images. Nano Banana 2.1 and Nano Banana 2 support up to 10 objects and 4 characters. Pro supports up to 6 objects and 5 characters.

Verdict

Nano Banana 2.1 is the practical default for new Gemini image workloads. It cuts Nano Banana 2’s per-image cost in half while keeping the same grounding, video-input, and reference-image limits.

Stay on Nano Banana 2 only when you need 512px output or when measured long-history editing costs favor it. Use Lite for simple high-volume 1K generation. Keep Pro where its premium positioning matches your production requirements, but validate that value with a side-by-side test before paying roughly four times as much per 1K image.

How to Use Nano Banana 2.1 for Free ?

Hassann — Tue, 06 Oct 2026 17:21:08 +0000

Google launched Nano Banana 2.1 on October 6, 2026, with a post from the Google AI Studio account saying the image model “outperforms our previous models across the board” and inviting people to “try it out today in ai.studio.” The first question most people asked: is it free?

Try Apidog today

The honest answer is: partly. The Gemini API has no free tier for 2.1. Google AI Studio is free to use, but Google has not said how much 2.1 usage a free account receives. The Gemini app and Google Flow offer free image generation, but neither help page lists 2.1 yet.

If you plan to call the model from code, you also need a way to validate requests without wasting paid calls on retries. Apidog can help with that, as shown near the end.

TL;DR: every route, checked October 7, 2026

Route	Free?	Limits	Best for
Google AI Studio playground	AI Studio is free; free access to 2.1 not confirmed	Free plan gets a “modest quota”; no number published	Trying prompts before paying
Gemini API free tier	No	“Not available”	Nothing
Gemini app	Not confirmed for 2.1	Nano Banana 2 is available to all users	Casual images
Google Flow	Not confirmed for 2.1	Nano Banana 2 Lite is free	Images for video projects
Google Cloud $300 trial (Vertex AI)	Possibly, unconfirmed	90 days; billing account required	New Google Cloud accounts
Third-party sites	None verified	Unknown	Not recommended
Batch API (paid)	No, but cheap	$0.0168 per 1K image; up to 24-hour turnaround	Bulk generation

Route 1: Google AI Studio, the most likely free option

Google AI Studio is the web playground for Gemini models, and it is where Google directed users on launch day. The 2.1 card on the Gemini API pricing page also includes a “Try it in Google AI Studio” link.

Google’s pricing page states: “Google AI Studio usage is free of charge in all available regions.” Its billing FAQ adds an important condition: it “remains free of charge unless users link a paid API key for access to paid features.”

The unknown is the quota. Google’s AI plans page gives free accounts a “modest quota” with “basic limits and access.” Google AI Pro gets a higher quota and “access to premium models like Gemini Pro, Nano Banana, and Lyria.” The same page says Pro and Ultra plans “unlock paid models and higher rate limits in the Google AI Studio Playground.”

Google does not say whether a free account can run 2.1 or how many images it can generate.

What to do

Sign in at ai.studio.
Open the Playground.
Select Gemini Nano Banana 2.1.
Run a simple prompt.
If the request generates successfully, your account has free access within Google’s quota.
If AI Studio asks you to upgrade or link a paid key, free access is unavailable for your account.

For a playground walkthrough, see how to use Google AI Studio for free.

Two caveats apply:

Free usage helps train Google’s models. The pricing page lists free-tier data as “Used to improve our products: Yes”; paid-tier data is “No.” Do not upload client photos, personal images, or unreleased product shots to a free account.
Playground access is not API access. Google says AI plan benefits “apply only within the Google AI Studio web interface.” Programmatic usage goes through the paid API.

Route 2: the Gemini API free tier does not exist

On the pricing page, the free tier for gemini-nano-banana-2.1 reads “Not available” for both input and output. Nano Banana 2, 2 Lite, and Pro have the same limitation.

A free API key cannot generate 2.1 images. You need billing enabled.

For new accounts, the billing FAQ says upgrading requires “prepaying to add a minimum of $5” in credits.

The walkthrough for getting a Gemini API key for free still works for text models, but it does not provide free Nano Banana 2.1 image generation.

Route 3: the Gemini app, not confirmed for 2.1

Google’s Gemini help page lists Nano Banana 2 for all users and Nano Banana Pro for Google AI Plus and higher plans. It does not mention 2.1.

Nokia Power User reported on October 6 that 2.1 “has begun surfacing directly inside Gemini apps,” but Google has not confirmed that availability.

If you need free image generation and do not specifically need 2.1, the free Gemini app with Nano Banana 2 works today. See the Nano Banana 2 free guide.

Route 4: Google Flow, not confirmed for 2.1

Flow, Google’s AI creative studio, is where 2.1 first appeared. Users spotted it in the model picker on October 5 before Google pulled it and launched it the next day.

Flow’s help page identifies Nano Banana 2 Lite as “the default model available at no charge,” with Nano Banana 2 as the standard model and Pro as the default for AI Ultra subscribers. As of October 7, the page does not list 2.1.

Reports are inconsistent:

Nokia Power User says 2.1 generations in Flow “consume standard subscription credits.”
OrcaRouter saw a user screenshot showing zero credits, but notes that this reflects that account’s plan rather than official pricing.

Before generating, open Flow’s model picker and check the displayed credit cost for Nano Banana 2.1.

Route 5: Google Cloud trial credits on Vertex AI, unconfirmed

Nano Banana 2.1 also has a model page on Google Cloud’s Gemini Enterprise Agent Platform, formerly Vertex AI, with pay-as-you-go and provisioned-throughput options.

New Google Cloud customers can get a $300 Welcome credit that expires after 90 days.

What is confirmed:

The billing FAQ says that “starting March 2026, Gemini API usage costs are specifically excluded from the $300 Google Cloud Free Trial program.”
The Free Trial page, updated October 5, 2026, says the credit “can’t pay for Gemini API in AI Studio costs” and cannot be used for partner models offered as managed APIs.

Neither page excludes Google’s own models on the Enterprise Agent Platform. The credit may cover 2.1 there, but Google has not confirmed it for this model.

How to verify it

Create a Google Cloud billing account and enable the relevant service.
Send a small number of test requests.
Open your Cloud billing report.
Confirm whether the requests consumed Welcome credits or generated a separate charge.

Do not assume the trial covers production generation until you see the billing result.

Route 6: third-party sites

Sites using the Nano Banana name already have 2.1 pages, and some advertise free generations.

There is no verified evidence that these sites run Google’s 2.1 model or that they handle uploaded images safely. They are not Google products.

If you try one, avoid personal images, client assets, or any confidential content.

The cheapest paid route: Batch API at $0.0168 per image

Nano Banana 2.1 image output costs $30 per million tokens on Standard pricing, and a 1K image is 1,120 tokens. The Batch API cuts that output cost in half.

Resolution	Standard	Batch	Images per $1, Batch	Images per $5, Batch
1K	$0.0336	$0.0168	About 59	About 297
2K	$0.0504	$0.0252	About 39	About 198
4K	$0.0756	$0.0378	About 26	About 132

The $5 minimum prepay buys roughly 297 1K images at Batch rates.

Nano Banana 2 costs $0.067 per 1K image on Standard pricing, so 2.1 costs half as much at every shared resolution.

Watch these costs and constraints:

Input costs more. Input is $1.50 per million tokens, three times Nano Banana 2’s input cost. Edits with several reference images, up to 14, can add up.
Text and thinking output costs $7.50 per million tokens. Use an image-only response format when possible to avoid an unnecessary text response.
Batch is slow. Google’s documentation mentions “a turnaround of up to 24 hours.” Use Batch for bulk asset generation, not interactive user-facing features.

For a model breakdown, see Nano Banana 2.1 vs Nano Banana 2 vs Pro. For implementation details, read the Nano Banana 2.1 API guide.

Test the API without wasting credits

Every successful 2.1 API call is billed.

Google’s billing FAQ says requests that fail with a 400 or 500 are not charged for tokens, but they still count against quota. Invalid payloads and sloppy retries can therefore consume time and rate-limit capacity even when they do not consume generation credits.

Start with Google’s REST example:

curl -s -X POST "https://generativelanguage.googleapis.com/v1beta/interactions" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gemini-nano-banana-2.1",
    "input": [
      {
        "type": "text",
        "text": "Create a picture of a nano banana dish in a fancy restaurant with a Gemini theme"
      }
    ]
  }'

Set up the request in Apidog

Import the cURL command into a new request in Apidog. Apidog fills in the URL, headers, and JSON body. Save this as your known-good baseline.
Store the API key in an environment variable named GEMINI_API_KEY, then reference it in the x-goog-api-key header. This keeps secrets out of saved requests and makes it easier to switch between test and production projects.
Add response assertions for:
- A 200 response status.
- An image block in the response body.

Use the raw JSON from your first successful request to identify the exact field path.

Save request variants for 1K, 2K, and reference-image edits. This makes cost comparisons intentional instead of accidental.
Validate payload changes before sending production traffic. Test model names, headers, response formats, and image inputs using a controlled request collection.

Apidog does not make image generation free. Each successful send is still a billed API call. It helps remove guesswork before you make that call.

FAQ

Is Nano Banana 2.1 free?

Not on the Gemini API, where the free tier is listed as “Not available.” AI Studio usage is free, but Google has not confirmed a free Nano Banana 2.1 quota.

Is Nano Banana 2.1 free in the Gemini app?

Not confirmed. Google’s help page lists Nano Banana 2 for all users but does not mention 2.1.

Does Flow charge credits for Nano Banana 2.1?

Google has not said. Check the cost shown in Flow’s model picker before generating. Nano Banana 2 Lite is free there.

Can I use the $300 Google Cloud credit?

Not for the Gemini API or AI Studio. It may apply on the Enterprise Agent Platform, but that is unconfirmed for 2.1.

What is the cheapest way to generate many images?

The Batch API: $0.0168 per 1K image, or about 59 images per dollar.

Bottom line

You may be able to try Nano Banana 2.1 for free in Google AI Studio, which is the route Google itself promotes. Do not build a production plan around it: Google has not published the free quota, and its AI plans page lists Nano Banana among premium models for subscribers.

The Gemini app and Flow have free image-generation options, but neither currently documents Nano Banana 2.1 availability.

When free access runs out, the Batch API provides about 59 1K images per dollar at half Nano Banana 2’s price. Set up the request once in Apidog, keep the key in an environment variable, and use assertions to catch mistakes before you pay for them.

For details on the model update, read what Nano Banana 2.1 is.

Nano Banana 2.1 Is Out: Half the Price of Nano Banana 2, and the Text Finally Works

Hassann — Tue, 06 Oct 2026 17:19:36 +0000

Google shipped Nano Banana 2.1 on October 6, 2026, and it did it quietly. There was no launch blog post and no benchmark chart. The model showed up in Google Flow’s model picker on October 5, disappeared, and then came back the next day with a short post from @GoogleAIStudio saying it “outperforms our previous models across the board.”

Try Apidog today

The part that matters for anyone paying for image generation is on the pricing page. Nano Banana 2.1 costs half as much per image as Nano Banana 2 at every resolution the two share, and Google’s docs list “accurate text rendering” among its upgrades. Here is what changed, what it costs, and the catches the launch post skips.

TL;DR

What it is: Gemini Nano Banana 2.1, model ID gemini-nano-banana-2.1, an update to Nano Banana 2 (Gemini 3.1 Flash Image). Google’s docs call it “the primary high-efficiency workhorse model” for image generation and editing.
What Google says improved: Better visual design, mask-based editing, subject consistency, and more natural-looking images, plus text rendering, multi-turn character consistency, and search grounding.
Price: $0.0336 per 1K image, $0.0504 per 2K image, and $0.0756 per 4K image. That is half of Nano Banana 2 at each shared size.
The catches: Input tokens cost 3x Nano Banana 2’s price, there is no 512px tier, there is no free tier on the Gemini API, and Google has published no benchmarks for 2.1.
Where to try it: Google AI Studio, the Gemini API Interactions API, Vertex AI, and Google Flow.

What Nano Banana 2.1 is

Nano Banana is Google’s name for image models in the Gemini family. The original Nano Banana (gemini-2.5-flash-image) is now legacy. Nano Banana 2 (gemini-3.1-flash-image) became the fast default, Nano Banana 2 Lite took the budget slot, and Nano Banana Pro (gemini-3-pro-image) covers professional asset work.

Nano Banana 2.1 is an update to Nano Banana 2. Google’s image generation docs describe it as:

Built for high-efficiency image generation and conversational editing with improved visual quality, multi-turn character consistency, accurate text rendering, and search-grounded generation across 1K, 2K, and 4K resolutions.

Key specs

Feature	Nano Banana 2.1
Model ID	`gemini-nano-banana-2.1`
Output resolutions	1K, 2K, 4K
Inputs	Text, image, video (no audio)
Reference images	Up to 14
Thinking	On by default; cannot be disabled in the API
Interim “thought images”	Up to two, not charged
Search grounding	Google Web Search and Google Image Search
Watermark	SynthID on every output

What Google says got better

Google’s launch post lists better visual design, mask-based editing, subject consistency, and more natural-looking images. Its documentation adds multi-turn character consistency, accurate text rendering, and Google Image Search grounding.

Text rendering

Garbled lettering has been a common giveaway of AI-generated images. Google says the Nano Banana family can generate legible, stylized text for infographics, menus, diagrams, and marketing assets, and lists accurate text rendering as a Nano Banana 2.1 improvement.

This remains Google’s claim, not a measured result: there is no published text-accuracy benchmark for 2.1.

Before routing production traffic to the model, test representative prompts such as:

Create a restaurant menu with these exact items and prices:
- Grilled salmon — $24
- Mushroom risotto — $19
- Lemon tart — $8

Use clear, readable serif typography. Do not change any wording or prices.

Validate the rendered copy programmatically or through human review before using the output in menus, posters, product labels, or UI mockups.

Mask-based editing

Google calls this “semantic masking.” Instead of drawing a pixel mask, describe the region and intended change in the prompt.

Use a constrained instruction such as:

Using the provided image, change only the backpack from red to navy blue.
Keep the person, pose, lighting, background, composition, and all other objects exactly the same.

Be explicit about both:

The element to change
Everything that must remain unchanged

This reduces unintended edits, especially in product images and marketing creative.

Subject and character consistency

A character, product, or mascot should remain recognizable across a sequence of edits. In the API, chain interactions with previous_interaction_id and include up to 14 reference images when needed.

Typical workflow:

Generate the initial image.
Save the returned interaction ID.
Send the next edit with previous_interaction_id.
Reuse relevant reference images for product or character details.
Repeat until the asset is complete.

Search grounding

Nano Banana 2.1 and 3.1 Flash Image can ground requests with Google Image Search and web search. This can help generate visuals based on recent events, weather maps, or stock charts.

One limitation: grounding cannot use real-world images of people pulled from web search.

Price: half of Nano Banana 2 per image

Paid-tier Gemini API prices from Google’s pricing page, October 7, 2026, using standard non-batch pricing:

Model	Input (per 1M)	Image output (per 1M)	0.5K	1K	2K	4K
Nano Banana 2.1	$1.50	$30	n/a	$0.0336	$0.0504	$0.0756
Nano Banana 2	$0.50	$60	$0.045	$0.067	$0.101	$0.151
Nano Banana 2 Lite	$0.25	$30	n/a	$0.0336	n/a	n/a
Nano Banana Pro	$2.00	$120	n/a	$0.134	$0.134	$0.24

What the numbers mean

Half price per image: Image output tokens dropped from $60 to $30 per million. The token count per image remains the same: 1,120 at 1K, 1,680 at 2K, and 2,520 at 4K.
Lower 1K cost: 1,000 images at 1K cost $33.60 on 2.1 versus $67 on Nano Banana 2.
Lite-level 1K pricing: Nano Banana 2.1 costs the same as Nano Banana 2 Lite at 1K, while also supporting 2K and 4K.
About one-quarter of Pro at 1K: $0.0336 versus $0.134.
Batch pricing halves output pricing again: $0.0168 at 1K, $0.0252 at 2K, and $0.0378 at 4K.

Search grounding is billed separately: 5,000 free search requests per month are shared across Gemini 3.x models, then usage costs $14 per 1,000 requests.

For the full Nano Banana 2 breakdown, see the Nano Banana 2 pricing guide.

The catches

Input costs 3x more

Input tokens increased from $0.50 to $1.50 per million. Text and thinking output increased from $3 to $7.50 per million.

For short text-to-image prompts, this has little impact. For editing workflows that attach multiple reference images, the added input cost can reduce or eliminate the output-price advantage.

Using Google’s listed prices:

Nano Banana 2.1 costs $1 more per million input tokens than Nano Banana 2.
At 1K, it saves roughly $0.033 per image.
The break-even point is roughly 33,000 input tokens per request.
At 4K, the image savings are around $0.075, moving break-even to roughly 75,000 input tokens.

Measure actual usage instead of relying on estimates. Check the API response usage data for representative production requests.

No 512px tier

Nano Banana 2 supports a 0.5K (512px) size at $0.045. Google’s docs state that this size is not supported on Nano Banana 2.1.

For thumbnail workloads, Nano Banana 2.1’s 1K price of $0.0336 is still lower than Nano Banana 2’s 512px price. However, your pipeline must be able to handle larger generated files.

No free tier on the API

Google’s pricing page lists the Gemini API free tier as “Not available” for Nano Banana 2.1, Nano Banana 2, Lite, and Pro.

Its model card links to the Google AI Studio playground, but Google does not state how much a free account can generate there. Production API calls require a paid key.

See how to use Nano Banana 2.1 for free for the available options.

No benchmarks yet

“Outperforms our previous models across the board” comes with no published benchmark results and no official launch blog post.

Treat the quality improvement as plausible, but unproven. Run the same prompt set through both models and compare:

Text accuracy
Character consistency
Edit preservation
Latency
Token usage
Cost per accepted image

A quiet rollout

The model appeared in Google Flow before the API announcement. Third-party reports say it is available in Flow using subscription credits and has started appearing in Gemini apps, but Google has not confirmed the Gemini app rollout.

Who should switch

Switch now if

You run Nano Banana 2 at 1K, 2K, or 4K for text-to-image generation and want to cut per-image costs in half.
You use Nano Banana 2 Lite but need 2K or 4K output.
Your images contain real text, such as product labels, menus, or slide graphics, and you can test Google’s text-rendering claim against your own prompts.

Hold off if

Your pipeline depends on 512px output.
Your requests are input-heavy and include many reference images per call.
You need Pro-level quality for final marketing assets.

For a feature and price comparison, see Nano Banana 2.1 vs Nano Banana 2 vs Pro.

Try Nano Banana 2.1 via the API

Nano Banana 2.1 runs on the Gemini Interactions API.

Send a minimal request

curl -s -X POST "https://generativelanguage.googleapis.com/v1beta/interactions" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gemini-nano-banana-2.1",
    "input": [
      {
        "type": "text",
        "text": "A ripe banana wearing tiny sunglasses on a beach towel, bold hand-lettered sign that reads OPEN"
      }
    ]
  }'

The image response is returned as base64 data.

Save the generated image in Python

from google import genai
import base64

client = genai.Client()

interaction = client.interactions.create(
    model="gemini-nano-banana-2.1",
    input="A ripe banana wearing tiny sunglasses on a beach towel",
    response_format={
        "type": "image",
        "mime_type": "image/png",
        "aspect_ratio": "16:9",
        "image_size": "2K",
    },
)

with open("banana.png", "wb") as f:
    f.write(base64.b64decode(interaction.output_image.data))

Set type to image when you want image-only output and do not need a text response.

Chain a follow-up edit

Use the previous interaction ID to preserve context:

edited = client.interactions.create(
    model="gemini-nano-banana-2.1",
    previous_interaction_id=interaction.id,
    input=(
        "Change only the sunglasses to round gold frames. "
        "Keep the banana, beach towel, lighting, and composition unchanged."
    ),
    response_format={
        "type": "image",
        "mime_type": "image/png",
        "image_size": "2K",
    },
)

Add search grounding

To ground a request with search, include:

tools=[{"type": "google_search"}]

Compare models without writing a script

If you want to compare requests interactively, Apidog can be used to build a repeatable model test.

Save the request. Create a POST request to the Interactions endpoint. Store your key in an environment variable so the request header is:

   x-goog-api-key: {{GEMINI_API_KEY}}

Clone it per model. Duplicate the request and change only the model value:

   {
     "model": "gemini-3.1-flash-image"
   }

Send both requests with the same prompt, then compare image outputs, latency, and token usage.

Add assertions. Verify that the response returns a 200 status and includes an image output block. Save both requests in a test scenario so they can serve as a regression check when Google updates either model.

The detailed walkthrough, including image editing, multi-turn chains, and cost tracking, is in the Nano Banana 2.1 API guide. If you still need credentials, get a Gemini API key first.

FAQ

What is the Nano Banana 2.1 model ID?

gemini-nano-banana-2.1. The official name is Gemini Nano Banana 2.1.

Is Nano Banana 2.1 cheaper than Nano Banana 2?

Per image, yes. It costs half as much at 1K, 2K, and 4K. Input tokens cost three times as much, so highly input-heavy editing requests can narrow or erase the savings.

Does Nano Banana 2.1 render text correctly?

Google says it provides “accurate text rendering.” Google has not published benchmarks for that claim, so test it with your own text-heavy prompts.

Is Nano Banana 2.1 free?

Not through the Gemini API. The free tier is listed as unavailable. Google links the model to the AI Studio playground but has not published a free usage limit for Nano Banana 2.1 there.

Bottom line

Nano Banana 2.1 is a straightforward cost reduction for image developers: it uses the same per-image token counts as Nano Banana 2, charges half the image-output token price, and offers 2K and 4K output at Nano Banana 2 Lite’s 1K price.

Google says text rendering, editing, and consistency improved, but those claims need validation against your own workloads until benchmarks appear. Watch the 3x input price when you send many reference images, plan around the missing 512px tier, and run the same prompts against both models in Apidog before moving production traffic.

DEV Community: Hassann

Claude Haiku 5.5 vs GPT-6 Luna

Price side by side

Apply the pricing thresholds

Tokenizers move the threshold

Specs

Benchmarks: Anthropic’s table and who ran each Luna cell

Cost per attempt at each effort level

OSWorld 2.1: offline subset

GDPval-AA v2.1

Routing: which model for which workload

Test both side by side in Apidog

FAQ

Pick by prompt length, then test

Claude Haiku 5.5 Benchmarks

The launch table

Who ran each benchmark

The FrontierCode comparison trap

Additional system card benchmarks

Default effort scores lower

Score and cost by effort

Where Haiku 5.5 still trails

Independent results: none yet

What customers report

Run your own eval

FAQ

Next step

Claude Haiku 5.5 vs Haiku 4.5: What Changed and the Breaking Changes to Fix First

Haiku 4.5 vs. Haiku 5.5 at a glance

The five breaking changes

1. Replace manual thinking budgets

2. Remove sampling parameters

3. Remove assistant prefills

4. Migrate computer use to the new toolset

5. Do not edit earlier turns before replaying thinking blocks

Silent changes that will not throw an error

What got better

Test the migration in Apidog

FAQ

Next step

Claude Haiku 5.5 Pricing

Claude Haiku 5.5 API pricing table

Where “around 75% less” comes from

Cost per attempt at each effort level

How Haiku 5.5 compares on price

API credits and consumer plans

Track cost per request in Apidog

FAQ

Next step: price your own workload

How to Use the Claude Haiku 5.5 API ?

Claude Haiku 5.5 API at a glance

Your first Claude Haiku 5.5 API call

curl

Python

TypeScript

Pick an effort level

Control thinking

Cache prompts and batch jobs

Handle stop_reason: "refusal"

Computer use and browser use

Rate limits

Test the Claude Haiku 5.5 API in Apidog

FAQ

Next step

How to Use Claude Haiku 5.5 for Free ?

Every route at a glance

Route 1: Use the Claude.ai Free plan

Is there a free Claude Haiku 5.5 API?

Max and Team monthly API credits: paid, not free

Vercel AI Gateway: unconfirmed

The cheapest paid path

What is not free

Test your first Haiku 5.5 request in Apidog

FAQ

Start in chat, then pay pennies for the API

How to Use Claude Haiku 5.5 in Claude Code (and as Your Subagent Model)

Claude Haiku 5.5 in Claude Code at a glance

Step 1: Update Claude Code

Step 2: Select Haiku 5.5 as the main model

The haiku alias only means Haiku 5.5 on the Anthropic API

Handle `stop_reason: "refusal"`

The `haiku` alias only means Haiku 5.5 on the Anthropic API

2. Use uppercase `K`