# Risposte in streaming: la risposta mentre viene scritta

> Fai streaming delle chat completion con server-sent events: stream: true, i chunk, l'uso dei token nell'ultimo evento ed esempi in curl, Python e Node.js.

- URL: https://llmwithcrypto.com/it/docs/streaming/
- Ultimo aggiornamento: 2026-10-23
- Editore: LLMwithCrypto (https://llmwithcrypto.com)

Con `stream: true`, la risposta arriva a piccoli pezzi mentre il modello la scrive, come nelle interfacce di chat in cui il testo appare progressivamente. Il formato è quello di OpenAI: server-sent events, un chunk JSON per evento, poi `[DONE]`.

**Risposta rapida — Come faccio lo streaming di una chat completion da LLMwithCrypto?**

Aggiungi `"stream": true` al body di `POST https://llmwithcrypto.com/api/v1/chat/completions`. **LLMwithCrypto** risponde poi con server-sent events: ogni riga `data:` contiene un `chat.completion.chunk` con un pezzo di testo in `delta.content`, e lo stream termina con `data: [DONE]`. Aggiungi `"stream_options": {"include_usage": true}` per ottenere i conteggi dei token in un ultimo chunk. Funziona su ogni modello, come documentato al 23 ottobre 2026.

## Perché fare lo streaming?

Per le persone, perché le prime parole appaiono in un attimo invece che dopo che l'intera risposta è stata scritta. Una risposta lunga di un modello grande può richiedere molti secondi per essere completata; in streaming, il lettore inizia a leggere subito.

Per i programmi conta meno: uno script che ha bisogno del testo completo non guadagna nulla dallo streaming e ha più parsing da fare. Fai lo streaming quando c'è una persona che guarda, e invia una richiesta normale negli altri casi. Il prezzo è lo stesso in entrambi i casi. Paghi per token dal tuo saldo: i token di input e di output vengono contati dal tokenizer del modello stesso e addebitati al prezzo di quel modello per 1M di token. Una chiamata che termina con un errore non costa nulla.

*curl: -N mantiene la connessione senza buffering*

```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: stampa il testo man mano che arriva*

```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 sui chunk*

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

```

## Come appare lo stream sulla rete?

Ogni evento è una riga che inizia con `data: `, seguita da una riga vuota. Il primo chunk di solito contiene il `role`, quelli successivi qualche carattere di `content` ciascuno, e il chunk con un `finish_reason` chiude la risposta. Con `include_usage`, segue un altro chunk con un array `choices` vuoto e l'oggetto `usage`. Lo stream termina sempre con `data: [DONE]`. Gli id e i conteggi qui sotto sono illustrativi.

*Server-sent events di una risposta breve (illustrativi)*

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

```

## E se lo stream si interrompe?

Un errore rilevato prima del primo token, come una chiave sbagliata o un saldo vuoto, torna come un normale errore HTTP con un body JSON, non come uno stream; la [pagina degli errori](https://llmwithcrypto.com/it/docs/errors/) li elenca. Un errore durante la generazione termina lo stream in anticipo, senza un `finish_reason`.

Se chiudi tu la connessione, la generazione si ferma. Paghi poi per l'input e per i token già generati, come in qualsiasi chiamata. Il tuo codice dovrebbe trattare uno stream che termina senza un `finish_reason` e senza `[DONE]` come incompleto, e inviare di nuovo la richiesta se ha bisogno della risposta completa.

## Streaming: domande frequenti

### Lo streaming costa di più?

No. Gli stessi token sono fatturati allo stesso prezzo. Paghi per token dal tuo saldo: i token di input e di output vengono contati dal tokenizer del modello stesso e addebitati al prezzo di quel modello per 1M di token. Una chiamata che termina con un errore non costa nulla.

### Posso fare lo streaming con il tool calling?

Sì, sui modelli che supportano i tool: il nome della funzione e gli argomenti arrivano a pezzi in `delta.tool_calls` e vanno uniti prima dell'uso. La [pagina sul tool calling](https://llmwithcrypto.com/it/docs/tool-calling/) mostra il loop non in streaming, che è più semplice per iniziare.

### Perché non ricevo l'utilizzo in una chiamata in streaming?

Aggiungi `"stream_options": {"include_usage": true}`. Senza, uno stream non porta conteggi di token; la dashboard li mostra comunque.

---

LLMwithCrypto: LLMwithCrypto è un'API LLM compatibile con OpenAI per modelli open-weight — 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 — pagati a token da un saldo prepagato in criptovalute, al 5% sotto il prezzo mediano degli host pubblici. Senza KYC: niente documento, niente selfie, niente documenti. I prompt e gli output non vengono memorizzati.