---
title: "Latência de LLM: TTFT, tokens/s e ponta a ponta | BroadRouter"
description: "O que medem o time to first token, os tokens por segundo e a latência de ponta a ponta, como cronometrar cada um no cliente e qual ajuste move qual número."
url: https://broadrouter.com/pt/blog/llm-latency-ttft-throughput/
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-latency-ttft-throughput/) (atualizado em 2026-11-16).

# Latência de LLM: TTFT, tokens por segundo e tempo de ponta a ponta

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

O time to first token (TTFT) é a espera até o primeiro token de saída. Tokens por segundo é a rapidez com que a resposta chega depois. A latência de ponta a ponta é TTFT mais o tempo de geração (≈ tokens de saída ÷ velocidade). Tamanho do prompt e filas definem o TTFT, tamanho do modelo e carga, a velocidade, e o da resposta, o total. Meça os três em p50 e p95.

## Pontos principais

-   Latência de ponta a ponta ≈ TTFT + (tokens de saída − 1) × latência entre tokens, ou seja, cerca de TTFT + tokens de saída ÷ tokens por segundo por usuário. Em respostas longas, velocidade e tamanho dominam; nas curtas, o TTFT.
-   Em modelos de raciocínio, o primeiro token visível vem depois do raciocínio, então meça o tempo até o primeiro token de conteúdo separado do tempo até o primeiro token.
-   Prompts longos aumentam o TTFT porque o modelo lê o prompt inteiro primeiro; prefixos em cache costumam ajudar.
-   A cerca de 100 tokens por segundo, o tempo de geração cresce junto com a resposta: dez vezes mais tokens de saída levam cerca de dez vezes mais tempo para chegar em streaming.
-   Informe p50 e p95 junto com o tamanho do prompt; uma média sem o tamanho do prompt não é comparável.

**Nesta página**

1.  O que são TTFT, tokens por segundo e latência de ponta a ponta?
2.  Por que modelos de raciocínio precisam de um quarto número?
3.  Como medir a latência a partir do cliente?
4.  O que realmente melhora cada número?
5.  Como o tamanho do prompt muda o trade-off?
6.  Onde a BroadNet Inference se encaixa

“A API está lenta” pode significar três coisas diferentes, e cada uma tem uma solução diferente. Um usuário de chat espera a primeira palavra. Um agente espera a chamada de ferramenta inteira. Um job em lote se importa com tokens por hora. Este post define os três números, mostra como medi-los a partir do seu próprio código e associa cada ajuste ao número que ele realmente move.

## O que são TTFT, tokens por segundo e latência de ponta a ponta?

O guia de benchmarking da NVIDIA traz definições claras, que batem com o que você consegue observar a partir de um cliente:

