Claude Fable 5.1 API nutzen: Schritt-für-Schritt Anleitung mit Apidog

Claude Fable 5.1 wurde am 1. September 2026 ausgeliefert, und die API-Modell-ID ist die genaue Zeichenfolge claude-fable-5-1, ohne Datumssuffix. Es kostet die gleichen $10 pro Million Eingabe-Token und $50 pro Million Ausgabe-Token wie Fable 5, wobei Cache-Lesevorgänge auf $0.25 pro Million reduziert wurden, und es enthält drei bahnbrechende Änderungen, die Fable 5 nicht hatte.

Dieser Leitfaden beschreibt den gesamten Weg: das Beschaffen eines Schlüssels, das Senden einer ersten Anfrage, die Steuerung des Aufwands, Streaming, Tool-Nutzung ohne erzwungenes tool_choice, Ablehnungs-Fallbacks, Fortschrittsaktualisierungen und das Lesen des usage-Objekts, um zu bestätigen, dass Ihr Cache mit der neuen Rate funktioniert. Jede Anfrage ist reines HTTP mit JSON, sodass Sie sie in Apidog erstellen und debuggen können, bevor sie in den Anwendungscode gelangt.

Wenn Sie einen bestehenden Fable 5 oder Opus 5 Dienst migrieren, anstatt neu zu beginnen, lesen Sie den vollständigen Migrationsleitfaden parallel zu diesem. Für einen Modellüberblick beginnen Sie mit was Claude Fable 5.1 ist.

Vor Ihrem ersten Anruf: drei Dinge, die 400 zurückgeben

1. Denken kann nicht konfiguriert, sondern nur gesteuert werden. Fable 5.1 führt bei jeder Anfrage adaptives Denken aus. Lassen Sie das Feld thinking weg, oder senden Sie {"type": "adaptive"}. Sowohl {"type": "disabled"} als auch {"type": "enabled", "budget_tokens": N} geben einen 400er zurück. Wenn Sie von Opus 5 kommen, wo disabled bei high Aufwand oder darunter akzeptiert wurde, entfernen Sie es und steuern Sie stattdessen die Ausgaben mit output_config.effort.

2. Erzwingende Tool-Nutzung ist entfallen. tool_choice: {"type": "any"} und {"type": "tool", "name": "..."} geben tool_choice: type "tool" and "any" are not supported for this model. zurück. Die Lösung finden Sie im Schritt zur Tool-Nutzung weiter unten.

3. Ihre Organisation benötigt eine 30-tägige Datenaufbewahrung. Fable 5.1 ist ein abgedecktes Modell. Eine Anfrage von einer Organisation oder einem Arbeitsbereich mit keiner Datenaufbewahrung gibt 400 invalid_request_error ohne weitere Hinweise zurück. Wenn Ihr erster Anruf fehlschlägt und der Body korrekt aussieht, überprüfen Sie zuerst die Aufbewahrungsrichtlinien.

Alle drei sind in Anthropic’s Was ist neu in Claude Fable 5.1 dokumentiert.

Schritt 1: API-Schlüssel erhalten

Melden Sie sich bei der Claude Console an, öffnen Sie den API-Schlüsselbereich Ihrer Organisationseinstellungen und erstellen Sie einen Schlüssel. Kopieren Sie ihn einmal; Sie können ihn später nicht mehr auslesen. Exportieren Sie ihn, anstatt ihn in den Code einzufügen:

export ANTHROPIC_API_KEY="sk-ant-..."

In Apidog speichern Sie ihn als Umgebungsvariable namens ANTHROPIC_API_KEY und referenzieren ihn als {{ANTHROPIC_API_KEY}} im Header, damit der Schlüssel niemals in einem gespeicherten Anfrage-Body landet.

Schritt 2: Senden Sie Ihre erste Anfrage

Erstellen Sie einen POST-Request an https://api.anthropic.com/v1/messages mit drei Headern: x-api-key, anthropic-version: 2023-06-01 und content-type: application/json.

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-1",
    "max_tokens": 16000,
    "messages": [
      {"role": "user", "content": "Explain the difference between idempotent and safe HTTP methods, with one example each."}
    ]
  }'

Derselbe Aufruf in Python mit dem offiziellen SDK:

import anthropic

client = anthropic.Anthropic()

response = client.messages.create(
    model="claude-fable-5-1",
    max_tokens=16000,
    messages=[{"role": "user", "content": "Explain the difference between idempotent and safe HTTP methods, with one example each."}],
)

