·7 min read
✦

Claude Fable 5.2 Is on Antbase — $8/$40 per 1M, 20% Under 5.1, and Three Parameters That Will 400 Your Existing Code

Anthropic's most capable widely released model is cheaper than the one it replaces: $8 per 1M in, $40 out, against 5.1's $10/$50. It is already catalogued and answering on Antbase. It also quietly removed three request parameters your current code probably still sends — here is the full list, verified end to end.

AntbaseClaudeClaude Fable 5.2Anthropicpricingroutingmigration

Claude Fable 5.2 is out — Anthropic's most capable widely released model, built for long-horizon work: large coding projects, research, analysis that runs for hours rather than seconds. It has a 1M-token context window, up to 128K output tokens, and it checks its own work as it goes.

There are two quite different ways to get at it, and it is worth being clear about which one you want. If you are a person typing into Claude, it arrives in the model selector on your plan, metered against your seat: on Team plans Fable is included up to half of each member's weekly usage limit, and from 16 November 2026 standard seats keep using it only through organisation usage credits. That is a sensible shape for a seat-based product, and nothing below is a criticism of it.

But if you are building software, you do not want a seat, a weekly percentage, or a date in the calendar to plan around. You want a model string, a price per token, and a bill that scales with what you actually send. That is the version of Fable 5.2 this post is about, and it is already live here.

What it costs

Per 1M tokens, input / output, as catalogued today:

  • •Fable 5.2 — $8.00 / $40.00
  • •Fable 5.1 — $10.00 / $50.00
  • •Fable 5 — $10.00 / $50.00
  • •Fable 5.2, batch route — $4.00 / $20.00

Read the first two lines together. The newest and most capable model in the line is 20% cheaper on both input and output than the one it succeeds. That is not the usual direction of travel for a frontier release, and it means the upgrade is one of the rare ones with no cost argument against it: if you are on 5.1 today you are paying more for less.

The batch route halves it again, to $4/$20, if your work tolerates asynchronous turnaround. For anything you are not watching a user wait on — overnight document processing, backfills, evaluation runs — that is the line to look at, not the first one.

Antbase adds nothing on top of any of these. No percentage markup on tokens, no orchestration fee, no per-seat charge — both fee defaults are pinned at zero by a test that fails the build if either moves.

Verified, not assumed

A catalogue row is a claim, not a capability. The hard-won rule in this codebase is that a model id can look correct, resolve somewhere you did not intend, and return a cheerful 200 from something other than the model you asked for. So every route gets a real request before it is believed, and the response is checked for which model actually served it:

text
route        status    latency    reply   served as                      tokens
route A      HTTP 200    2128ms    "ok"    anthropic/claude-fable-5.2     18 / 17
route B      HTTP 200    2789ms    "ok"    claude-fable-5-2               18 / 17

Both echo back a real 5.2 identifier rather than silently substituting a sibling, which is the specific failure this check exists to catch. A third catalogued route was not serving at the time of writing; no request noticed, because the model string does not name a provider and the orchestrator picks from whatever is healthy.

Now look at the token counts. A two-character answer cost 17 output tokens. Thinking is always on in this model and the reasoning is billed, so there is no such thing as a cheap short reply from Fable 5.2 — budget accordingly, and do not benchmark it on one-word questions.

Three parameters that now return 400

This is the part that will cost you an afternoon if nobody tells you, so here it is plainly. Fable 5.2 removed request parameters that worked fine on older Claude models, and the failure mode is a 400, not a warning:

  • •`temperature`, `top_p`, `top_k` — rejected outright. Not ignored, not clamped: the request fails.
  • •`thinking: {type: "disabled"}` and `thinking: {budget_tokens: N}` — both rejected. Thinking cannot be turned off and has no fixed budget any more. Use `output_config.effort` (`low` through `max`) to control depth instead.
  • •Assistant message prefill — rejected. If you were steering output format by pre-filling the assistant turn, switch to structured outputs or a system instruction.
  • •Forced tool choice (`tool_choice: {type: "any"}` or `{type: "tool", ...}`) — rejected. Use `auto` with `strict: true` on the tool and name the tool in the prompt.

The sampling one is handled for you here. Antbase strips `temperature` and `top_p` before they reach any model in the Fable family, because an earlier version of this exact problem — a plain Fable call 400ing on a sampling parameter and failing over to a different provider — is already in the codebase as a fixed bug. The guard matches the family rather than a version list, so 5.2 inherited the fix on the day it appeared. The other three you will need to handle in your own request builder.

One more thing worth knowing before you put it in front of an auditor: the raw chain of thought is never returned on this model. You can ask for a readable summary of the reasoning, but the unedited thinking is not available at any setting. If your compliance story depends on logging exactly what the model thought, that is a design constraint, not a configuration option.

How to call it

bash
curl https://antbase.ai/v1/chat/completions \
  -H "authorization: Bearer $ANTBASE_KEY" \
  -H "content-type: application/json" \
  -d '{
    "model": "anthropic/claude-fable-5.2",
    "messages": [{"role": "user", "content": "Refactor this module and explain the tradeoffs."}],
    "max_tokens": 8000
  }'

Give `max_tokens` real headroom, as above. On a model that always thinks, a tight output cap is consumed by reasoning before the answer starts, and you get an empty string back that looks exactly like an outage. If you would rather not choose at all, `ant:best` weights quality at the maximum and picks the strongest healthy model for the request.

Leave the id unpinned and you get the cheapest healthy route. Prefix it with a provider when you need the route to be reproducible — under audit, or when you are comparing two of them deliberately. Pinning is the right call less often than people think: it trades away the failover that makes the unpinned form worth using.

On effort, which is the dial that matters now

With sampling parameters gone and thinking permanently on, `output_config.effort` is the only real control you have over how hard the model works, and it runs `low`, `medium`, `high`, `xhigh`, `max`. The useful advice is narrower than the range suggests: start at `high`. Gains above it are uneven, so `xhigh` earns its cost only where you have measured one, and `max` is for finding the ceiling rather than for production.

Downward is where the money is. Routine work frequently runs just as well at `medium`, and lower effort on a newer model often beats high effort on the one it replaced — which is the whole reason the 20% price cut compounds rather than just being 20%.

What it costs to try

One honest caveat, because it is better to read it here than to hit it. The free tier — 50 requests a day, no card — runs on genuinely free models, and a frontier model at $8 per 1M input is not one of them. Accounts that have never completed a payment are also held to an average cost ceiling that Fable 5.2 sits well above. So this specific model needs credit on the account; $10 lifts the ceiling, raises your daily allowance to 1,000 requests, and is still yours to spend 1:1 on usage.

That ceiling is not a sales tactic. It exists because signup credit was being converted one-for-one into premium upstream spend, which is the single failure mode that would eventually force a real markup onto everyone else. Bring your own key instead and it does not apply at all — BYOK is exempt, and free, because the provider is billing you directly.

Open it in the playground and put it next to 5.1 on the same prompt. The price gap is the easy part to verify; whether the newer model does your particular job better at lower effort is the question actually worth ten minutes.

Try ANT routing today

Drop-in OpenAI-compatible API. Change your base URL and every request gets intelligent routing across 30+ providers.