BroadRouter

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

Par l’équipe BroadNet Inference · 5 min de lecture · Publié · Mis à jour

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.

Il vous faut le nombre de tokens avant d’envoyer une requête, pour trois raisons : rester dans la fenêtre de contexte, choisir une valeur raisonnable pour 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 (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 gratuit, ou avec les compteurs par famille pour DeepSeek, Qwen et GPT. Pour voir ce qu’une modification de prompt fait gagner, comparez les deux versions dans le diff de tokens de prompt. 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.

Comment compter les tokens exactement ?

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

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 :

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 ne se transposent pas à 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. 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 1 048 576 environ 897 000
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 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.

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 couvre le reste. Pour transformer des comptes de tokens en facture mensuelle, voir estimer le coût d’une API LLM avant le lancement.

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, et les prix par million de tokens figurent sur la page des prix.

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 en MarkdownDemander à ChatGPTDemander à ClaudeDemander à Perplexity