# Streaming-Antworten: die Antwort, während sie geschrieben wird

> Streamen Sie Chat Completions mit Server-Sent Events: stream: true, das Chunk-Format, Token-Nutzung im letzten Event und Beispiele in curl, Python und Node.js.

- URL: https://llmwithcrypto.com/de/docs/streaming/
- Zuletzt aktualisiert: 2026-10-23
- Herausgeber: LLMwithCrypto (https://llmwithcrypto.com)

Mit `stream: true` kommt die Antwort in kleinen Stücken an, während das Modell schreibt, so wie Chat-Oberflächen Text erscheinen lassen. Das Format ist das von OpenAI: Server-Sent Events, ein JSON-Chunk pro Event, dann `[DONE]`.

**Kurze Antwort — Wie streame ich eine Chat Completion aus LLMwithCrypto?**

Fügen Sie `"stream": true` zum Body von `POST https://llmwithcrypto.com/api/v1/chat/completions` hinzu. **LLMwithCrypto** antwortet dann mit Server-Sent Events: jede `data:`-Zeile enthält ein `chat.completion.chunk` mit einem Stück Text in `delta.content`, und der Stream endet mit `data: [DONE]`. Fügen Sie `"stream_options": {"include_usage": true}` hinzu, um die Token-Zählungen in einem letzten Chunk zu erhalten. Das funktioniert bei jedem Modell, wie am 23. Oktober 2026 dokumentiert.

## Warum überhaupt streamen?

Für Menschen, weil die ersten Wörter sofort erscheinen statt erst, nachdem die ganze Antwort geschrieben ist. Eine lange Antwort von einem großen Modell kann viele Sekunden zum Fertigwerden brauchen; gestreamt beginnt der Leser sofort zu lesen.

Für Programme ist es weniger wichtig: ein Skript, das den vollständigen Text braucht, gewinnt nichts durch Streaming und hat mehr zu parsen. Streamen Sie, wenn ein Mensch zusieht, und senden Sie sonst eine normale Anfrage. Der Preis ist in beiden Fällen gleich. Sie zahlen pro Token aus Ihrem Guthaben: Input- und Output-Tokens werden mit dem eigenen Tokenizer des Modells gezählt und zum Preis des Modells pro 1M Tokens berechnet. Ein Aufruf, der mit einem Fehler endet, kostet nichts.

*curl: -N hält die Verbindung ungepuffert*

```bash
curl -sN "https://llmwithcrypto.com/api/v1/chat/completions" \
  -H "Authorization: Bearer $LLMWITHCRYPTO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek-v4.1-flash",
    "messages": [{"role": "user", "content": "Write a haiku about latency."}],
    "stream": true,
    "stream_options": {"include_usage": true},
    "max_tokens": 120
  }'

```

*Python: den Text ausgeben, sobald er ankommt*

```python
import os

from openai import OpenAI

client = OpenAI(
    base_url="https://llmwithcrypto.com/api/v1",
    api_key=os.environ["LLMWITHCRYPTO_API_KEY"],
)

stream = client.chat.completions.create(
    model="deepseek-v4.1-flash",
    messages=[{"role": "user", "content": "Write a haiku about latency."}],
    stream=True,
    stream_options={"include_usage": True},
    max_tokens=120,
)
for chunk in stream:
    if chunk.choices and chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="", flush=True)
    if chunk.usage:
        print("\n", chunk.usage.prompt_tokens, "in,", chunk.usage.completion_tokens, "out")

```

*Node.js: for await über die Chunks*

```javascript
import OpenAI from 'openai';

const client = new OpenAI({
  baseURL: 'https://llmwithcrypto.com/api/v1',
  apiKey: process.env.LLMWITHCRYPTO_API_KEY,
});

const stream = await client.chat.completions.create({
  model: 'deepseek-v4.1-flash',
  messages: [{ role: 'user', content: 'Write a haiku about latency.' }],
  stream: true,
  stream_options: { include_usage: true },
  max_tokens: 120,
});
for await (const chunk of stream) {
  const text = chunk.choices[0]?.delta?.content;
  if (text) process.stdout.write(text);
  if (chunk.usage) console.log(`\n${chunk.usage.prompt_tokens} in, ${chunk.usage.completion_tokens} out`);
}

```

## Wie sieht der Stream auf der Leitung aus?

Jedes Event ist eine Zeile, die mit `data: ` beginnt, gefolgt von einer Leerzeile. Der erste Chunk trägt üblicherweise die `role`, die nächsten wenige Zeichen von `content` jeweils, und der Chunk mit einem `finish_reason` schließt die Antwort ab. Mit `include_usage` folgt ein weiterer Chunk mit einem leeren `choices`-Array und dem `usage`-Objekt. Der Stream endet immer mit `data: [DONE]`. Die ids und Zählungen unten sind illustrativ.

*Server-Sent Events einer kurzen Antwort (illustrativ)*

```text
data: {"id":"chatcmpl-5a1e","object":"chat.completion.chunk","created":1792742400,"model":"deepseek-v4.1-flash","choices":[{"index":0,"delta":{"role":"assistant","content":""},"finish_reason":null}]}

data: {"id":"chatcmpl-5a1e","object":"chat.completion.chunk","created":1792742400,"model":"deepseek-v4.1-flash","choices":[{"index":0,"delta":{"content":"Packets"},"finish_reason":null}]}

data: {"id":"chatcmpl-5a1e","object":"chat.completion.chunk","created":1792742400,"model":"deepseek-v4.1-flash","choices":[{"index":0,"delta":{"content":" cross the"},"finish_reason":null}]}

data: {"id":"chatcmpl-5a1e","object":"chat.completion.chunk","created":1792742400,"model":"deepseek-v4.1-flash","choices":[{"index":0,"delta":{},"finish_reason":"stop"}]}

data: {"id":"chatcmpl-5a1e","object":"chat.completion.chunk","created":1792742400,"model":"deepseek-v4.1-flash","choices":[],"usage":{"prompt_tokens":14,"completion_tokens":19,"total_tokens":33}}

data: [DONE]

```

## Was, wenn der Stream abbricht?

Ein Fehler vor dem ersten Token, etwa ein falscher Schlüssel oder ein leeres Guthaben, kommt als normaler HTTP-Fehler mit JSON-Body zurück, nicht als Stream; die [Fehlerseite](https://llmwithcrypto.com/de/docs/errors/) listet sie. Ein Fehler während der Generierung beendet den Stream frühzeitig, ohne `finish_reason`.

Wenn Sie die Verbindung selbst schließen, stoppt die Generierung. Sie zahlen dann für den Input und die bereits generierten Token, wie bei jedem Aufruf. Ihr Code sollte einen Stream, der ohne `finish_reason` und ohne `[DONE]` endet, als unvollständig behandeln und die Anfrage erneut senden, wenn er die vollständige Antwort braucht.

## Streaming: häufige Fragen

### Kostet Streaming mehr?

Nein. Dieselben Token werden zum selben Preis abgerechnet. Sie zahlen pro Token aus Ihrem Guthaben: Input- und Output-Tokens werden mit dem eigenen Tokenizer des Modells gezählt und zum Preis des Modells pro 1M Tokens berechnet. Ein Aufruf, der mit einem Fehler endet, kostet nichts.

### Kann ich mit Tool Calling streamen?

Ja, bei den Modellen, die Tools unterstützen: Funktionsname und Argumente kommen in Stücken in `delta.tool_calls` an und müssen vor der Verwendung zusammengefügt werden. Die [Tool-Calling-Seite](https://llmwithcrypto.com/de/docs/tool-calling/) zeigt die nicht gestreamte Schleife, mit der man einfacher beginnt.

### Warum bekomme ich bei einem gestreamten Aufruf keine Nutzungsdaten?

Fügen Sie `"stream_options": {"include_usage": true}` hinzu. Ohne diesen enthält ein Stream keine Token-Zahlen; das Dashboard zeigt sie dennoch an.

---

LLMwithCrypto: LLMwithCrypto ist eine OpenAI-kompatible LLM-API für Open-Weight-Modelle — DeepSeek V4 Pro, DeepSeek V4.1 Flash, DeepSeek R1, Qwen3.5 397B A17B, Qwen3 235B A22B Instruct, gpt-oss-120b, gpt-oss-20b, GLM-4.7, Llama 3.3 70B Instruct, Gemma 4 31B, Mistral Large 3, Mistral Small 4 — pro Token aus einem vorausbezahlten Krypto-Guthaben bezahlt, 5 % unter dem Medianpreis der öffentlichen Hosts. Ohne KYC: kein Ausweis, kein Selfie, keine Dokumente. Prompts und Ausgaben werden nicht gespeichert.