claude-fable-5-1

Use claude-fable-5-1 with either reAPI endpoint. Native Messages exposes Anthropic's parameter names and response events. Existing OpenAI clients retain Chat Completions and can also send native extensions. Current prices are on the model page.

Both use your reAPI key and credit balance. reAPI supplies the default Anthropic protocol version automatically; no version header is required. Set anthropic-beta on either endpoint when a feature requires it. No automatic retries are performed.

Native Messages example

curl --no-buffer https://reapi.ai/api/v1/messages \
  -H "x-api-key: YOUR_REAPI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-fable-5-1",
    "max_tokens": 4096,
    "system": "Explain your answer clearly and concisely.",
    "messages": [{"role":"user","content":"Review this design and suggest a minimal verification plan."}],
    "output_config": {"effort":"high"},
    "stream": true
  }'

For the Anthropic SDK, set its base URL to https://reapi.ai/api (the SDK appends /v1/messages) and use a reAPI API key. Set the SDK's retry count to 0 when you require one attempt per application action.

Native request parameters

The request body is forwarded without a field allowlist or schema rewriting. Model-specific validation is performed by the model. Admission checks the model, request size and output ceiling.

The official model has a 1,000,000-token context and always-on adaptive thinking. Effort values are low, medium, high, xhigh, and max; the native default is high. Manual thinking budgets and thinking.type: "disabled" are not supported by this model. Input images/documents must use public HTTP(S) URLs under reAPI's media policy.

Structured output

Use the native format below. The schema is sent unchanged, including validation constraints; reAPI does not silently remove keywords or invent missing required entries.

{
  "output_config": {
    "format": {
      "type": "json_schema",
      "schema": {
        "type": "object",
        "properties": {"answer": {"type":"string"}},
        "required": ["answer"],
        "additionalProperties": false
      }
    }
  }
}

On Chat Completions, the equivalent field is response_format: {"type":"json_schema","json_schema":{"name":"answer","schema": ...}}. Native output_config.format takes precedence when both are provided. The legacy json_object option remains accepted but does not enforce a JSON schema; use json_schema for structured output.

OpenAI compatibility mapping

The existing compatibility handling of temperature, top_p, top_k, n, seed, logprobs, frequency_penalty, and presence_penalty is unchanged: they do not control this model. minimal maps to low effort; none is not a portable way to disable this model's thinking. Prefer an official effort value.

Existing OpenAI clients

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

Responses, tool loops and streaming

Messages returns the native message envelope: id, content[], stop_reason, stop_sequence, stop_details when present, and usage. Preserve signed thinking, redacted_thinking, tool blocks and their ordering when sending an assistant turn back. Do not substitute a displayed reasoning summary for the original blocks. Your application executes client tools and supplies their results; the playground does not execute them.

Native SSE uses message_start, content_block_start, content_block_delta, content_block_stop, message_delta and message_stop, with ping or error events as applicable. Thinking signatures and partial tool JSON are retained. There is no [DONE] event on Messages.

Chat Completions keeps choices[].message.content, tool_calls, reasoning_content, finish_reason and SSE ending in [DONE]. It adds:

• Non-streaming choices[].message.anthropic_content: the complete native content array. Send it back as the assistant message's anthropic_content to preserve signed state; it takes precedence over duplicated text/tool calls.
• Streaming anthropic_event: the corresponding complete native event on each chunk. Accumulate these using the Messages event rules to reconstruct content for a subsequent turn.
• anthropic: native message ID and stop details. A refusal is a valid HTTP 200 response (stop_reason: "refusal", compatible finish_reason: "content_filter"), potentially with empty visible text.
• usage.anthropic: native token/cache/server-tool counters. Compatible prompt totals include uncached input, cache creation and cache reads. Native input/cache counts from message_start are retained when later usage contains only cumulative output.

Capability availability

Parameter forwarding and actual model behavior are separate checks. Core native/compatible translation, streaming and billing have local contract tests. This change does not certify every optional feature against a live provider.

Native Messages parameters, including beta fields and unknown extensions, are forwarded unchanged. reAPI does not reject fields because their behavior has not been verified. The upstream decides whether to accept, ignore or reject them; an HTTP 200 response alone does not demonstrate that a parameter took effect.

Billing and errors

Successful delivery is billed using the recorded per-request cost, including applicable caching/tool charges. Input/output rates are shown on the model page. Do not infer a cache discount or feature support from HTTP 200 alone. Missing trusted usage/cost, failed delivery, truncation or cancellation follows the existing no-charge settlement path.

Messages errors use {"type":"error","error":{"type":"invalid_request_error","message":"..."},"request_id":"..."}. Compatibility clients retain their existing error envelope. There is one upstream generation attempt per request and no automatic retry after a failure.

References

Reviewed 2026-10-09: Messages, beta Messages, model guidance, structured outputs, streaming.