if response.stop_reason == "refusal":
    print("declined:", response.stop_details.category if response.stop_details else None)
else:
    for block in response.content:
        if block.type == "text":
            print(block.text)

Zwei Gewohnheiten, die Sie sich vom ersten Anruf an aneignen sollten. Überprüfen Sie stop_reason, bevor Sie content lesen, da eine Klassifizierungsablehnung ein HTTP 200 mit einem leeren Content-Array ist. Und geben Sie max_tokens ausreichend Raum. Es begrenzt Denk-Token und Antwort-Token zusammen, und das Denken ist immer aktiviert, daher wird ein für ein Modell ohne Denkfunktion optimierter, knapper Wert hier abgeschnitten.

Die Antwort enthält einen thinking-Block, dessen Text unter der Standardeinstellung display von "omitted" leer ist. Das ist zu erwarten. Geben Sie ihn beim nächsten Zug unverändert zurück.

Schritt 3: Kosten und Tiefe mit Aufwand steuern

Der Aufwandsparameter ist der primäre Hebel bei Fable 5.1. Er befindet sich innerhalb von output_config, nicht auf der obersten Ebene, und akzeptiert low, medium, high, xhigh und max. Der Standardwert ist high.

{
  "model": "claude-fable-5-1",
  "max_tokens": 16000,
  "output_config": {"effort": "medium"},
  "messages": [{"role": "user", "content": "Summarize this changelog in five bullets."}]
}

Anthropic’s Empfehlung: Beginnen Sie bei high, testen Sie dann die anderen Stufen mit Ihren eigenen Bewertungen und wiederholen Sie den Test, selbst wenn Sie ihn bereits mit Fable 5 durchgeführt haben, da die Namen der Stufen nicht der gleichen Denkintensität über alle Modelle hinweg entsprechen. Sie behaupten, dass medium in etwa Fable 5 zu geringeren Kosten entspricht und dass low oft mit Opus und Sonnet bei den Kosten pro Aufgabe konkurrieren kann. Zwei aufwandspezifische Verhaltensweisen, die Sie kennen sollten: Bei low ruft Fable 5.1 Such- und Abruftools seltener auf und antwortet mehr aus dem Gedächtnis, und bei xhigh und max kann es ein langes Ergebnis in seinem Denkprozess entwerfen und es dann erneut schreiben, daher setzen Sie max_tokens für beide.

Änderung des Aufwands mitten im Gespräch (Beta). Bei Fable 5 führte das Ändern des obersten Aufwands zwischen Anfragen zum Verlust des gecachten Präfixes. Bei Fable 5.1 ändert eine role: "system"-Nachricht mit leerem Inhalt und einer output_config den Aufwand ab dem nächsten Benutzerzug, ohne den Cache zu invalidieren. Es erfordert den Beta-Header mid-conversation-output-config-2026-07-01 und den client.beta.messages-Namensraum.

response = client.beta.messages.create(
    model="claude-fable-5-1",
    max_tokens=16000,
    output_config={"effort": "high"},
    betas=["mid-conversation-output-config-2026-07-01"],
    messages=[
        {"role": "user", "content": "Plan a migration from SQLite to PostgreSQL in three short steps."},
        {"role": "assistant", "content": "1. Export the SQLite data. 2. Create the PostgreSQL schema. 3. Import the data and verify row counts."},
        {"role": "system", "content": [], "output_config": {"effort": "low"}},
        {"role": "user", "content": "Summarize the plan in one sentence."},
    ],
)

Den Aufwand auf diese Weise zu senken ist zuverlässig. Das Erhöhen funktioniert am besten für große Sprünge, wie von low zu xhigh. Der Leitfaden für den Aufwandsparameter von Opus 5 behandelt die fünf Stufen ausführlich, und dieselben Semantikregeln gelten hier.

Schritt 4: Die Antwort streamen

Fable 5.1 kann bei schwierigen Aufgaben mit höherem Aufwand minutenlang laufen, streamen Sie daher alles, was lang sein könnte. Das SDK erfordert Streaming für max_tokens-Werte nahe der Obergrenze von 128.000, um HTTP-Timeouts zu vermeiden.

with client.messages.stream(
    model="claude-fable-5-1",
    max_tokens=64000,
    messages=[{"role": "user", "content": "Write a test plan for a rate-limited public API."}],
) as stream:
    for text in stream.text_stream:
        print(text, end="", flush=True)
    final = stream.get_final_message()

