Claude Fable 5.1 via API: setup, pricing and spend control

Claude Fable 5.1 is in the Zukko catalog, but it is one of the most expensive models there: $3.48 per million input tokens and $17.4 per million output tokens. If you want to connect the claude fable 5.1 api without an unexpected charge, below are the endpoints and working code, a per-request cost calculation, how caching works, and how to set up a key with a spend limit and an allowed-models list.

Claude Fable 5.1 pricing and where it sits in the catalog

Numbers first. Prices are in USD per 1M tokens, as of 2026-10-06.

For GPT a cache write is not charged separately: the first request is billed in full at the input price.

The vendor's official price for Fable 5.1 is $10 / $50; on Zukko it is $3.48 / $17.4. Inside the catalog, though, the picture is different: the intelligence index (Artificial Analysis Intelligence Index, a composite benchmark score) for Fable 5.1 is 53. That is lower than Opus 5.5 (58) and equal to GPT-6 Astra, while Fable costs more than both.

The index is an average; it does not tell you how a model will handle your specific task. But the numbers do not support picking Fable 5.1 by default on the theory that "expensive means strong". Use it deliberately, after testing.

For the current model list and prices, call GET https://api.zukko.pro/v1/models or open the Models page in the dashboard.

How to connect Claude Fable 5.1 via API

The model works in both formats, OpenAI-compatible and Anthropic. One key, fetch_..., created in the dashboard.

OpenAI-compatible format

Base URL https://api.zukko.pro/v1, endpoint POST /v1/chat/completions:

curl https://api.zukko.pro/v1/chat/completions \
  -H "Authorization: Bearer fetch_your_key" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-fable-5-1",
    "max_tokens": 1000,
    "messages": [{"role": "user", "content": "Find three weak spots in this launch plan: ..."}]
  }'

This is the easy way to plug in existing OpenAI SDK apps. The downside for Fable is significant: in the OpenAI format, all input to Claude models is billed at the input price, with no cache discount.

Anthropic format with caching

For long, repeated contexts use POST https://api.zukko.pro/v1/messages — there the gateway sees how much input came from cache and bills it at the cache-read price. The official Anthropic SDK appends /v1 itself, so the base URL goes without it:

from anthropic import Anthropic

client = Anthropic(base_url="https://api.zukko.pro", api_key="fetch_your_key")

contract = open("contract.txt", encoding="utf-8").read()

