---
title: "Latencia de LLM: TTFT, tokens por segundo y tiempo total"
description: "Qué miden el tiempo hasta el primer token, los tokens por segundo y la latencia total, cómo medirlos desde el cliente con código y qué ajuste mejora cada cifra."
url: https://broadrouter.com/es/blog/llm-latency-ttft-throughput/
lang: es
updated: 2026-11-14
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

Traducido del inglés con ayuda de IA. [Lea el original en inglés](https://broadrouter.com/blog/llm-latency-ttft-throughput/) (actualizado el 2026-11-16).

# Latencia de LLM: TTFT, tokens por segundo y latencia total

Por el equipo de BroadNet Inference · 4 min de lectura · Publicado 2026-11-14 · Actualizado 2026-11-16

El tiempo hasta el primer token (TTFT) es la espera hasta el primer token de salida. Los tokens por segundo miden la rapidez con que llega la respuesta. La latencia total: TTFT + tiempo de generación (≈ salida ÷ velocidad). El TTFT depende de la longitud del prompt y las colas; la velocidad, del tamaño del modelo y la carga; el total, de la longitud de la respuesta. Mida las tres en p50 y p95.

## Puntos clave

-   Latencia de extremo a extremo ≈ TTFT + (tokens de salida − 1) × latencia entre tokens, es decir, aproximadamente TTFT + tokens de salida ÷ tokens por segundo por usuario. En respuestas largas dominan la velocidad y la longitud; en las cortas, el TTFT.
-   En los modelos de razonamiento, el primer token visible llega después del razonamiento, así que mida el tiempo hasta el primer token de contenido aparte del tiempo hasta el primer token.
-   Los prompts largos elevan el TTFT porque el modelo lee primero todo el prompt; los prefijos en caché suelen ayudar.
-   A unos 100 tokens por segundo, el tiempo de generación crece al mismo ritmo que la respuesta: diez veces más tokens de salida tardan unas diez veces más en transmitirse.
-   Informe p50 y p95 junto con la longitud del prompt; un promedio sin el tamaño del prompt no es comparable.

**En esta página**

1.  ¿Qué son el TTFT, los tokens por segundo y la latencia de extremo a extremo?
2.  ¿Por qué los modelos de razonamiento necesitan una cuarta cifra?
3.  ¿Cómo se mide la latencia desde el cliente?
4.  ¿Qué mejora realmente cada cifra?
5.  ¿Cómo cambia el equilibrio la longitud del prompt?
6.  Dónde encaja BroadNet Inference

“La API va lenta” puede significar tres cosas distintas, y cada una se corrige de forma diferente. El usuario de un chat espera la primera palabra. Un agente espera la llamada a herramienta completa. Un trabajo por lotes se fija en los tokens por hora. Este artículo define las tres cifras, muestra cómo medirlas desde su propio código y relaciona cada ajuste con la cifra que realmente mejora.

## ¿Qué son el TTFT, los tokens por segundo y la latencia de extremo a extremo?

La guía de benchmarking de NVIDIA ofrece definiciones claras, y coinciden con lo que se puede observar desde un cliente:

| Métrica | Qué mide | Quién la nota | Depende de |
| --- | --- | --- | --- |
| [Tiempo hasta el primer token](https://broadrouter.com/es/glossary/time-to-first-token/) (TTFT) | Solicitud enviada → primer token recibido | Usuarios de chat | Red, colas, longitud del prompt (prefill), aciertos de caché |
| Latencia entre tokens (ITL) | Intervalo medio entre tokens | Quien lee una respuesta en streaming | Tamaño del modelo, hardware, carga del servidor |
| [Tokens por segundo](https://broadrouter.com/es/glossary/tokens-per-second/) por usuario | Tokens de salida después del primero ÷ tiempo de generación (del primer token al último); equivale a 1 ÷ ITL media | Lectores, agentes | Lo mismo que la ITL |
| Latencia de extremo a extremo | Solicitud enviada → último token recibido | Agentes, APIs, lotes | TTFT + tiempo de generación |

La fórmula que las relaciona:

**extremo a extremo ≈ TTFT + (tokens de salida − 1) × ITL ≈ TTFT + tokens de salida ÷ tokens por segundo por usuario**

La velocidad por usuario no es lo mismo que el [throughput](https://broadrouter.com/es/glossary/throughput/) del servidor, es decir, el total de tokens que produce para todos los usuarios; un proveedor puede aumentar uno mientras el otro baja.

Tome la velocidad típica que BroadNet publica para el modelo de sus planes, unos 100 tokens por segundo. El tiempo de generación crece con la longitud de la respuesta: un archivo de código de 4,000 tokens tarda unas ochenta veces más en generarse que una clasificación de 50 tokens, mientras que ambos esperan el mismo TTFT. En respuestas cortas, el TTFT es casi toda la espera; en las largas, lo son la velocidad y la longitud.

## ¿Por qué los modelos de razonamiento necesitan una cuarta cifra?

Los modelos de razonamiento como [DeepSeek V4.1 Flash](https://broadrouter.com/es/models/deepseek-v4.1-flash/) piensan antes de responder, y ese razonamiento también son tokens de salida. Si el modelo dedica 800 tokens a razonar a unos 100 tokens por segundo, el usuario espera a que se generen los 800 antes de ver la primera palabra, aunque el TTFT en la red parezca rápido. Por eso conviene medir aparte el **tiempo hasta el primer token de contenido**. En BroadNet Inference, `reasoning_effort: "low"` acorta el razonamiento en pasos sencillos; la [guía de razonamiento](https://broadrouter.com/es/guides/reasoning-tokens-empty-response/) explica la contrapartida.

## ¿Cómo se mide la latencia desde el cliente?

Mida donde están sus usuarios, con el [streaming](https://broadrouter.com/es/glossary/streaming/) activado. Los temporizadores del lado del servidor no ven la red ni ningún proxy.

```python
import os, time, statistics
from openai import OpenAI

client = OpenAI(base_url="https://inference.broadnet.ai/v1", api_key=os.environ["BROADNET_API_KEY"])

def timed(model, messages, max_tokens=1500):
    t0 = time.perf_counter()
    first = first_content = None
    usage = None
    stream = client.chat.completions.create(
        model=model, messages=messages, max_tokens=max_tokens,
        stream=True, stream_options={"include_usage": True},
    )
    for chunk in stream:
        now = time.perf_counter()
        if chunk.choices:
            if first is None:
                first = now
            if chunk.choices[0].delta.content and first_content is None:
                first_content = now
        if chunk.usage:
            usage = chunk.usage
    end = time.perf_counter()
    out = usage.completion_tokens if usage else 0
    return {
        "ttft": first - t0,
        "ttfct": (first_content or end) - t0,
        "e2e": end - t0,
        "tps": (out - 1) / (end - first) if out > 1 and end > first else 0,
        "prompt_tokens": usage.prompt_tokens if usage else None,
    }

runs = [timed("broadnet/gemma-4-26b-a4b", [{"role": "user", "content": "Summarise SSE in 100 words."}]) for _ in range(50)]
for k in ("ttft", "ttfct", "e2e", "tps"):
    xs = sorted(r[k] for r in runs)
    print(k, "p50", round(statistics.median(xs), 3), "p95", round(xs[int(len(xs) * 0.95) - 1], 3))
```

Cinco reglas para un benchmark justo:

1.  **Fije la longitud del prompt** e indíquela. El TTFT con 500 tokens de prompt y con 200,000 son cifras distintas. El [contador de tokens](https://broadrouter.com/tools/token-counter/) le dice cuánto mide un prompt de prueba antes de enviarlo.
2.  **Fije la longitud de la salida** con `max_tokens` y un prompt que la llene, para que los tokens por segundo sean comparables.
3.  **Informe p50 y p95**, no la media. La latencia de cola es lo que recuerdan los usuarios.
4.  **Reparta las ejecuciones en el tiempo.** La carga cambia a lo largo del día.
5.  **Haga un calentamiento primero.** La primera llamada paga el DNS, el TLS y el establecimiento de la conexión; reutilice un mismo cliente.

## ¿Qué mejora realmente cada cifra?

| Para mejorar | Haga esto | Por qué |
| --- | --- | --- |
| TTFT | Acorte el prefijo del prompt o póngalo en caché | El tiempo de prefill crece con la longitud del prompt; los prefijos en caché se ahorran trabajo |
| TTFT | Mantenga las conexiones abiertas y use una región cercana | Elimina el establecimiento de conexión y viajes de ida y vuelta |
| Tiempo hasta el primer token de contenido | Baje el esfuerzo de razonamiento o use un modelo sin razonamiento en pasos sencillos | Menos razonamiento oculto antes de la respuesta |
| Tokens por segundo | Use un modelo más pequeño o más rápido para ese paso | La velocidad de decodificación depende del tamaño del modelo y de cómo se sirve |
| Extremo a extremo | Pida salidas más cortas (esquemas, límites de palabras) | La longitud de la salida multiplica la ITL |
| Extremo a extremo con muchas llamadas | Ejecute en paralelo las llamadas independientes dentro de su límite de [concurrencia](https://broadrouter.com/es/glossary/concurrency/) | El tiempo real baja aunque cada llamada sea igual |
| Latencia percibida | Transmita la respuesta al usuario en streaming | Lee mientras el modelo escribe |

La longitud de la salida es la palanca más infravalorada. Pedir “JSON con estos cuatro campos” en lugar de “explique su respuesta” puede reducir el tiempo de generación en un orden de magnitud sin tocar la infraestructura. La [salida estructurada](https://broadrouter.com/es/glossary/structured-output/) ayuda en esto.

La palanca de la caché se trata en [estructura del prompt para la caché](https://broadrouter.com/es/blog/prompt-structure-for-caching/). La del paralelismo choca pronto con los límites de frecuencia; consulte [cómo manejar los errores 429](https://broadrouter.com/es/blog/handle-llm-api-429-rate-limits/).

## ¿Cómo cambia el equilibrio la longitud del prompt?

El TTFT crece con el prompt porque el modelo debe procesar cada token de entrada antes de poder escribir. Ese es el costo oculto de los prompts muy largos y parte de la decisión entre [contexto largo y RAG](https://broadrouter.com/es/blog/long-context-vs-rag/): un prompt de 1M de tokens responde preguntas que RAG no puede, pero empieza más lento. Si importa la velocidad interactiva, mantenga corto el camino crítico y envíe el contexto grande solo cuando la pregunta lo necesite.

## Dónde encaja BroadNet Inference

BroadNet publica una velocidad típica de unos 100 tokens por segundo para el modelo de sus planes y transmite con el formato SSE estándar, así que el código anterior funciona sin cambios. No publica cifras de TTFT ni SLA de latencia, de modo que mida con sus propios prompts antes de comprometerse; una [hora Meteoro (Meteor)](https://inference.broadnet.ai/plans?utm_source=broadrouter&utm_medium=referral&utm_campaign=es-blog-llm-latency-ttft-throughput&utm_content=body) de $1 basta para un benchmark de 50 ejecuciones, y el crédito inicial cubre uno con Gemma 4 VL 26B. Si necesita una latencia inferior al segundo garantizada a gran escala, pruebe con cuidado: una clave de pago por uso admite 4 solicitudes en curso, lo que se ajusta más a aplicaciones y agentes que a un servicio en tiempo real de gran volumen. Los modelos y sus precios están en las páginas de [modelos](https://broadrouter.com/es/models/) y [precios](https://broadrouter.com/es/pricing/).

Herramientas gratuitas sobre este tema (en 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.

[Herramientas gratuitas (en inglés)](https://broadrouter.com/tools/)

## Términos de este artículo

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

Un token es la unidad de texto que un modelo de lenguaje lee y escribe: una palabra, parte de una palabra, un signo de puntuación o una secuencia de bytes producida por el tokenizador del modelo. Las APIs de LLM cuentan, limitan y normalmente facturan el uso en tokens.

[Tiempo hasta el primer token (TTFT)](https://broadrouter.com/es/glossary/time-to-first-token/)

El tiempo hasta el primer token (TTFT) es lo que pasa desde que se envía una solicitud a un modelo de lenguaje hasta que llega el primer token de salida. Incluye la red, la cola del servidor y el prefill, cuando el modelo lee todo el prompt, así que crece con el largo del prompt y la carga.

[Latencia (latency)](https://broadrouter.com/es/glossary/latency/)

La latencia, en una API de modelos de lenguaje, es el tiempo que tarda una solicitud desde que se envía hasta que se recibe el último token de salida. Es la suma del tiempo hasta el primer token y el tiempo de generación, y suele reportarse en percentiles como p50 y p95, no como promedio.

[Streaming (respuestas en tiempo real)](https://broadrouter.com/es/glossary/streaming/)

El streaming es una forma de devolver la respuesta de un modelo de lenguaje en pequeños fragmentos mientras aún se genera, en lugar de una sola respuesta al final. Las APIs compatibles con OpenAI hacen streaming mediante server-sent events cuando la solicitud define stream como true.

[Concurrencia (concurrency)](https://broadrouter.com/es/glossary/concurrency/)

La concurrencia es el número de solicitudes que un cliente tiene en curso al mismo tiempo. Las APIs de LLM suelen limitarla por clave o por plan, aparte de las solicitudes por minuto, porque cada solicitud abierta ocupa capacidad de GPU hasta que su respuesta termina.

[Tokens por segundo (TPS)](https://broadrouter.com/es/glossary/tokens-per-second/)

Los tokens por segundo (TPS) son la velocidad a la que un modelo de lenguaje genera tokens de salida, normalmente medida en una solicitud tras llegar su primer token. Marcan qué tan rápido fluye la respuesta. Sumados en todas las solicitudes concurrentes son el throughput del sistema; la espera hasta el primer token se mide aparte.

[Throughput (rendimiento total)](https://broadrouter.com/es/glossary/throughput/)

El throughput, en el servicio de LLMs, es la cantidad total de trabajo que un sistema completa por unidad de tiempo en todas las solicitudes concurrentes, normalmente medida en tokens de salida por segundo o solicitudes por segundo. Es distinto de la velocidad por stream, que es qué tan rápido recibe sus tokens una sola solicitud.

[Tokens de entrada y de salida (input and output tokens)](https://broadrouter.com/es/glossary/input-and-output-tokens/)

Los tokens de entrada son los que un modelo de lenguaje lee en una solicitud, incluidos el prompt de sistema, el historial de la conversación, las definiciones de herramientas y las imágenes. Los tokens de salida son los que genera en la respuesta, incluido el razonamiento. Las APIs de LLM suelen cobrarlos por separado, y la salida suele costar más.

## Preguntas frecuentes

### ¿Cuál es un buen tiempo hasta el primer token en una API de LLM?

En un chat, menos de un segundo aproximadamente con prompts cortos se percibe como ágil. Los prompts largos y los modelos de razonamiento tardan más por diseño. Compare el TTFT solo con la misma longitud de prompt y el mismo modelo.

### ¿Los tokens por segundo son lo mismo que el throughput?

No exactamente. Los tokens por segundo por usuario indican a qué velocidad llega una respuesta. El throughput es el total de tokens que produce un servidor para todos los usuarios. Un proveedor puede aumentar el throughput total mientras baja la velocidad de cada usuario.

### ¿Por qué el TTFT es tan alto en un modelo de razonamiento?

El modelo genera tokens de razonamiento ocultos antes de la respuesta visible. El primer token puede llegar rápido, pero el primer token de contenido espera a que termine el razonamiento. Baje reasoning\_effort en tareas sencillas.

### ¿El streaming reduce la latencia?

No acorta el tiempo de extremo a extremo. Permite que el usuario lea la respuesta mientras se escribe, así que la latencia percibida baja aproximadamente al TTFT.

### ¿Cuántas solicitudes necesito para un benchmark de latencia fiable?

Las suficientes para ver la cola. Entre cincuenta y cien solicitudes por tamaño de prompt dan un p95 utilizable. Repártalas a lo largo del día, porque la carga cambia.

## Siga leyendo

-   [Streaming de LLM explicado: chunks SSE, deltas, usage y cancelación](https://broadrouter.com/es/blog/llm-streaming-sse-explained/)
-   [Cómo estructurar los prompts para que el prefijo quede en caché](https://broadrouter.com/es/blog/prompt-structure-for-caching/)
-   [Contexto largo vs RAG: cuándo 1M de tokens reemplaza la base vectorial](https://broadrouter.com/es/blog/long-context-vs-rag/)
-   [El hardware GPU de BroadNet y cómo sirve los modelos, según BroadNet](https://broadrouter.com/es/blog/broadnet-gpu-fleet-and-serving/)
-   [Caché de respuestas de APIs de LLM para reducir costos en Python](https://broadrouter.com/es/blog/cache-llm-responses-cut-cost/)
-   [Guía: Streaming de chat completions y conexiones interrumpidas](https://broadrouter.com/es/guides/streaming-chat-completions/)
-   [Guía: ¿Por qué un modelo de razonamiento devuelve una respuesta vacía?](https://broadrouter.com/es/guides/reasoning-tokens-empty-response/)

Pruébelo con su carga de trabajo real. Las cuentas nuevas empiezan con USD 5 de crédito para Gemma y transcripción. DeepSeek, GLM y Qwen3.8 requieren una recarga.

[Comenzar](https://inference.broadnet.ai/account/?utm_source=broadrouter&utm_medium=referral&utm_campaign=es-blog-llm-latency-ttft-throughput&utm_content=page-cta) ·

**Fuentes**

-   [Guía de benchmarking de NVIDIA NIM, métricas de latencia y throughput de LLM (consultado el 2026-11-14)](https://docs.nvidia.com/nim/benchmarking/llm/metrics)
-   [Planes de BroadNet Inference, velocidad típica (consultado el 2026-11-15)](https://inference.broadnet.ai/es/plans?utm_source=broadrouter&utm_medium=referral&utm_campaign=es-blog-llm-latency-ttft-throughput&utm_content=sources)
-   [Referencia de la API de BroadNet Inference, streaming y razonamiento (consultado el 2026-11-15) (en inglés)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=es-blog-llm-latency-ttft-throughput&utm_content=sources)
-   [Baseten Inference Engineering, cómo medir la latencia y el throughput (consultado el 2026-11-16)](https://www.baseten.co/inference-engineering/book/01-prerequisites/measuring-latency-and-throughput/)
