Streaming der Claude API — die wichtigsten Funktionen erklärt

Wenn du willst, dass sich Claude schnell anfühlt, aktiviere Streaming. Statt 15–25 Sekunden auf eine vollständige Antwort zu warten, sehen Nutzer den ersten Token oft schon nach etwa 300–800 ms.

Hier die Kurzfassung:

• Ich würde SSE-Streaming einsetzen, wenn Antworten erscheinen sollen, während sie generiert werden
• Ich würde Claude-Aufrufe hinter einem Backend-Proxy halten, um API-Keys zu schützen
• Ich würde TTFT (Time to First Token), max_tokens und Verbindungsabbrüche überwachen, um UX und Kosten zu steuern
• Ich würde gestreamte Events der Reihe nach parsen: message_start, Content-Block-Events, message_delta, dann message_stop
• Ich würde Tool-JSON-Fragmente puffern, bis der Content-Block endet
• Ich würde mit abgebrochenen Verbindungen rechnen, denn Claude setzt Streams nicht nativ fort

Ein paar Zahlen stechen heraus:

• Haiku 4.5: etwa 410 ms TTFT
• Sonnet 4.6: etwa 720 ms TTFT
• Opus 4.7: etwa 980 ms TTFT
• Standard-Proxy-Timeouts von 30–60 Sekunden können lange Ausgaben abschneiden
• Längere Read-Timeouts von 120–300 Sekunden sind oft nötig
• Batch-Jobs können 50 % weniger kosten als Standard-Token-Tarife

Ganz einfach gesagt: Streaming ändert die Auslieferung, nicht das Modell. Die Claude API sendet Text in kleinen Event-Chunks über eine offene Verbindung, und meine App setzt die finale Antwort auf dem Bildschirm wieder zusammen. Bei Chats, Copiloten und Assistenten bedeutet das meist ein besseres Nutzergefühl, weniger Idle-Timeout-Probleme und mehr Arbeit auf Client- und Backend-Seite.

Darauf kommt es am meisten an:

Wenn ich das also aufsetzen würde, würde ich Streaming als UX- und Infrastruktur-Entscheidung betrachten, nicht nur als API-Flag.

Entwickeln mit der Claude API – Teil 4 – Response-Streaming

Wie Claude-API-Streaming auf Protokollebene funktioniert

Streaming zu aktivieren, ändert nicht das Modell selbst. Es ändert, wie die Ausgabe ausgeliefert wird. Statt auf eine vollständige Antwort zu warten, sendet Claude kleine Chunks, sobald sie bereit sind.

Welcher Endpunkt und welche Request-Einstellungen Streaming aktivieren

Streaming nutzt denselben Claude-Messages-API-Endpunkt, /v1/messages, wie ein normaler Request. Der einzige Unterschied ist das Hinzufügen von "stream": true zum Request-Body ^[1][3]. Dieses Flag verschiebt die Verbindung von einem üblichen Request-Response-Ablauf zu Server-Sent Events (SSE), bei denen der Server Chunks pusht, sobald sie generiert werden.

Die offiziellen Python- und TypeScript-SDKs enthalten Stream-Helfer, die das Event-Parsing und die Nachrichtenzusammensetzung für dich übernehmen. Wenn der Stream endet, liefert der Aufruf von .get_final_message() in Python oder .finalMessage() in TypeScript die vollständige Antwort zurück, samt Token-Zahlen und Stop-Grund ^[1][4].

Diese Einstellungen starten den Stream. Der nächste Baustein ist der Event-Fluss, der über die Verbindung zurückkommt.

Welche Events während eines Streams eintreffen

Ein Stream folgt einer festen Abfolge benannter Events. Jedes Event trägt die Daten, die dein Client braucht, um die vollständige Antwort korrekt wieder aufzubauen.

Das sind die Daten, die dein Client puffert und in Echtzeit anzeigt. Für reine Textausgabe hängst du jedes text_delta an einen lokalen Puffer an, sobald die Events eintreffen. So setzt sich der vollständige Antwort-String Stück für Stück zusammen. Tool-Call-Inputs funktionieren etwas anders: Sie kommen als input_json_delta-Fragmente an, du solltest sie also zuerst puffern und erst nach content_block_stop parsen ^[1][6].

Wann APIMart für Claude-Streaming relevant ist

Wenn Claude-Streaming in einer Multi-Modell-App steckt, gibt dir APIMart einen zentralen Ort, um Claude-Zugriff und Streaming über eine einheitliche LLM-API zu routen. Das ist vor allem dann wichtig, wenn du denselben Streaming-Ablauf über Web- und Mobile-Clients hinweg willst.

So fügst du Claude-Streaming in Web- und Mobile-Apps ein

SSE, HTTP-Streaming oder WebSocket-Wrapper: welches davon nutzen?

Sobald du verstehst, wie Claude gestreamte Events sendet, ist der nächste Schritt, diese Events zu Web- und Mobile-Clients zu bringen. Die Hauptfrage ist einfach: welcher Transport passt am besten zu deiner App?

