Claude Fable 5.2 API: First Call, Cost and 4 Traps

To use the Claude Fable 5.2 API, set model to claude-fable-5-2 in your OpenAI client and keep everything else, but watch four traps: three requests Anthropic refuses for this model (forced tool use, turning thinking off, plain JSON mode) and one parameter that is ignored (temperature and its neighbours). One answer to one question cost between 70.458 and 140.096 credits depending on effort, about KES 5.20 to KES 10.35, calculated on 10 November 2026 with the 12% discount in force. The details follow, with code and a real answer.

This guide does not compare Fable 5.2 with another model. It answers one question: what happens when you plug claude-fable-5-2 into code that already works? Anthropic released it on 9 November 2026. The token counts, latencies and capabilities below come from our own runs on 10 November 2026.

What one answer costs: three effort levels

Same prompt, three values of output_config.effort, run by us on 10 November 2026 on claude-fable-5-2. All three stopped at end_turn, so these are complete answers, not truncated ones. These calls went directly to Anthropic: tokens and latencies are measured, credits are calculated (tokens times our rate card, not a billed amount).

The charged rate on 10 November 2026 is 15.453 credits per 1,000 input tokens and 77.273 credits per 1,000 output tokens. That is a 12% discount on the list price (17.56 and 87.81 credits), running until 31 December 2026; after that date the same runs would cost about 12% more. Re-read the model page before you budget, because prices and discounts move. The KES column uses the live rate read on 10 November 2026: 1 credit = KES 0.07385 (fxRate 0.221568). The same day, 1 credit was also 2.2871 UGX, 0.8431 RWF and 0.0116 ZMW. Exchange rates move with the market, so the amount you pay in your currency is the one shown at checkout when you top up.

One question costs a few shillings (KES 5.20 to KES 10.35 here), and effort roughly doubles the bill from low to xhigh (70.458 to 140.096 credits on this test). Call this model when the answer is worth that price, not to say hello.

A caution on Anthropic's own figures. In the model's system card (§8.4), effort moves the cost per task about 21 times ($2.10 to $44.70). That was measured on a long agentic coding benchmark, where higher effort buys more turns and more subagents. Do not carry that multiplier over to a single call: on ours the ratio is about 2.

One thing that changes invoices: this model's default effort is high, while Opus 5.5 defaults to medium. If you change the model string and nothing else, you have also changed the effort.

The first call

OpenAI code changes only by key, base URL and model (base URL docs). Key sk-tch-…, base URL https://tchavi.com/api/v1:

import OpenAI from 'openai';

const client = new OpenAI({
  apiKey: process.env.TCHAVI_API_KEY, // sk-tch-...
  baseURL: 'https://tchavi.com/api/v1',
});

const res = await client.chat.completions.create({
  model: 'claude-fable-5-2',
  messages: [
    {
      role: 'user',
      content:
        'A mobile money API sometimes returns HTTP 200 while the transaction failed at the operator. We credit from the webhook, never from the client callback. What are the three most serious risks left?',
    },
  ],
});

console.log(res.choices[0].message.content);

The Anthropic-format /v1/messages endpoint works too. Capabilities read from our key on 10 November 2026 (GET /v1/models/claude-fable-5-2): 1,000,000 input tokens, 128,000 output tokens, image and PDF input, structured outputs, batch, citations, code execution, context management, server tools (web search, code execution), effort low, medium, high, xhigh or max, adaptive thinking only. Released 9 November 2026.

Four traps: three refused requests, one ignored parameter

These are Anthropic's documented behaviours for this model, read on its Models API and in its documentation on 10 November 2026. Tchavi passes your requests through: we have not yet replayed these three refusals through our own API, except the fourth, which our code confirms. If you are migrating code that worked on another model, this is where it may break.

1. Forced tool use is refused by Anthropic

tool_choice: {"type":"any"}, or naming a tool, is rejected by Anthropic for this model. Three ways out:

• Send tool_choice: "auto" and say in the prompt which tool to call: "Call the create_order tool with this data."
• Put strict: true on the tool so arguments are still validated against your schema (behaviour described by Anthropic, not tested by us through the OpenAI format).
• If the forced call only existed to get JSON back, use a structured output (trap 4).

const res = await client.chat.completions.create({
  model: 'claude-fable-5-2',
  tools: [createOrderTool],
  tool_choice: 'auto', // not { type: 'function', function: { name: ... } }
  messages: [
    {
      role: 'user',
      content: 'Call the create_order tool for: 2 wax prints, delivery to Nairobi.',
    },
  ],
});

2. Sampling parameters are refused by Anthropic, Tchavi drops them