print(final.stop_reason, final.usage.output_tokens)

In Apidog werden Streaming-Antworten gerendert, sobald sie eintreffen, was der schnellste Weg ist, um zu sehen, wie lange ein `high`-Aufwandszug nachdenkt, bevor das erste Text-Token erscheint.

Schritt 5: Tool-Nutzung ohne Zwang hinzufügen

Definieren Sie Tools auf die gleiche Weise wie bei Fable 5. Was sich ändert, ist die Art und Weise, wie Sie einen Aufruf garantieren. Bei Fable 5 konnten Sie es mit tool_choice: {"type": "tool", ...} erzwingen. Bei Fable 5.1 gibt dies einen 400er zurück, da ein erzwungener Aufruf das Denken überspringen würde und das Modell seine Arbeitsergebnisse in die Argumente schreiben würde.

Der Ersatz besteht aus drei Teilen: Behalten Sie tool_choice bei auto, benennen Sie das Tool in der Anweisung und setzen Sie strict: true (strikte Tool-Nutzung) für das Tool mit additionalProperties: false im Schema, damit die Argumente immer validiert werden.

record_summary_tool = {
    "name": "record_summary",
    "description": "Record the structured summary of the document.",
    "strict": True,
    "input_schema": {
        "type": "object",
        "properties": {"summary": {"type": "string"}},
        "required": ["summary"],
        "additionalProperties": False,
    },
}

response = client.messages.create(
    model="claude-fable-5-1",
    max_tokens=16000,
    tools=[record_summary_tool],
    tool_choice={"type": "auto"},
    messages=[{"role": "user", "content": "Summarize: The meeting moved to Thursday. Call the record_summary tool with your result."}],
)

Wenn der erzwungene Aufruf nur dazu diente, JSON zurückzuerhalten, verwenden Sie stattdessen strukturierte Ausgaben (output_config.format) anstelle eines Tools. Wenn Ihre Anwendung, nicht der Benutzer, einen spezifischen Aufruf im aktuellen Zug eines mehrstufigen Gesprächs erfordert, hängen Sie eine role: "system"-Nachricht nach dem letzten Benutzerzug an, die das Tool benennt und besagt, dass der Aufruf erforderlich ist, und behalten Sie diese Nachricht anschließend im Verlauf bei. tool_choice: {"type": "none"} funktioniert weiterhin für einen Zug, der keine Tools aufrufen darf.

Der agentische Loop selbst bleibt unverändert: Wenn stop_reason tool_use ist, führen Sie jeden tool_use-Block aus, geben Sie alle tool_result-Blöcke in einer Benutzernachricht zurück und hängen Sie den Assistant-Zug genau so an, wie er zurückgegeben wurde, einschließlich der `thinking`-Blöcke. Diese letzte Klausel ist bei Fable 5.1 wichtiger als bei jedem früheren Modell, aus Gründen, die der Leitfaden zum erhaltenen Denken erklärt.

Ein Verhalten, das man beachten sollte: In langen Schleifen, in denen die nächsten unabhängigen Lesevorgänge nur durch die Aufgabe impliziert werden, kann Fable 5.1 pro Zug einen Tool-Aufruf senden, wo Fable 5 mehrere gebündelt hat. Anthropic’s Lösung ist ein einzeiliger Hinweis, der nach jeder Tool-Ergebnisnachricht angehängt wird: „Listen Sie zuerst privat auf, was Sie als Nächstes benötigen; fordern Sie dann jedes Element an, das nicht vom Ergebnis eines anderen abhängt, in dieser einen Antwort.“ Senden Sie es als zugbezogene Systemnachricht (clear_at: "next_user_message", Beta-Header mid-conversation-system-clear-at-2026-08-21) und belassen Sie jede frühere Kopie an ihrem Platz.

Schritt 6: Ablehnungen mit Fallbacks behandeln

Fable 5.1 führt Sicherheitsklassifikatoren aus. Eine abgelehnte Anfrage wird als HTTP 200 mit stop_reason: "refusal" und einem stop_details-Objekt zurückgegeben, das die Kategorie benennt: cyber, bio, frontier_llm, reasoning_extraction oder general_harms. Eine Ablehnung vor jeglicher Ausgabe wird nicht berechnet.

Standardmäßig Fallbacks aktivieren. Die einfachste Form ist fallbacks: "default" mit dem Beta-Header server-side-fallback-2026-07-01, der eine abgelehnte Anfrage auf dem Modell erneut versucht, das Anthropic für diese Kategorie empfiehlt. Für Fable 5.1 sind die erlaubten Ziele claude-opus-4-8 und claude-opus-5.

