Claude Opus 5.5 API Pricing: Half of Anthropic's Standard Price, Task by Task

Claude Opus 5.5 costs $2.02 per million input tokens and $10.08 per million output tokens on HiAPI, half of Anthropic's standard price of $4 and $20. It's the same claude-opus-5-5 model, with the same 1M-token context window and 128K-token output limit, called through an OpenAI-compatible endpoint.

Anthropic prices from its pricing page; HiAPI prices from the live HiAPI price list. Both checked October 6, 2026.

What One Task Costs

Per-token prices are hard to picture, so here are four common jobs priced out. The token counts are typical sizes for each job; your own counts will vary, but the ratio stays the same.

Each line is input tokens × input price + output tokens × output price. At 1,000 pull request reviews a month, that's $160 at Anthropic's standard price and $80.72 on HiAPI.

Two things raise the bill more than people expect:

• Thinking counts as output. Opus 5.5 always thinks before it answers, and those thinking tokens are billed at the output rate. A higher effort setting means more thinking, so more output tokens.
• Long documents add up on the input side. The 150-page summary writes only 3,000 tokens, but reading 200,000 tokens makes it the most expensive job in the table.

What That Money Buys: A Sample Review

Here is the kind of answer you pay for. We gave Claude Opus 5.5 a short checkout function and asked for a code review:

def apply_discount(cart, code):
    discounts = {"SAVE10": 0.10, "SAVE20": 0.20}
    rate = discounts.get(code.upper())
    total = sum(item["price"] * item["qty"] for item in cart)
    if rate:
        total = total - total * rate
    return round(total, 2)

Claude Opus 5.5's review:

1. code.upper() crashes when no code is entered. If code is None, this raises AttributeError. Use (code or "").strip().upper().
2. Money as floats. price * qty in floating point can drift by a cent across many items, and round() uses banker's rounding. Store prices in cents (integers) or use Decimal.
3. Unknown codes fail silently. A typo like SAVE01 returns the full price with no signal. Return or raise something the checkout can show the customer.
4. Discount table is hard-coded. Fine for two codes; move it to config before marketing adds a third.

A review like this is a few hundred visible tokens plus thinking, so it falls in the "chat answer" to "pull request review" range above: between 1 and 8 cents on HiAPI.

Cut the Bill Further with Caching

If many requests share the same long prefix, such as a system prompt, a style guide or a codebase summary, cache it. On Opus 5.5 a cache read costs only 5% of the normal input price.

Example: a 30,000-token system prompt reused across 100 requests, each adding 1,000 new input tokens and 1,000 output tokens:

On HiAPI, add cache_control to the system message. Five-minute cache writes are supported; one-hour cache writes are not yet available.

{
  "model": "claude-opus-5-5",
  "messages": [
    {
      "role": "system",
      "content": [
        {
          "type": "text",
          "text": "Answer as a concise architecture reviewer. ...",
          "cache_control": {"type": "ephemeral", "ttl": "5m"}
        }
      ]
    },
    {"role": "user", "content": "Review this design: ..."}
  ],
  "output_config": {"effort": "medium"}
}

The usage field in each response shows how many tokens were written to or read from the cache.

Control Cost with Effort

Opus 5.5's thinking can't be turned off. You choose how much of it happens with output_config.effort: low, medium (the default), high, xhigh or max. More effort means more thinking tokens, which are billed as output.

• Use low for classification, extraction and short rewrites.
• Keep medium for most coding and writing.
• Save high and above for hard debugging, long plans and multi-step agent work.
• Set max_tokens as a hard cap. It covers thinking and the visible answer together.

Calling It on HiAPI

HiAPI serves Opus 5.5 through POST https://api.hiapi.ai/v1/chat/completions, the OpenAI Chat Completions format, so existing OpenAI SDK code works by changing the base URL, the key and the model name:

from openai import OpenAI

client = OpenAI(base_url="https://api.hiapi.ai/v1", api_key="YOUR_HIAPI_KEY")

reply = client.chat.completions.create(
    model="claude-opus-5-5",
    messages=[{"role": "user", "content": "Review this function for bugs: ..."}],
    extra_body={"output_config": {"effort": "medium"}},
    max_tokens=4096,
)
print(reply.choices[0].message.content)
print(reply.usage)

A few differences from Anthropic's own API to know before you switch:

• Thinking settings: don't send thinking or a thinking budget. Use output_config.effort only.
• Tools: use tool_choice: "auto". Forcing a specific tool returns an error.
• Caching: five-minute cache writes only.
• Batch API and fast mode: these are Anthropic-only features. Anthropic's Batch API is also 50% off ($2/$10), but results come back asynchronously: most batches finish within an hour, and a batch can take up to 24 hours. HiAPI's price applies to normal real-time requests.

For curl examples, streaming and error handling, see the Claude Opus 5.5 API quickstart. To try a prompt in the browser first, open the Claude Opus 5.5 model page.

FAQ

How much does the Claude Opus 5.5 API cost?

Anthropic's standard price is $4 per million input tokens and $20 per million output tokens. On HiAPI it is $2.02 and $10.08, half the standard price.

Is Claude Opus 5.5 cheaper than Opus 5?

Yes. Anthropic cut the price from $5/$25 for Opus 5 to $4/$20 for Opus 5.5, and cache reads from $0.50 to $0.20. On HiAPI, Opus 5.5 is $2.02/$10.08.

Are thinking tokens billed?

Yes, as output tokens. Opus 5.5 always uses thinking; lower effort to use fewer thinking tokens.

What is the model ID for Claude Opus 5.5?

claude-opus-5-5, on both Anthropic's API and HiAPI.

How big is the Claude Opus 5.5 context window?

1 million tokens of input, with up to 128,000 tokens of output. Long inputs are billed at the same per-token rate as short ones.

Can I turn off thinking on Claude Opus 5.5?

No. Thinking is always on. Use output_config.effort: "low" for the least thinking.