---
title: "Latence LLM expliquée : TTFT, tokens/s, bout en bout"
description: "Ce que mesurent le time to first token, les tokens par seconde et la latence de bout en bout, comment les chronométrer côté client, et quel levier agit sur quoi."
url: https://broadrouter.com/fr/blog/llm-latency-ttft-throughput/
lang: fr
updated: 2026-11-14
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

Traduit de l’anglais avec l’aide de l’IA. [Lire l’original en anglais](https://broadrouter.com/blog/llm-latency-ttft-throughput/) (mis à jour le 2026-11-16).

# Latence LLM : TTFT, tokens par seconde et temps de bout en bout

Par l’équipe BroadNet Inference · 4 min de lecture · Publié 2026-11-14 · Mis à jour 2026-11-16

Le time to first token (TTFT) est l’attente avant le premier token de sortie. Les tokens par seconde mesurent la vitesse de diffusion. La latence de bout en bout est le total : TTFT plus temps de génération (≈ sortie ÷ vitesse). Le prompt et la file d’attente pèsent sur le TTFT, le modèle et la charge sur la vitesse, la longueur de réponse sur le total. Mesurez les trois au p50 et au p95.

## À retenir

-   Latence de bout en bout ≈ TTFT + (tokens de sortie − 1) × latence inter-tokens, soit environ TTFT + tokens de sortie ÷ tokens par seconde par utilisateur. Pour les réponses longues, vitesse et longueur dominent ; pour les courtes, c’est le TTFT.
-   Sur les modèles de raisonnement, le premier token visible arrive après la réflexion : mesurez le temps jusqu’au premier token de contenu séparément du temps jusqu’au premier token.
-   Les prompts longs augmentent le TTFT, car le modèle lit d’abord tout le prompt ; les préfixes en cache aident généralement.
-   À environ 100 tokens par seconde, le temps de génération croît au même rythme que la réponse : dix fois plus de tokens de sortie prennent environ dix fois plus de temps à être diffusés.
-   Donnez le p50 et le p95 avec la longueur du prompt ; une moyenne sans taille de prompt n’est pas comparable.

**Sur cette page**

1.  Que sont le TTFT, les tokens par seconde et la latence de bout en bout ?
2.  Pourquoi les modèles de raisonnement ont-ils besoin d’un quatrième chiffre ?
3.  Comment mesurer la latence côté client ?
4.  Qu’est-ce qui améliore réellement chaque chiffre ?
5.  Comment la longueur du prompt change-t-elle le compromis ?
6.  Où se situe BroadNet Inference

« L’API est lente » peut vouloir dire trois choses différentes, et chacune a sa solution. Un utilisateur de chat attend le premier mot. Un agent attend l’appel d’outil complet. Un traitement par lots se soucie des tokens par heure. Cet article définit les trois chiffres, montre comment les mesurer depuis votre propre code, et associe chaque correctif au chiffre qu’il fait réellement bouger.

## Que sont le TTFT, les tokens par seconde et la latence de bout en bout ?

Le guide de benchmark de NVIDIA donne des définitions nettes, qui correspondent à ce que vous pouvez observer côté client :

| Métrique | Ce qu’elle mesure | Qui la ressent | Dépend de |
| --- | --- | --- | --- |
| [Time to first token](https://broadrouter.com/fr/glossary/time-to-first-token/) (TTFT) | Requête envoyée → premier token reçu | Utilisateurs de chat | Réseau, file d’attente, longueur du prompt (prefill), hits de cache |
| Latence inter-tokens (ITL) | Écart moyen entre deux tokens | Lecteurs d’une réponse en streaming | Taille du modèle, matériel, charge du serveur |
| [Tokens par seconde](https://broadrouter.com/fr/glossary/tokens-per-second/) par utilisateur | Tokens de sortie après le premier ÷ temps de génération (du premier au dernier token) ; égal à 1 ÷ ITL moyenne | Lecteurs, agents | Comme l’ITL |
| Latence de bout en bout | Requête envoyée → dernier token reçu | Agents, API, traitements par lots | TTFT + temps de génération |

La formule qui les relie :

**bout en bout ≈ TTFT + (tokens de sortie − 1) × ITL ≈ TTFT + tokens de sortie ÷ tokens par seconde par utilisateur**

La vitesse par utilisateur n’est pas le [débit](https://broadrouter.com/fr/glossary/throughput/) du serveur, c’est-à-dire le total des tokens qu’il produit pour tous les utilisateurs ; un fournisseur peut augmenter l’un pendant que l’autre baisse.

Prenons la vitesse typique que BroadNet publie pour son modèle de forfait, environ 100 tokens par seconde. Le temps de génération croît avec la longueur de la réponse : un fichier de code de 4 000 tokens prend environ quatre-vingts fois plus de temps à générer qu’une classification de 50 tokens, alors que les deux attendent le même TTFT. Pour les réponses courtes, le TTFT représente l’essentiel de l’attente ; pour les longues, ce sont la vitesse et la longueur.

## Pourquoi les modèles de raisonnement ont-ils besoin d’un quatrième chiffre ?

Les modèles de raisonnement comme [DeepSeek V4.1 Flash](https://broadrouter.com/fr/models/deepseek-v4.1-flash/) réfléchissent avant de répondre, et cette réflexion est elle aussi faite de tokens de sortie. Si le modèle consacre 800 tokens au raisonnement à environ 100 tokens par seconde, l’utilisateur attend que les 800 soient générés avant de voir le premier mot, même si le TTFT mesuré sur le réseau paraît rapide. Mesurez donc séparément le **temps jusqu’au premier token de contenu**. Sur BroadNet Inference, `reasoning_effort: "low"` raccourcit la réflexion pour les étapes simples ; le [guide du raisonnement](https://broadrouter.com/fr/guides/reasoning-tokens-empty-response/) explique le compromis.

## Comment mesurer la latence côté client ?

Chronométrez là où se trouvent vos utilisateurs, avec le [streaming](https://broadrouter.com/fr/glossary/streaming/) activé. Les chronomètres côté serveur ignorent le réseau et tout 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))
```

Cinq règles pour un benchmark équitable :

1.  **Fixez la longueur du prompt** et indiquez-la. Le TTFT à 500 tokens de prompt et à 200 000 sont deux chiffres différents. Le [compteur de tokens](https://broadrouter.com/tools/token-counter/) vous donne la longueur d’un prompt de test avant de l’envoyer.
2.  **Fixez la longueur de sortie** avec `max_tokens` et un prompt qui la remplit, pour que les tokens par seconde soient comparables.
3.  **Indiquez le p50 et le p95**, pas la moyenne. C’est la latence de traîne dont les utilisateurs se souviennent.
4.  **Étalez les exécutions dans le temps.** La charge varie au cours de la journée.
5.  **Faites d’abord un échauffement.** Le premier appel paie le DNS, le TLS et l’établissement de la connexion ; réutilisez un même client.

## Qu’est-ce qui améliore réellement chaque chiffre ?

| Pour améliorer | Faites ceci | Pourquoi |
| --- | --- | --- |
| TTFT | Raccourcir ou mettre en cache le préfixe du prompt | Le temps de prefill croît avec la longueur du prompt ; les préfixes en cache évitent du travail |
| TTFT | Garder les connexions chaudes, utiliser une région proche | Supprime l’établissement de connexion et des allers-retours |
| Temps jusqu’au premier token de contenu | Baisser l’effort de raisonnement, ou utiliser un modèle sans raisonnement pour les étapes simples | Moins de réflexion cachée avant la réponse |
| Tokens par seconde | Utiliser un modèle plus petit ou plus rapide pour l’étape | La vitesse de décodage dépend de la taille du modèle et du service |
| Bout en bout | Demander une sortie plus courte (schémas, limites de mots) | La longueur de sortie multiplie l’ITL |
| Bout en bout sur de nombreux appels | Exécuter en parallèle les appels indépendants dans la limite de votre [simultanéité](https://broadrouter.com/fr/glossary/concurrency/) | Le temps total baisse même si chaque appel reste identique |
| Latence perçue | Diffuser en streaming vers l’utilisateur | Il lit pendant que le modèle écrit |

La longueur de sortie est le levier le plus sous-estimé. Demander « du JSON avec ces quatre champs » au lieu de « explique ta réponse » peut réduire le temps de génération d’un ordre de grandeur, sans aucun travail d’infrastructure. La [sortie structurée](https://broadrouter.com/fr/glossary/structured-output/) y aide.

Le levier du cache est traité dans [structurer ses prompts pour le cache](https://broadrouter.com/fr/blog/prompt-structure-for-caching/). Le levier du parallélisme se heurte vite aux limites de débit ; voir [gérer les erreurs 429](https://broadrouter.com/fr/blog/handle-llm-api-429-rate-limits/).

## Comment la longueur du prompt change-t-elle le compromis ?

Le TTFT croît avec le prompt, car le modèle doit traiter chaque token d’entrée avant de pouvoir écrire. C’est le coût caché des prompts très longs, et une partie de l’arbitrage [contexte long ou RAG](https://broadrouter.com/fr/blog/long-context-vs-rag/) : un prompt de 1 M de tokens répond à des questions que le RAG ne peut pas traiter, mais il démarre plus lentement. Si la vitesse interactive compte, gardez le chemin critique court et n’envoyez le gros contexte que lorsque la question l’exige.

## Où se situe BroadNet Inference

BroadNet publie une vitesse typique de environ 100 tokens par seconde pour son modèle de forfait et diffuse au format SSE standard : le code ci-dessus fonctionne donc tel quel. Il ne publie ni chiffres de TTFT ni SLA de latence ; mesurez donc sur vos propres prompts avant de vous engager. Une [heure Meteor](https://inference.broadnet.ai/plans?utm_source=broadrouter&utm_medium=referral&utm_campaign=fr-blog-llm-latency-ttft-throughput&utm_content=body) à $1 suffit pour un benchmark de 50 exécutions, et le crédit de départ en couvre un sur Gemma 4 VL 26B. S’il vous faut une latence garantie sous la seconde à grande échelle, testez soigneusement : une clé à l’usage autorise 4 requêtes en cours, ce qui convient mieux aux applications et aux agents qu’à un service temps réel à fort volume. Les modèles et leurs prix sont sur les pages [modèles](https://broadrouter.com/fr/models/) et [tarifs](https://broadrouter.com/fr/pricing/).

Outils gratuits sur ce sujet (en anglais)

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

[Outils gratuits (en anglais)](https://broadrouter.com/tools/)

## Termes de cet article

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

Un token est l’unité de texte qu’un modèle de langage lit et écrit : un mot, une partie de mot, un signe de ponctuation ou une suite d’octets produite par le tokenizer du modèle. Les API LLM comptent, limitent et facturent généralement l’usage en tokens.

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

Le time to first token (TTFT) est le temps écoulé entre l’envoi d’une requête à un modèle de langage et l’arrivée du premier token de sortie. Il comprend le temps réseau, la file d’attente côté serveur et le prefill, où le modèle lit tout le prompt : il augmente donc avec la longueur du prompt et la charge.

[Latence (LLM)](https://broadrouter.com/fr/glossary/latency/)

Pour une API de modèle de langage, la latence est le temps que prend une requête entre son envoi et la réception du dernier token de sortie. C’est la somme du time to first token et du temps de génération, généralement exprimée en percentiles comme le p50 et le p95 plutôt qu’en moyenne.

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

Le streaming est une manière de renvoyer la réponse d’un modèle de langage par petits chunks pendant sa génération, plutôt qu’en un seul bloc à la fin. Les API compatibles OpenAI streament via des server-sent events quand la requête règle stream sur true.

[Concurrence (requêtes simultanées)](https://broadrouter.com/fr/glossary/concurrency/)

La concurrence est le nombre de requêtes qu’un client a en cours au même moment. Les API de LLM la plafonnent souvent par clé ou par forfait, indépendamment des requêtes par minute, car chaque requête ouverte occupe de la capacité GPU jusqu’à la fin de sa réponse.

[Tokens par seconde (TPS)](https://broadrouter.com/fr/glossary/tokens-per-second/)

Les tokens par seconde (TPS) sont le rythme auquel un modèle de langage génère des tokens de sortie, généralement mesuré pour une requête après son premier token. Ils fixent la vitesse d’affichage d’une réponse lancée. Additionnés sur toutes les requêtes simultanées, ils donnent le débit du système ; l’attente avant le premier token se mesure à part.

[Débit (throughput)](https://broadrouter.com/fr/glossary/throughput/)

Le débit (throughput), dans le service de LLM, est la quantité totale de travail qu’un système accomplit par unité de temps sur toutes les requêtes simultanées, généralement mesurée en tokens de sortie par seconde ou en requêtes par seconde. Il se distingue de la vitesse par flux, c’est-à-dire la vitesse à laquelle une seule requête reçoit ses tokens.

[Tokens d’entrée et de sortie](https://broadrouter.com/fr/glossary/input-and-output-tokens/)

Les tokens d’entrée sont les tokens qu’un modèle de langage lit dans une requête, dont le prompt système, l’historique de conversation, les définitions d’outils et les images. Les tokens de sortie sont ceux qu’il génère en réponse, raisonnement compris. Les API LLM les facturent généralement séparément, et la sortie coûte en général plus cher.

## Questions fréquentes

### Quel est un bon time to first token pour une API LLM ?

Pour du chat, moins d’une seconde environ sur des prompts courts donne une impression de réactivité. Les prompts longs et les modèles de raisonnement prennent plus de temps par nature. Ne comparez le TTFT qu’à longueur de prompt et modèle identiques.

### Les tokens par seconde, est-ce la même chose que le débit ?

Pas tout à fait. Les tokens par seconde par utilisateur indiquent à quelle vitesse une réponse est diffusée. Le débit est le total des tokens qu’un serveur produit pour l’ensemble des utilisateurs. Un fournisseur peut augmenter le débit total pendant que la vitesse de chaque utilisateur baisse.

### Pourquoi le TTFT est-il si élevé sur un modèle de raisonnement ?

Le modèle génère des tokens de raisonnement cachés avant la réponse visible. Le premier token peut arriver vite, mais le premier token de contenu attend la fin de la réflexion. Baissez reasoning\_effort pour les tâches simples.

### Le streaming réduit-il la latence ?

Il ne raccourcit pas le temps de bout en bout. Il permet à l’utilisateur de lire la réponse pendant qu’elle s’écrit : la latence perçue tombe donc à peu près au TTFT.

### Combien de requêtes faut-il pour un benchmark de latence fiable ?

Assez pour voir la traîne. Cinquante à cent requêtes par taille de prompt donnent un p95 exploitable. Répartissez-les sur la journée, car la charge varie.

## À lire ensuite

-   [Le streaming LLM expliqué : chunks SSE, deltas, usage et annulation](https://broadrouter.com/fr/blog/llm-streaming-sse-explained/)
-   [Structurer ses prompts pour que le préfixe soit mis en cache](https://broadrouter.com/fr/blog/prompt-structure-for-caching/)
-   [Contexte long ou RAG : quand 1M de tokens remplace la base vectorielle](https://broadrouter.com/fr/blog/long-context-vs-rag/)
-   [Matériel GPU et serving de BroadNet, tels que BroadNet les décrit](https://broadrouter.com/fr/blog/broadnet-gpu-fleet-and-serving/)
-   [Mettre en cache les réponses d’API LLM : un cache exact en Python](https://broadrouter.com/fr/blog/cache-llm-responses-cut-cost/)
-   [Guide : Streamer des chat completions et gérer les connexions coupées](https://broadrouter.com/fr/guides/streaming-chat-completions/)
-   [Guide : Pourquoi un modèle de raisonnement renvoie une réponse vide](https://broadrouter.com/fr/guides/reasoning-tokens-empty-response/)

Essayez-le sur votre vraie charge de travail. Les nouveaux comptes démarrent avec USD 5 de crédit pour Gemma et transcription. DeepSeek, GLM et Qwen3.8 nécessitent une recharge.

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

**Sources**

-   [Guide de benchmark de NVIDIA NIM, métriques de latence et de débit des LLM (consulté le 2026-11-14)](https://docs.nvidia.com/nim/benchmarking/llm/metrics)
-   [Forfaits de BroadNet Inference, vitesse typique (vérifié le 2026-11-15) (en anglais)](https://inference.broadnet.ai/plans?utm_source=broadrouter&utm_medium=referral&utm_campaign=fr-blog-llm-latency-ttft-throughput&utm_content=sources)
-   [Référence de l’API de BroadNet Inference, streaming et raisonnement (vérifié le 2026-11-15) (en anglais)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=fr-blog-llm-latency-ttft-throughput&utm_content=sources)
-   [Baseten Inference Engineering, mesurer la latence et le débit (vérifié le 2026-11-16)](https://www.baseten.co/inference-engineering/book/01-prerequisites/measuring-latency-and-throughput/)