temperature, top_p and top_k are refused by Anthropic for this model. Tchavi drops them rather than failing your request, so your call goes through without an error. But they have no effect: a test that relied on temperature: 0 for reproducibility no longer has it.

3. Thinking cannot be turned off

Anthropic's Models API reports disabled, between_tools and enabled all as unsupported, so a request that tries to switch thinking off is refused. The only control is output_config.effort. Anthropic's prompting page adds that at high the model thinks before almost every reply, "including a reply to a greeting". That makes it the wrong tool for a cheap chatbot: you would pay for reasoning to say hello. For that use case, pick a lighter model.

4. Plain JSON mode is refused

response_format: {"type":"json_object"} has no Anthropic equivalent. This one we did verify in our own code (anthropic-translator.ts): the proxy refuses it for Claude models and points to json_schema, with your schema. That is forwarded to Anthropic as output_config.format.

const res = await client.chat.completions.create({
  model: 'claude-fable-5-2',
  messages: [{ role: 'user', content: 'Extract the amount and currency: "KES 12,500"' }],
  response_format: {
    type: 'json_schema',
    json_schema: {
      name: 'payment',
      strict: true,
      schema: {
        type: 'object',
        properties: { amount: { type: 'number' }, currency: { type: 'string' } },
        required: ['amount', 'currency'],
        additionalProperties: false,
      },
    },
  },
});

Proxy errors follow the format in the errors documentation.

One last constraint, on Anthropic's side: this model requires 30-day data retention, so it is not served under zero data retention. If your contract forbids that, choose another model.

A real answer, on our own subject

We asked it the question from the code above (in French, our canonical language): a mobile money API sometimes returns HTTP 200 while the transaction failed at the operator, we credit from the webhook and never from the client callback, what are the three most serious risks left? The answer (119 input tokens, 888 output, end_turn, 70.458 calculated credits, run of 10 November 2026 at low effort) opens with "Crediting from the webhook is the right choice, but three serious flaws remain" (our translation of the French original) and names them:

1. A forged or lying webhook. Verify the HMAC signature on the raw body with a constant-time comparison, never credit on the webhook's word alone but query the operator's status API server to server, and compare amount, currency and reference with the original order.
2. Double credit. A unique constraint on the operator's transaction id, and the credit plus the state change in a single SQL transaction, with a conditional transition such as UPDATE ... SET status='credited' WHERE id=? AND status='pending'.
3. A missing, late or later-contradicted webhook. A reconciliation job for transactions left pending, a daily comparison with the operator's settlement statement, and handling of reversals.

It concludes that if you could do only one thing, actively checking the status before crediting, combined with the daily reconciliation, covers the exact flaw described. The three risks are real and the remedies are standard. It is not proof of quality in general: it is one question, one run.

Should you start with Fable 5.2?

Anthropic suggests trying it when your tests on Opus 5.5 at higher effort still fall short. Choosing between the two is a separate question, covered in Claude Fable 5.2 vs Opus 5.5. If you have no failing test yet, start with Claude Sonnet 5.5: same key, same URL, you only change the model field.

FAQ

How do I call the Claude Fable 5.2 API with the OpenAI SDK?

Set baseURL: 'https://tchavi.com/api/v1', your sk-tch-… key and model: 'claude-fable-5-2'. Anthropic's /v1/messages format works too.

How much does one Claude Fable 5.2 answer cost?

On one prompt run on 10 November 2026: 70.458 calculated credits (KES 5.20) at low effort, 92.573 (KES 6.84) at high, 140.096 (KES 10.35) at xhigh, including the 12% discount that runs until 31 December 2026. The charged rates are 15.453 and 77.273 credits per 1,000 tokens (input and output), against 17.56 and 87.81 at list price.

Why does my forced tool_choice fail?

Anthropic refuses forced tool use for this model. Send tool_choice: "auto" and name the tool in the prompt, add strict: true on the tool, or use a structured output if you only wanted JSON.

Can I turn off thinking on Claude Fable 5.2?

No. Only output_config.effort (low to max) sets the intensity. The default effort is high.

Does temperature work on Claude Fable 5.2?

No: Anthropic refuses it for this model. Tchavi drops it so your call goes through, but it has no effect.

How do I get valid JSON?

Not with json_object, which our proxy refuses for Claude models. Use a response_format of type json_schema with your schema.

Can I try it with the signup credits?

Eligible new accounts receive 50 trial credits once, when the email is verified. That does not cover a full test (70.458 credits at low effort). Top up with mobile money, no bank card.

create your account and top up with mobile money

This article is part of the series "Building an AI product from Africa". Tchavi is an OpenAI-compatible AI API gateway: one key gives access to over 100 text, image, audio and video models, and you pay for it with mobile money, no bank card (countries and operators). More guides on the blog. Follow us: LinkedIn and X.