| Métrica | O que mede | Quem sente | Depende de |
| --- | --- | --- | --- |
| [Time to first token](https://broadrouter.com/pt/glossary/time-to-first-token/) (TTFT) | Requisição enviada → primeiro token recebido | Usuários de chat | Rede, filas, tamanho do prompt (prefill), acertos de cache |
| Latência entre tokens (ITL) | Intervalo médio entre tokens | Quem lê uma resposta em streaming | Tamanho do modelo, hardware, carga do servidor |
| [Tokens por segundo](https://broadrouter.com/pt/glossary/tokens-per-second/) por usuário | Tokens de saída depois do primeiro ÷ tempo de geração (do primeiro ao último token); igual a 1 ÷ ITL médio | Leitores, agentes | O mesmo que o ITL |
| Latência de ponta a ponta | Requisição enviada → último token recebido | Agentes, APIs, lote | TTFT + tempo de geração |

A fórmula que liga tudo:

**ponta a ponta ≈ TTFT + (tokens de saída − 1) × ITL ≈ TTFT + tokens de saída ÷ tokens por segundo por usuário**

A velocidade por usuário não é o mesmo que o [throughput](https://broadrouter.com/pt/glossary/throughput/) do servidor, o total de tokens que um servidor produz para todos os usuários; um provedor pode aumentar um enquanto o outro cai.

Tome a velocidade típica que a BroadNet publica para o modelo dos planos, cerca de 100 tokens por segundo. O tempo de geração cresce com o tamanho da resposta: um arquivo de código de 4.000 tokens leva cerca de oitenta vezes mais para ser gerado do que uma classificação de 50 tokens, enquanto os dois esperam o mesmo TTFT. Em respostas curtas, o TTFT é a maior parte da espera; nas longas, contam a velocidade e o tamanho.

## Por que modelos de raciocínio precisam de um quarto número?

Modelos de raciocínio como o [DeepSeek V4.1 Flash](https://broadrouter.com/pt/models/deepseek-v4.1-flash/) pensam antes de responder, e o raciocínio também é feito de tokens de saída. Se o modelo gasta 800 tokens raciocinando a cerca de 100 tokens por segundo, o usuário espera que todos os 800 sejam gerados antes da primeira palavra visível, mesmo que o TTFT medido na rede pareça rápido. Por isso, meça à parte o **tempo até o primeiro token de conteúdo**. Na BroadNet Inference, `reasoning_effort: "low"` encurta o raciocínio em etapas simples; o [guia de raciocínio](https://broadrouter.com/pt/guides/reasoning-tokens-empty-response/) explica o trade-off.

## Como medir a latência a partir do cliente?

Meça onde seus usuários estão, com [streaming](https://broadrouter.com/pt/glossary/streaming/) ligado. Cronômetros do lado do servidor não enxergam a rede nem qualquer 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 regras para um benchmark justo:

1.  **Fixe o tamanho do prompt** e informe esse valor. O TTFT com 500 tokens de prompt e com 200.000 são números diferentes. O [contador de tokens](https://broadrouter.com/tools/token-counter/) diz o tamanho de um prompt de teste antes de você enviá-lo.
2.  **Fixe o tamanho da saída** com `max_tokens` e um prompt que o preencha, para que os tokens por segundo sejam comparáveis.
3.  **Informe p50 e p95**, não a média. A latência de cauda é o que os usuários lembram.
4.  **Espalhe as execuções no tempo.** A carga muda ao longo do dia.
5.  **Aqueça antes.** A primeira chamada paga DNS, TLS e abertura de conexão; reutilize um único cliente.

## O que realmente melhora cada número?

| Para melhorar | Faça isto | Por quê |
| --- | --- | --- |
| TTFT | Encurte ou coloque em cache o prefixo do prompt | O tempo de prefill cresce com o tamanho do prompt; prefixos em cache pulam trabalho |
| TTFT | Mantenha as conexões aquecidas, use uma região próxima | Elimina setup e idas e voltas |
| Tempo até o primeiro token de conteúdo | Reduza o esforço de raciocínio, ou use um modelo sem raciocínio em etapas simples | Menos raciocínio oculto antes da resposta |
| Tokens por segundo | Use um modelo menor ou mais rápido para a etapa | A velocidade de decodificação depende do tamanho do modelo e do serving |
| Ponta a ponta | Peça saídas mais curtas (schemas, limites de palavras) | O tamanho da saída multiplica o ITL |
| Ponta a ponta em muitas chamadas | Rode chamadas independentes em paralelo dentro do seu limite de [concorrência](https://broadrouter.com/pt/glossary/concurrency/) | O tempo de relógio cai, mesmo que cada chamada seja igual |
| Latência percebida | Faça streaming para o usuário | Ele lê enquanto o modelo escreve |

O tamanho da saída é a alavanca mais subestimada. Pedir “JSON com estes quatro campos” em vez de “explique sua resposta” pode cortar o tempo de geração em uma ordem de grandeza, sem nenhum trabalho de infraestrutura. A [saída estruturada](https://broadrouter.com/pt/glossary/structured-output/) ajuda nisso.

A alavanca do cache é tratada em [estrutura de prompt para cache](https://broadrouter.com/pt/blog/prompt-structure-for-caching/). A do paralelismo esbarra rápido nos rate limits; veja [como lidar com erros 429](https://broadrouter.com/pt/blog/handle-llm-api-429-rate-limits/).

## Como o tamanho do prompt muda o trade-off?

O TTFT cresce com o prompt porque o modelo precisa processar cada token de entrada antes de começar a escrever. Esse é o custo escondido de prompts muito longos e parte da decisão entre [contexto longo e RAG](https://broadrouter.com/pt/blog/long-context-vs-rag/): um prompt de 1M de tokens responde perguntas que a RAG não consegue, mas começa mais devagar. Se a velocidade interativa importa, mantenha curto o caminho principal e envie o contexto grande só quando a pergunta precisar.

## Onde a BroadNet Inference se encaixa

A BroadNet publica uma velocidade típica de cerca de 100 tokens por segundo para o modelo dos planos e faz streaming no formato SSE padrão, então o código acima funciona sem mudanças. Ela não publica números de TTFT nem SLAs de latência, então meça com seus próprios prompts antes de se comprometer; uma [hora Meteor](https://inference.broadnet.ai/plans?utm_source=broadrouter&utm_medium=referral&utm_campaign=pt-blog-llm-latency-ttft-throughput&utm_content=body) de $1 basta para um benchmark de 50 execuções, e o crédito inicial cobre um no Gemma 4 VL 26B. Se você precisa de latência garantida abaixo de um segundo em grande escala, teste com cuidado: uma chave de pagamento por uso permite 4 requisições em andamento, o que combina mais com apps e agentes do que com serving em tempo real de alto volume. Os modelos e seus preços estão nas páginas de [modelos](https://broadrouter.com/pt/models/) e [preços](https://broadrouter.com/pt/pricing/).

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.

[Time to first token (TTFT)](https://broadrouter.com/pt/glossary/time-to-first-token/)

Time to first token (TTFT) é o tempo entre o envio de uma requisição a um modelo de linguagem e a chegada do primeiro token de saída. Inclui o tempo de rede, a fila no servidor e o prefill, etapa em que o modelo lê o prompt inteiro, então cresce com o tamanho do prompt e a carga.

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

[Concorrência (concurrency)](https://broadrouter.com/pt/glossary/concurrency/)

Concorrência é o número de requisições que um cliente tem em andamento ao mesmo tempo. APIs de LLM muitas vezes a limitam por chave ou por plano, separadamente das requisições por minuto, porque cada requisição aberta ocupa capacidade de GPU até a resposta terminar.

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

Tokens por segundo (TPS) são a taxa com que um modelo de linguagem gera tokens de saída, geralmente medida para uma requisição depois que o primeiro token chega. Definem a rapidez com que a resposta flui depois de começar. Somados em todas as requisições simultâneas, viram throughput do sistema; a espera pelo primeiro token é medida à parte.

[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 entrada e de saída](https://broadrouter.com/pt/glossary/input-and-output-tokens/)

Tokens de entrada são os tokens que um modelo de linguagem lê em uma requisição, incluindo o system prompt, o histórico da conversa, as definições de ferramentas e as imagens. Tokens de saída são os que ele gera na resposta, incluindo o raciocínio. As APIs de LLM costumam cobrá-los separadamente, e a saída costuma custar mais.

[Latência (latency)](https://broadrouter.com/pt/glossary/latency/)

Latência, em uma API de modelos de linguagem, é o tempo entre o envio de uma requisição e o recebimento do último token de saída. É a soma do time to first token com o tempo de geração e costuma ser informada em percentis, como p50 e p95, e não como média.

## Perguntas frequentes

### Qual é um bom time to first token para uma API de LLM?

Para chat, menos de cerca de um segundo em prompts curtos já parece responsivo. Prompts longos e modelos de raciocínio demoram mais por natureza. Compare o TTFT só com o mesmo tamanho de prompt e o mesmo modelo.

### Tokens por segundo é a mesma coisa que throughput?

Não exatamente. Tokens por segundo por usuário é a rapidez com que uma resposta chega. Throughput é o total de tokens que um servidor produz para todos os usuários. Um provedor pode aumentar o throughput total enquanto a velocidade de cada usuário cai.

### Por que o TTFT é tão alto num modelo de raciocínio?

O modelo gera tokens de raciocínio ocultos antes da resposta visível. O primeiro token pode chegar rápido, mas o primeiro token de conteúdo espera o fim do raciocínio. Reduza o reasoning\_effort em tarefas simples.

### O streaming reduz a latência?

Não encurta o tempo de ponta a ponta. Ele deixa o usuário ler a resposta enquanto ela ainda está sendo escrita, então a latência percebida cai para mais ou menos o TTFT.

### Quantas requisições preciso para um benchmark de latência confiável?

O suficiente para enxergar a cauda. De cinquenta a cem requisições por tamanho de prompt dão um p95 utilizável. Espalhe-as ao longo do dia, porque a carga muda.

## Continue lendo

-   [Streaming de LLM explicado: chunks SSE, deltas, usage e cancelamento](https://broadrouter.com/pt/blog/llm-streaming-sse-explained/)
-   [Como estruturar prompts para o prefixo entrar em cache](https://broadrouter.com/pt/blog/prompt-structure-for-caching/)
-   [Contexto longo vs RAG: quando 1M de tokens substitui um banco vetorial](https://broadrouter.com/pt/blog/long-context-vs-rag/)
-   [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: Por que um modelo de raciocínio devolve uma resposta vazia](https://broadrouter.com/pt/guides/reasoning-tokens-empty-response/)

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-latency-ttft-throughput&utm_content=page-cta) ·

**Fontes**

-   [Guia de benchmarking do NVIDIA NIM, métricas de latência e throughput de LLM (consultado em 2026-11-14)](https://docs.nvidia.com/nim/benchmarking/llm/metrics)
-   [Planos da BroadNet Inference, velocidade típica (verificado em 2026-11-15) (em inglês)](https://inference.broadnet.ai/plans?utm_source=broadrouter&utm_medium=referral&utm_campaign=pt-blog-llm-latency-ttft-throughput&utm_content=sources)
-   [Referência da API da BroadNet Inference, streaming e raciocínio (verificado em 2026-11-15) (em inglês)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=pt-blog-llm-latency-ttft-throughput&utm_content=sources)
-   [Baseten Inference Engineering, como medir latência e throughput (verificado em 2026-11-16)](https://www.baseten.co/inference-engineering/book/01-prerequisites/measuring-latency-and-throughput/)
