Anthropic hat Claude Fable 5 am 9. Juni 2026 ausgeliefert, und wenn Sie beruflich Code schreiben, ist die Claude Fable 5 API der Teil, der Sie interessiert. Sie läuft auf derselben Messages API, die Sie bereits kennen, sodass sich nur der Modellstring wirklich ändert: claude-fable-5. Dieser Leitfaden führt Sie durch jeden Aufruf, den Sie benötigen, um funktionierenden Code vor eine echte Antwort zu bekommen, von einer einzeiligen Curl-Anfrage bis hin zu Streaming, Tool-Nutzung, Fehlerbehandlung und Kostenberechnung. Wenn Sie bereits mit Claude gearbeitet haben, wird sich die Struktur vertraut anfühlen. Wenn Sie von einem älteren Modell migriert sind, ist der Umzug hauptsächlich ein String-Austausch, genau wie bei der Claude Opus 4.8 API.
TL;DR
Holen Sie sich einen API-Schlüssel von der Anthropic Konsole, setzen Sie ihn als ANTHROPIC_API_KEY, und senden Sie dann eine POST-Anfrage an die Messages API mit model: "claude-fable-5", einem max_tokens-Wert und einem messages-Array. Verwenden Sie das offizielle Anthropic SDK für Python oder TypeScript, oder raw HTTP. Streamen Sie lange Ausgaben, um Request-Timeouts zu vermeiden. Die Preise betragen 10 $ pro Million Eingabe-Token und 50 $ pro Million Ausgabe-Token.
Bevor Sie beginnen
Bevor Sie Ihre erste Anfrage stellen, benötigen Sie vier Dinge:
- Ein Anthropic-Konto. Registrieren Sie sich unter console.anthropic.com. In der Konsole verwalten Sie Schlüssel, Nutzung und Abrechnung.
- Ein API-Schlüssel. Erstellen Sie einen in der Konsole unter API Keys. Kopieren Sie ihn einmal; Sie werden ihn nicht wiedersehen. Behandeln Sie ihn wie ein Passwort.
- Abrechnung oder ein Enterprise-Plan. Fable 5 ist über die Standard Claude API verfügbar und vollständig in verbrauchsabhängigen Enterprise-Plänen enthalten. Fügen Sie eine Zahlungsmethode hinzu oder bestätigen Sie, dass Ihr Plan dies abdeckt, bevor Sie Datenverkehr senden. Wenn Sie noch unentschlossen sind, ob Fable 5 für Ihren Anwendungsfall geeignet ist, bietet die Übersicht darüber, was Claude Fable 5 ist, die Stärken des Modells in einfachen Worten.
- Ein SDK (optional, aber empfohlen). Installieren Sie das offizielle Anthropic SDK für Ihre Sprache. Sie können den raw HTTP-Endpunkt auch mit curl oder einem beliebigen HTTP-Client aufrufen, wenn Sie dies bevorzugen.
Setzen Sie den Schlüssel als Umgebungsvariable, damit er niemals in Ihrem Quellcode landet:
export ANTHROPIC_API_KEY="sk-ant-..."
Beide SDKs lesen ANTHROPIC_API_KEY automatisch aus der Umgebung, sodass Sie es selten im Code übergeben müssen. Halten Sie Schlüssel aus Git heraus. Wenn ein Schlüssel kompromittiert wird, drehen Sie ihn sofort in der Konsole.
Eine vorab wichtige Information: Fable 5 verfügt über Schutzmechanismen, die einen kleinen Teil sensibler Anfragen (Cybersicherheit, Biologie und Chemie sowie Versuche zur Modell-Destillation) stattdessen an Claude Opus 4.8 weiterleiten. Dies tritt in weniger als 5 % der Sitzungen auf. Sie müssen dafür nichts konfigurieren, aber es erklärt die gelegentlichen Antworten, die als ein anderes Modell gekennzeichnet zurückkommen. Mehr dazu im Abschnitt zur Fehlerbehandlung.
Ihr erster Claude Fable 5 API-Aufruf
Beginnen Sie mit curl, damit Sie die rohe Anfrage und Antwort ohne Hindernisse sehen können. Der Endpunkt ist POST https://api.anthropic.com/v1/messages, dokumentiert in der Anthropic Messages API Referenz, und er benötigt drei Header sowie einen JSON-Body.
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."}]}'
Drei Header sind hier wichtig. x-api-key enthält Ihren Schlüssel. anthropic-version fixiert die API-Version (2023-06-01 ist der aktuelle stabile Wert). content-type teilt dem Server mit, dass Sie JSON senden. Der Body hat drei erforderliche Felder: model, max_tokens und messages. Das ist der gesamte Vertrag.
Die Antwort kommt als JSON-Objekt zurück. Der Teil, der Sie interessiert, ist content, eine Liste von Blöcken:
{
"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 }
}
content ist eine Liste, kein String, da eine einzelne Antwort Text-, Tool-Nutzungs- und Denkblöcke mischen kann. Durchlaufen Sie die Liste immer und überprüfen Sie den type jedes Blocks, bevor Sie text lesen. Der stop_reason sagt Ihnen, warum das Modell gestoppt hat (end_turn ist ein sauberer Abschluss), und usage gibt Ihnen die Token-Anzahlen, die Sie später für die Kostenberechnung verwenden werden.
Aufruf von Fable 5 aus Python
Das offizielle Anthropic Python SDK entfernt den Header- und JSON-Standardcode. Installieren Sie es zuerst:
pip install anthropic
Hier ist der grundlegende Aufruf. Der Client liest Ihren Schlüssel aus der Umgebung, sodass Sie ihn nicht übergeben müssen:
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)
Das Muster spiegelt den Curl-Aufruf wider. Sie übergeben model, max_tokens und messages und erhalten eine Antwort zurück, deren content eine Liste von Blöcken ist. Die Schleife prüft auf block.type == "text", sodass Sie niemals über einen Nicht-Text-Block stolpern.
System-Prompt hinzufügen
Ein System-Prompt legt die Rolle des Modells und die Grundregeln für die gesamte Konversation fest. Übergeben Sie ihn als system-Feld, getrennt von messages:
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)
Der System-Prompt ist der richtige Ort für Persona, Regeln für das Ausgabeformat und Einschränkungen, die Sie über jeden Durchgang hinweg beibehalten möchten. Halten Sie ihn stabil, da eine Änderung bei jeder Anfrage das Prompt-Caching zunichtemacht, falls Sie es später hinzufügen.
Lange Ausgaben streamen
Für alles, was eine lange Antwort produziert, streamen Sie es. Streaming sendet Token, sobald sie generiert werden, sodass Sie sofort Fortschritte sehen und Request-Timeouts vermeiden, die bei großen, nicht-gestreamten Antworten auftreten. Die Langzeitfähigkeiten von Fable 5 machen dies zur Standardwahl für reale Workloads:
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}")
stream.text_stream liefert Text-Chunks, sobald sie eintreffen. Das flush=True ist wichtig, damit jeder Chunk sofort gedruckt wird, anstatt zu puffern. Wenn der Stream beendet ist, übergibt Ihnen stream.get_final_message() die vollständig zusammengestellte Nachricht, einschließlich der endgültigen usage-Zahlen, sodass Sie das gestreamte Benutzererlebnis und das vollständige Objekt ohne eine zweite Anfrage erhalten.
Aufruf von Fable 5 aus TypeScript / Node
Das Node SDK folgt der gleichen Struktur. Installieren Sie es:
npm install @anthropic-ai/sdk
Führen Sie dann den Aufruf durch. Der Client liest ANTHROPIC_API_KEY aus der Umgebung, genau wie Python:
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);
msg.content ist dieselbe Liste von Blöcken, die Sie in Python und Curl gesehen haben. Um nur den Text zu extrahieren, filtern Sie nach dem Blocktyp:
const text = msg.content
.filter((block) => block.type === "text")
.map((block) => block.text)
.join("");
console.log(text);
Streaming funktioniert genauso wie in Python. Verwenden Sie client.messages.stream({...}) und iterieren Sie die Ereignisse, oder warten Sie auf finalMessage(), um das zusammengestellte Ergebnis zu erhalten. Wenn Sie dies in einen Frontend-Chat einbinden, streamen Sie von einer Server-Route und leiten die Chunks an den Browser weiter. Dieselben Testgewohnheiten gelten, egal ob Sie in Node oder Python entwickeln, und ein Tool wie Apidog macht es einfach, den Vertrag zu überprüfen, bevor Sie Client-Code schreiben, was derselbe Workflow ist, der beim Testen der ChatGPT API mit Apidog behandelt wird.
Tool-Nutzung (Funktionsaufrufe) mit Fable 5
Die Tool-Nutzung ermöglicht es Fable 5, von Ihnen definierte Funktionen aufzurufen. Sie beschreiben ein Tool mit einem JSON-Schema, das Modell entscheidet, wann es aufgerufen werden soll, und Sie führen die eigentliche Funktion aus und geben das Ergebnis zurück. Fable 5 ist stark in der Tool-Nutzung, weshalb es gut zu Agenten-Loops passt.
Definieren Sie ein Tool mit einem Namen, einer Beschreibung und einem input_schema:
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"],
},
}
]
Übergeben Sie tools an die Anfrage, genau wie Sie messages ü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,
)
Wenn das Modell ein Tool verwenden möchte, kommt die Antwort mit stop_reason == "tool_use" und einem tool_use-Block zurück, der den Tool-Namen und die von ihm gewählte Eingabe enthält. Die Schleife ist unkompliziert: Hängen Sie die Antwort des Assistenten an, führen Sie das Tool aus und senden Sie das Ergebnis dann als tool_result-Block in einem neuen Benutzerzug zurück:
if response.stop_reason == "tool_use":
tool_use = next(b for b in response.content if b.type == "tool_use")
# Führen Sie Ihre reale Funktion mit der vom Modell gewählten Eingabe aus
result = lookup_order(tool_use.input["order_id"]) # Ihr Code
messages.append({"role": "assistant", "content": response.content})
messages.append({
"role": "user",
"content": [{
"type": "tool_result",
"tool_use_id": tool_use.id,
"content": result,
}],
})
# Senden Sie das Ergebnis zurück; das Modell antwortet nun damit
followup = client.messages.create(
model="claude-fable-5",
max_tokens=1024,
tools=tools,
messages=messages,
)
Das entscheidende Detail ist tool_use_id: Der tool_result-Block muss die genaue id aus dem tool_use-Block referenzieren, damit das Modell weiß, welche Anfrage Ihr Ergebnis beantwortet. Für mehrstufige Agenten wickeln Sie dies in eine Schleife, die so lange läuft, bis stop_reason `end_turn` ist. Das Python SDK liefert auch einen Tool-Runner mit, der die Schleife für Sie übernimmt, aber die manuelle Version oben zeigt, was unter der Haube passiert, und bietet Ihnen einen Ort, um Genehmigungsschranken oder Logging hinzuzufügen.
Adaptives Denken und Aufwand
Fable 5 unterstützt adaptives Denken, wobei das Modell selbst entscheidet, wann und wie tiefgründig es argumentieren soll, bevor es antwortet. Es ist optional. Schalten Sie es ein, indem Sie thinking übergeben, und passen Sie die gesamte Tiefe und den Token-Verbrauch mit output_config an:
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."}],
)
effort steuert, wie viel das Modell denkt und arbeitet: geringerer Aufwand bedeutet prägnantere, schnellere Antworten, höherer Aufwand bedeutet gründlichere Argumentation bei höheren Token-Kosten. Lassen Sie beides aus für einfache Suchen und kurze Antworten, bei denen die zusätzliche Argumentation die Token nicht wert ist. Greifen Sie darauf zurück bei schwierigen, mehrstufigen Problemen, der Art von Langzeitplanung, für die Fable 5 entwickelt wurde. Halten Sie es am Anfang einfach; Sie können thinking später hinzufügen, sobald Sie wissen, dass eine Route es benötigt.
Fehlerbehandlung und der Schutzmechanismus-Fallback
Echte Integrationen müssen Fehler sauber behandeln. Das SDK löst typisierte Ausnahmen aus, fangen Sie also die spezifische Klasse ab, anstatt Fehlermeldungen abzugleichen. Die drei, die Sie am häufigsten sehen werden, entsprechen HTTP 401, 429 und 400:
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. Überprüfen Sie ANTHROPIC_API_KEY.
print("Ungültiger API-Schlüssel. Drehen Sie ihn in der Konsole und exportieren Sie ihn erneut.")
except anthropic.RateLimitError as e:
# 429: Zu viele Anfragen. Warten Sie ab und versuchen Sie es erneut.
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 (falsche Parameter, leere Nachrichten, falsche Form).
print(f"Fehlerhafte Anfrage: {e.message}")
Hier ist, was jeder einzelne bedeutet und wie man ihn behebt:
- 401 (
AuthenticationError): Der Schlüssel fehlt, ist fehlerhaft oder wurde widerrufen. Bestätigen Sie, dassANTHROPIC_API_KEYin der Umgebung gesetzt ist, in der Ihr Code tatsächlich ausgeführt wird, und dass der Schlüssel in der Konsole noch aktiv ist. - 429 (
RateLimitError): Sie haben Ihr Limit für Anfragen pro Minute oder Token pro Minute überschritten. Das SDK versucht 429- und 5xx-Fehler bereits mit exponentiellem Backoff erneut (standardmäßig zwei Wiederholungen). Lesen Sie denretry-after-Header, wenn Sie ein benutzerdefiniertes Backoff hinzufügen. - 400 (
BadRequestError): Die Anfrage ist fehlerhaft. Häufige Ursachen sind ein leeresmessages-Array, ein fehlendermax_tokens-Wert oder Nachrichten, die Rollen nicht korrekt abwechseln. Die Fehlermeldung nennt normalerweise das Feld.
Nun zum Schutzmechanismus-Fallback. Fable 5 leitet eine kleine Menge sensibler Anfragen (Cybersicherheit, Biologie und Chemie sowie Destillationsversuche) an Claude Opus 4.8 weiter, anstatt direkt zu antworten. Dies tritt in weniger als 5 % der Sitzungen auf. Es ist kein Fehler, und Ihre Anfrage ist immer noch erfolgreich, aber die Antwort kann mit einem anderen Modell gekennzeichnet zurückkommen. Wenn Sie response.model protokollieren oder überprüfen, sollten Sie keinen harten Fehler auslösen, wenn es nicht claude-fable-5 ist; die Anfrage wurde bearbeitet, nur von einem anderen Modell im Hintergrund. Wenn Ihre Anwendung unbedingt wissen muss, welches Modell geantwortet hat, lesen Sie response.model aus dem zurückgegebenen Objekt, anstatt davon auszugehen, dass es dem entspricht, was Sie gesendet haben.
Kosten pro Anfrage schätzen
Die Preise betragen 10 $ pro Million Eingabe-Token und 50 $ pro Million Ausgabe-Token. Jede Antwort enthält die genauen Zählungen in usage, sodass Sie die Kosten pro Anfrage präzise berechnen können, anstatt zu raten:
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}")
Ausgabe-Token kosten das Fünffache der Eingabe-Token, daher ist der günstigste Hebel, den Sie haben, Antworten prägnant zu halten. Eine Anfrage mit 2.000 Eingabe-Token und 500 Ausgabe-Token kostet 2000 / 1M * $10 + 500 / 1M * $50, was $0.02 + $0.025 = $0.045 entspricht. Multiplizieren Sie mit Ihrem Anfragevolumen, um ein Budget festzulegen. Wenn die Ausgabekosten Ihre Rechnung dominieren, begrenzen Sie max_tokens und bitten Sie im System-Prompt um prägnante Antworten. Die Ausgabepreise sind dieselbe Berechnung, die Sie für das Claude Opus 4.8 Preismodell durchführen würden, nur mit den Zahlen von Fable 5.
Die Claude Fable 5 API mit Apidog testen und debuggen
Bevor Sie Client-Code schreiben, lohnt es sich, einige Anfragen manuell zu senden und genau zu beobachten, was zurückkommt. Apidog ist ein dafür entwickelter API-Client: Sie senden echte Anfragen an https://api.anthropic.com/v1/messages, inspizieren die gestreamte Antwort und speichern die Anfrage, damit Ihr gesamtes Team mit derselben Definition arbeiten kann. Hier ist ein sauberer Weg von Null zu einer funktionierenden, gespeicherten Anfrage.
- Die Anfrage erstellen. Erstellen Sie in Apidog eine neue HTTP-Anfrage, setzen Sie die Methode auf
POSTund fügen Sie die URLhttps://api.anthropic.com/v1/messagesein. Dies ist derselbe Endpunkt, den jedes Beispiel in diesem Leitfaden anspricht. - Speichern Sie Ihren Schlüssel als Umgebungsvariable. Erstellen Sie eine Apidog-Umgebungsvariable, nennen Sie sie beispielsweise
anthropic_api_key, und fügen Sie Ihren Schlüssel als geheimen Wert ein. Den Schlüssel in der Umgebung zu belassen bedeutet, dass er nicht in der gespeicherten Anfrage und nicht in Exporten, die Sie teilen, enthalten ist. - Die Header setzen. Fügen Sie
x-api-keymit dem Wert{{anthropic_api_key}}, dannanthropic-version: 2023-06-01undcontent-type: application/jsonhinzu. Wenn Sie eine Bearer-Stil-Geheimvariable bevorzugen, speichern Sie das Token auf die gleiche Weise und referenzieren Sie es mit der{{...}}-Syntax, damit der Rohwert niemals in der Anfrage erscheint. - Den JSON-Body hinzufügen. Fügen Sie die minimale Nutzlast ein:
{"model": "claude-fable-5", "max_tokens": 1024, "messages": [{"role": "user", "content": "Explain idempotency keys for payment APIs."}]}. Senden Sie es und lesen Sie die Antwort. Sie sollten diecontent-Blöcke,stop_reasonundusagedirekt im Antwortbereich sehen. - Gestreamte Antworten anzeigen. Setzen Sie
"stream": trueim Body und senden Sie erneut. Apidog rendert die Server-Sent Events, sobald sie eintreffen, sodass Sie die Token beim Streaming beobachten und bestätigen können, dass Ihre Streaming-Logik dem entspricht, was die API tatsächlich sendet, bevor Sie es in eine App einbauen. - Code speichern und generieren. Speichern Sie die Anfrage in einer Sammlung, damit Teamkollegen sie wiederverwenden können, und verwenden Sie dann die Code-Generierung von Apidog, um einen funktionierenden Code-Snippet in Python, JavaScript, Curl oder einer anderen Sprache zu exportieren. Das gibt Ihnen einen getesteten Startpunkt anstelle einer leeren Datei.
Dieser Workflow ist der schnellste Weg, um die genaue Antwortstruktur der API zu lernen und eine Anfrage zu debuggen, die sich in Ihrer App fehlerhaft verhält, da Sie die Anfrage Ihres Codes Seite an Seite mit einer bekanntermaßen funktionierenden vergleichen können. Wenn Sie bereit sind, es einzurichten, laden Sie Apidog herunter und beginnen Sie mit dem minimalen Body oben.