Claude Haiku 5.5 vs Gemini 4 Carbon

vs

Which one, when

claude-haiku-5-5 and gemini-4-carbon both read text and images across about a million tokens of context (1000000 and 1048576), but the rate cards are far apart: $0.1 input and $0.5 output against $2 and $10, 20x on both, with cache reads at $0.01 against $0.1. Pick claude-haiku-5-5 for high-volume text and image work, replies up to 128000 tokens, or thinking you can switch off. Pick gemini-4-carbon when the input includes audio or video, which claude-haiku-5-5 does not take.

Benchmarks

Claude Haiku 5.5: the vendor has not published benchmark scores.

Above averageNo peer higherGemini 4 Carbon12 / 1210 / 12
Claude Haiku 5.5 Gemini 4 Carbon other models measured peer average ★ no peer scored higher
FrontierSWE 2 Proximal leaderboard, Carbon report
N/A
61.2%
OSWorld 2.1 82 offline tasks, partial score. Gemini: best of 3. Peers: published evaluations
N/A
81.5%
AutomationBench (Zapier) Zapier private set
N/A
no peer scored higher 53.9%
GraphWalks BFS (F1) 256k to 1M tokens, 200 tasks, Google evaluation
N/A
no peer scored higher 96.2%
Blueprint-Bench 2 Similarity score, Andon Labs leaderboard
N/A
no peer scored higher 58.6%
Vending-Bench 2 (USD) Andon Labs leaderboard, Carbon report · 5422-16484
N/A
no peer scored higher 16484
Chartography No tools, Carbon report
N/A
no peer scored higher 72.5%

Vendor-published: Google

Pricing

Claude Haiku 5.5 Gemini 4 Carbon Δ
Input / 1M tokens $0.1 $2 0.05×
Output / 1M tokens $0.5 $10 0.05×
Cache read / 1M tokens $0.01 $0.1 0.1×
Cache write 1.25x (5m) / 2x (1h) - -

Rates from the live catalogue at build time; each model page carries the current rate card. The main table shows base rates. Prompt length can change the rate for the entire request. See each model’s full rate card.

Claude Haiku 5.5 · Rates by prompt length

The whole request uses the rate for its input-length tier. Prices are USD per million tokens.

Input tokensInputOutput
0 - 100,000 $0.1 $0.5
100,001 - 1,000,000 $0.5 $2.5

Where they sit · input price per 1M tokens across all 86 chat models on this billing unit (log scale)

Capabilities

Claude Haiku 5.5 Gemini 4 Carbon
Tool calling yes yes
Thinking control configurable always on
Structured output yes yes
Prompt caching explicit (you mark the prefix) implicit (automatic)
Cache lifetime 5m default, 1h option not published
Minimum cached prefix 512 tokens 4,096 tokens

Specs

Claude Haiku 5.5 Gemini 4 Carbon
Input modalities text image text image audio video
Output modalities text text
Released 2026-10-07 2026-11-10
Knowledge cutoff 2026-06 2026-03
Context window 1,000,000 1,048,576
Max output 128,000 65,536
Thinking parameter output_config.effort thinking_level
Accepted values
output_config.effort
  • low
  • medium
  • high
  • xhigh
  • max
thinking_level
  • low
  • medium
  • high

"minimal" and thinking_budget return 400

Default medium medium

Specs are transcribed from each vendor’s documentation; a row a vendor does not publish is left out rather than inferred. Full sources: Claude Haiku 5.5 · Gemini 4 Carbon

One prompt, both models, measured through the gateway

PROMPT Explain to a CFO, in exactly three sentences, why our LLM bill doubled after we enabled reasoning. CHECK exactly 3 sentences

Claude Haiku 5.5 passed · 3 sentences

Enabling reasoning makes the model generate a long internal chain of thought before its answer, and those thinking tokens are billed as output tokens, which cost several times more than input tokens. The model often produces many times more output per request than it did without reasoning, so the per-call cost rises even when the visible answer looks about the same length. Because that extra spend scales with every request, the bill roughly doubled, and we can control it by setting reasoning budgets, using reasoning only for tasks that need it, or routing simpler requests to a non-reasoning model.

out 332 tok (+159 thinking) latency 2.9 s

Gemini 4 Carbon passed · 3 sentences

Enabling reasoning instructs the AI to generate a lengthy, behind-the-scenes "thought process" to verify its logic before delivering a final answer. Because our vendor bills us based on total output volume, we are charged for all of that invisible scratchpad work in addition to the visible response, effectively doubling the compute consumed per query. Moving forward, we can control this cost by restricting reasoning strictly to complex, high-stakes workflows where higher accuracy justifies the premium, while routing routine tasks back to standard, lower-cost models.

out 908 tok (+799 thinking) latency 18.0 s

Instruction following (exactly three sentences, so countable), audience shaping (CFO register), and the hidden-thinking billing gap the token meters below expose.

PROMPT This function is supposed to return the longest run of consecutive equal items, but callers report it is off by one on single-element inputs and misses runs that end at the last index. Fix it and explain the bug in one paragraph. CHECK fix passes tests

Claude Haiku 5.5 passed · 8/8 cases

```python def longest_run(xs): if not xs: return 0 best = cur = 1 for i in range(1, len(xs)): if xs[i] == xs[i - 1]: cur += 1 else: cur = 1 best = max(best, cur) return best ``` The bug is that `cur` counts adjacent equal *pairs*, not run *elements*. A run of k equal items produces k−1 matching pairs, so the function returns one less than the true length, and a single-element input produces no pairs at all, so it returns 0 instead of 1. Resetting `cur` to 0 on a mismatch compounds this by starting every run one step behind. The fix starts both `cur` and `best` at 1 (a non-empty list always has a run of at least one element), resets `cur` to 1 on a mismatch, and updates `best` after every element rather than only inside the equal-branch. The empty-list guard keeps the function from returning 1 for `[]`. […]

