Claude Opus 5.5 vs Sonnet 5.5 vs Fable 5: API Pricing, Reasoning Tokens and Setup (2026)
Opus 5.5 and Sonnet 5.5 are live on cocodot at 10% below the official per-token list price, and Fable 5 is now 15% below the official per-token list price. How to split work between them, what one request really costs, why Opus 5.5 can return an empty reply, and how to point Claude Code at it.
1. What changed: two 5.5 models and a lower Fable 5 rate
Three things moved at once. Claude Opus 5.5 is live. Anthropic positions it as the daily driver for agentic coding and enterprise work, lists it at $4 input / $20 output per million tokens, and cocodot charges $3.60 / $18 — 10% below the official per-token list price. Claude Sonnet 5.5 is live. Anthropic calls it the high-performance model for coding and agents; list is $2 / $10, and the rate here is $1.80 / $9, again 10% below the official per-token list price. Claude Fable 5 got cheaper. Its official list price is unchanged at $10 / $50, and the cocodot rate is now $8.50 / $42.50, 15% below the official per-token list price. All three are metered by the token with no subscription attached. Both Anthropic's list prices and ours can change, so quote the live pricing page in any budget rather than this article. If you want a single rule of thumb: Sonnet 5.5 for everyday work, Opus 5.5 for tasks that need a plan before they act, and Fable 5 only for the problems the first two keep getting wrong. For where Fable 5 fits as a model, see /hub/fable-5-api-china.
2. The odd one out: Opus 5.5 lists below Opus 5
This is the detail most worth checking. On Anthropic's pricing page (checked 2026-10-22), Opus 5 lists at $5 / $25 and Opus 5.5 at $4 / $20 — the newer model is a fifth cheaper per token. On cocodot the same pair is $4.50 / $22.50 versus $3.60 / $18. If your code pins claude-opus-5 and nothing forces you to keep it, switching to claude-opus-5-5 has a real chance of lowering the bill. Two things to check before flipping everything. First, per-token is not per-request: Opus 5.5 reasons before it answers, and those thinking tokens are charged at the output rate, so the only honest comparison is your own traffic measured from usage. Second, a new model can format output and call tools differently; any pipeline that parses strict JSON or relies on a fixed answer shape should be regression-tested against your eval set. The safe path is a canary: route a small slice of real requests to Opus 5.5, compare average cost and output quality against Opus 5 on the same request types, then widen. Opus 5 remains on sale, so there is no deadline forcing a one-shot migration.
3. Choosing between Sonnet 5.5, Opus 5.5 and Fable 5
The expensive mistake is picking the biggest model by default and discovering the bill a month later. A more controllable approach is to escalate on failures, not on reputation. Run 20 to 50 real tasks from your backlog through Sonnet 5.5. Take the ones it gets wrong and run only those through Opus 5.5. Take what Opus 5.5 still gets wrong and try Fable 5. You end up with a number instead of an impression — the share of your workload that actually needs a pricier tier — and that share turns straight into a budget. As a starting split: Sonnet 5.5 for completions, single-file edits, writing tests, bulk text processing and the retrieval or summarising steps inside an agent; Opus 5.5 for cross-file changes, plan-then-execute tasks and decisions where a wrong answer is costly; Fable 5, the highest-priced Claude model cocodot sells, for long agent chains and the cases the other two keep failing. All three share one key and one balance, and switching is just the model field, so routing by task type inside your own code adds almost no integration work.
4. What one request actually costs
Prices per million tokens are hard to map onto a budget, so price a single request instead: cost = input tokens x input rate / 1,000,000 + output tokens x output rate / 1,000,000. Take a typical coding question with 20,000 input tokens (context plus a few files), 2,000 output tokens and no cache hits. At current cocodot rates that is about $0.054 on Sonnet 5.5, $0.108 on Opus 5.5 and $0.255 on Fable 5, with Opus 5 at about $0.135 for reference. Remember that Opus 5.5's output count includes its thinking, so real output is usually longer than the visible answer; estimate from the usage object, never from the length of the text. Caching follows a simple rule: cache hits at half the input price; cache writes at 1.25x the input price (2x for the portion written to the 1-hour cache), the same structure as the official pricing. Be clear-eyed about what that means: Anthropic charges less than that for cache hits, so an agent that replays one huge context and lives mostly on cache hits is cheaper on that line item when it calls Anthropic directly. Where cocodot comes out cheaper is output and uncached input. The reliable way to decide is to take a week of your own usage, split it into cache hits, uncached input and output, and price each bucket on both sides.
5. Opus 5.5 thinks first: the empty-reply trap
Opus 5.5 works through the problem before it writes the answer, and those thinking tokens count as output tokens, billed at the output rate. Two practical consequences follow. A small max_tokens can return nothing. max_tokens caps thinking and answer together, so if you carry over the tiny limits you set for non-reasoning models — a few dozen or a few hundred tokens — the thinking can use the whole allowance and the answer comes back empty. We reproduced exactly this in October 2026 with max_tokens set to a few dozen. The bill follows usage, not answer length. On the OpenAI protocol, read usage.completion_tokens_details.reasoning_tokens; on the Anthropic protocol, read usage.output_tokens_details.thinking_tokens. That is the thinking share, and it is already included in the output total. Three habits help: leave headroom in max_tokens for Opus 5.5; when you get an empty reply, check whether the thinking share filled the limit before you swap models or retry (every retry is billed too); and meter cost from usage everywhere. Opus 5.5 decides how long to think on its own, so leave the thinking parameter out; in our test, sending thinking: {type: 'enabled', budget_tokens: 1024} on the Anthropic protocol returned 400 (not billed). Sonnet 5.5 showed no thinking tokens in the same minimal test, which does not prove it never reasons, so metering from usage is simply the safer default. More on reasoning models in general: /hub/reasoning-models-api-china.
6. Calling it: one key, two protocols
OpenAI-compatible: in any OpenAI SDK, set base_url to https://cocodot.co/api/ai/v1 and model to claude-opus-5-5, claude-sonnet-5-5 or claude-fable-5; the short codes mco-8 / mcs-7 / mcf-1 work as well. Anthropic-compatible: in projects built on the Anthropic SDK, set the base URL to https://cocodot.co/api/ai and send requests to /v1/messages with the same model names; authenticate with either x-api-key or Authorization: Bearer. Note that in our tests both Opus 5.5 and Sonnet 5.5 returned a 400 (not billed) when the request carried the manual thinking-budget form (thinking type enabled with budget_tokens), so leave that parameter out. The same key also reaches GPT, Gemini and other models, so you do not need a separate account and balance per vendor. One limit to know up front: only function tools are accepted. Built-in tools that run on the server side, such as web search or code execution, are not supported: listing them in tools returns 400, and the OpenAI-protocol web_search_options parameter is ignored. If your agent needs search or code execution, implement it in your own process and hand it to the model as a function tool. The three commands below check the model name, your key and both protocols before you wire anything into a project.
# 1) Confirm the model is listed (public endpoint, no key needed)
curl https://cocodot.co/api/ai/v1/models
# 2) OpenAI protocol, Opus 5.5: reasoning model, so leave max_tokens headroom
curl https://cocodot.co/api/ai/v1/chat/completions \
-H "Authorization: Bearer YOUR_KEY" \
-H "Content-Type: application/json" \
-d '{"model":"claude-opus-5-5","max_tokens":4000,"messages":[{"role":"user","content":"Explain idempotency in three sentences"}]}'
# 3) Anthropic protocol, Sonnet 5.5: same key
curl https://cocodot.co/api/ai/v1/messages \
-H "x-api-key: YOUR_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "Content-Type: application/json" \
-d '{"model":"claude-sonnet-5-5","max_tokens":1000,"messages":[{"role":"user","content":"ping"}]}'7. Running Claude Code on Opus 5.5 or Sonnet 5.5
Claude Code can be pointed at an Anthropic-compatible endpoint with environment variables; cocodot's Anthropic-compatible endpoint, which Claude Code uses, is in beta. Set ANTHROPIC_BASE_URL=https://cocodot.co/api/ai (no trailing /v1) and ANTHROPIC_AUTH_TOKEN to your key, then choose the main model with ANTHROPIC_MODEL: claude-sonnet-5-5 (code mcs-7) when cost matters most, claude-opus-5-5 (code mco-8) for hard tasks. Claude Code's default thinking mode works with both models (we tested it in October 2026), but don't set MAX_THINKING_TOKENS: neither Opus 5.5 nor Sonnet 5.5 accepts a manual thinking budget, and a request that carries one returns 400 (not billed). For the background model, set ANTHROPIC_DEFAULT_HAIKU_MODEL (older Claude Code versions read ANTHROPIC_SMALL_FAST_MODEL) to the inexpensive Haiku tier, mch-1. Open a new terminal for the change to take effect; to switch models later, change the variable and restart claude. Two cautions. Claude Code fires many requests per task with long contexts, so after switching the main model, give it one small edit first, confirm it answers normally, check what that cost in the console, and only then hand it a long job. And the function-tools-only rule above still applies: anything that needs the server to execute on your behalf, such as web search, will error, so use a local alternative. Full variable syntax, Windows setup and error fixes are in /hub/claude-code-china-direct.
8. Getting access, and a pre-production checklist
The sign-up path (from 2026-10-22): register, verify your email, complete identity verification (real name plus an email code, about a minute, free, no document upload), top up, create an API key in the console, call the API. Calls from an account that has not finished verification return 403, and the error message carries the link to the verification step. You can top up with Alipay or WeChat Pay (charged in CNY) or with a credit or debit card. Usage is deducted from the balance per token, and when the balance runs out, new requests are refused, and requests already in flight are settled at actual usage. For teams running agents, that prepaid balance works as a spending ceiling in itself; add one named key per project, revoke any key you stop using, and it becomes easy to see which project spent what. More ways to stop an agent from burning money: /hub/agent-api-cost-runaway. Before production, run this checklist: (1) pin full model names with the version, claude-opus-5-5 rather than a bare opus; (2) give Opus 5.5 max_tokens headroom for thinking; (3) meter cost from usage, not from answer length; (4) send only function tools; (5) budget against the live rates at https://cocodot.co/pricing, not the snapshot here. Ready to start: check the rates on the pricing page, register, verify, create a key, and run the curl commands above.
Claude per-token rates, USD per million tokens (checked 2026-10-22; live rates at cocodot.co/pricing)
| Model | Model name / code | Anthropic list (in / out) | cocodot (in / out) | Best used for |
|---|---|---|---|---|
| Claude Sonnet 5.5 | claude-sonnet-5-5 / mcs-7 | $2 / $10 | $1.80 / $9 (10% below the per-token list price) | Default for coding and agent sub-steps, bulk text work |
| Claude Opus 5.5 | claude-opus-5-5 / mco-8 | $4 / $20 | $3.60 / $18 (10% below the per-token list price) | Plan-then-act multi-step tasks, cross-file changes; reasoning model |
| Claude Fable 5 | claude-fable-5 / mcf-1 | $10 / $50 | $8.50 / $42.50 (15% below the per-token list price) | Long agent chains, problems the other two keep failing |
| Claude Opus 5 (reference) | claude-opus-5 / mco-7 | $5 / $25 | $4.50 / $22.50 | Existing projects you are not ready to migrate |