Claude Haiku 4.5 through the API

The work Haiku 4.5 is built to absorb

Claude Haiku 4.5 is the fastest and lowest-cost model in the Claude family, and you reach it through the standard Anthropic Messages API with the model ID claude-haiku-4-5 — same request shape, same headers, same streaming as Sonnet or Opus. It is the right default for any workload where latency and per-token price matter more than deep reasoning. Through apiToken.sale it runs on prepaid balance at a flat 50% below official rates, with no subscription and no waitlist.

Haiku earns its keep at the edges of a pipeline, where requests are short, frequent and interchangeable:

• Classification and tagging: support tickets, content moderation, intent detection — short inputs, short outputs, thousands of calls a day.
• Extraction and parsing: pull structured fields from invoices, emails, logs or HTML before a larger model ever sees the data.
• Routing and triage: decide which model or tool should handle a request, then escalate only the hard ones.
• Latency-sensitive chat: agent inner loops, tool-call glue and autocomplete-style UX where the user is staring at a spinner.
• Cheap pre-processing: summarizing, cleaning and chunking long context ahead of an Opus or Sonnet call.

Haiku is the wrong tool for deep multi-step reasoning, high-stakes analysis and very long generation. If a task keeps failing your quality bar, that is a routing decision, not a prompting problem — send it to Sonnet or Opus instead.

See also: Claude Sonnet API access: Sonnet 5 and Sonnet 4.6

Model ID, context window and output ceiling

There is one current Haiku ID to memorize: claude-haiku-4-5. It accepts the full Messages API feature set — system prompts, multi-turn messages, tool use, streaming and prompt caching — inside a 200K-token context window with a 64K-token maximum output. Both ceilings are smaller than the Opus and Sonnet line, which matters if you batch large documents into single calls.

The Messages API requires max_tokens on every request, streaming or not. Set it to the largest response you actually expect rather than the model ceiling — an unconstrained cap plus a verbose habit is how a cheap workload quietly becomes an expensive one.

Your first Haiku request

1. 01Create an account and generate a key from the dashboard — it looks like sk-pool-… and works across every supported Claude, GPT, Gemini and Kimi model.
2. 02Point any Anthropic-compatible client at the router: set ANTHROPIC_BASE_URL to https://router.apitoken.sale and ANTHROPIC_API_KEY to your key. The official SDKs need no other change.
3. 03Send POST /v1/messages with the x-api-key and anthropic-version headers, model set to claude-haiku-4-5, and an explicit max_tokens.

curl https://router.apitoken.sale/v1/messages \
  -H "x-api-key: sk-pool-•••" \
  -H "anthropic-version: 2023-06-01" \
  -H "content-type: application/json" \
  -d '{
    "model": "claude-haiku-4-5",
    "max_tokens": 256,
    "messages": [
      {"role": "user", "content": "Classify this ticket as billing, bug or feature: \"My invoice shows the wrong total.\""}
    ]
  }'

The response is the standard Messages shape: an array of content blocks plus a usage object with input and output token counts. That usage object is the record your balance is billed from — metered at official Anthropic rates, with the flat 50% discount subtracted before the draw.

What Haiku costs per call, per million, per month

Official pricing is $1 per million input tokens and $5 per million output tokens; here that is $0.50/$2.50 after the discount. Output tokens cost five times input tokens, so response-length discipline saves more than prompt trimming on chatty workloads.

Make it concrete: a classification call with a 600-token prompt and an 80-token answer meters 680 tokens and costs about $0.0005 at the discounted rates. A hundred thousand such calls a month lands near $50 — the kind of volume where per-token pricing stops being an abstraction and starts being a line item.

Estimate your own volume in the free cost calculator →

Keep first-token latency low with streaming

Set "stream": true and the endpoint returns server-sent events instead of one blocking response: message_start, a sequence of content_block_delta events carrying the text as it is generated, then a terminal message_delta with the final usage and message_stop. Render the deltas as they arrive and the perceived latency of a chat UI drops to the first token, which is where Haiku's speed shows. Streaming changes latency perception, not price — the same tokens are metered either way.

Take the authoritative token counts from the terminal message_delta event, not from counting deltas yourself. If a stream drops mid-generation, do not retry in a tight loop: issue one fresh request and reconcile spend from the usage you did receive.

Cache the prefix you resend on every call

High-volume loops re-send the same prefix every time: system prompt, label definitions, few-shot examples. Mark the end of that stable prefix with a cache_control breakpoint and Anthropic holds it in a short-lived cache — a five-minute TTL, refreshed on each hit. The write costs 1.25× the input rate; every subsequent read bills at 0.1×, and the 50% discount stacks on top.

Put the breakpoint after the last block that never changes and keep per-request content after it. A breakpoint on text that varies every call never hits and only costs you the write premium — on Haiku rates the premium is small, but at volume it is still wasted spend.

Claude Haiku 4.5 pricing in detail (cache rates, context, FAQ) →

Escalate the hard fraction to Sonnet or Opus on the same key

One key and one balance cover every supported model, so routing is a client-side if statement, not an infrastructure project. Send the bulk of traffic to Haiku; when the input is long, the confidence is low or the task genuinely needs multi-step reasoning, resend the same messages array with a different model field — claude-sonnet-5 or an Opus ID. Most production traffic is easy traffic, so most of your spend stays at Haiku rates while the hard requests still get a stronger model.

import anthropic

client = anthropic.Anthropic(
    base_url="https://router.apitoken.sale",
    api_key="sk-pool-•••",
)

def answer(question: str) -> str:
    triage = client.messages.create(
        model="claude-haiku-4-5",
        max_tokens=8,
        system="Reply with one word: EASY for a simple lookup or short task, HARD if it needs multi-step reasoning.",
        messages=[{"role": "user", "content": question}],
    )
    verdict = triage.content[0].text.strip().upper()
    model = "claude-sonnet-5" if verdict.startswith("HARD") else "claude-haiku-4-5"
    reply = client.messages.create(
        model=model,
        max_tokens=1024,
        messages=[{"role": "user", "content": question}],
    )
    return reply.content[0].text

Triage itself costs a Haiku call, so only route when the mix is genuinely uneven. If 95% of requests are trivial, calling Haiku directly with no triage at all is cheaper than paying an extra round trip per request.

Frequently asked questions

Related guides