resp = client.messages.create(
    model="claude-fable-5-1",
    max_tokens=2000,
    system=[
        {"type": "text", "text": "You are a contract analyst. Answer only from the contract text."},
        {"type": "text", "text": contract, "cache_control": {"type": "ephemeral"}},
    ],
    messages=[{"role": "user", "content": "Which clauses allow unilateral termination?"}],

The block with cache_control marks the contract text for caching. Follow-up questions about the same contract read it from cache. More on the format in the /v1/messages docs↗.

Claude Code

export ANTHROPIC_BASE_URL=https://api.zukko.pro
export ANTHROPIC_AUTH_TOKEN=fetch_your_key
export ANTHROPIC_MODEL=claude-fable-5-1
claude

Note: the variable is ANTHROPIC_AUTH_TOKEN, and the URL has no /v1. Step by step in the Claude Code guide↗. An agent session sends the whole accumulated context on every step, so running Fable as your main Claude Code model is expensive. It makes more sense to work on a cheaper model and switch to Fable for specific tasks.

What a Fable 5.1 request costs

Formula without caching:

Example: 20,000 input tokens and 2,000 output tokens.

• input: 20,000 × 3.48 / 1,000,000 = $0.0696
• output: 2,000 × 17.4 / 1,000,000 = $0.0348
• total: $0.1044 per request, or $104.40 per 1,000 such requests

The same volume on Claude Opus 5.5: 20,000 × 0.4 / 1,000,000 + 2,000 × 2 / 1,000,000 = $0.008 + $0.004 = $0.012 per request, $12.00 per 1,000.

Fable's output costs five times its input (17.4 vs 3.48), so long answers hurt the budget more than long prompts. max_tokens sets the ceiling: with max_tokens=4000, one request's output costs at most 4,000 × 17.4 / 1,000,000 = $0.0696.

Caching: where it actually changes the bill

With caching the formula is: fresh input × input price + cache reads × read price + cache writes × write price + output × output price.

Take an agent step with a 100,000-token context, of which 90,000 are already cached, 10,000 are new, and the answer is 2,000 tokens:

• fresh input: 10,000 × 3.48 = 34,800
• cache read: 90,000 × 0.3 = 27,000
• output: 2,000 × 17.4 = 34,800
• total: 96,600 / 1,000,000 = $0.0966

The same step without caching (e.g. via the OpenAI format): 100,000 × 3.48 + 2,000 × 17.4 = 382,800 → $0.3828.

The first step costs more than usual: 90,000 tokens are written to cache at $3.663, i.e. 90,000 × 3.663 / 1,000,000 = $0.3297, plus $0.0348 for fresh input and $0.0348 for output — $0.3993 in total. The cache pays off from the second request that reuses the same prefix. If the context is new every time, caching does not help, and writes only add cost.

When Fable 5.1 is justified

We have no data on which specific tasks Fable 5.1 does better than other models, and we will not make it up. Practical criteria:

• You tested it on your own tasks. You ran 20–50 real examples through Fable 5.1, Opus 5.5, and GPT-6 Astra, and Fable gives a clearly better result for you.
• Low volume, high cost of error. A dozen requests a day where a bad answer costs more than $0.10 per request.
• A long context is reused. Many questions about one large document via the Anthropic format, so most input is billed at the cache-read price.

Bad fits: bulk processing, high-traffic chatbots, long agent sessions without caching. For those, look at cheaper models, weighing the intelligence index against price.

How to cap spend: key limits and allowed_models

An expensive model is best isolated with key settings. Every Zukko key has a name, a daily and monthly USD limit, and an allowed-models list, allowed_models. All of this is set on the API keys page in the dashboard.

A working setup:

1. A separate key for Fable. For example, fable-research with allowed_models set to claude-fable-5-1 only, a $5 daily limit and a $50 monthly limit. The limit caps spend on this key even if a script loops.
2. A main key without Fable. List only your working models in the main key's allowed_models. If someone sets claude-fable-5-1 in code or in IDE settings, the request gets 403 model_not_allowed_for_key instead of spending money.
3. max_tokens on every request. It caps the most expensive part, the output.
4. Watch spend. Charge history is in the dashboard's Usage section and available via API. If the balance runs out, requests get 402.

Details in the key limits and cache docs↗ and in the allowed_models article↗.

If you want to try Fable 5.1 on your tasks, create a separate key with a limit in the dashboard and connect it using the examples above.

FAQ

Why is Fable 5.1 more expensive than Opus 5.5 if its index is lower?

Price and intelligence index are not directly linked: each model has its own price, and the index is an average across a set of benchmarks. By the catalog numbers, Opus 5.5 is both cheaper and higher on the index. Fable only makes sense if it shows better results on your tasks. A detailed calculation is in the article Claude Fable 5.1 or Opus 5.5↗.

Can I call Fable 5.1 with the OpenAI SDK?

Yes, via https://api.zukko.pro/v1. But in this format there is no cache discount for Claude models: all input is billed at $3.48 per 1M. For long repeated contexts, use the Anthropic format.

Does Fable 5.1 accept images, and what is its context?

Per the catalog, yes, image input is supported, and the context is 1M tokens. Keep in mind that images also become input tokens billed at the input price.

How do I keep an agent from accidentally switching to Fable?

Leave claude-fable-5-1 out of allowed_models for the key the agent uses. Requests to it will then return 403 model_not_allowed_for_key.