out 1012 tok (+591 thinking) latency 6.0 s

Gemini 4 Carbon passed · 8/8 cases

```python def longest_run(xs): if not xs: return 0 best = 1 cur = 1 for i in range(1, len(xs)): if xs[i] == xs[i - 1]: cur += 1 best = max(best, cur) else: cur = 1 return best ``` The original function counts the number of matching adjacent *transitions* rather than the number of *elements* in a run because `best` and `cur` are initialized and reset to `0` instead of `1`. Because a single item on its own already forms a run of length `1`, starting at `0` causes every non-empty result to be short by one: single-element lists (where the loop never executes) and lists with no duplicates return `0` instead of `1`, and any run of $k$ equal items—including one ending at the last index—only increments `cur` $k - 1$ times, making it appear as though the final element of the run was missed. […]

out 1411 tok (+1131 thinking) latency 32.7 s

Whether the fix is actually correct (runnable), explanation density, and token efficiency on a bounded task.

PROMPT Extract a JSON object with fields {company, quarter, revenue_usd_m, growth_pct, guidance} from this text. Use null for anything not stated; add no other fields. CHECK valid JSON, schema exact

Claude Haiku 5.5 passed · 5/5 fields, guidance "Formal guidance withheld pending the Q4 "

```json { "company": "Meridian Robotics", "quarter": "September quarter", "revenue_usd_m": null, "growth_pct": 11, "guidance": "Formal guidance withheld pending the Q4 close" } ``` Notes: The text gives revenue as 412 but doesn't state the currency, so I left `revenue_usd_m` as null. Growth is "eleven and change," so 11 is an approximation.

out 725 tok (+572 thinking) latency 4.6 s

Gemini 4 Carbon passed · 5/5 fields, guidance null

```json { "company": "Meridian Robotics", "quarter": "September quarter", "revenue_usd_m": null, "growth_pct": null, "guidance": null } ```

out 3338 tok (+3281 thinking) latency 61.6 s

Schema obedience (no invented fields), hallucination pressure (guidance is explicitly withheld), and structured-output path differences.

PROMPT Write a 120-word product announcement for an API gateway feature that caches prompts across providers. Forbidden words: "seamless", "unlock", "game-changer", "revolutionize", "empower". Exactly one sentence must be a question. CHECK 120 words, 0 banned words

Claude Haiku 5.5 passed · 120 words, 0 banned, 1 question

**Introducing Prompt Cache Sync, the newest feature in GatewayOne.** Teams routing requests across OpenAI, Anthropic, and Google have often paid to process the same long system prompts again and again. Now the gateway stores those prompts once and reuses them wherever they appear, regardless of provider. Repeated context is matched by content hash, so cached prefixes return faster and cost less, with no changes to your application code. How much could this save your team? Enable Prompt Cache Sync from the dashboard, and your next billing report will show the difference. Cache entries follow your existing retention settings and can be purged per project at any time. Availability begins this week for all Scale and Enterprise plans worldwide. Start today.

out 2164 tok (+1929 thinking) latency 9.9 s

Gemini 4 Carbon passed · 120 words, 0 banned, 1 question

Are your engineering teams paying multiple AI vendors to generate identical responses? Today, we are introducing Universal Prompt Caching for our flagship API Gateway. When applications route traffic across providers like OpenAI, Anthropic, and Mistral, duplicate queries drain budgets and degrade user experiences. Our new unified caching layer intercepts incoming prompts directly at the network edge. If an identical request was previously fulfilled by any connected model, the gateway delivers the stored response in milliseconds, completely bypassing external API calls. This practical upgrade cuts monthly token expenses substantially while accelerating overall application speed. Best of all, deployment requires zero complex code changes. Simply activate this capability inside your gateway configuration dashboard today to start reducing latency and infrastructure costs immediately.

out 2620 tok (+2480 thinking) latency 31.1 s

Constraint obedience (word budget, banned-word list, the single question), style fingerprint, and length control.

Switch between them with one line

Both ids are in every tab below; the highlighted pair of lines is the only edit. Same endpoint, same key, same request shape.

from openai import OpenAI

client = OpenAI(
    base_url="https://synthorai.io/v1",
    api_key="sk-syn-...",
)

resp = client.chat.completions.create(
    model="claude-haiku-5-5",
    # model="gemini-4-carbon",  # uncomment this line, comment the one above
    messages=[{"role": "user", "content": "Summarize this diff"}],
    reasoning_effort="medium",
)
print(resp.choices[0].message.content)

Get your API key →

FAQ

Which is cheaper, Claude Haiku 5.5 or Gemini 4 Carbon?

The main table shows base rates. Prompt length can change the rate for the entire request. See each model’s full rate card.

Can I A/B test Claude Haiku 5.5 against Gemini 4 Carbon without two integrations?

Yes. Both are served through the same OpenAI-compatible endpoint with one API key. Switching is a one-line change to the model id, so you can route a fraction of traffic to each and compare bills directly.

Do Claude Haiku 5.5 and Gemini 4 Carbon support prompt caching?

Yes. Both bill cache reads below their input rate, so warm-prefix workloads cost less than the list rates suggest. The exact cache-read rows are in the pricing table above.

Related comparisons

From our measured studies