# Streaming odpowiedzi: odpowiedź w miarę, jak jest zapisywana

> Streamuj chat completions za pomocą server-sent events: stream: true, format chunka, zużycie tokenów w ostatnim evencie oraz przykłady w curl, Python i Node.js.

- URL: https://llmwithcrypto.com/pl/docs/streaming/
- Ostatnia aktualizacja: 2026-10-23
- Wydawca: LLMwithCrypto (https://llmwithcrypto.com)

Dzięki `stream: true` odpowiedź przychodzi w małych kawałkach w miarę, jak model ją pisze, tak jak interfejsy czatu pokazują pojawiający się tekst. Format jest taki jak w OpenAI: server-sent events, jeden chunk JSON na event, a potem `[DONE]`.

**Krótka odpowiedź — Jak streamować chat completion z LLMwithCrypto?**

Dodaj `"stream": true` do body `POST https://llmwithcrypto.com/api/v1/chat/completions`. **LLMwithCrypto** odpowiada wtedy server-sent events: każda linia `data:` zawiera `chat.completion.chunk` z fragmentem tekstu w `delta.content`, a stream kończy się `data: [DONE]`. Dodaj `"stream_options": {"include_usage": true}`, aby otrzymać liczby tokenów w ostatnim chunku. Działa to na każdym modelu, zgodnie z dokumentacją z 23 października 2026.

## Po co w ogóle streamować?

Dla ludzi, bo pierwsze słowa pojawiają się w mgnieniu oka, a nie po zapisaniu całej odpowiedzi. Długa odpowiedź dużego modelu może powstawać wiele sekund; streamowana, czytelnik zaczyna czytać od razu.

Dla programów ma to mniejsze znaczenie: skrypt, który potrzebuje pełnego tekstu, nic nie zyskuje na streamingu, a ma więcej parsowania. Streamuj, gdy człowiek patrzy, a w przeciwnym razie wysyłaj zwykłe zapytanie. Cena jest taka sama w obu przypadkach. Płacisz za token z salda: tokeny wejściowe i wyjściowe są liczone przez tokenizer danego modelu i rozliczane według ceny tego modelu za 1M tokenów. Wywołanie zakończone błędem nic nie kosztuje.

*curl: -N utrzymuje połączenie bez buforowania*

```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: wypisuj tekst w miarę, jak przychodzi*

```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 po chunkach*

```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`);
}

```

## Jak stream wygląda na poziomie transmisji?

Każdy event to jedna linia zaczynająca się od `data: `, po której następuje pusta linia. Pierwszy chunk zwykle zawiera `role`, kolejne po kilka znaków `content` każdy, a chunk z `finish_reason` zamyka odpowiedź. Przy `include_usage` następuje jeszcze jeden chunk z pustą tablicą `choices` i obiektem `usage`. Stream zawsze kończy się `data: [DONE]`. Poniższe identyfikatory i liczby są przykładowe.

*Server-sent events jednej krótkiej odpowiedzi (przykład)*

```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]

```

## Co, jeśli stream się zerwie?

Błąd wykryty przed pierwszym tokenem, taki jak zły klucz lub puste saldo, wraca jako normalny błąd HTTP z body JSON, a nie jako stream; [strona błędów](https://llmwithcrypto.com/pl/docs/errors/) je wymienia. Błąd podczas generowania kończy stream przedwcześnie, bez `finish_reason`.

Jeśli sam zamkniesz połączenie, generowanie się zatrzyma. Płacisz wtedy za dane wejściowe i już wygenerowane tokeny, tak jak przy każdym wywołaniu. Twój kod powinien traktować stream, który kończy się bez `finish_reason` i bez `[DONE]`, jako niekompletny, i wysłać zapytanie ponownie, jeśli potrzebuje pełnej odpowiedzi.

## Streaming: często zadawane pytania

### Czy streaming kosztuje więcej?

Nie. Te same tokeny są rozliczane w tej samej cenie. Płacisz za token z salda: tokeny wejściowe i wyjściowe są liczone przez tokenizer danego modelu i rozliczane według ceny tego modelu za 1M tokenów. Wywołanie zakończone błędem nic nie kosztuje.

### Czy mogę streamować z tool calling?

Tak, na modelach obsługujących narzędzia: nazwa funkcji i argumenty przychodzą w kawałkach w `delta.tool_calls` i trzeba je połączyć przed użyciem. [Strona o tool calling](https://llmwithcrypto.com/pl/docs/tool-calling/) pokazuje pętlę bez streamingu, od której łatwiej zacząć.

### Dlaczego w streamowanym wywołaniu nie dostaję usage?

Dodaj `"stream_options": {"include_usage": true}`. Bez tego strumień nie zawiera liczby tokenów; dashboard nadal je pokazuje.

---

LLMwithCrypto: LLMwithCrypto to zgodne z OpenAI API LLM dla modeli z otwartymi wagami — 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 — płatne za token z przedpłaconego salda kryptowalutowego, o 5% poniżej mediany ceny publicznych hostów. Bez KYC: bez dowodu, bez selfie, bez dokumentów. Prompty i odpowiedzi nie są przechowywane.