DEV Community

Cover image for So nutzen Sie die Claude Fable 5 API
Emre Demir
Emre Demir

Posted on • Originally published at apidog.com

So nutzen Sie die Claude Fable 5 API

Anthropic hat Claude Fable 5 am 9. Juni 2026 veröffentlicht. Für Entwickler ist vor allem die Claude Fable 5 API relevant: Sie nutzt weiterhin die bekannte Messages API. In vielen bestehenden Integrationen ändern Sie daher hauptsächlich den Modellnamen auf claude-fable-5. Dieser Leitfaden zeigt die wichtigsten Implementierungsschritte: Curl, Python, TypeScript, Streaming, Tool-Nutzung, Fehlerbehandlung, Kostenberechnung und manuelles Testen. Wenn Sie von einem älteren Claude-Modell migrieren, ähnelt der Wechsel einem einfachen Modellstring-Tausch wie bei der Claude Opus 4.8 API.

Probieren Sie Apidog noch heute aus

TL;DR

  1. API-Schlüssel in der Anthropic Konsole erstellen.
  2. Schlüssel als Umgebungsvariable setzen: 
export ANTHROPIC_API_KEY="sk-ant-..."
Enter fullscreen mode Exit fullscreen mode
  1. Anfrage an die Messages API senden: 
{
  "model": "claude-fable-5",
  "max_tokens": 1024,
  "messages": [
    {
      "role": "user",
      "content": "Summarize what makes a good REST API in 3 bullet points."
    }
  ]
}
Enter fullscreen mode Exit fullscreen mode
  1. Für lange Antworten Streaming verwenden.
  2. Kosten über usage.input_tokens und usage.output_tokens berechnen.

Die Preise betragen 10 $ pro Million Eingabe-Token und 50 $ pro Million Ausgabe-Token.

Voraussetzungen

Bevor Sie die API aufrufen, benötigen Sie:

  1. Ein Anthropic-Konto

    Registrieren Sie sich unter console.anthropic.com. Dort verwalten Sie API-Schlüssel, Nutzung und Abrechnung.

  2. Einen API-Schlüssel

    Erstellen Sie den Schlüssel in der Konsole unter API Keys. Kopieren Sie ihn direkt nach der Erstellung und behandeln Sie ihn wie ein Passwort.

  3. Abrechnung oder Enterprise-Zugriff

    Fable 5 ist über die Standard Claude API verfügbar und in verbrauchsabhängigen Enterprise-Plänen enthalten. Aktivieren Sie eine Zahlungsmethode oder prüfen Sie, ob Ihr Plan die Nutzung abdeckt. Wenn Sie zuerst einschätzen möchten, ob das Modell passt, lesen Sie die Übersicht zu Claude Fable 5.

  4. Optional: ein SDK

    Für Python und TypeScript/Node gibt es offizielle Anthropic SDKs. Alternativ können Sie den HTTP-Endpunkt direkt mit Curl oder einem beliebigen HTTP-Client aufrufen.

Setzen Sie den API-Schlüssel als Umgebungsvariable:

export ANTHROPIC_API_KEY="sk-ant-..."
Enter fullscreen mode Exit fullscreen mode

Die offiziellen SDKs lesen ANTHROPIC_API_KEY automatisch aus der Umgebung. Speichern Sie den Schlüssel nicht im Quellcode und committen Sie ihn nicht in Git. Wenn ein Schlüssel kompromittiert wurde, rotieren Sie ihn sofort in der Konsole.

Wichtig: Fable 5 besitzt Schutzmechanismen, die einen kleinen Teil sensibler Anfragen, etwa zu Cybersicherheit, Biologie, Chemie oder Modell-Destillation, stattdessen an Claude Opus 4.8 weiterleiten. Das betrifft weniger als 5 % der Sitzungen. Sie müssen dafür nichts konfigurieren, sollten aber beim Logging nicht hart davon ausgehen, dass response.model immer exakt claude-fable-5 ist.

Erster API-Aufruf mit Curl

