Claude Haiku 5.5 is Anthropic's fastest model, released on October 7, 2026 and built for high-volume, latency-sensitive work such as classification, extraction, routing and subagent tasks.
- Input
- text image $0.1/M
- Output
- text $0.5/M
- Cache read
- $0.01/M
- Context
- 1M
- vs GPT-4o
- ~98% cheaper
- Knowledge cutoff
- 2026-06
Prompts over 100K tokens: the whole request bills at $0.5/M input · $2.5/M output
Price in context
Where the price sits among 68 comparable models
The bar shows how this model’s price compares with every other model of the same kind on Synthorai. The cheapest and the most expensive are named at each end. These are base rates; batch, region and cache-write discounts are on the pricing page.
Specs & limits
Tokens
| Context window (vendor spec) | 1,000,000 |
|---|---|
| Max output (vendor spec) | 128,000 |
| Knowledge cutoff | 2026-06 |
Prompt caching
| How it caches | explicit (opt-in) |
|---|---|
| Min prefix | 512 provider default is 1,024 |
| Lifetime | 5m default, 1h option |
| Write cost | 1.25x (5m) / 2x (1h) |
Thinking
| Vendor control | output_config.effort |
|---|---|
| Accepted values | low · medium · high · xhigh · max |
| Default | medium applied when the request sets nothing |
| Can be turned off | Yes |
| Thinking behaviour | Adaptive thinking is on by default. thinking {"type": "disabled"} turns it off at high effort or below and returns a 400 error at xhigh or max; a manual {"type": "enabled", "budget_tokens": N} and "between_tools" both return a 400 error. |
| Parameter | reasoning_effort |
| Values | minimal · low · medium · high the gateway's parameter surface; the vendor mapping above applies |
Model
| Modalities | text + image → text |
|---|
- Priced by prompt length: a prompt over 100,000 tokens is billed at 5x on input, output and every cache rate ($0.50 in, $2.50 out per million)
- prompt-cache reads cost 0.1x input on both tiers
- minimum cacheable prompt 512 tokens
- setting temperature, top_p or top_k to a non-default value returns a 400
- assistant message prefill returns an error
- thinking blocks work only in the account that produced them
- up to 300k output tokens on the Message Batches API with the output-300k-2026-03-24 beta header
One prompt, measured through the gateway
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
Instruction following (exactly three sentences, so countable), audience shaping (CFO register), and the hidden-thinking billing gap the token meters below expose.
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
Whether the fix is actually correct (runnable), explanation density, and token efficiency on a bounded task.
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
Schema obedience (no invented fields), hallucination pressure (guidance is explicitly withheld), and structured-output path differences.
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
Constraint obedience (word budget, banned-word list, the single question), style fingerprint, and length control.
Use Claude Haiku 5.5 in 30 seconds
OpenAI-compatible: swap the base_url, keep your SDK. POST /v1/chat/completions
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",
messages=[{"role": "user", "content": "Summarize this diff"}],
reasoning_effort="medium",
)
print(resp.choices[0].message.content)import OpenAI from "openai";
const client = new OpenAI({
baseURL: "https://synthorai.io/v1",
apiKey: "sk-syn-...",
});
const resp = await client.chat.completions.create({
model: "claude-haiku-5-5",
messages: [{ role: "user", content: "Summarize this diff" }],
reasoning_effort: "medium",
});
console.log(resp.choices[0].message.content);curl https://synthorai.io/v1/chat/completions \
-H "Authorization: Bearer sk-syn-..." \
-H "Content-Type: application/json" \
-d '{
"model": "claude-haiku-5-5",
"messages": [{"role": "user", "content": "Hello"}],
"reasoning_effort": "medium"
}'package main
import (
"context"
"fmt"
"github.com/openai/openai-go/v3"
"github.com/openai/openai-go/v3/option"
)
func main() {
client := openai.NewClient(
option.WithBaseURL("https://synthorai.io/v1"),
option.WithAPIKey("sk-syn-..."),
)
resp, _ := client.Chat.Completions.New(context.TODO(), openai.ChatCompletionNewParams{
Model: "claude-haiku-5-5",
Messages: []openai.ChatCompletionMessageParamUnion{
openai.UserMessage("Summarize this diff"),
},
ReasoningEffort: openai.ReasoningEffortMedium,
})
fmt.Println(resp.Choices[0].Message.Content)
}import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.chat.completions.*;
import com.openai.models.ReasoningEffort;
OpenAIClient client = OpenAIOkHttpClient.builder()
.baseUrl("https://synthorai.io/v1")
.apiKey("sk-syn-...")
.build();
ChatCompletion resp = client.chat().completions().create(
ChatCompletionCreateParams.builder()
.model("claude-haiku-5-5")
.addUserMessage("Summarize this diff")
.reasoningEffort(ReasoningEffort.MEDIUM)
.build());
System.out.println(resp.choices().get(0).message().content().orElse(""));About Claude Haiku 5.5
- It is priced by prompt length: a prompt of up to 100,000 tokens costs $0.10 per million input tokens and $0.50 per million output tokens, and a prompt over 100,000 tokens costs $0.50 and $2.50.
- Prompt-cache reads are 10% of the input price on both tiers ($0.01 and $0.05 per million), 5-minute cache writes are $0.125 and $0.625, and 1-hour cache writes are $0.20 and $1.
- The context window is 1M tokens and the maximum output 128K, up from 200K and 64K on Claude Haiku 4.5, and the model accepts text and image input.
- Adaptive thinking is on by default with a default effort of medium; thinking can still be turned off with a disabled thinking block at high effort or below, while a manual budget_tokens request returns a 400.
- Setting temperature, top_p or top_k to a non-default value also returns a 400, and so does an assistant message prefill.
- Anthropic notes that the model uses the newer tokenizer introduced with Claude Opus 4.7, so the same text counts as roughly 30% more tokens than on Claude Haiku 4.5.
- The minimum cacheable prompt is 512 tokens.
- Synthorai serves Claude Haiku 5.5 through the same OpenAI-compatible API as the rest of the fleet.
FAQ
Is the Claude Haiku 5.5 API free to try?
Yes: new accounts get 10 trial calls and up to $1 in free credit, no card required. At $0.1/M input tokens, that credit alone covers roughly 1,250 requests of ~8K tokens against Claude Haiku 5.5.
What is Claude Haiku 5.5 best at?
Anthropic's fastest model, for high-volume, latency-sensitive work; priced by prompt length: $0.10 in, $0.50 out per million up to 100K tokens; 1M context, 128K output, adaptive thinking with effort control. See the About section for the full picture from the vendor's own release notes.
How much does Claude Haiku 5.5 cost?
Claude Haiku 5.5 costs $0.1 per million input tokens and $0.5 per million output tokens on Synthorai. That is the provider's list price, with no platform markup. Cached input tokens bill at $0.01/M.
What is Claude Haiku 5.5's context window?
Claude Haiku 5.5 has a context window of 1M tokens on Synthorai. A single response can be up to 128,000 tokens long.
Does Claude Haiku 5.5 support prompt caching?
Yes, via opt-in: mark stable prefixes with cache_control breakpoints. Cached input tokens bill at $0.01/M vs $0.1/M uncached; prompts need a 512-token stable prefix to cache (TTL 5m default, 1h option). Prompt caching guide →
How do I get access to Claude Haiku 5.5?
Point your existing OpenAI SDK at base_url="https://synthorai.io/v1", set model="claude-haiku-5-5", and you're done. One API key covers every model on the gateway.
What is Claude Haiku 5.5's knowledge cutoff?
Claude Haiku 5.5's knowledge cutoff is 2026-06, per the vendor's official documentation (as of 2026-10-08).
Related models
Compare
Every value on this page is transcribed from the vendor's own documentation, linked above, and carries the date it was checked. Prices are compared across the catalogue; specification values that vendors define differently are shown with the difference stated rather than charted. Nothing here is measured by us, and nothing is scored.