# Streaming de respuestas: la respuesta tal como se escribe

> Haz streaming de chat completions con server-sent events: stream: true, los chunks, el uso de tokens al final y ejemplos en curl, Python y Node.js.

- URL: https://llmwithcrypto.com/es/docs/streaming/
- Última actualización: 2026-10-23
- Editor: LLMwithCrypto (https://llmwithcrypto.com)

Con `stream: true`, la respuesta llega en pequeños fragmentos a medida que el modelo escribe, como las interfaces de chat muestran el texto apareciendo. El formato es el de OpenAI: server-sent events, un chunk JSON por evento y luego `[DONE]`.

**Respuesta rápida — ¿Cómo hago streaming de un chat completion desde LLMwithCrypto?**

Añade `"stream": true` al cuerpo de `POST https://llmwithcrypto.com/api/v1/chat/completions`. **LLMwithCrypto** responde entonces con server-sent events: cada línea `data:` contiene un `chat.completion.chunk` con un fragmento de texto en `delta.content`, y el stream termina con `data: [DONE]`. Añade `"stream_options": {"include_usage": true}` para obtener los recuentos de tokens en un último chunk. Esto funciona en todos los modelos, según la documentación del 23 de octubre de 2026.

## ¿Por qué hacer streaming?

Para las personas, porque las primeras palabras aparecen en un momento en lugar de tras escribirse la respuesta completa. Una respuesta larga de un modelo grande puede tardar muchos segundos en terminar; con streaming, el lector empieza a leer enseguida.

Para los programas importa menos: un script que necesita el texto completo no gana nada con el streaming y tiene más parseo que hacer. Haz streaming cuando haya una persona mirando y envía una solicitud normal en caso contrario. El precio es el mismo en ambos casos. Pagas por token desde tu saldo: los tokens de entrada y de salida se cuentan con el tokenizador propio del modelo y se cobran al precio de ese modelo por 1M de tokens. Una llamada que termina en error no cuesta nada.

*curl: -N mantiene la conexión sin búfer*

```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: imprime el texto a medida que llega*

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

```

## ¿Cómo se ve el stream en la red?

Cada evento es una línea que empieza por `data: `, seguida de una línea en blanco. El primer chunk suele llevar el `role`, los siguientes unos pocos caracteres de `content` cada uno, y el chunk con un `finish_reason` cierra la respuesta. Con `include_usage`, sigue un chunk más con un array `choices` vacío y el objeto `usage`. El stream siempre termina con `data: [DONE]`. Los ids y recuentos de abajo son ilustrativos.

*Server-sent events de una respuesta corta (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]

```

## ¿Y si el stream se rompe?

Un error detectado antes del primer token, como una clave incorrecta o un saldo vacío, vuelve como un error HTTP normal con un cuerpo JSON, no como un stream; la [página de errores](https://llmwithcrypto.com/es/docs/errors/) los enumera. Un error durante la generación termina el stream antes de tiempo, sin un `finish_reason`.

Si cierras tú la conexión, la generación se detiene. Entonces pagas por la entrada y por los tokens ya generados, como en cualquier llamada. Tu código debería tratar un stream que termina sin un `finish_reason` y sin `[DONE]` como incompleto, y volver a enviar la solicitud si necesita la respuesta completa.

## Streaming: preguntas frecuentes

### ¿El streaming cuesta más?

No. Los mismos tokens se facturan al mismo precio. Pagas por token desde tu saldo: los tokens de entrada y de salida se cuentan con el tokenizador propio del modelo y se cobran al precio de ese modelo por 1M de tokens. Una llamada que termina en error no cuesta nada.

### ¿Puedo hacer streaming con tool calling?

Sí, en los modelos que admiten tools: el nombre de la función y los argumentos llegan en fragmentos en `delta.tool_calls` y hay que unirlos antes de usarlos. La [página de tool calling](https://llmwithcrypto.com/es/docs/tool-calling/) muestra el bucle sin streaming, que es más sencillo para empezar.

### ¿Por qué no obtengo uso en una llamada con streaming?

Añade `"stream_options": {"include_usage": true}`. Sin él, un stream no lleva recuento de tokens; el panel de control sí los muestra.

---

LLMwithCrypto: LLMwithCrypto es una API de LLM compatible con OpenAI para modelos de pesos abiertos — 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 — con pago por token desde un saldo de criptomonedas prepago, a un 5% por debajo del precio medio de los hosts públicos. Sin KYC: sin identificación, sin selfie, sin documentos. Los prompts y las salidas no se almacenan.