Der Endpunkt lautet:

POST https://api.anthropic.com/v1/messages
Enter fullscreen mode Exit fullscreen mode

Die Messages API ist in der Anthropic Messages API Referenz dokumentiert.

Minimaler Curl-Aufruf:

curl https://api.anthropic.com/v1/messages \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "content-type: application/json" \
  -d '{
    "model": "claude-fable-5",
    "max_tokens": 1024,
    "messages": [
      {
        "role": "user",
        "content": "Summarize what makes a good REST API in 3 bullet points."
      }
    ]
  }'
Enter fullscreen mode Exit fullscreen mode

Die drei wichtigen Header:

Header Zweck
x-api-key Ihr Anthropic API-Schlüssel
anthropic-version API-Version, hier 2023-06-01
content-type Muss bei JSON-Anfragen application/json sein

Der Body benötigt mindestens:

Feld Zweck
model Modellname, hier claude-fable-5
max_tokens Maximale Anzahl an Ausgabe-Token
messages Konversationsnachrichten

Beispielantwort:

{
  "id": "msg_01ABC...",
  "type": "message",
  "role": "assistant",
  "model": "claude-fable-5",
  "content": [
    {
      "type": "text",
      "text": "- Predictable, resource-oriented URLs..."
    }
  ],
  "stop_reason": "end_turn",
  "usage": {
    "input_tokens": 18,
    "output_tokens": 96
  }
}
Enter fullscreen mode Exit fullscreen mode

content ist eine Liste von Blöcken, kein einzelner String. Eine Antwort kann Text-, Tool-Use- oder andere Blocktypen enthalten. Prüfen Sie deshalb immer type, bevor Sie auf text zugreifen.

Claude Fable 5 mit Python aufrufen

Installieren Sie zuerst das offizielle Anthropic Python SDK:

pip install anthropic
Enter fullscreen mode Exit fullscreen mode

Minimaler Aufruf:

import anthropic

client = anthropic.Anthropic()  # liest ANTHROPIC_API_KEY aus der Umgebung

response = client.messages.create(
    model="claude-fable-5",
    max_tokens=1024,
    messages=[
        {
            "role": "user",
            "content": "Summarize what makes a good REST API."
        }
    ],
)

for block in response.content:
    if block.type == "text":
        print(block.text)
Enter fullscreen mode Exit fullscreen mode

Das SDK übernimmt Header und JSON-Serialisierung. Sie übergeben weiterhin dieselben Kernfelder: model, max_tokens und messages.

System-Prompt verwenden

Ein System-Prompt definiert Rolle, Regeln und Ausgabeformat für die Konversation. Er wird separat von messages übergeben:

response = client.messages.create(
    model="claude-fable-5",
    max_tokens=2048,
    system="You are a senior backend engineer. Be concise and use code examples.",
    messages=[
        {
            "role": "user",
            "content": "Write a Flask route that validates a JSON body."
        }
    ],
)

for block in response.content:
    if block.type == "text":
        print(block.text)
Enter fullscreen mode Exit fullscreen mode

Nutzen Sie den System-Prompt für stabile Regeln wie:

  • gewünschte Antwortsprache
  • Ausgabeformat
  • technische Rolle
  • Einschränkungen
  • Stilvorgaben

Wenn Sie später Prompt-Caching einsetzen, sollten Sie den System-Prompt möglichst stabil halten.

Lange Antworten streamen

Für lange Antworten sollten Sie Streaming verwenden. So erhalten Sie Tokens direkt während der Generierung und reduzieren das Risiko von Timeouts.

with client.messages.stream(
    model="claude-fable-5",
    max_tokens=4096,
    messages=[
        {
            "role": "user",
            "content": "Explain idempotency keys for payment APIs."
        }
    ],
) as stream:
    for text in stream.text_stream:
        print(text, end="", flush=True)

    final = stream.get_final_message()

print(f"\n\nTokens: {final.usage.output_tokens}")
Enter fullscreen mode Exit fullscreen mode