response = client.beta.messages.create(
    model="claude-fable-5-1",
    max_tokens=16000,
    fallbacks="default",
    betas=["server-side-fallback-2026-07-01"],
    messages=[{"role": "user", "content": "Audit this authentication middleware for logic bugs."}],
)

fallback_ran = any(
    entry.type == "fallback_message" for entry in (response.usage.iterations or [])
)
if fallback_ran and response.stop_reason != "refusal":
    print("served by", response.model)

Die Antwort benennt das dienende Modell in ihrem Top-Level-Feld model, und ein fallback-Inhaltsblock markiert die Übergabe. Behalten Sie diesen Block an der Stelle bei, an der er erschien, wenn Sie den Zug zurückgeben. Zwei Einschränkungen: fallbacks wird bei der Batches API abgelehnt und ist nicht auf Bedrock, Google Cloud oder Foundry verfügbar, wo Sie stattdessen die BetaRefusalFallbackMiddleware des SDKs auf dem Client registrieren. Der Leitfaden zur Ablehnungsbehandlung behandelt Abrechnung, Sticky Routing und die manuelle Wiederholung mit Fallback-Guthaben.

Schritt 7: Fortschrittsaktualisierungen während langer Züge erhalten

Zwischen Tool-Aufrufen schreibt Fable 5.1 kurze Notizen darüber, was es gefunden hat und was es als Nächstes tun wird. Jeder Block kommt als eigener thinking-Block unmittelbar vor dem Tool-Aufruf an, und unter der Standardeinstellung display sind diese Blöcke leer. Setzen Sie display: "updates" mit dem Beta-Header thinking-display-updates-2026-08-18, um sie als Text zu erhalten, während die eigentliche Begründung verborgen bleibt.

{
  "model": "claude-fable-5-1",
  "max_tokens": 16000,
  "thinking": {"type": "adaptive", "display": "updates"},
  "tools": [...],
  "messages": [{"role": "user", "content": "Review the PRs open against our billing service."}]
}

Jeder thinking-Block mit nicht leerem Text ist dann eine Statuszeile, die Sie rendern können. Fable 5.1 schreibt weniger davon als Fable 5. Wenn Ihre Benutzeroberfläche also von Erzählungen abhängt, entfernen Sie auch jede Prompt-Zeile, die dem Modell sagt, Ergebnisse für die endgültige Antwort zurückzuhalten.

Schritt 8: Das Usage-Objekt für den $0.25 Cache-Tarif lesen

Prompt-Caching ist der Bereich, in dem die Preisänderung von Fable 5.1 zum Tragen kommt. Setzen Sie cache_control auf das stabile Präfix und bestätigen Sie Treffer in usage:

response = client.messages.create(
    model="claude-fable-5-1",
    max_tokens=16000,
    system=[{"type": "text", "text": LONG_STABLE_SYSTEM_PROMPT, "cache_control": {"type": "ephemeral"}}],
    messages=[{"role": "user", "content": "Which endpoints in the spec lack an error schema?"}],
)
u = response.usage
print(u.input_tokens, u.cache_creation_input_tokens, u.cache_read_input_tokens)

Beim ersten Senden ist cache_creation_input_tokens ungleich Null (abgerechnet mit $12.50 pro Million für die 5-minütige TTL). Beim zweiten Senden innerhalb von fünf Minuten sollte cache_read_input_tokens ungleich Null sein, abgerechnet mit $0.25 pro Million. Bleibt er bei identischen Anfragen Null, ändert sich jedes Mal etwas im Präfix: ein Zeitstempel im System-Prompt, unsortiertes JSON, ein variierendes Tool-Array. Der minimal cachefähige Prompt beträgt 512 Token.

Zwei Cache-Fakten, die spezifisch für dieses Modell sind. Da ein Fehlgriff das 40-fache eines Treffers kostet, ist es wichtiger, den Cache warm zu halten als bei Fable 5, und sowohl der Aufwand pro Nachricht als auch zugbezogene Systemnachrichten existieren teilweise, damit Sie Dinge mitten in der Sitzung ohne einen Reset ändern können. Und dieselben Bearbeitungen, die den Cache zurücksetzen (Neuerstellung von system, Bearbeitung früherer Züge), invalidieren nun auch Denkblöcke, sodass die Append-only-Disziplin doppelt zahlt.