Für die meisten browserbasierten Apps ist SSE die Standardwahl. Es funktioniert gut mit den meisten Proxys und CDNs, und die Browser-Unterstützung ist unkompliziert.

WebSockets können trotzdem sinnvoll sein. Wenn deine App ohnehin auf bidirektionaler Live-Kommunikation basiert, passen sie womöglich genau. Aber für eine Standard-Chat-App bringen sie oft mehr bewegliche Teile mit, als sie wert sind.

Warum ein Backend-Proxy meist die sicherste Architektur ist

Nachdem du den Transport gewählt hast, lege das Stream-Handling hinter deinen Server. Halte Claude-Requests hinter einem Backend-Proxy, um deine API-Keys für verschiedene Modelle zu schützen ^[9][5].

Diese Proxy-Schicht ist außerdem der richtige Ort, um:

• System-Prompts einzuspeisen
• Rate-Limits pro Nutzer durchzusetzen
• das Timing von erstem und letztem Token zu loggen

Setze X-Accel-Buffering: no, um das Proxy-Buffering zu stoppen ^[2][8]. Verbinde außerdem das Abort-Signal des Clients mit dem Stream. So wird der Request, wenn ein Nutzer die Generierung stoppt, sofort abgebrochen, statt Tokens für eine Antwort zu verbrennen, die niemand lesen wird.

Noch eine Falle: Standard-Timeouts von 30–60 Sekunden können lange Antworten abschneiden ^[9][2]. Verwende in der Produktion Read-Timeouts von etwa 120–300 Sekunden für längere Generierungen.

Wie eine gute Client-seitige UX während einer Live-Antwort aussieht

Sobald der Stream geschützt und weitergeleitet ist, verlagert sich die Arbeit auf die UI. Hier fühlt sich Streaming entweder flüssig oder holprig an.

Zeige einen „Denkt nach …"-Indikator oder Spinner, sobald der Nutzer einen Prompt absendet. Das überbrückt die Verzögerung bis zum ersten Token. Sobald das erste content_block_delta eintrifft, entferne den Indikator und beginne, Text zu rendern.

Hänge dann jedes text_delta an, sobald es eintrifft, sodass die Antwort mit einem Schreibmaschineneffekt erscheint. Damit die Oberfläche nicht ruckelt, bündle Updates mit requestAnimationFrame, um nicht zu viele Re-Renders auszulösen. Auto-Scroll sollte der Antwort während der Generierung folgen, sich aber zurückhalten, wenn der Nutzer nach oben scrollt, um älteren Inhalt zu lesen.

Baue immer einen „Stop"-Button ein, der mit AbortController verdrahtet ist, damit er den Fetch-Request abbrechen kann. Das sollte den Stream sauber beenden, ohne bereits angezeigten Text zu löschen.

Wenn die Verbindung abbricht, halte die Teilausgabe sichtbar. Für die Wiederherstellung behalte diesen Teiltext und starte mit einem Fortsetzungs-Prompt neu, da Claude einen abgebrochenen Stream nicht nativ fortsetzt ^[3][1].

So steuerst du Latenz, Kosten und Zuverlässigkeit in der Produktion

Sobald der Stream läuft, läuft die Produktionsarbeit auf drei Stellschrauben hinaus: Latenz, Ausgaben und Wiederherstellung.

Wie Streaming die wahrgenommene Latenz verändert

Die wichtigste UX-Kennzahl hier ist Time to First Token (TTFT): die Zeit, bis das erste Wort erscheint. In einer Streaming-App prägt dieser erste sichtbare Token das gesamte Gefühl des Produkts. Erscheint er schnell, wirkt die App reaktionsschnell. Zieht er sich, fällt es den Nutzern auf.

Benchmarks zeigen klare Unterschiede zwischen den Claude-Modellen: Haiku 4.5 erreicht etwa 410 ms TTFT, Sonnet 4.6 liegt bei rund 720 ms, und Opus 4.7 kommt auf ungefähr 980 ms ^[3]. Die einfache Regel lautet: Nutze das schnellste Modell, das deine Qualitätsanforderungen noch erfüllt.

Auch die Prompt-Größe spielt eine Rolle. Größere Kontextfenster können die TTFT auf 1–3 Sekunden treiben ^[5]. Wenn dein System-Prompt also zusätzliche Anweisungen, alte Regeln oder aufgeblähte Beispiele enthält, kann deren Kürzung die App deutlich flotter wirken lassen.

Wie du Token-Verbrauch verfolgst und USD-Kosten kontrollierst

Streaming und Batch kosten pro Token dasselbe. Das Einzige, was sich ändert, ist, wann die Ausgabe eintrifft. Token-Zahlen sind im Stream selbst enthalten: Das message_start-Event enthält usage.input_tokens, und das message_delta-Event gegen Ende enthält die finalen kumulierten usage.output_tokens ^[1][4]. Dein Backend sollte diese finalen Nutzungsdaten nach dem Streamende speichern, damit die Abrechnung korrekt bleibt.