stream.text_stream liefert Text-Chunks, sobald sie verfügbar sind. flush=True sorgt dafür, dass die Ausgabe sofort erscheint. Nach Abschluss erhalten Sie mit stream.get_final_message() die vollständige Antwort inklusive usage.

Claude Fable 5 mit TypeScript / Node aufrufen

Installieren Sie das Node SDK:

npm install @anthropic-ai/sdk
Enter fullscreen mode Exit fullscreen mode

Minimaler Aufruf:

import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic(); // liest ANTHROPIC_API_KEY

const msg = await client.messages.create({
  model: "claude-fable-5",
  max_tokens: 1024,
  messages: [
    {
      role: "user",
      content: "List 3 common API security mistakes.",
    },
  ],
});

console.log(msg.content);
Enter fullscreen mode Exit fullscreen mode

Um nur Textblöcke zu extrahieren:

const text = msg.content
  .filter((block) => block.type === "text")
  .map((block) => block.text)
  .join("");

console.log(text);
Enter fullscreen mode Exit fullscreen mode

Für Streaming verwenden Sie client.messages.stream({...}). In einer Web-App sollten Sie nicht direkt aus dem Browser zur Anthropic API aufrufen. Implementieren Sie stattdessen eine Server-Route, die:

  1. den API-Schlüssel sicher serverseitig hält,
  2. die Anfrage an Anthropic sendet,
  3. Streaming-Chunks an den Browser weiterleitet.

Dasselbe Testmuster gilt in Node und Python: Erst den API-Vertrag manuell prüfen, dann Client-Code schreiben. Ein Tool wie Apidog hilft dabei, Requests zu validieren, ähnlich wie beim Testen der ChatGPT API mit Apidog.

Tool-Nutzung mit Fable 5

Tool-Nutzung erlaubt dem Modell, von Ihnen definierte Funktionen anzufordern. Der Ablauf:

  1. Sie definieren Tools mit JSON-Schema.
  2. Das Modell entscheidet, ob ein Tool benötigt wird.
  3. Ihre Anwendung führt die echte Funktion aus.
  4. Sie senden das Ergebnis als tool_result zurück.
  5. Das Modell erzeugt daraus die finale Antwort.

Tool definieren 

tools = [
    {
        "name": "get_order_status",
        "description": "Look up the status of a customer order by ID.",
        "input_schema": {
            "type": "object",
            "properties": {
                "order_id": {
                    "type": "string"
                }
            },
            "required": ["order_id"],
        },
    }
]
Enter fullscreen mode Exit fullscreen mode

Tool an die Anfrage übergeben 

messages = [
    {
        "role": "user",
        "content": "What's the status of order A1855?"
    }
]

response = client.messages.create(
    model="claude-fable-5",
    max_tokens=1024,
    tools=tools,
    messages=messages,
)
Enter fullscreen mode Exit fullscreen mode

Wenn das Modell ein Tool nutzen möchte, enthält die Antwort:

  • stop_reason == "tool_use"
  • einen tool_use-Block in response.content

Tool ausführen und Ergebnis zurückgeben 

if response.stop_reason == "tool_use":
    tool_use = next(
        block for block in response.content
        if block.type == "tool_use"
    )

    # Ihre reale Funktion
    result = lookup_order(tool_use.input["order_id"])

    messages.append({
        "role": "assistant",
        "content": response.content,
    })

    messages.append({
        "role": "user",
        "content": [
            {
                "type": "tool_result",
                "tool_use_id": tool_use.id,
                "content": result,
            }
        ],
    })

    followup = client.messages.create(
        model="claude-fable-5",
        max_tokens=1024,
        tools=tools,
        messages=messages,
    )
Enter fullscreen mode Exit fullscreen mode

Das wichtigste Feld ist tool_use_id. Der tool_result-Block muss exakt die id aus dem vorherigen tool_use-Block referenzieren.

