claude-fable-5-1

Quick example

curl https://reapi.ai/api/v1/chat/completions \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-fable-5-1",
    "messages": [
      { "role": "user", "content": "Port this module to the new API and keep going until the test suite is green." }
    ],
    "reasoning_effort": "high",
    "max_tokens": 16000,
    "stream": true
  }'

from openai import OpenAI

client = OpenAI(
    api_key="YOUR_API_KEY",
    base_url="https://reapi.ai/api/v1",
)

stream = client.chat.completions.create(
    model="claude-fable-5-1",
    messages=[{"role": "user", "content": "Port this module to the new API and keep going until the test suite is green."}],
    reasoning_effort="high",
    max_tokens=16000,
    stream=True,
)
for chunk in stream:
    delta = chunk.choices[0].delta.content if chunk.choices else None
    if delta:
        print(delta, end="")

import OpenAI from "openai";

const client = new OpenAI({
  apiKey: "YOUR_API_KEY",
  baseURL: "https://reapi.ai/api/v1",
});

const stream = await client.chat.completions.create({
  model: "claude-fable-5-1",
  messages: [{ role: "user", content: "Port this module to the new API and keep going until the test suite is green." }],
  reasoning_effort: "high",
  max_tokens: 16000,
  stream: true,
});

for await (const chunk of stream) {
  process.stdout.write(chunk.choices[0]?.delta?.content ?? "");
}

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io"
    "net/http"
)

func main() {
    body, _ := json.Marshal(map[string]any{
        "model": "claude-fable-5-1",
        "messages": []map[string]string{
            {"role": "user", "content": "Port this module to the new API and keep going until the test suite is green."},
        },
        "reasoning_effort": "high",
        "max_tokens":       16000,
    })
    req, _ := http.NewRequest("POST",
        "https://reapi.ai/api/v1/chat/completions", bytes.NewReader(body))
    req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
    req.Header.Set("Content-Type", "application/json")

    resp, _ := http.DefaultClient.Do(req)
    defer resp.Body.Close()
    out, _ := io.ReadAll(resp.Body)
    fmt.Println(string(out))
}

Authentication

Use your reAPI API key — the same key that calls the image, video and audio endpoints — as a bearer token:

Authorization: Bearer YOUR_API_KEY

Create one under API keys in your reAPI dashboard. Chat requests are billed from the same credit balance as every other model on the platform.

Endpoint

POST /api/v1/chat/completions

Base URL https://reapi.ai/api/v1. The wire format is OpenAI-compatible, so the same SDKs work once you swap the base URL, the key and the model string. The request is translated to Anthropic's native shape before it reaches the model, which is what the parameter table below is describing.

Parameter support on this model

The table records what each Chat Completions field does by the time the model sees it — some are translated, some are dropped in the translation, and some are rejected by the model itself.

Request body

model — string, required

Must be claude-fable-5-1 exactly. Note that claude-fable-5 is a different model — the predecessor in the same tier — and not an alias.

messages — array, required

Conversation history, each entry an object with role and content. Roles are system, user and assistant.

max_tokens — integer

Upper bound on generated tokens for this response, thinking tokens included. The documented maximum output is 128,000 tokens. max_completion_tokens is accepted as an alias. Omitted, the request runs under the model's ceiling.

reasoning_effort — string

How deeply the model thinks before answering. See Reasoning effort. Anthropic's family default is high.

stream — boolean, default false

When true, tokens arrive as server-sent events terminated by data: [DONE], with a final chunk carrying usage. Worth enabling here: a single request on a hard task can run for many minutes before the first visible token, and a non-streamed request with a large budget can reach an HTTP timeout.

stop — string or array of strings

Sequences that end the response when generated. Translated to the model's native stop sequences.

Reasoning effort

Thinking is always on for this model. There is no way to switch it off: reasoning_effort: "none" does not disable it — and it does not select the shallowest setting either: the request runs at the default, high. The control is depth, not presence, and the cheapest depth is low, sent explicitly.

All five reach this model. Effort is the first quality-trading lever after caching, and the top of the range earns its cost only on hard problems — raise to max when measurement shows headroom at the level below, not by default.

Tool calling

Tools work on this endpoint. What this model rejects is forcing a tool: tool_choice set to a specific tool, or to "any tool", returns an error.

Leave tool_choice on its automatic setting and name the tool you want in the prompt instead. If the forced call only existed to get structured JSON back, describe the schema in the prompt and validate the result — response_format does not reach this model through this endpoint.

The model is built for long-horizon agentic runs, so give it the full task specification up front rather than feeding it one step at a time.

Operating constraints

Two things about this model are policy rather than parameters, and both can surprise a caller who has only used other tiers.

Refusals arrive as a successful response

Anthropic runs safety classifiers on this model that may decline a request. On this endpoint the result is HTTP 200 with choices[0].finish_reason: "content_filter" — the OpenAI-format spelling of Anthropic's native refusal stop reason — not an error status. Check finish_reason before reading the content, or a declined request reads as an empty answer. Anthropic's native stop_details.category is not part of the Chat Completions shape and is not carried through.

30-day data retention is required

This model is not available under zero data retention unless Anthropic has expressly authorized it. An organization whose retention configuration does not meet the requirement gets a 400 invalid_request_error.

Pricing dimensions

Billing is per token, from your reAPI credit balance, with separate input and output rates:

• Thinking tokens bill as output. Effort is the first lever on cost, and on this model it is the main one.
• One rate at every prompt length. Unlike some flagship models, there is no long-context tier here — a 900K-token prompt bills at the same per-token rate as a 900-token one.
• Tier is the second lever. Route the routine turns to a cheaper chat model and escalate by changing the model string.

Both rates sit 20% below Anthropic's published per-token rate. Current numbers are on the model page — that table is the canonical source, not this page. The platform constants are 1 credit = $0.001 and $1 = 1,000 credits; a request's cost is its input and output tokens at the per-million rates, converted at that ratio.

Response shape

Non-streaming (stream: false)

{
  "id": "chatcmpl-...",
  "object": "chat.completion",
  "created": 1788600000,
  "model": "claude-fable-5-1",
  "choices": [
    {
      "index": 0,
      "message": { "role": "assistant", "content": "..." },
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 1204,
    "completion_tokens": 860,
    "total_tokens": 2064
  }
}

usage.completion_tokens includes thinking tokens, so it is the number to reconcile a bill against.

Streaming (stream: true)

Server-sent events, each data: line carrying a chat.completion.chunk with the incremental text in choices[0].delta.content. The last chunk before data: [DONE] carries usage; a chunk with an empty choices array is normal and should be skipped.

Errors

Failures use the standard envelope: error.code, error.message and error.request_id. See the errors catalog for the full code list. Common cases:

Tips

• Stream, and budget generously. Requests on hard tasks run for minutes and the thinking you pay for is invisible until the answer starts.
• Give it the whole task. This model is tuned for autonomy; prompts written for earlier models are often too prescriptive and reduce output quality.
• Sweep effort downward, not upward. Start at the default and check whether medium or low holds on your evals before assuming the top rungs are needed.
• Don't reach for temperature. It does nothing here. Effort and the token budget are the two controls that change the result.
• Coming from the predecessor? claude-fable-5 is the same tier at the same per-token price. Moving up costs nothing per token; the surface tightens around forced tool choice.

Related

• Claude Fable 5.1 model page — current rates
• Claude Fable 5 — the predecessor in the same tier
• Claude Opus 5 — the tier below
• GPT-6 Astra — the other flagship on this endpoint
• Errors catalog
• Authentication
• Quickstart