---
title: "Streaming LLM via SSE: chunk, delta, usage, annullamento"
description: "Come funziona lo streaming delle chat completion, come ricostruire la risposta dai delta, leggere usage dall’ultimo chunk e annullare in Python, Node e curl."
url: https://broadrouter.com/it/blog/llm-streaming-sse-explained/
lang: it
updated: 2026-11-14
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

Tradotto dall’inglese con l’aiuto dell’IA. [Leggi l’originale in inglese](https://broadrouter.com/blog/llm-streaming-sse-explained/) (aggiornato il 2026-11-16).

# Streaming degli LLM spiegato: chunk SSE, delta, usage e annullamento

A cura del team di BroadNet Inference · 4 min di lettura · Pubblicato 2026-11-14 · Aggiornato 2026-11-16

Un’API LLM invia una chat completion in streaming come Server-Sent Events: ogni riga data contiene un chunk JSON il cui choices\[0\].delta porta il pezzo successivo di testo. Concatena i delta, fermati a data: \[DONE\] e imposta include\_usage in stream\_options per ricevere i conteggi dei token in un chunk finale con una lista choices vuota. Per annullare, chiudi la connessione.

## Punti chiave

-   Uno stream è semplice HTTP: `Content-Type: text/event-stream`, una riga `data:` per chunk, una riga vuota tra un evento e l’altro e `data: [DONE]` alla fine.
-   Ogni chunk porta un `delta`, non il messaggio completo. Unisci le stringhe `delta.content` per ricostruire la risposta.
-   Negli stream usage è disattivato per impostazione predefinita. `stream_options: {"include_usage": true}` aggiunge un ultimo chunk con usage e un array `choices` vuoto.
-   Proteggi ogni accesso a `choices[0]`: il chunk di usage non ha choices, e un parser che dà per scontato il contrario va in crash.
-   Si annulla chiudendo la connessione HTTP. Uno stream che finisce senza `[DONE]` è una risposta incompleta, non una risposta conclusa.

**In questa pagina**

1.  Com’è fatto uno stream SSE sulla connessione?
2.  Cosa c’è in un chunk?
3.  Come si ottiene l’usage dei token da uno stream?
4.  Python: streaming, raccolta dell’usage, annullamento
5.  Node: streaming con un AbortController
6.  curl: vedere gli eventi grezzi
7.  Come si annulla uno stream, e quanto costa?
8.  Cinque bug di streaming da controllare
9.  Dove si inserisce BroadNet Inference

Senza [streaming](https://broadrouter.com/it/glossary/streaming/), una chat completion non restituisce nulla finché la risposta non è completa. Una risposta da 600 token a circa 100 token al secondo significa diversi secondi di silenzio. Con lo streaming, le prime parole compaiono appena il modello le scrive. Questo articolo spiega cosa viaggia davvero sulla connessione, come fare il parsing, come ottenere l’usage dei [token](https://broadrouter.com/it/glossary/token/) da uno stream e come fermarlo in modo pulito. Per le regole specifiche di BroadNet in forma breve, vedi la [guida di riferimento allo streaming](https://broadrouter.com/it/guides/streaming-chat-completions/).

## Com’è fatto uno stream SSE sulla connessione?

I Server-Sent Events sono una semplice risposta HTTP con `Content-Type: text/event-stream`. Il server tiene aperta la connessione e scrive eventi. Ogni evento è una o più righe `data:` seguite da una riga vuota. Le API compatibili con OpenAI mettono un chunk JSON in ogni evento e chiudono con un `[DONE]` letterale:

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

La forma qui sopra è un esempio semplificato. I chunk reali portano anche `model` e `created`, e i modelli di ragionamento possono riportare i token di ragionamento in usage.

## Cosa c’è in un chunk?

| Campo | Dove | Cosa significa |
| --- | --- | --- |
| `choices[0].delta.role` | Primo chunk | Di solito `assistant`. Inviato una sola volta. |
| `choices[0].delta.content` | Quasi tutti i chunk | Il pezzo successivo di testo. Può essere vuoto. |
| `choices[0].delta.tool_calls` | Chiamate ai tool | Frammenti del nome della funzione e degli argomenti JSON, da unire per `index`. |
| `choices[0].finish_reason` | Ultimo chunk di contenuto | `stop`, `length` o `tool_calls`. `null` fino ad allora. |
| `usage` | Chunk finale, se richiesto | Totali dell’intera richiesta. `null` in tutti gli altri. |

Il concetto chiave è **delta, non istantanea**. Ogni chunk contiene solo ciò che è nuovo. Ricostruisci il messaggio unendo i pezzi in ordine. Le [chiamate ai tool](https://broadrouter.com/it/glossary/tool-calling/) arrivano in streaming allo stesso modo: gli argomenti arrivano come frammenti di stringa che non sono JSON valido finché non arriva l’ultimo, quindi fai il parsing solo dopo che `finish_reason` è `tool_calls`.

## Come si ottiene l’usage dei token da uno stream?

Una risposta senza streaming include sempre `usage`. Uno stream no, a meno che tu non lo chieda. Imposta `stream_options: {"include_usage": true}` e il server invia un chunk in più prima di `[DONE]`. Quel chunk ha i totali e un **array `choices` vuoto**. Su BroadNet Inference l’usage può includere anche `prompt_tokens_details.cached_tokens` e `completion_tokens_details.reasoning_tokens` quando il modello li riporta, ed è ciò che ti serve per il [logging dei costi](https://broadrouter.com/it/blog/llm-api-usage-logging/).

Il bug tipico: il codice che legge `chunk.choices[0]` su ogni chunk solleva un errore di indice sul chunk di usage. Controlla prima `choices`.

## Python: streaming, raccolta dell’usage, annullamento

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

Il solo `break` smette di leggere, ma il socket resta aperto finché non viene raccolto dal garbage collector. Chiudilo esplicitamente così il server vede la disconnessione.

## Node: streaming con un 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);
}
```

Il [README di openai-node](https://github.com/openai/openai-node) documenta l’opzione `signal`, che funziona anche mentre il body viene ancora letto. In un server web, collega `controller.abort()` all’evento `close` della richiesta del client, così anche un utente che lascia la pagina ferma la generazione. Più dettagli di configurazione nella [guida all’SDK per Node](https://broadrouter.com/it/guides/openai-node-sdk/).

## curl: vedere gli eventi grezzi

```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` disattiva il buffering dell’output così gli eventi vengono stampati appena arrivano. Premi Ctrl+C per annullare; questo chiude la connessione. Il [generatore di richieste API](https://broadrouter.com/tools/api-request-builder/) crea questa richiesta, e le versioni Python e Node, per qualsiasi modello e base URL.

## Come si annulla uno stream, e quanto costa?

In SSE annullare significa semplicemente chiudere la connessione. Non esiste un messaggio di “stop”. Cosa succede dopo dipende dal server: uno che si comporta bene si accorge del socket chiuso e smette di generare. I token prodotti prima di quel momento sono stati lavoro reale. Il riferimento API di BroadNet non documenta la fatturazione degli stream annullati, quindi pianifica come se i token generati fino alla disconnessione venissero fatturati con il [pagamento a consumo](https://broadrouter.com/it/glossary/pay-as-you-go/), e controlla i tuoi dati di consumo. Con un piano flat uno stream annullato non costa nulla in più, ma libera la sessione solo quando il server si ferma.

## Cinque bug di streaming da controllare

1.  **Proxy che fanno buffering.** Nginx e alcune CDN mettono in buffer le risposte, quindi il client riceve tutto in una volta. Disattiva il buffering del proxy per la route di streaming.
2.  **Nessun controllo su `[DONE]`.** Una connessione caduta sembra una risposta corta. Considera incompleta una risposta senza `[DONE]` e registra l’`X-Request-ID`, come descrive la [guida agli errori](https://broadrouter.com/it/guides/errors-and-retries/).
3.  **Retry a metà stream.** Gli SDK non fanno retry una volta che il body ha iniziato ad arrivare. Un retry è una nuova richiesta e, con il pagamento a consumo, una nuova fattura.
4.  **Ignorare `finish_reason: length`.** Sui modelli di ragionamento come [DeepSeek V4.1 Flash](https://broadrouter.com/it/models/deepseek-v4.1-flash/) il thinking conta in [max\_tokens](https://broadrouter.com/it/glossary/max-tokens/), quindi un limite basso può fermare lo stream prima di qualsiasi testo visibile. [Quanto costano i token di ragionamento](https://broadrouter.com/it/blog/reasoning-tokens-cost/).
5.  **Dividere male le righe.** Se fai il parsing SSE a mano, accumula i byte finché non vedi una riga vuota. Una lettura TCP può finire a metà di un chunk JSON.

## Dove si inserisce BroadNet Inference

BroadNet Inference usa il formato di streaming standard [compatibile con OpenAI](https://broadrouter.com/it/glossary/openai-compatible-api/), quindi gli SDK Python e Node lo leggono senza modifiche. L’usage nel chunk finale include i token in cache e di ragionamento quando il modello li riporta. La sua documentazione dice che lo streaming va comunque verificato modello per modello prima di andare in produzione, quindi esegui il codice qui sopra sul modello esatto che metti in produzione. Se ti interessa soprattutto quanto arriva in fretta il primo token, leggi poi [TTFT e throughput](https://broadrouter.com/it/blog/llm-latency-ttft-throughput/). Se ti serve la voce in tempo reale via WebSocket, questa API non è fatta per quello: offre chat completions e trascrizione di file.

Strumenti gratuiti sul tema (in inglese)

-   [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.

[Strumenti gratuiti (in inglese)](https://broadrouter.com/tools/)

## Termini in questo articolo

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

Lo streaming è un modo di restituire la risposta di un modello linguistico in piccoli pezzi mentre viene ancora generata, invece che in un’unica risposta alla fine. Le API compatibili con OpenAI trasmettono in streaming tramite server-sent event quando la richiesta imposta stream a true.

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

Un token è l’unità di testo che un modello linguistico legge e scrive: una parola, una parte di parola, un segno di punteggiatura o una sequenza di byte prodotta dal tokenizer del modello. Le API LLM contano, limitano e di solito fatturano l’uso in token.

[Pagamento a consumo (pay-as-you-go)](https://broadrouter.com/it/glossary/pay-as-you-go/)

Il pagamento a consumo è un modello di prezzo in cui paghi solo ciò che usi, misurato per unità come token, richieste o minuti di audio, senza abbonamento né impegno minimo. La maggior parte delle API LLM fattura così, da un saldo prepagato o con una fattura periodica.

[Server-sent events (SSE)](https://broadrouter.com/it/glossary/sse/)

I server-sent events (SSE) sono uno standard web con cui un server invia a un client un flusso di eventi testuali su un’unica risposta HTTP di lunga durata, con content type text/event-stream. Ogni evento è composto da una o più righe di campo, come data:, ed è chiuso da una riga vuota.

[Base URL (URL di base)](https://broadrouter.com/it/glossary/base-url/)

La base URL è l’indirizzo radice fisso di un’API, come https://api.example.com/v1, che un client antepone a ogni percorso di endpoint, come /chat/completions. Negli SDK compatibili con OpenAI, cambiare la base URL, insieme alla chiave API e all’ID del modello, punta lo stesso codice verso un altro provider.

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

Il throughput, nel serving di LLM, è la quantità totale di lavoro che un sistema completa per unità di tempo su tutte le richieste concorrenti, di solito misurata in token di output al secondo o richieste al secondo. È diverso dalla velocità per stream, cioè quanto rapidamente una singola richiesta riceve i suoi token.

[Token di ragionamento (reasoning tokens)](https://broadrouter.com/it/glossary/reasoning-tokens/)

I token di ragionamento sono token che un modello di ragionamento genera per elaborare un problema prima di scrivere la risposta visibile. Di solito sono fatturati come token di output, contano nel limite di output e nella finestra di contesto, e l’API può nasconderli o riassumerli.

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

La Chat Completions API è l’endpoint HTTP di OpenAI, POST /v1/chat/completions, che riceve il nome di un modello e una lista di messaggi con un ruolo e restituisce il messaggio successivo del modello. La forma della sua richiesta e risposta è diventata il formato comune che riusano provider e SDK compatibili con OpenAI.

## Domande frequenti

### Che differenza c’è tra SSE e WebSocket per lo streaming degli LLM?

SSE è unidirezionale, dal server al client, su una normale risposta HTTP. È tutto ciò che serve a una chat completion, per questo le API compatibili con OpenAI usano SSE. I WebSocket sono bidirezionali e richiedono un upgrade del protocollo; si usano per la voce in tempo reale, non per le chat completion.

### Perché usage è null nei miei chunk in streaming?

Usage viene inviato solo se lo chiedi. Aggiungi stream\_options con include\_usage impostato a true. A quel punto ogni chunk tranne l’ultimo ha usage null, e l’ultimo porta i totali con una lista choices vuota.

### Pago se annullo uno stream?

Dipende dal provider, e molti non lo documentano. Dai per scontato che i token generati prima che il server si accorga della connessione chiusa vengano fatturati. Registra l’X-Request-ID e confrontalo con i tuoi dati di consumo.

### Come capisco se uno stream è finito normalmente?

Hai ricevuto data: \[DONE\] e l’ultimo chunk di contenuto aveva un finish\_reason come stop. Un finish\_reason length significa che max\_tokens ha tagliato la risposta. Nessun \[DONE\] significa che la connessione è caduta.

### Lo streaming rende il modello più veloce?

No. Il tempo totale di generazione è lo stesso. Lo streaming riduce il tempo prima che l’utente veda le prime parole, ed è questo che rende reattiva un’interfaccia di chat.

## Continua a leggere

-   [Latenza degli LLM: TTFT, token al secondo e tempo end-to-end](https://broadrouter.com/it/blog/llm-latency-ttft-throughput/)
-   [Log di utilizzo delle API LLM: costo per utente e funzione, senza PII](https://broadrouter.com/it/blog/llm-api-usage-logging/)
-   [Errore 429 nelle API LLM: backoff, jitter e limitatori](https://broadrouter.com/it/blog/handle-llm-api-429-rate-limits/)
-   [Hardware GPU e serving di BroadNet, come li descrive BroadNet](https://broadrouter.com/it/blog/broadnet-gpu-fleet-and-serving/)
-   [Cache delle risposte delle API LLM: una cache esatta in Python](https://broadrouter.com/it/blog/cache-llm-responses-cut-cost/)
-   [Guida: Streaming delle chat completions e connessioni interrotte](https://broadrouter.com/it/guides/streaming-chat-completions/)
-   [Guida: Usare l’SDK Python di OpenAI con BroadNet Inference](https://broadrouter.com/it/guides/openai-python-sdk/)
-   [Guida: Usare l’SDK Node.js di OpenAI con BroadNet Inference](https://broadrouter.com/it/guides/openai-node-sdk/)
-   [Guida: Codici di errore di BroadNet Inference e quando ritentare](https://broadrouter.com/it/guides/errors-and-retries/)

Provalo sul tuo carico di lavoro reale. I nuovi account partono con USD 5 di credito per Gemma e trascrizione. DeepSeek, GLM e Qwen3.8 richiedono una ricarica.

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

**Fonti**

-   [Riferimento API di BroadNet Inference, streaming e usage (in inglese)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=it-blog-llm-streaming-sse-explained&utm_content=sources#requests)
-   [MDN, uso dei server-sent events](https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events/Using_server-sent_events)
-   [Annuncio nella community di OpenAI, statistiche di usage nello streaming (stream\_options)](https://community.openai.com/t/usage-stats-now-available-when-using-streaming-with-the-chat-completions-api-or-completions-api/738156)
-   [README di openai-python, risposte in streaming e retry (consultato il 2026-11-14)](https://github.com/openai/openai-python)
-   [README di openai-node, annullamento con AbortSignal (consultato il 2026-11-14)](https://github.com/openai/openai-node)