Setze max_tokens bei jedem Request. Das gibt dir einen harten Stopp und verhindert, dass lange Generierungen die Kosten hochtreiben ^[1][11]. Du solltest außerdem serverseitig auf Client-Abbrüche achten. Wenn der Nutzer weg ist und die Generierung weiterläuft, verbrennst du weiterhin ohne Grund Tokens ^[5][7].

Für Jobs, die keine Live-Ausgabe brauchen, ändert sich die Rechnung. Batch-Zusammenfassungen, Offline-Verarbeitung und nächtliche Report-Generierung sind gute Beispiele. In diesen Fällen bietet die Batch API einen Rabatt von 50 % auf die normalen Token-Tarife ^[5][10].

Claude 3.5 Sonnet kostet im Standard-Streaming etwa 3,00 $ pro 1 Million Input-Tokens und 15,00 $ pro 1 Million Output-Tokens ^[8]. Mit der Batch API kosten asynchrone Workloads nur halb so viel.

Diese Nutzungszahlen helfen auch beim Monitoring von Abrechnung und Rate-Limits. Weitere Strategien zum Umgang mit hohem Anfragevolumen findest du in unseren Tipps zu AI-API-Kosten.

Wie du abgebrochene Streams verhinderst und sicher wiederherstellst

Claude hat keine serverseitige Resume-Funktion ^[1][3]. Wenn ein Stream abbricht, sende die Teilausgabe in einem neuen Request und bitte Claude, ab dem Abbruchpunkt fortzufahren.

Wiederhole nur Fehler, die sich wahrscheinlich von selbst beheben.

Danach besteht der letzte Schritt darin, zu entscheiden, welche Streaming-Funktionen am wichtigsten sind.

Fazit: Welche Claude-Streaming-Funktionen am wichtigsten sind

Wenn du dir Latenz, Kosten und Zuverlässigkeit angesehen hast, läuft Claude-Streaming auf drei Dinge hinaus: wahrgenommene Reaktionsschnelligkeit, klare Event-Signale und solides Error-Handling.

Streaming ist wichtig, weil die Auslieferung des ersten Tokens Claude schnell und reaktionsschnell wirken lässt.

Der SSE-Event-Fluss liefert dir Text-Deltas, Nutzungszahlen und Fehlersignale in Echtzeit ^[1][3].

Nutze einen Backend-Proxy, um Keys zu schützen, das Buffering auszuschalten und mit Verbindungsabbrüchen umzugehen ^[2][8]. Für Multi-Modell-Apps kann APIMart Claude-Streaming, Logging und Abrechnung zentralisieren.

In der Produktion zählen schnelle TTFT, Nutzungs-Tracking und Proxy-Resilienz am meisten.

FAQs

Wann sollte ich Streaming statt einer normalen Claude-API-Antwort verwenden?

Nutze Streaming, wenn deine App nutzerorientiert ist. Sie sendet Tokens, während sie generiert werden, sodass sich Antworten fast sofort anfühlen. Dieser kleine Wechsel kann das gesamte Produkt schneller und flüssiger wirken lassen.

Streaming eignet sich am besten für Echtzeit-Chat, lange Antworten und Agent-Workflows mit Tool-Calls. Es hilft außerdem, Timeouts zu vermeiden, wenn Ausgaben lang werden oder Token-Limits hoch sind.

Verzichte darauf bei kurzen, einfachen Requests oder Batch-Jobs, bei denen Durchsatz wichtiger ist als Latenz.

Was soll ich tun, wenn ein Claude-Stream mitten in der Antwort abbricht?

Wenn ein Claude-Stream abbricht, setzen Server-Sent Events nicht von selbst dort fort, wo sie aufgehört haben. Deine App muss diesen Teil übernehmen.

Wenn die Verbindung abbricht, kannst du entweder den vollständigen Request erneut senden oder die bereits gespeicherte Teilausgabe anzeigen. Nutze einen try/except-Block, um APIConnectionError oder APIStatusError abzufangen, und behalte eine Referenz auf den bisher angesammelten Inhalt.

Wenn du willst, dass der Stream mit weniger Reibung fortgesetzt wird, verfolge die letzte Event-ID und spiele den Stream ab diesem Punkt manuell erneut ab.

Wie kann ich Streaming-Kosten senken, ohne die UX zu beeinträchtigen?

Konzentriere dich auf Prompt-Tuning und effizientes Session-Handling. Setze harte max_tokens-Limits, halte Prompts kurz und füge eine Option zum frühen Abbruch hinzu, damit Nutzer die Generierung stoppen können, sobald sie haben, was sie brauchen.

Für Batch-Workloads, die kein sofortiges Hin und Her brauchen, nutze den Non-Streaming-Modus. Für ein genaues Kosten-Tracking warte auf das finale message_stop-Event, statt aus Chunks mitten im Stream zu schätzen.