---
title: "LLM-Streaming per SSE: Chunks, Deltas, Usage, Abbruch"
description: "Wie Streaming von Chat Completions auf der Leitung funktioniert, wie Sie die Antwort aus Deltas zusammensetzen, Usage lesen und sauber abbrechen: Python, Node, curl."
url: https://broadrouter.com/de/blog/llm-streaming-sse-explained/
lang: de
updated: 2026-11-14
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

Mit KI-Unterstützung aus dem Englischen übersetzt. [Englisches Original lesen](https://broadrouter.com/blog/llm-streaming-sse-explained/) (aktualisiert am 2026-11-16).

# LLM-Streaming erklärt: SSE-Chunks, Deltas, Usage und Abbruch

Vom Team von BroadNet Inference · 4 Min. Lesezeit · Veröffentlicht 2026-11-14 · Aktualisiert 2026-11-16

Eine LLM-API streamt eine Chat Completion als Server-Sent Events: Jede data-Zeile enthält einen JSON-Chunk, dessen choices\[0\].delta das nächste Textstück trägt. Hängen Sie die Deltas aneinander, stoppen Sie bei data: \[DONE\] und setzen Sie stream\_options include\_usage, um die Token-Zahlen in einem letzten Chunk mit leerer choices-Liste zu erhalten. Zum Abbrechen schließen Sie die Verbindung.

## Das Wichtigste in Kürze

-   Ein Stream ist schlichtes HTTP: `Content-Type: text/event-stream`, eine `data:`\-Zeile pro Chunk, eine Leerzeile zwischen Events und `data: [DONE]` am Ende.
-   Jeder Chunk trägt ein `delta`, nicht die ganze Nachricht. Fügen Sie die `delta.content`\-Strings zusammen, um die Antwort zu rekonstruieren.
-   Usage ist in Streams standardmäßig aus. `stream_options: {"include_usage": true}` ergänzt einen letzten Chunk mit Usage und einem leeren `choices`\-Array.
-   Sichern Sie jeden Zugriff auf `choices[0]` ab: Der Usage-Chunk hat keine choices, und ein Parser, der welche voraussetzt, stürzt ab.
-   Brechen Sie ab, indem Sie die HTTP-Verbindung schließen. Ein Stream, der ohne `[DONE]` endet, ist eine unvollständige Antwort, keine fertige.

**Auf dieser Seite**

1.  Wie sieht ein SSE-Stream auf der Leitung aus?
2.  Was steckt in einem Chunk?
3.  Wie bekommen Sie die Token-Usage aus einem Stream?
4.  Python: streamen, Usage sammeln, abbrechen
5.  Node: streamen mit einem AbortController
6.  curl: die rohen Events sehen
7.  Wie brechen Sie einen Stream ab, und was kostet das?
8.  Fünf Streaming-Bugs, auf die Sie prüfen sollten
9.  Wo BroadNet Inference ins Bild passt

Ohne [Streaming](https://broadrouter.com/de/glossary/streaming/) liefert eine Chat Completion nichts, bis die ganze Antwort fertig ist. Eine Antwort mit 600 Tokens bei etwa 100 Tokens pro Sekunde bedeutet mehrere Sekunden Stille. Mit Streaming erscheinen die ersten Wörter, sobald das Modell sie schreibt. Dieser Beitrag behandelt, was tatsächlich über die Leitung geht, wie Sie es parsen, wie Sie die [Token](https://broadrouter.com/de/glossary/token/)\-Usage aus einem Stream holen und wie Sie einen Stream sauber stoppen. Die BroadNet-spezifischen Regeln in Kurzform finden Sie im [Referenzleitfaden zu Streaming](https://broadrouter.com/de/guides/streaming-chat-completions/).

## Wie sieht ein SSE-Stream auf der Leitung aus?

Server-Sent Events sind eine schlichte HTTP-Antwort mit `Content-Type: text/event-stream`. Der Server hält die Verbindung offen und schreibt Events. Jedes Event besteht aus einer oder mehreren `data:`\-Zeilen, gefolgt von einer Leerzeile. OpenAI-kompatible APIs legen einen JSON-Chunk in jedes Event und enden mit einem wörtlichen `[DONE]`:

```text
data: {"id":"c1","object":"chat.completion.chunk","choices":[{"index":0,"delta":{"role":"assistant","content":""},"finish_reason":null}],"usage":null}

data: {"id":"c1","object":"chat.completion.chunk","choices":[{"index":0,"delta":{"content":"One, "},"finish_reason":null}],"usage":null}

data: {"id":"c1","object":"chat.completion.chunk","choices":[{"index":0,"delta":{"content":"two, three."},"finish_reason":"stop"}],"usage":null}

data: {"id":"c1","object":"chat.completion.chunk","choices":[],"usage":{"prompt_tokens":14,"completion_tokens":6,"total_tokens":20}}

data: [DONE]
```

Die Form oben ist illustrativ und gekürzt. Echte Chunks tragen außerdem `model` und `created`, und Reasoning-Modelle können Reasoning-Tokens in usage ausweisen.

## Was steckt in einem Chunk?

| Feld | Wo | Bedeutung |
| --- | --- | --- |
| `choices[0].delta.role` | Erster Chunk | Meist `assistant`. Wird einmal gesendet. |
| `choices[0].delta.content` | Die meisten Chunks | Das nächste Textstück. Kann leer sein. |
| `choices[0].delta.tool_calls` | Tool Calls | Fragmente des Funktionsnamens und der JSON-Argumente, nach `index` zusammenzufügen. |
| `choices[0].finish_reason` | Letzter Inhalts-Chunk | `stop`, `length` oder `tool_calls`. Bis dahin `null`. |
| `usage` | Letzter Chunk, falls angefordert | Summen für die ganze Anfrage. Überall sonst `null`. |

Die Kernidee lautet **Delta, nicht Snapshot**. Jeder Chunk enthält nur das Neue. Sie setzen die Nachricht zusammen, indem Sie die Stücke der Reihe nach aneinanderhängen. [Tool Calls](https://broadrouter.com/de/glossary/tool-calling/) werden genauso gestreamt: Die Argumente kommen als String-Fragmente an, die erst mit dem letzten gültiges JSON ergeben. Parsen Sie sie daher erst, wenn `finish_reason` den Wert `tool_calls` hat.

## Wie bekommen Sie die Token-Usage aus einem Stream?

Eine Antwort ohne Streaming enthält immer `usage`. Ein Stream nicht, es sei denn, Sie fragen danach. Setzen Sie `stream_options: {"include_usage": true}`, dann sendet der Server vor `[DONE]` einen zusätzlichen Chunk. Dieser Chunk enthält die Summen und ein **leeres `choices`\-Array**. Bei BroadNet Inference kann die Usage außerdem `prompt_tokens_details.cached_tokens` und `completion_tokens_details.reasoning_tokens` enthalten, wenn das Modell sie meldet. Genau das brauchen Sie für das [Kosten-Logging](https://broadrouter.com/de/blog/llm-api-usage-logging/).

Der häufige Bug: Code, der bei jedem Chunk `chunk.choices[0]` liest, wirft beim Usage-Chunk einen Indexfehler. Prüfen Sie zuerst `choices`.

## Python: streamen, Usage sammeln, abbrechen

```python
import os
from openai import OpenAI

client = OpenAI(base_url="https://inference.broadnet.ai/v1", api_key=os.environ["BROADNET_API_KEY"])

stream = client.chat.completions.create(
    model="broadnet/deepseek-v4.1-flash",  # DeepSeek V4.1 Flash, a reasoning model
    messages=[{"role": "user", "content": "Explain SSE in three sentences."}],
    stream=True,
    stream_options={"include_usage": True},
    max_tokens=2000,  # reasoning counts toward this limit
)

def user_pressed_stop():  # replace with your own condition
    return False

parts, usage, finish = [], None, None
try:
    for chunk in stream:
        if chunk.choices:
            choice = chunk.choices[0]
            if choice.delta.content:
                parts.append(choice.delta.content)
                print(choice.delta.content, end="", flush=True)
            if choice.finish_reason:
                finish = choice.finish_reason
        if chunk.usage:
            usage = chunk.usage
        if user_pressed_stop():  # your own condition
            break
finally:
    stream.close()  # closes the HTTP connection

text = "".join(parts)
```

`break` allein beendet nur das Lesen, der Socket bleibt aber offen, bis er per Garbage Collection aufgeräumt wird. Schließen Sie ihn explizit, damit der Server die Trennung bemerkt.

## Node: streamen mit einem AbortController

```javascript
import OpenAI from "openai";

const client = new OpenAI({ baseURL: "https://inference.broadnet.ai/v1", apiKey: process.env.BROADNET_API_KEY });
const controller = new AbortController();
setTimeout(() => controller.abort(), 30_000); // hard stop after 30 s

const stream = await client.chat.completions.create(
  {
    model: "broadnet/deepseek-v4.1-flash",
    messages: [{ role: "user", content: "Explain SSE in three sentences." }],
    stream: true,
    stream_options: { include_usage: true },
  },
  { signal: controller.signal },
);

let text = "";
for await (const chunk of stream) {
  const delta = chunk.choices[0]?.delta?.content;
  if (delta) text += delta;
  if (chunk.usage) console.log(chunk.usage);
}
```

Das [openai-node-README](https://github.com/openai/openai-node) dokumentiert die Option `signal`, und sie funktioniert auch noch, während der Body gelesen wird. Verbinden Sie in einem Webserver `controller.abort()` mit dem `close`\-Event der Client-Anfrage, damit ein Nutzer, der die Seite verlässt, auch die Generierung stoppt. Mehr zur Einrichtung im [Leitfaden zum Node SDK](https://broadrouter.com/de/guides/openai-node-sdk/).

## curl: die rohen Events sehen

```bash
curl -N https://inference.broadnet.ai/v1/chat/completions \
  -H "Authorization: Bearer $BROADNET_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model":"broadnet/gemma-4-26b-a4b","stream":true,"stream_options":{"include_usage":true},"messages":[{"role":"user","content":"Count to five."}]}'
```

`-N` schaltet die Ausgabepufferung ab, sodass Events beim Eintreffen ausgegeben werden. Mit Strg+C brechen Sie ab; das schließt die Verbindung. Der [API-Request-Builder](https://broadrouter.com/tools/api-request-builder/) erzeugt diese Anfrage sowie die Python- und Node-Varianten für jedes Modell und jede Base-URL.

## Wie brechen Sie einen Stream ab, und was kostet das?

Abbrechen heißt bei SSE einfach, die Verbindung zu schließen. Eine „Stopp“-Nachricht gibt es nicht. Was danach passiert, liegt beim Server: Ein sauber implementierter Server bemerkt den geschlossenen Socket und hört auf zu generieren. Tokens, die bis dahin erzeugt wurden, waren echte Arbeit. Die API-Referenz von BroadNet dokumentiert die Abrechnung abgebrochener Streams nicht. Planen Sie also so, als würden bei [Pay-as-you-go](https://broadrouter.com/de/glossary/pay-as-you-go/) die bis zur Trennung erzeugten Tokens berechnet, und prüfen Sie Ihre Usage-Daten. Bei einem Pauschalplan kostet ein abgebrochener Stream nichts extra, gibt die Session aber erst frei, wenn der Server stoppt.

## Fünf Streaming-Bugs, auf die Sie prüfen sollten

1.  **Puffernde Proxys.** Nginx und manche CDNs puffern Antworten, sodass der Client alles auf einmal bekommt. Schalten Sie die Proxy-Pufferung für die Streaming-Route ab.
2.  **Keine Prüfung auf `[DONE]`.** Eine abgebrochene Verbindung sieht aus wie eine kurze Antwort. Behandeln Sie ein fehlendes `[DONE]` als unvollständig und notieren Sie die `X-Request-ID`, wie im [Leitfaden zu Fehlern](https://broadrouter.com/de/guides/errors-and-retries/) beschrieben.
3.  **Retry mitten im Stream.** SDKs wiederholen nicht mehr, sobald der Body eintrifft. Ein Retry ist eine neue Anfrage und bei Pay-as-you-go eine neue Rechnung.
4.  **`finish_reason: length` ignorieren.** Bei Reasoning-Modellen wie [DeepSeek V4.1 Flash](https://broadrouter.com/de/models/deepseek-v4.1-flash/) zählt das Thinking zu [max\_tokens](https://broadrouter.com/de/glossary/max-tokens/), ein kleines Limit kann den Stream also stoppen, bevor sichtbarer Text erscheint. [Was Reasoning-Tokens kosten](https://broadrouter.com/de/blog/reasoning-tokens-cost/).
5.  **Zeilen falsch trennen.** Wenn Sie SSE von Hand parsen, puffern Sie Bytes, bis Sie eine Leerzeile sehen. Ein TCP-Read kann mitten in einem JSON-Chunk enden.

## Wo BroadNet Inference ins Bild passt

BroadNet Inference nutzt das übliche [OpenAI-kompatible](https://broadrouter.com/de/glossary/openai-compatible-api/) Streaming-Format, sodass die SDKs für Python und Node es unverändert parsen. Die Usage im letzten Chunk enthält gecachte und Reasoning-Tokens, wenn das Modell sie meldet. Laut Doku sollte Streaming vor dem Produktiveinsatz trotzdem pro Modell geprüft werden; lassen Sie den Code oben also gegen genau das Modell laufen, das Sie ausliefern. Wenn es Ihnen vor allem darum geht, wie schnell das erste Token ankommt, lesen Sie als Nächstes [TTFT vs. Durchsatz](https://broadrouter.com/de/blog/llm-latency-ttft-throughput/). Brauchen Sie Echtzeit-Sprache über WebSockets, ist diese API dafür nicht gebaut; sie bietet Chat Completions und Transkription von Dateien.

Kostenlose Tools zum Thema (auf Englisch)

-   [OpenAI to BroadNet migration helper](https://broadrouter.com/tools/openai-to-broadnet-migration/) Paste OpenAI SDK code; get base URL, key and model edits, a diff and the checks that remain.
-   [max\_tokens calculator for reasoning models](https://broadrouter.com/tools/reasoning-token-budget/) Answer length + reasoning budget + margin = a max\_tokens that does not cut the answer off.
-   [JSON schema generator for LLM structured output](https://broadrouter.com/tools/json-schema-generator/) Sample JSON to strict schema, Pydantic, Zod and a ready request.
-   [LLM JSON output validator](https://broadrouter.com/tools/llm-json-output-validator/) Parse errors by line and column, safe repairs, cut-off detection and JSON Schema checks for model output.

[Kostenlose Tools (auf Englisch)](https://broadrouter.com/tools/)

## Begriffe in diesem Artikel

[Token](https://broadrouter.com/de/glossary/token/)

Ein Token ist die Texteinheit, die ein Sprachmodell liest und schreibt: ein Wort, ein Wortteil, ein Satzzeichen oder eine Bytefolge, die der Tokenizer des Modells erzeugt. LLM-APIs zählen, begrenzen und berechnen die Nutzung meist in Tokens.

[Streaming](https://broadrouter.com/de/glossary/streaming/)

Streaming ist eine Art, die Antwort eines Sprachmodells in kleinen Chunks zurückzugeben, während sie noch erzeugt wird, statt als eine Antwort am Ende. OpenAI-kompatible APIs streamen über Server-Sent Events, wenn die Anfrage stream auf true setzt.

[Server-Sent Events (SSE)](https://broadrouter.com/de/glossary/sse/)

Server-Sent Events (SSE) sind ein Webstandard, mit dem ein Server einem Client über eine einzige, lang offene HTTP-Antwort mit dem Content-Type text/event-stream einen Strom von Text-Events schickt. Jedes Event besteht aus einer oder mehreren Feldzeilen, etwa data:, und endet mit einer Leerzeile.

[Pay-as-you-go](https://broadrouter.com/de/glossary/pay-as-you-go/)

Pay-as-you-go ist ein Preismodell, bei dem Sie nur für tatsächliche Nutzung zahlen, gemessen pro Einheit wie Tokens, Anfragen oder Audiominuten, ohne Abonnement oder Mindestabnahme. Die meisten LLM-APIs rechnen so ab, aus einem vorausbezahlten Guthaben oder per regelmäßiger Rechnung.

[Reasoning-Tokens](https://broadrouter.com/de/glossary/reasoning-tokens/)

Reasoning-Tokens sind Tokens, die ein Reasoning-Modell erzeugt, um ein Problem durchzuarbeiten, bevor es seine sichtbare Antwort schreibt. Sie werden meist als Output-Tokens berechnet, zählen zum Output-Limit und zum Kontextfenster und können von der API verborgen oder zusammengefasst werden.

[Tool Calling (Function Calling)](https://broadrouter.com/de/glossary/tool-calling/)

Tool Calling, auch Function Calling genannt, ist eine Funktion von LLM-APIs, bei der das Modell eine strukturierte Anfrage zurückgibt, eine vom Entwickler definierte Funktion mit JSON-Argumenten auszuführen. Die Anwendung führt die Funktion aus und sendet das Ergebnis zurück; das Modell selbst führt nie Code aus.

[Chat Completions API](https://broadrouter.com/de/glossary/chat-completions-api/)

Die Chat Completions API ist der HTTP-Endpoint von OpenAI, POST /v1/chat/completions, der einen Modellnamen und eine Liste von Nachrichten mit Rollen entgegennimmt und die nächste Nachricht des Modells zurückgibt. Ihr Format für Anfrage und Antwort wurde zum gemeinsamen Standard, den OpenAI-kompatible Anbieter und SDKs übernehmen.

[Durchsatz (Throughput)](https://broadrouter.com/de/glossary/throughput/)

Durchsatz (Throughput) ist beim Betrieb von LLMs die gesamte Arbeit, die ein System pro Zeiteinheit über alle gleichzeitigen Anfragen erledigt, meist gemessen in Output-Tokens pro Sekunde oder Anfragen pro Sekunde. Er unterscheidet sich von der Geschwindigkeit pro Stream, also davon, wie schnell eine einzelne Anfrage ihre Tokens erhält.

## Häufige Fragen

### Was ist der Unterschied zwischen SSE und WebSockets beim LLM-Streaming?

SSE ist einseitig, vom Server zum Client, über eine normale HTTP-Antwort. Mehr braucht eine Chat Completion nicht, deshalb nutzen OpenAI-kompatible APIs SSE. WebSockets sind bidirektional und brauchen ein Protokoll-Upgrade; sie werden für Echtzeit-Sprache genutzt, nicht für Chat Completions.

### Warum ist usage in meinen Streaming-Chunks null?

Usage wird nur gesendet, wenn Sie danach fragen. Ergänzen Sie stream\_options mit include\_usage auf true. Dann hat jeder Chunk außer dem letzten usage null, und der letzte Chunk trägt die Summen mit einer leeren choices-Liste.

### Wird mir ein abgebrochener Stream berechnet?

Das ist je nach Anbieter verschieden, und viele dokumentieren es nicht. Gehen Sie davon aus, dass Tokens berechnet werden, die erzeugt wurden, bevor der Server die geschlossene Verbindung bemerkt hat. Loggen Sie die X-Request-ID und gleichen Sie sie mit Ihren Usage-Daten ab.

### Woran erkenne ich, dass ein Stream normal beendet wurde?

Sie haben data: \[DONE\] erhalten, und der letzte Inhalts-Chunk hatte einen finish\_reason wie stop. Ein finish\_reason length bedeutet, dass max\_tokens die Antwort abgeschnitten hat. Kein \[DONE\] bedeutet, dass die Verbindung abgebrochen ist.

### Macht Streaming das Modell schneller?

Nein. Die gesamte Generierungszeit bleibt gleich. Streaming verkürzt die Zeit, bis der Nutzer die ersten Wörter sieht, und genau das lässt eine Chat-Oberfläche schnell wirken.

## Weiterlesen

-   [LLM-Latenz: TTFT vs. Tokens pro Sekunde vs. End-to-End-Zeit](https://broadrouter.com/de/blog/llm-latency-ttft-throughput/)
-   [LLM-API-Nutzung loggen: Kosten pro Nutzer und Feature, ohne PII](https://broadrouter.com/de/blog/llm-api-usage-logging/)
-   [LLM-API-Fehler 429 behandeln: Backoff, Jitter und Limiter](https://broadrouter.com/de/blog/handle-llm-api-429-rate-limits/)
-   [GPU-Hardware und Serving von BroadNet, wie BroadNet sie beschreibt](https://broadrouter.com/de/blog/broadnet-gpu-fleet-and-serving/)
-   [LLM-Antworten cachen, Kosten senken: ein Exact-Match-Cache in Python](https://broadrouter.com/de/blog/cache-llm-responses-cut-cost/)
-   [Anleitung: Chat Completions streamen und abgebrochene Verbindungen behandeln](https://broadrouter.com/de/guides/streaming-chat-completions/)
-   [Anleitung: OpenAI Python SDK mit BroadNet Inference nutzen](https://broadrouter.com/de/guides/openai-python-sdk/)
-   [Anleitung: OpenAI Node.js SDK mit BroadNet Inference nutzen](https://broadrouter.com/de/guides/openai-node-sdk/)
-   [Anleitung: Fehlercodes von BroadNet Inference: Wann ist ein Retry sinnvoll?](https://broadrouter.com/de/guides/errors-and-retries/)

Testen Sie es mit Ihrem echten Workload. Neue Konten starten mit USD 5 Guthaben für Gemma und Transkription. DeepSeek, GLM und Qwen3.8 erfordern eine Aufladung.

[Loslegen](https://inference.broadnet.ai/account/?utm_source=broadrouter&utm_medium=referral&utm_campaign=de-blog-llm-streaming-sse-explained&utm_content=page-cta) ·

**Quellen**

-   [API-Referenz von BroadNet Inference, Streaming und Usage (auf Englisch)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=de-blog-llm-streaming-sse-explained&utm_content=sources#requests)
-   [MDN, Server-Sent Events verwenden](https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events/Using_server-sent_events)
-   [Ankündigung in der OpenAI-Community, Usage-Statistiken beim Streaming (stream\_options)](https://community.openai.com/t/usage-stats-now-available-when-using-streaming-with-the-chat-completions-api-or-completions-api/738156)
-   [openai-python-README, Streaming-Antworten und Retries (abgerufen am 2026-11-14)](https://github.com/openai/openai-python)
-   [openai-node-README, Abbruch per AbortSignal (abgerufen am 2026-11-14)](https://github.com/openai/openai-node)
