# Respostas em streaming: a resposta conforme ela é escrita

> Faça streaming de chat completions com server-sent events: stream true, formato dos chunks, uso de tokens no último evento e exemplos em curl, Python e Node.js.

- URL: https://llmwithcrypto.com/pt/docs/streaming/
- Última atualização: 2026-10-23
- Editor: LLMwithCrypto (https://llmwithcrypto.com)

Com `stream: true`, a resposta chega em pequenos pedaços conforme o modelo a escreve, do jeito que as interfaces de chat mostram o texto aparecendo. O formato é o da OpenAI: server-sent events, um chunk JSON por evento, depois `[DONE]`.

**Resposta rápida — Como faço streaming de um chat completion a partir de LLMwithCrypto?**

Adicione `"stream": true` ao corpo de `POST https://llmwithcrypto.com/api/v1/chat/completions`. **LLMwithCrypto** então responde com server-sent events: cada linha `data:` contém um `chat.completion.chunk` com um trecho de texto em `delta.content`, e o stream termina com `data: [DONE]`. Adicione `"stream_options": {"include_usage": true}` para receber as contagens de tokens em um último chunk. Isso funciona em todos os modelos, conforme documentado em 23 de outubro de 2026.

## Por que fazer streaming, afinal?

Para pessoas, porque as primeiras palavras aparecem em instantes, em vez de só depois que a resposta inteira é escrita. Uma resposta longa de um modelo grande pode levar muitos segundos para terminar; em streaming, o leitor começa a ler na hora.

Para programas importa menos: um script que precisa do texto completo não ganha nada com streaming e tem mais parsing para fazer. Faça streaming quando um humano estiver acompanhando e envie uma requisição normal caso contrário. O preço é o mesmo dos dois jeitos. Você paga por token a partir do seu saldo: tokens de entrada e de saída são contados pelo tokenizer do próprio modelo e cobrados ao preço daquele modelo por 1M de tokens. Uma chamada que termina em erro não custa nada.

*curl: -N mantém a conexão sem buffer*

```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: imprima o texto conforme ele chega*

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

```

## Como o stream aparece na rede?

Cada evento é uma linha começando com `data: `, seguida de uma linha em branco. O primeiro chunk normalmente carrega o `role`, os seguintes alguns caracteres de `content` cada, e o chunk com um `finish_reason` fecha a resposta. Com `include_usage`, segue mais um chunk com um array `choices` vazio e o objeto `usage`. O stream sempre termina com `data: [DONE]`. Os ids e contagens abaixo são ilustrativos.

*Server-sent events de uma resposta curta (ilustrativo)*

```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 o stream quebrar?

Um erro encontrado antes do primeiro token, como uma chave errada ou um saldo vazio, volta como um erro HTTP normal com um corpo JSON, não como um stream; a [página de erros](https://llmwithcrypto.com/pt/docs/errors/) os lista. Um erro durante a geração encerra o stream antes do fim, sem um `finish_reason`.

Se você mesmo fechar a conexão, a geração para. Você então paga pela entrada e pelos tokens já gerados, como em qualquer chamada. Seu código deve tratar um stream que termina sem um `finish_reason` e sem `[DONE]` como incompleto, e enviar a requisição novamente se precisar da resposta completa.

## Streaming: perguntas frequentes

### Fazer streaming custa mais?

Não. Os mesmos tokens são cobrados pelo mesmo preço. Você paga por token a partir do seu saldo: tokens de entrada e de saída são contados pelo tokenizer do próprio modelo e cobrados ao preço daquele modelo por 1M de tokens. Uma chamada que termina em erro não custa nada.

### Posso fazer streaming com tool calling?

Sim, nos modelos que suportam tools: o nome e os argumentos da função chegam em pedaços em `delta.tool_calls` e precisam ser juntados antes do uso. A [página de tool calling](https://llmwithcrypto.com/pt/docs/tool-calling/) mostra o loop sem streaming, que é mais simples para começar.

### Por que não recebo uso em uma chamada com streaming?

Adicione `"stream_options": {"include_usage": true}`. Sem isso, um stream não traz contagem de tokens; o dashboard ainda as mostra.

---

LLMwithCrypto: O LLMwithCrypto é uma API de LLM compatível com OpenAI para modelos 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 — paga por token a partir de um saldo cripto pré-pago, a 5% abaixo do preço mediano dos hosts públicos. Sem KYC: sem documento de identidade, sem selfie, sem documentos. Prompts e respostas não são armazenados.