---
title: "Streaming de LLM via SSE: chunks, deltas, usage, cancelar"
description: "Como o streaming de chat completions funciona na conexão, como montar a resposta a partir dos deltas, ler o usage do último chunk e cancelar em Python, Node e curl."
url: https://broadrouter.com/pt/blog/llm-streaming-sse-explained/
lang: pt-BR
updated: 2026-11-14
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

Traduzido do inglês com ajuda de IA. [Leia o original em inglês](https://broadrouter.com/blog/llm-streaming-sse-explained/) (atualizado em 2026-11-16).

# Streaming de LLM explicado: chunks SSE, deltas, usage e cancelamento

Pela equipe da BroadNet Inference · 4 min de leitura · Publicado em 2026-11-14 · Atualizado em 2026-11-16

Uma API de LLM transmite uma chat completion como Server-Sent Events: cada linha data traz um chunk JSON cujo choices\[0\].delta contém o próximo pedaço de texto. Concatene os deltas, pare em data: \[DONE\] e defina include\_usage em stream\_options para receber as contagens de tokens em um chunk final com a lista choices vazia. Para cancelar, feche a conexão.

## Pontos principais

-   Um stream é HTTP comum: `Content-Type: text/event-stream`, uma linha `data:` por chunk, uma linha em branco entre eventos e `data: [DONE]` no fim.
-   Cada chunk traz um `delta`, não a mensagem completa. Junte as strings de `delta.content` para montar a resposta.
-   Em streams, o usage vem desligado por padrão. `stream_options: {"include_usage": true}` acrescenta um último chunk com usage e um array `choices` vazio.
-   Proteja todo acesso a `choices[0]`: o chunk de usage não tem choices, e um parser que supõe o contrário vai quebrar.
-   Cancele fechando a conexão HTTP. Um stream que termina sem `[DONE]` é uma resposta incompleta, não uma resposta concluída.

**Nesta página**

1.  Como é um stream SSE na conexão?
2.  O que vem em um chunk?
3.  Como obter o usage de tokens de um stream?
4.  Python: stream, coletar usage, cancelar
5.  Node: stream com um AbortController
6.  curl: ver os eventos brutos
7.  Como cancelar um stream, e quanto custa?
8.  Cinco bugs de streaming para conferir
9.  Onde a BroadNet Inference se encaixa

Sem [streaming](https://broadrouter.com/pt/glossary/streaming/), uma chat completion não devolve nada até a resposta inteira ficar pronta. Uma resposta de 600 tokens a cerca de 100 tokens por segundo significa vários segundos de silêncio. Com streaming, as primeiras palavras aparecem assim que o modelo as escreve. Este post mostra o que de fato trafega pela conexão, como fazer o parse, como tirar o usage de [tokens](https://broadrouter.com/pt/glossary/token/) de um stream e como pará-lo de forma limpa. Para as regras específicas da BroadNet de forma resumida, veja o [guia de referência de streaming](https://broadrouter.com/pt/guides/streaming-chat-completions/).

## Como é um stream SSE na conexão?

Server-Sent Events é uma resposta HTTP comum com `Content-Type: text/event-stream`. O servidor mantém a conexão aberta e escreve eventos. Cada evento é uma ou mais linhas `data:` seguidas de uma linha em branco. As APIs compatíveis com a OpenAI colocam um chunk JSON em cada evento e terminam com um `[DONE]` literal:

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

O formato acima é ilustrativo e resumido. Chunks reais também trazem `model` e `created`, e modelos de raciocínio podem informar tokens de raciocínio no usage.

## O que vem em um chunk?

| Campo | Onde | O que significa |
| --- | --- | --- |
| `choices[0].delta.role` | Primeiro chunk | Normalmente `assistant`. Enviado uma vez. |
| `choices[0].delta.content` | A maioria dos chunks | O próximo pedaço de texto. Pode vir vazio. |
| `choices[0].delta.tool_calls` | Chamadas de ferramenta | Fragmentos do nome da função e dos argumentos JSON, para juntar por `index`. |
| `choices[0].finish_reason` | Último chunk de conteúdo | `stop`, `length` ou `tool_calls`. `null` até lá. |
| `usage` | Chunk final, se pedido | Totais da requisição inteira. `null` em todos os outros. |

A ideia central é **delta, não snapshot**. Cada chunk traz só o que é novo. Você monta a mensagem juntando os pedaços em ordem. [Chamadas de ferramenta](https://broadrouter.com/pt/glossary/tool-calling/) chegam do mesmo jeito: os argumentos vêm como fragmentos de string que não são JSON válido até o último chegar, então faça o parse só depois que `finish_reason` for `tool_calls`.

## Como obter o usage de tokens de um stream?

Uma resposta sem streaming sempre inclui `usage`. Um stream não, a menos que você peça. Defina `stream_options: {"include_usage": true}` e o servidor envia um chunk extra antes do `[DONE]`. Esse chunk tem os totais e um **array `choices` vazio**. Na BroadNet Inference, o usage também pode incluir `prompt_tokens_details.cached_tokens` e `completion_tokens_details.reasoning_tokens` quando o modelo os informa, que é o que você precisa para o [registro de custos](https://broadrouter.com/pt/blog/llm-api-usage-logging/).

O bug comum: código que lê `chunk.choices[0]` em todo chunk dá erro de índice no chunk de usage. Confira `choices` primeiro.

## Python: stream, coletar usage, cancelar

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

Só o `break` para a leitura, mas o socket continua aberto até ser recolhido pelo garbage collector. Feche-o explicitamente para o servidor perceber a desconexão.

## Node: stream com um 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);
}
```

O [README do openai-node](https://github.com/openai/openai-node) documenta a opção `signal`, e ela funciona enquanto o corpo ainda está sendo lido. Em um servidor web, ligue `controller.abort()` ao evento `close` da requisição do cliente, para que um usuário que sai da página também pare a geração. Mais configuração no [guia do SDK para Node](https://broadrouter.com/pt/guides/openai-node-sdk/).

## curl: ver os eventos brutos

```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` desliga o buffer de saída, então os eventos aparecem conforme chegam. Pressione Ctrl+C para cancelar; isso fecha a conexão. O [gerador de requisições de API](https://broadrouter.com/tools/api-request-builder/) monta esta requisição, e as versões em Python e Node, para qualquer modelo e base URL.

## Como cancelar um stream, e quanto custa?

Cancelar em SSE é só fechar a conexão. Não existe mensagem de “stop”. O que acontece depois depende do servidor: um servidor bem-comportado percebe o socket fechado e para de gerar. Os tokens produzidos antes desse momento foram trabalho real. A referência da API da BroadNet não documenta a cobrança de streams cancelados, então planeje como se os tokens gerados até a desconexão fossem cobrados no [pagamento por uso](https://broadrouter.com/pt/glossary/pay-as-you-go/), e confira os seus registros de uso. Em um plano de preço fixo, um stream cancelado não custa nada a mais, mas só libera a sessão quando o servidor para.

## Cinco bugs de streaming para conferir

1.  **Proxies com buffer.** O Nginx e algumas CDNs fazem buffer das respostas, então o cliente recebe tudo de uma vez. Desative o buffer do proxy na rota de streaming.
2.  **Sem checar o `[DONE]`.** Uma conexão que caiu parece uma resposta curta. Trate a falta de `[DONE]` como resposta incompleta e registre o `X-Request-ID`, como descreve o [guia de erros](https://broadrouter.com/pt/guides/errors-and-retries/).
3.  **Retry no meio do stream.** Os SDKs não fazem retry depois que o corpo começa a chegar. Um retry é uma nova requisição e, no pagamento por uso, uma nova cobrança.
4.  **Ignorar `finish_reason: length`.** Em modelos de raciocínio como o [DeepSeek V4.1 Flash](https://broadrouter.com/pt/models/deepseek-v4.1-flash/), o pensamento conta em [max\_tokens](https://broadrouter.com/pt/glossary/max-tokens/), então um limite pequeno pode parar o stream antes de qualquer texto visível. [Quanto custam os tokens de raciocínio](https://broadrouter.com/pt/blog/reasoning-tokens-cost/).
5.  **Dividir as linhas errado.** Se você faz o parse de SSE na mão, acumule bytes até ver uma linha em branco. Uma leitura TCP pode terminar no meio de um chunk JSON.

## Onde a BroadNet Inference se encaixa

A BroadNet Inference usa o formato padrão de streaming [compatível com a OpenAI](https://broadrouter.com/pt/glossary/openai-compatible-api/), então os SDKs de Python e Node fazem o parse sem mudanças. O usage no chunk final inclui tokens em cache e de raciocínio quando o modelo os informa. A documentação diz que o streaming ainda deve ser verificado por modelo antes do uso em produção, então rode o código acima no modelo exato que você vai usar. Se o que mais importa para você é a rapidez com que o primeiro token chega, leia em seguida [TTFT vs throughput](https://broadrouter.com/pt/blog/llm-latency-ttft-throughput/). Se você precisa de voz em tempo real via WebSockets, esta API não foi feita para isso; ela oferece chat completions e transcrição de arquivos.

Ferramentas gratuitas sobre o tema (em inglês)

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

[Ferramentas gratuitas (em inglês)](https://broadrouter.com/tools/)

## Termos neste artigo

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

Um token é a unidade de texto que um modelo de linguagem lê e escreve: uma palavra, parte de uma palavra, um sinal de pontuação ou uma sequência de bytes gerada pelo tokenizador do modelo. As APIs de LLM contam, limitam e normalmente cobram o uso em tokens.

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

Streaming é uma forma de devolver a resposta de um modelo de linguagem em pequenos pedaços enquanto ela ainda está sendo gerada, em vez de uma resposta única no final. APIs compatíveis com a OpenAI fazem streaming via server-sent events quando a requisição define stream como true.

[Pagamento por uso (pay-as-you-go)](https://broadrouter.com/pt/glossary/pay-as-you-go/)

Pagamento por uso é um modelo de preço em que você paga só pelo que usa, medido por unidade, como tokens, requisições ou minutos de áudio, sem assinatura nem compromisso mínimo. A maioria das APIs de LLM cobra assim, a partir de um saldo pré-pago ou de uma fatura periódica.

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

Server-sent events (SSE) é um padrão web para um servidor enviar a um cliente um fluxo de eventos de texto por uma única resposta HTTP de longa duração, com content type text/event-stream. Cada evento tem uma ou mais linhas de campo, como data:, e termina com uma linha em branco.

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

A base URL é o endereço raiz fixo de uma API, como https://api.example.com/v1, que um cliente coloca antes de cada caminho de endpoint, como /chat/completions. Nos SDKs compatíveis com a OpenAI, trocar a base URL, junto com a chave de API e o ID do modelo, aponta o mesmo código para outro provedor.

[Throughput (vazão)](https://broadrouter.com/pt/glossary/throughput/)

Throughput, ou vazão, no serving de LLMs, é a quantidade total de trabalho que um sistema conclui por unidade de tempo em todas as requisições simultâneas, geralmente medida em tokens de saída ou requisições por segundo. É diferente da velocidade por stream, que é a rapidez com que uma única requisição recebe seus tokens.

[Tokens de raciocínio (reasoning tokens)](https://broadrouter.com/pt/glossary/reasoning-tokens/)

Tokens de raciocínio são tokens que um modelo de raciocínio gera para trabalhar um problema antes de escrever a resposta visível. Normalmente são cobrados como tokens de saída, contam para o limite de saída e para a janela de contexto, e a API pode ocultá-los ou resumi-los.

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

A Chat Completions API é o endpoint HTTP da OpenAI, POST /v1/chat/completions, que recebe o nome de um modelo e uma lista de mensagens marcadas com papéis e devolve a próxima mensagem do modelo. O formato da requisição e da resposta virou o padrão comum que provedores e SDKs compatíveis com a OpenAI reutilizam.

## Perguntas frequentes

### Qual é a diferença entre SSE e WebSockets para streaming de LLM?

SSE é unidirecional, do servidor para o cliente, sobre uma resposta HTTP normal. É tudo de que uma chat completion precisa, por isso as APIs compatíveis com a OpenAI usam SSE. WebSockets são bidirecionais e exigem upgrade de protocolo; são usados para voz em tempo real, não para chat completions.

### Por que o usage vem null nos meus chunks de streaming?

O usage só é enviado quando você pede. Adicione stream\_options com include\_usage definido como true. Aí todos os chunks, menos o último, têm usage null, e o último traz os totais com a lista choices vazia.

### Sou cobrado se cancelar um stream?

Depende do provedor, e muitos não documentam. Suponha que os tokens gerados antes de o servidor perceber a conexão fechada são cobrados. Registre o X-Request-ID e compare com os seus registros de uso.

### Como sei se um stream terminou normalmente?

Você recebeu data: \[DONE\] e o último chunk de conteúdo tinha um finish\_reason como stop. Um finish\_reason length significa que max\_tokens cortou a resposta. Sem \[DONE\], a conexão caiu.

### O streaming deixa o modelo mais rápido?

Não. O tempo total de geração é o mesmo. O streaming reduz o tempo até o usuário ver as primeiras palavras, e é isso que faz uma interface de chat parecer rápida.

## Continue lendo

-   [Latência de LLM: TTFT, tokens por segundo e tempo de ponta a ponta](https://broadrouter.com/pt/blog/llm-latency-ttft-throughput/)
-   [Log de uso de API de LLM: custo por usuário e recurso, sem PII](https://broadrouter.com/pt/blog/llm-api-usage-logging/)
-   [Erro 429 em API de LLM: backoff, jitter e limitadores](https://broadrouter.com/pt/blog/handle-llm-api-429-rate-limits/)
-   [Hardware de GPU e serving da BroadNet, segundo a própria BroadNet](https://broadrouter.com/pt/blog/broadnet-gpu-fleet-and-serving/)
-   [Cache de respostas de LLM para cortar custo: um cache exato em Python](https://broadrouter.com/pt/blog/cache-llm-responses-cut-cost/)
-   [Guia: Streaming de chat completions e conexões que caem](https://broadrouter.com/pt/guides/streaming-chat-completions/)
-   [Guia: Como usar o SDK Python da OpenAI com a BroadNet Inference](https://broadrouter.com/pt/guides/openai-python-sdk/)
-   [Guia: Como usar o SDK Node.js da OpenAI com a BroadNet Inference](https://broadrouter.com/pt/guides/openai-node-sdk/)
-   [Guia: Códigos de erro da BroadNet Inference e quando tentar de novo](https://broadrouter.com/pt/guides/errors-and-retries/)

Teste com a sua carga de trabalho real. Contas novas começam com US$ 5 de crédito para Gemma e transcrição. DeepSeek, GLM e Qwen3.8 exigem uma recarga.

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

**Fontes**

-   [Referência da API da BroadNet Inference, streaming e usage (em inglês)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=pt-blog-llm-streaming-sse-explained&utm_content=sources#requests)
-   [MDN, usando server-sent events](https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events/Using_server-sent_events)
-   [Anúncio na comunidade da OpenAI, estatísticas de usage no 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 do openai-python, respostas em streaming e retries (consultado em 2026-11-14)](https://github.com/openai/openai-python)
-   [README do openai-node, cancelamento com AbortSignal (consultado em 2026-11-14)](https://github.com/openai/openai-node)
