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

> Claude Fable 5.2 on Tchavi: a first call, what one answer costs (70 to 140 credits, 12% off) and four traps: three refused requests, one ignored parameter.

- Published: 2026-11-10
- Author: Gael — Tchavi founder
- Canonical: https://tchavi.com/en/blog/claude-fable-5-2-api-first-call-four-refusals

---


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).

| Effort | Input tokens | Output tokens | Credits (calculated) | KES   | Latency |
| ------ | ------------ | ------------- | -------------------- | ----- | ------- |
| low    | 119          | 888           | 70.458               | 5.20  | 11.3 s  |
| high   | 120          | 1,174         | 92.573               | 6.84  | 14.9 s  |
| xhigh  | 120          | 1,789         | 140.096              | 10.35 | 22.4 s  |

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](https://tchavi.com/en/m/anthropic/claude-fable-5-2) 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](https://tchavi.com/en/docs/base-url)). Key `sk-tch-…`, base URL `https://tchavi.com/api/v1`:

```javascript
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).

```javascript
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`.

```javascript
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](https://tchavi.com/en/docs/errors).

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](https://tchavi.com/en/blog/claude-fable-5-2-vs-opus-5-5). If you have no failing test yet, start with [Claude Sonnet 5.5](https://tchavi.com/en/blog/claude-sonnet-5-5-now-on-tchavi): 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](https://tchavi.com/en/register?next=%2Fdashboard%2Fbilling%3Ffrom%3Dblog-fable-5-2-en)

> _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](https://tchavi.com/en/docs/payments)). More guides on [the blog](https://tchavi.com/en/blog). Follow us: [LinkedIn](https://www.linkedin.com/company/tchavi) and [X](https://x.com/tchaviai)._