Für Agenten-Loops kapseln Sie diesen Ablauf in einer Schleife, bis stop_reason end_turn ist. Die manuelle Implementierung ist nützlich, wenn Sie Logging, Berechtigungsprüfungen oder Genehmigungsschritte einbauen möchten.

Adaptives Denken und Aufwand steuern

Fable 5 unterstützt adaptives Denken. Dabei entscheidet das Modell, wann und wie tief es vor der Antwort argumentiert. Aktivieren Sie es mit thinking und steuern Sie die Tiefe über output_config.

response = client.messages.create(
    model="claude-fable-5",
    max_tokens=4096,
    thinking={"type": "adaptive"},
    output_config={"effort": "high"},  # low | medium | high
    messages=[
        {
            "role": "user",
            "content": "Design a retry strategy for a flaky webhook receiver."
        }
    ],
)
Enter fullscreen mode Exit fullscreen mode

Verwenden Sie adaptives Denken nicht automatisch für jede Anfrage. Sinnvolle Einsatzfälle sind:

  • mehrstufige technische Entscheidungen
  • Architektur- oder Planungsaufgaben
  • Debugging komplexer Fehler
  • Agenten-Workflows mit mehreren Schritten

Für kurze Antworten, einfache Klassifikationen oder direkte Lookups sparen Sie Tokens, indem Sie thinking weglassen.

Fehlerbehandlung

Produktive Integrationen sollten typische API-Fehler explizit behandeln. Das Python SDK wirft typisierte Exceptions:

import anthropic

client = anthropic.Anthropic()

try:
    response = client.messages.create(
        model="claude-fable-5",
        max_tokens=1024,
        messages=[
            {
                "role": "user",
                "content": "Explain CORS preflight requests."
            }
        ],
    )

except anthropic.AuthenticationError:
    # 401: Ungültiger oder fehlender API-Schlüssel
    print("Ungültiger API-Schlüssel. Prüfen Sie ANTHROPIC_API_KEY.")

except anthropic.RateLimitError as e:
    # 429: Zu viele Anfragen
    retry_after = e.response.headers.get("retry-after", "60")
    print(f"Ratelimit überschritten. Wiederholen Sie nach {retry_after}s.")

except anthropic.BadRequestError as e:
    # 400: Fehlerhafte Anfrage
    print(f"Fehlerhafte Anfrage: {e.message}")
Enter fullscreen mode Exit fullscreen mode

Häufige Ursachen:

Fehler Bedeutung Lösung
401 AuthenticationError Schlüssel fehlt, ist falsch oder widerrufen ANTHROPIC_API_KEY prüfen und Schlüssel in der Konsole validieren
429 RateLimitError Request- oder Token-Limit überschritten Backoff nutzen und retry-after beachten
400 BadRequestError Anfrageformat ungültig messages, max_tokens, Rollenabfolge und JSON-Struktur prüfen

Das SDK versucht 429- und 5xx-Fehler bereits mit exponentiellem Backoff erneut, standardmäßig mit zwei Wiederholungen. Wenn Sie eigenes Retry-Verhalten implementieren, lesen Sie den retry-after-Header aus.

Fallback durch Schutzmechanismen berücksichtigen

Fable 5 kann bestimmte sensible Anfragen an Claude Opus 4.8 weiterleiten. Das ist kein Fehler. Die Anfrage ist erfolgreich, aber response.model kann ein anderes Modell enthalten.

Implementieren Sie deshalb kein hartes Matching wie:

assert response.model == "claude-fable-5"
Enter fullscreen mode Exit fullscreen mode

Besser:

print(f"Answered by model: {response.model}")
Enter fullscreen mode Exit fullscreen mode

Wenn Ihre Anwendung das tatsächlich verwendete Modell anzeigen oder protokollieren muss, lesen Sie immer response.model aus der Antwort.

Kosten pro Anfrage berechnen

Fable 5 kostet:

  • 10 $ pro Million Eingabe-Token
  • 50 $ pro Million Ausgabe-Token

Jede Antwort enthält die Token-Zahlen in usage.

