---
title: "Compter les tokens avant l’envoi : estimations et marges"
description: "Estimer les tokens d’un prompt par langue et modèle avant d’appeler une API LLM : écarts entre tokenizers, mesures en cinq langues et marges sûres pour max_tokens."
url: https://broadrouter.com/fr/blog/count-tokens-before-sending/
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/count-tokens-before-sending/) (mis à jour le 2026-11-16).

# Compter les tokens avant d’envoyer une requête LLM

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

Comptez les tokens avec le tokenizer du modèle que vous appelez s’il est public ; sinon, calibrez un ratio caractères par token à partir du champ usage de vraies requêtes, par langue et par type de contenu. Ajoutez une marge de 10 à 20 %, puis vérifiez que les tokens du prompt plus max\_tokens tiennent dans la fenêtre de contexte, en laissant de la place aux tokens de raisonnement des modèles qui réfléchissent.

## À retenir

-   Les tokenizers diffèrent d’un modèle à l’autre. Dans notre test, la même phrase arabe a donné 102 tokens avec cl100k\_base, 46 avec o200k\_base et 48 à 58 avec les tokenizers des modèles ouverts.
-   La prose anglaise tournait autour de 4,5 caractères par token sur chaque tokenizer de ce court test ; le code, le JSON et la plupart des écritures non latines consomment plus de tokens par caractère.
-   Quand le tokenizer d’un modèle n’est pas public, calibrez : envoyez des échantillons, lisez usage.prompt\_tokens et enregistrez un ratio par langue et par type de contenu.
-   La fenêtre de contexte couvre le prompt plus la sortie. Budgétez prompt + max\_tokens + une marge, jamais le prompt seul.
-   Sur les modèles de raisonnement, la réflexion compte dans max\_tokens ; BroadNet recommande au moins 1 000, ou reasoning\_effort low.

**Sur cette page**

1.  Pourquoi le nombre de tokens varie-t-il d’un modèle à l’autre ?
2.  Comment compter les tokens exactement ?
3.  Comment estimer les tokens quand le tokenizer n’est pas public ?
4.  Quelles marges prévoir pour max\_tokens et le contexte ?
5.  Qu’est-ce qui fausse les estimations de tokens ?
6.  La place de BroadNet Inference