Den gesamten Ablauf in Apidog testen und debuggen

Speichern Sie jeden obigen Schritt als Anfrage in einer Apidog-Sammlung: erster Aufruf, Aufwandsvarianten, Streaming, Tool-Schleife, Fallback, Cache-Überprüfung. Verwenden Sie Umgebungsvariablen für den Schlüssel und für model, sodass das Wechseln einer gesamten Sammlung zwischen claude-fable-5 und claude-fable-5-1 eine einzige Bearbeitung ist. Fügen Sie dann Zusicherungen hinzu: stop_reason ist nicht refusal bei Ihren gutartigen Test-Prompts, usage.cache_read_input_tokens ist größer als Null bei der zweiten Cache-Anfrage, und kein input_transformations-Eintrag hat reason: "prefix_binding_mismatch", wenn Sie mit dem thinking-binding-Header arbeiten. Führen Sie die Sammlung vor und nach jeder Änderung der Testumgebung aus. Laden Sie Apidog herunter, um es einzurichten; dieselbe Sammlung funktioniert als CI-Prüfung über die Apidog CLI.

Fehler und Fallstricke, auf die Sie stoßen werden

• 400 tool_choice: type "tool" and "any" are not supported for this model. Wechseln Sie zu auto plus einer Anweisung und strict: true.
• 400 bei thinking: {"type": "disabled"}. Entfernen Sie das Feld. Reduzieren Sie stattdessen den Aufwand.
• 400 invalid_request_error mit einem gültigen Body. Überprüfen Sie, ob die Organisation oder der Arbeitsbereich eine 30-tägige Aufbewahrungsfrist hat.
• 400 Invalid signature in thinking block. The block is bound to a different conversation. Ihr Code hat einen früheren Zug, den System-Prompt oder das Tools-Array bearbeitet. Siehe den Leitfaden zum erhaltenen Denken.
• Stummer leerer Denktext. Erwartet unter display: "omitted". Verwenden Sie "summarized" oder "updates", wenn Sie es rendern.
• Cache-Lesevorgänge bei Null. Ein volatiles Präfix. Überprüfen Sie auf Zeitstempel und unsortierte Objekte.
• Priority Tier-Anfrage schlägt Validierung fehl. Fable 5.1 unterstützt Priority Tier nicht. Fable 5 schon.

FAQ

Wie lautet die Modell-ID für die Claude Fable 5.1 API? claude-fable-5-1. Auf Amazon Bedrock ist es anthropic.claude-fable-5-1; Google Cloud, Microsoft Foundry und Claude Platform auf AWS verwenden claude-fable-5-1.

Benötige ich einen Beta-Header, um Claude Fable 5.1 zu verwenden? Nein. Das Basismodell, adaptives Denken, Aufwand, Tools und Caching funktionieren alle mit dem Standard-Header anthropic-version: 2023-06-01. Beta-Header werden nur für den Aufwand pro Nachricht, zugbezogene Systemnachrichten, Fortschrittsaktualisierungen, serverseitige Fallbacks und die Steuerung des Denk-Bindings benötigt.

Kann ich einen Tool-Aufruf bei Claude Fable 5.1 erzwingen? Nein. tool_choice any und tool geben einen 400er zurück. Verwenden Sie auto, benennen Sie das Tool im Prompt und setzen Sie strict: true für schema-gültige Argumente, oder verwenden Sie strukturierte Ausgaben für die JSON-Extraktion.

Wie hoch ist die maximale Ausgabe der Claude Fable 5.1 API? 128.000 Token über die Messages API. Für alles Große streamen. Die 300.000-Token Batch API Beta ist nicht für Fable 5.1 gelistet.

Wie sehe ich die günstigeren Cache-Lesevorgänge? Schauen Sie sich usage.cache_read_input_tokens bei einer wiederholten Anfrage an. Diese Token werden bei Fable 5.1 mit $0.25 pro Million abgerechnet, im Vergleich zu $1 bei Fable 5 und $0.50 bei Opus 5. Die Preisübersicht zeigt die Zahlen.

Gilt der Fable 5 API-Leitfaden noch? Größtenteils. Der Fable 5 API-Leitfaden behandelt denselben Endpunkt, aber seine Beispiele für erzwungene Tool-Nutzung geben jetzt einen 400er zurück und er stammt aus der Zeit vor den Aufwands- und Fortschrittsaktualisierungen pro Nachricht.