response = client.messages.create(
    model="claude-fable-5",
    max_tokens=1024,
    messages=[
        {
            "role": "user",
            "content": "Write a SQL query to find duplicate emails."
        }
    ],
)

input_tokens = response.usage.input_tokens
output_tokens = response.usage.output_tokens

input_cost = input_tokens / 1_000_000 * 10
output_cost = output_tokens / 1_000_000 * 50
total = input_cost + output_cost

print(f"Input:  {input_tokens} tokens  = ${input_cost:.6f}")
print(f"Output: {output_tokens} tokens = ${output_cost:.6f}")
print(f"Total:  ${total:.6f}")
Enter fullscreen mode Exit fullscreen mode

Beispiel:

2.000 Eingabe-Token × 10 $ / 1.000.000 = 0,020 $
500 Ausgabe-Token × 50 $ / 1.000.000 = 0,025 $
Gesamt = 0,045 $
Enter fullscreen mode Exit fullscreen mode

Da Ausgabe-Token fünfmal so teuer sind wie Eingabe-Token, ist die effektivste Kostenkontrolle meist:

  • max_tokens passend begrenzen
  • im System-Prompt knappe Antworten verlangen
  • Streaming für lange Ausgaben nutzen
  • unnötige Wiederholungen im Prompt vermeiden

Die Berechnung ist dieselbe wie beim Claude Opus 4.8 Preismodell, nur mit den Preisen von Fable 5.

Claude Fable 5 API mit Apidog testen und debuggen

Bevor Sie SDK-Code schreiben, sollten Sie die API manuell testen. Apidog eignet sich dafür als API-Client: Sie senden echte Requests an https://api.anthropic.com/v1/messages, prüfen Header, Body, Streaming und Antwortstruktur und speichern die Anfrage für Ihr Team.

1. Anfrage erstellen

Erstellen Sie eine neue HTTP-Anfrage:

POST https://api.anthropic.com/v1/messages
Enter fullscreen mode Exit fullscreen mode

2. API-Schlüssel als Umgebungsvariable speichern

Legen Sie in Apidog eine Umgebungsvariable an, zum Beispiel:

anthropic_api_key
Enter fullscreen mode Exit fullscreen mode

Speichern Sie den Wert als Secret. So landet der Schlüssel nicht direkt in der gespeicherten Anfrage oder in Exporten.

3. Header setzen

Fügen Sie diese Header hinzu:

x-api-key: {{anthropic_api_key}}
anthropic-version: 2023-06-01
content-type: application/json
Enter fullscreen mode Exit fullscreen mode

4. Minimalen JSON-Body senden 

{
  "model": "claude-fable-5",
  "max_tokens": 1024,
  "messages": [
    {
      "role": "user",
      "content": "Explain idempotency keys for payment APIs."
    }
  ]
}
Enter fullscreen mode Exit fullscreen mode

Nach dem Senden sollten Sie in der Antwort direkt sehen:

  • content
  • stop_reason
  • usage
  • model

5. Streaming testen

Ergänzen Sie im Body:

"stream": true
Enter fullscreen mode Exit fullscreen mode

Apidog zeigt die Server-Sent Events beim Eintreffen an. So können Sie prüfen, wie die Chunks aussehen, bevor Sie Streaming in Ihre Anwendung einbauen.

6. Request speichern und Code generieren

Speichern Sie die Anfrage in einer Collection. Anschließend können Sie mit der Code-Generierung von Apidog Snippets für Python, JavaScript, Curl oder andere Sprachen erzeugen. Das gibt Ihnen einen getesteten Startpunkt statt einer leeren Datei.

Wenn Sie Ihre lokale Anfrage mit dem Verhalten Ihrer App vergleichen, finden Sie Fehler schneller: falsche Header, fehlerhafte JSON-Struktur, fehlende Umgebungsvariablen oder Probleme beim Streaming. Zum Einstieg können Sie Apidog herunterladen und den minimalen Body aus diesem Abschnitt verwenden.

Top comments (0)