Il vous faut le nombre de [tokens](https://broadrouter.com/fr/glossary/token/) avant d’envoyer une requête, pour trois raisons : rester dans la [fenêtre de contexte](https://broadrouter.com/fr/glossary/context-window/), choisir une valeur raisonnable pour [max\_tokens](https://broadrouter.com/fr/glossary/max-tokens/) et estimer le coût. Seul le tokenizer du modèle donne un compte exact. Une calibration donne de bonnes estimations. Cet article montre les deux, avec de vraies mesures.

## Pourquoi le nombre de tokens varie-t-il d’un modèle à l’autre ?

Un tokenizer découpe le texte en morceaux tirés d’un vocabulaire fixe. Chaque famille de modèles entraîne le sien. Un vocabulaire plus grand, ou entraîné sur davantage de texte dans une langue donnée, produit moins de tokens pour cette langue. La question « combien de tokens fait ce prompt ? » a donc une réponse différente pour chaque modèle.

Nous avons mesuré le même court message de service client, traduit en quatre langues, plus une petite fonction Python et un objet JSON de facture. Les comptes OpenAI viennent de [tiktoken](https://github.com/openai/tiktoken) (`cl100k_base`, époque GPT-4, et `o200k_base`, époque GPT-4o). Les comptes des modèles ouverts viennent des fichiers de tokenizer que chaque famille publie sur Hugging Face, comptés sans chat template, le 14 novembre 2026.

| Texte (même sens) | Caractères | cl100k\_base | o200k\_base | DeepSeek V4.1 Flash | GLM 5.3 | Qwen3.8 27B | Gemma 4 |
| --- | --- | --- | --- | --- | --- | --- | --- |
| Anglais, 31 mots | 173 | 37 | 37 | 37 | 38 | 39 | 39 |
| Espagnol | 160 | 47 | 40 | 50 | 45 | 43 | 42 |
| Arabe | 142 | 102 | 46 | 55 | 58 | 48 | 49 |
| Chinois | 54 | 51 | 37 | 34 | 35 | 36 | 38 |
| Fonction Python | 94 | 33 | 33 | 35 | 33 | 35 | 38 |
| JSON de facture | 140 | 59 | 60 | 63 | 60 | 72 | 72 |

Un seul échantillon par ligne : voyez ces chiffres comme une illustration, pas comme un benchmark. Trois leçons tiennent malgré tout. La génération du tokenizer compte : le texte arabe a été plus que divisé par deux entre `cl100k_base` et `o200k_base`. Les modèles ouverts diffèrent aussi entre eux : le même texte arabe allait de 48 à 58 tokens, et le JSON de 60 à 72. Enfin, le contenu structuré est dense en tokens partout : le JSON tournait autour de 2 caractères par token sur chaque tokenizer.

Vous pouvez refaire l’exercice sur votre propre texte avec le [compteur de tokens](https://broadrouter.com/tools/token-counter/) gratuit, ou avec les compteurs par famille pour [DeepSeek](https://broadrouter.com/tools/deepseek-token-counter/), [Qwen](https://broadrouter.com/tools/qwen-token-counter/) et [GPT](https://broadrouter.com/tools/gpt-token-counter/). Pour voir ce qu’une modification de prompt fait gagner, comparez les deux versions dans le [diff de tokens de prompt](https://broadrouter.com/tools/prompt-token-diff/). Pourquoi l’arabe en particulier coûte plus de tokens, mesuré sur des textes plus longs : c’est l’objet de [tokens par mot en arabe et en anglais](https://broadrouter.com/fr/blog/tokens-per-word-arabic-english/).

## Comment compter les tokens exactement ?

Si le tokenizer du modèle est public, chargez-le et comptez en local. Pour les modèles OpenAI :

```python
import tiktoken
enc = tiktoken.encoding_for_model("gpt-4o")
n = len(enc.encode(text))
```

Pour les familles open-weight, le tokenizer est généralement fourni avec le modèle sur Hugging Face et se charge avec `AutoTokenizer.from_pretrained(...)`. Deux réserves : le chat template ajoute des tokens pour les rôles et les séparateurs, et la version déployée par un fournisseur d’API peut différer des fichiers publics. La référence de l’API de BroadNet ne documente ni endpoint de comptage de tokens ni le tokenizer de chaque modèle : le tokenizer public donne donc une estimation proche, et le nombre exact est `usage.prompt_tokens` après l’appel.

## Comment estimer les tokens quand le tokenizer n’est pas public ?

Calibrez une fois par modèle, puis estimez en local :

```python
import os
from openai import OpenAI

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

def prompt_tokens(model, text):
    r = client.chat.completions.create(
        model=model, max_tokens=1000,  # room for reasoning on thinking models
        messages=[{"role": "user", "content": text}],
    )
    return r.usage.prompt_tokens

def measure(model, samples: dict[str, list[str]]):
    base = prompt_tokens(model, "hi")  # chat-template overhead plus one short word
    ratios = {}
    for kind, texts in samples.items():
        chars = toks = 0
        for t in texts:
            chars += len(t)
            toks += prompt_tokens(model, t) - base
        ratios[kind] = chars / toks
    return ratios  # e.g. {"english": 4.1, "arabic": 2.9, "json": 2.3}

def estimate(text, kind, ratios, overhead=10):
    return int(len(text) / ratios[kind]) + overhead
```

Utilisez au moins 20 échantillons réels par type de contenu (vos vrais prompts, pas du lorem ipsum). La requête de référence d’un seul mot retire le surcoût fixe du chat template, que `estimate` réintègre sous la forme de `overhead` ; réglez-le sur votre valeur de référence mesurée. Ne calibrez sur le modèle le moins cher de BroadNet que si c’est celui que vous appellerez : les ratios de [Gemma 4 VL 26B](https://broadrouter.com/fr/models/gemma-4-vl-26b/) ne se transposent pas à [DeepSeek V4.1 Flash](https://broadrouter.com/fr/models/deepseek-v4.1-flash/). Les images sont aussi facturées en tokens d’entrée, et les plus grandes en consomment davantage : calibrez-les à part, par résolution.

## Quelles marges prévoir pour max\_tokens et le contexte ?

La fenêtre couvre le prompt **et** la sortie. Sur les modèles de raisonnement, la sortie inclut la réflexion cachée, comptée en [tokens de raisonnement](https://broadrouter.com/fr/glossary/reasoning-tokens/). Budgétez ainsi :

1.  **Estimation du prompt** = compte calibré × 1,15 (marge de sécurité de 15 %).
2.  **Budget de réponse** = la réponse la plus longue que vous acceptez.
3.  **Budget de raisonnement** = pour les modèles qui réfléchissent, au moins 1 000 tokens ; la documentation de BroadNet recommande au moins 1 000 ou `reasoning_effort: "low"`, car une limite trop basse peut renvoyer une réponse vide.
4.  **max\_tokens** = budget de réponse + budget de raisonnement.
5.  **Vérification** : estimation du prompt + max\_tokens ≤ fenêtre de contexte. Sinon, raccourcissez le prompt, pas la réponse.

Fenêtres de contexte sur BroadNet Inference, d’après le fichier de prix publié :

| Modèle | Fenêtre de contexte | Plafond pratique du prompt avec 16K de sortie et 15 % de marge |
| --- | --- | --- |
| DeepSeek V4.1 Flash | 1 048 576 | environ 897 000 |
| [GLM 5.3](https://broadrouter.com/fr/models/glm-5.3/) | 1 048 576 | environ 897 000 |
| [Qwen3.8 27B](https://broadrouter.com/fr/models/qwen3.8-27b/) | 262 144 | environ 213 000 |
| Gemma 4 VL 26B | 32 768 | environ 14 000 |

La colonne du plafond vaut (fenêtre − 16 384) ÷ 1,15, arrondi à l’inférieur. Remplacez 16 384 par votre propre max\_tokens.

## Qu’est-ce qui fausse les estimations de tokens ?

-   **Compter des mots au lieu de tokens.** La règle de 0,75 mot par token vaut pour l’anglais. Notre échantillon arabe de 29 mots faisait de 46 à 102 tokens selon le tokenizer.
-   **Oublier les outils et le prompt système.** Les schémas d’outils sont en JSON, qui est dense en tokens. Comptez-les dans le prompt.
-   **Supposer une troncature silencieuse.** Certains outils suppriment les anciens messages sans vous le dire. BroadNet indique ne pas tronquer votre contexte : vérifiez donc la taille avant l’envoi au lieu de compter sur le serveur pour couper. Le [calculateur de fenêtre de contexte](https://broadrouter.com/tools/context-window-calculator/) fait la vérification pour vous.
-   **Ignorer la croissance de l’historique.** Dans un chat ou une boucle d’agent, le prompt grossit à chaque tour. Revérifiez le budget à chaque appel, pas une fois par session. Un historique stable se met aussi mieux en cache ; voir [structurer son prompt pour le cache](https://broadrouter.com/fr/blog/prompt-structure-for-caching/).

Si vous travaillez en arabe, le tokenizer est une raison de plus de tester les modèles sur votre propre texte ; [choisir un LLM pour l’arabe](https://broadrouter.com/fr/blog/choosing-an-llm-for-arabic/) couvre le reste. Pour transformer des comptes de tokens en facture mensuelle, voir [estimer le coût d’une API LLM avant le lancement](https://broadrouter.com/fr/blog/estimate-llm-api-cost-before-launch/).

## La place de BroadNet Inference

BroadNet Inference renvoie dans chaque réponse `prompt_tokens`, `completion_tokens` et, quand le modèle les indique, le nombre de tokens en cache et de tokens de raisonnement : c’est tout ce qu’il faut pour calibrer. BroadNet ne publie ni endpoint de comptage ni tokenizer par modèle, donc les comptes avant envoi restent des estimations. Le travail en contexte long sur les modèles à 1M de tokens est traité dans le [guide de la fenêtre de contexte](https://broadrouter.com/fr/blog/million-token-context-window-guide/), et les prix par million de tokens figurent sur la [page des prix](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.

[Tokenizer (tokeniseur)](https://broadrouter.com/fr/glossary/tokenizer/)

Un tokenizer est le composant qui convertit un texte en la suite d’ID entiers de tokens que lit un modèle de langage, et reconvertit les ID générés en texte. Chaque modèle a son propre tokenizer : un même texte peut donc produire un nombre de tokens différent selon le modèle.

[Appel d’outils (tool calling, function calling)](https://broadrouter.com/fr/glossary/tool-calling/)

L’appel d’outils, aussi appelé function calling, est une fonctionnalité des API LLM dans laquelle le modèle renvoie une demande structurée d’exécution d’une fonction définie par le développeur, avec des arguments JSON. L’application exécute la fonction et renvoie le résultat ; le modèle n’exécute jamais de code lui-même.

[Chat template (modèle de conversation)](https://broadrouter.com/fr/glossary/chat-template/)

Un chat template est la règle de mise en forme, généralement écrite en Jinja et livrée avec le tokenizer d’un modèle, qui convertit une liste de messages de chat avec leurs rôles en la séquence unique de tokens attendue par le modèle, tokens de contrôle spéciaux compris. Un mauvais template peut fortement dégrader les réponses d’un modèle.

[Fenêtre de contexte (context window)](https://broadrouter.com/fr/glossary/context-window/)

La fenêtre de contexte est le nombre maximal de tokens qu’un modèle de langage peut traiter dans une seule requête. Elle couvre le prompt, l’historique de conversation, les définitions d’outils, les images et la sortie générée, tokens de raisonnement compris. Ce qui ne tient pas doit être coupé, résumé ou réparti sur plusieurs requêtes.

[max\_tokens](https://broadrouter.com/fr/glossary/max-tokens/)

max\_tokens est un paramètre des API LLM qui fixe le nombre maximal de tokens qu’un modèle peut générer dans une réponse. Quand la génération atteint la limite, elle s’arrête et la réponse est marquée comme coupée, par exemple avec finish\_reason égal à « length ».

[Tokens de raisonnement (reasoning tokens)](https://broadrouter.com/fr/glossary/reasoning-tokens/)

Les tokens de raisonnement sont les tokens qu’un modèle de raisonnement génère pour résoudre un problème avant d’écrire sa réponse visible. Ils sont généralement facturés comme des tokens de sortie, comptent dans la limite de sortie et dans la fenêtre de contexte, et peuvent être masqués ou résumés par l’API.

[Agent IA (AI agent)](https://broadrouter.com/fr/glossary/agent/)

Un agent IA est un système dans lequel un modèle de langage dirige lui-même ses étapes vers un objectif : il décide quels outils appeler, lit les résultats et recommence jusqu’à produire une réponse finale ou atteindre une limite. Un script fixe qui appelle un modèle à des moments prévus s’appelle plutôt un workflow.

## Questions fréquentes

### Combien de tokens fait un mot ?

D’après le jeu de données de tokenizers de BroadRouter, qui regroupe cinq tokenizers (ceux des quatre modèles de chat de BroadNet et o200k\_base d’OpenAI ; le tableau d’exemple de l’article ajoute cl100k\_base), 1 000 mots anglais font environ 1,290 tokens, soit environ 1.29 tokens par mot. La règle empirique courante, 0,75 mot par token, est proche pour la prose anglaise. L’arabe, les autres écritures non latines et le code consomment plus de tokens par mot. Mesurez votre propre texte avec le modèle que vous appelez.

### Puis-je utiliser tiktoken pour compter les tokens de DeepSeek, Qwen ou Gemma ?

Seulement pour une estimation grossière. tiktoken implémente les encodages d’OpenAI. Les autres familles de modèles livrent leurs propres tokenizers, souvent sur Hugging Face, et les comptes diffèrent. Calibrez avec le champ usage.

### Existe-t-il un outil gratuit pour compter les tokens de DeepSeek, Qwen, GLM ou Gemma ?

Oui. Le compteur de tokens gratuit de BroadRouter exécute dans votre navigateur les tokenizers publiés de ces familles de modèles, donc le texte ne quitte pas votre machine. Considérez le résultat comme une estimation de ce que l’API indiquera, car les chat templates ajoutent quelques tokens.

### Que se passe-t-il si mon prompt dépasse la fenêtre de contexte ?

La plupart des API renvoient une erreur. Certains outils suppriment les anciens messages sans prévenir. BroadNet ne tronque pas votre contexte : vérifiez donc le prompt plus max\_tokens par rapport à la fenêtre avant l’envoi.

### Quelle marge laisser pour max\_tokens ?

Estimez la réponse la plus longue que vous attendez, ajoutez le budget de raisonnement pour les modèles qui réfléchissent, et gardez 10 à 20 % de la fenêtre libres pour l’erreur d’estimation.

## À lire ensuite

-   [Tokens par mot, arabe ou anglais : pourquoi l’arabe coûte plus cher](https://broadrouter.com/fr/blog/tokens-per-word-arabic-english/)
-   [Quand une fenêtre de contexte de 1M de tokens vaut le coup (ou pas)](https://broadrouter.com/fr/blog/million-token-context-window-guide/)
-   [Estimer le coût d’une API LLM avant de lancer une fonctionnalité](https://broadrouter.com/fr/blog/estimate-llm-api-cost-before-launch/)
-   [Structurer ses prompts pour que le préfixe soit mis en cache](https://broadrouter.com/fr/blog/prompt-structure-for-caching/)
-   [Réduire les tokens du prompt : prompts, outils et données mesurés](https://broadrouter.com/fr/blog/reduce-prompt-tokens/)
-   [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 : Pourquoi un modèle de raisonnement renvoie une réponse vide](https://broadrouter.com/fr/guides/reasoning-tokens-empty-response/)
-   [Guide : Utiliser le SDK Python d’OpenAI avec BroadNet Inference](https://broadrouter.com/fr/guides/openai-python-sdk/)

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-count-tokens-before-sending&utm_content=page-cta) ·

**Sources**

-   [README de tiktoken, encodages et environ 4 octets par token (consulté le 2026-11-14)](https://github.com/openai/tiktoken)
-   [Référence de l’API de BroadNet Inference, max\_tokens et raisonnement (consulté le 2026-11-14) (en anglais)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=fr-blog-count-tokens-before-sending&utm_content=sources)
-   [Prix et longueurs de contexte de BroadNet Inference au format lisible par machine (pricing.json, consulté le 2026-11-14) (en anglais)](https://inference.broadnet.ai/pricing.json?utm_source=broadrouter&utm_medium=referral&utm_campaign=fr-blog-count-tokens-before-sending&utm_content=sources)
-   [Hugging Face Transformers, documentation des tokenizers (consulté le 2026-11-14)](https://huggingface.co/docs/transformers/main_classes/tokenizer)
