---
title: "Réduire les tokens d’un prompt : mesures avant et après"
description: "Tokens gagnés en allégeant prompt système, exemples few-shot, schémas d’outils, format des données, historique et diacritiques arabes, mesurés sur vrais tokenizers."
url: https://broadrouter.com/fr/blog/reduce-prompt-tokens/
lang: fr
updated: 2026-11-15
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/reduce-prompt-tokens/) (mis à jour le 2026-11-16).

# Réduire les tokens du prompt : prompts, outils et données mesurés

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

Mesurez d’abord : journalisez prompt\_tokens par appel, repérez le plus gros poste, comparez avant/après via le tokenizer du modèle. Sur cinq tokenizers, alléger un prompt système verbeux a économisé 68 à 71 %, et le CSV a coûté 31 à 41 % de tokens de moins que le JSON minifié. Sur trois modèles, un prompt allégé et 3 outils courts au lieu de 10 verbeux ont réduit la requête rendue d’environ 65 à 71 %.

## À retenir

-   Comptez avec le vrai tokenizer, puis confirmez avec usage.prompt\_tokens. Le template de chat ajoute ses propres tokens, et il resérialise les schémas d’outils.
-   Les outils sont le plus gros coût fixe que nous ayons mesuré : 10 schémas d’outils verbeux ajoutaient 1 200 à 1 400 tokens à chaque prompt rendu. N’envoyez que les outils utilisables à l’étape en cours.
-   Données tabulaires : passer du JSON indenté au CSV a économisé 57 à 61 % ; du JSON minifié au CSV, encore 31 à 41 %. Les tokenizers de Qwen et Gemma découpent les nombres en chiffres isolés, donc les données riches en nombres y coûtent plus.
-   Remplacer 16 anciens tours par un résumé de 3 lignes a fait passer un prompt Qwen de 2 700 à 1 100 tokens. Les résumés perdent des détails : gardez les derniers tours tels quels.
-   L’arabe entièrement vocalisé a pris 2,4 à 3,5 fois plus de tokens que le même texte sans diacritiques. Retirez-les sauf si la tâche en a besoin.

**Sur cette page**

1.  Comment avons-nous mesuré ?
2.  Quelles coupes économisent le plus de tokens ?
3.  À quoi ressemble une requête complète ?
4.  Comment alléger un prompt système sans le casser ?
5.  De combien d’exemples few-shot avez-vous besoin ?
6.  Faut-il envoyer outils, données et historique autrement ?
7.  Où le cache intervient-il ?
8.  Comment mesurer votre propre prompt ?
9.  La place de BroadNet Inference

Des prompts plus courts coûtent moins cher, laissent davantage de [fenêtre de contexte](https://broadrouter.com/fr/glossary/context-window/) pour le travail utile et renvoient en général le premier token plus tôt. Mais « raccourcissez le prompt » reste un conseil vague. Cet article mesure des coupes courantes sur un prompt réaliste de bot de support, avec les vrais tokenizers de quatre modèles ouverts et `o200k_base` d’OpenAI, pour que vous voyiez quelles modifications valent votre temps.

Si vous utilisez un agent de code, [le budget de tokens d’un agent](https://broadrouter.com/fr/blog/agent-token-budget/) couvre cette boucle. Cet article porte sur les prompts d’application : chatbots, classifieurs et tâches d’extraction.

## Comment avons-nous mesuré ?

Tous les décomptes ci-dessous sont les nôtres, réalisés le 15 novembre 2026 :

-   **Tokenizers.** Les fichiers `tokenizer.json` officiels de DeepSeek V4.1 Flash, GLM 5.3, Qwen3.8 27B et de Gemma 4 26B A4B de Google, chacun à une révision Hugging Face figée (voir les sources), chargés avec `tokenizers` 0.23.3 de Hugging Face. Plus `o200k_base` de `tiktoken` 0.14.0, pour comparer avec les modèles GPT. Les tokens spéciaux n’ont pas été ajoutés.
-   **Prompts rendus.** Pour DeepSeek, GLM et Qwen, nous avons aussi rendu des requêtes complètes via le `chat_template.jinja` publié de chaque modèle (bac à sable Jinja2), avec prompt système, outils, historique et question, et compté le résultat. C’est proche de ce qu’un serveur tokenise, mais un fournisseur peut utiliser un autre template : c’est donc `usage.prompt_tokens` de l’API qui fait foi.
-   **Texte.** Un bot de support synthétique pour un opérateur télécom fictif : un prompt système de 261 mots, 10 outils, 8 exemples few-shot, 40 lignes de commandes, un historique de 20 tours et un paragraphe arabe de 31 mots. Un prompt n’est qu’un point de mesure. Vos économies seront différentes ; la méthode, elle, se transpose.

Gemma 4 VL 26B de BroadNet est basé sur le modèle de Google, son décompte est donc une estimation. Les autres utilisent les fichiers propres aux modèles.

## Quelles coupes économisent le plus de tokens ?

Texte brut, avant → après, avec la part économisée :

| Modification | DeepSeek V4.1 Flash | GLM 5.3 | Qwen3.8 27B | Gemma 4 | GPT o200k |
| --- | --- | --- | --- | --- | --- |
| Prompt système : 261 mots → 66 mots | 295 → 88 (70 %) | 294 → 89 (70 %) | 297 → 95 (68 %) | 297 → 96 (68 %) | 293 → 86 (71 %) |
| Few-shot : 8 exemples → 3 | 157 → 69 (56 %) | 157 → 69 (56 %) | 156 → 71 (54 %) | 156 → 71 (54 %) | 152 → 69 (55 %) |
| 40 lignes : JSON indenté → JSON minifié | 2 446 → 1 606 (34 %) | 2 460 → 1 581 (36 %) | 3 180 → 1 980 (38 %) | 3 210 → 2 010 (37 %) | 2 446 → 1 567 (36 %) |
| 40 lignes : JSON minifié → CSV | 1 606 → 948 (41 %) | 1 581 → 960 (39 %) | 1 980 → 1 359 (31 %) | 2 010 → 1 382 (31 %) | 1 567 → 946 (40 %) |
| 10 outils : descriptions verbeuses → courtes | 1 224 → 806 (34 %) | 1 214 → 797 (34 %) | 1 225 → 806 (34 %) | 1 252 → 827 (34 %) | 1 202 → 796 (34 %) |
| 10 outils verbeux → 3 courts | 1 224 → 258 (79 %) | 1 214 → 257 (79 %) | 1 225 → 266 (78 %) | 1 252 → 276 (78 %) | 1 202 → 255 (79 %) |
| Paragraphe arabe : entièrement vocalisé → sans voyelles | 193 → 74 (62 %) | 267 → 78 (71 %) | 151 → 62 (59 %) | 180 → 64 (64 %) | 218 → 62 (72 %) |

Pour la prose anglaise, les pourcentages sont proches d’un tokenizer à l’autre : une coupe qui aide sur un modèle aide aussi sur les autres. Deux lignes font exception. Les données de commandes coûtaient à Qwen et Gemma 23 à 46 % de tokens de plus qu’à DeepSeek et GLM dans tous les formats, car leurs tokenizers découpent les nombres en chiffres isolés : `100200` fait 6 tokens chez Qwen et 2 chez DeepSeek. Et les diacritiques arabes frappent certains tokenizers bien plus durement que d’autres.

## À quoi ressemble une requête complète ?

Le texte brut ignore le template de chat. Rendu via le template propre à chaque modèle, avec la même question client, le prompt complet mesurait :

| Requête | DeepSeek V4.1 Flash | GLM 5.3 | Qwen3.8 27B |
| --- | --- | --- | --- |
| A. Prompt système verbeux + 10 outils verbeux | 1 677 | 1 535 | 1 797 |
| B. Prompt système allégé + 10 outils courts | 1 052 | 913 | 1 176 |
| C. Prompt système allégé + 3 outils courts | 574 | 443 | 636 |
| D. Prompt système allégé, sans outils | 136 | 121 | 174 |
| C + 20 tours précédents en entier | 2 374 | 2 243 | 2 693 |
| C + résumé de 3 lignes + 4 derniers tours | 979 | 849 | 1 103 |

Passer de A à C a retiré environ 65 à 71 % de chaque requête (64,6 % sur Qwen, 71,1 % sur GLM). L’essentiel venait des outils. Rendus avec le prompt système verbeux, les 10 outils verbeux ajoutaient 1 334 tokens sur DeepSeek, 1 209 sur GLM et 1 421 sur Qwen ; les 3 outils courts de C ajoutaient 322 à 462 par rapport à D. Les schémas d’[appel d’outils](https://broadrouter.com/fr/glossary/tool-calling/) voyagent avec chaque requête, que le modèle s’en serve ou non.

À grande échelle, cela s’additionne. Sur [Qwen3.8 27B](https://broadrouter.com/fr/models/qwen3.8-27b/), passer de A à C économise 1 161 tokens par requête. À 100 000 requêtes par mois, cela fait environ 116 millions de tokens d’entrée, soit 116 × $0.175 par mois au prix d’entrée standard.

## Comment alléger un prompt système sans le casser ?

Notre prompt de 261 mots et celui de 66 mots portent les mêmes sept règles. Les coupes étaient toutes de même nature :

1.  **Supprimer la politesse envers le modèle.** « It is very important that you always remain polite and courteous at all times » (traduction : « Il est très important que tu restes toujours poli et courtois en toutes circonstances ») a disparu : la ligne de rôle l’implique déjà.
2.  **Une règle par ligne.** Des puces remplacent les phrases du type « Please make sure that you always… » (traduction : « Veille bien à toujours… »).
3.  **Fusionner les doublons.** Trois phrases sur la langue sont devenues « Reply in the customer’s language (Arabic or English), briefly. » (traduction : « Réponds brièvement dans la langue du client (arabe ou anglais). »)
4.  **Supprimer les évidences répétées.** « Remember to always be helpful! » (traduction : « N’oublie pas d’être toujours serviable ! ») ne change rien.

Ensuite, testez. Un prompt plus court qui perd une règle coûte plus qu’il n’économise. Passez les deux versions sur les mêmes 50 à 100 entrées réelles et comparez, comme dans [évaluer un LLM avant d’en changer](https://broadrouter.com/fr/blog/evaluate-llm-before-switching/).

## De combien d’exemples few-shot avez-vous besoin ?

De moins que ce que contiennent la plupart des prompts. Chaque exemple [few-shot](https://broadrouter.com/fr/glossary/few-shot-prompting/) est payé à chaque appel. Gardez ceux qui corrigent une erreur que le modèle commet sans eux, comme un exemple dialectal pour un classifieur arabe, et supprimez ceux qu’il réussit déjà. Notre passage de 8 à 3 a économisé 54 à 56 % du bloc d’exemples. Savoir si 3 suffisent pour votre tâche est une question de précision, pas de tokens : vérifiez-le sur votre jeu de test.

## Faut-il envoyer outils, données et historique autrement ?

**Outils.** N’envoyez que les outils utilisables à l’étape en cours. Une question de facturation a besoin de `get_account`, `get_bill` et `create_ticket`, pas de `order_esim`. Raccourcissez les descriptions à ce dont le modèle a besoin pour choisir l’outil et le remplir. L’indentation n’a pas d’importance ici : les templates que nous avons rendus resérialisent tous le tableau `tools` avec `tojson`, donc un tableau tools indenté coûte autant qu’un tableau minifié.

**Données dans les messages.** Les données que vous collez dans un message sont envoyées telles quelles. Minifiez au moins le JSON. Pour des enregistrements plats, le CSV ou le TSV supprime les clés répétées : 31 à 41 % de tokens de moins que le JSON minifié dans notre test. Les données imbriquées restent en JSON. Vérifiez que le modèle lit toujours correctement les colonnes.

**Historique.** Chaque tour passé est renvoyé. Remplacer 16 anciens tours par un résumé de trois lignes, en gardant les quatre derniers tours tels quels, a fait passer le prompt Qwen de 2 693 à 1 103 tokens. Un résumé perd des détails auxquels l’utilisateur pourrait revenir, et le réécrire modifie le préfixe, ce qui casse le cache. [La gestion du contexte des agents de longue durée](https://broadrouter.com/fr/blog/long-running-agent-context-management/) explique quand compacter.

**Diacritiques arabes.** La plupart des textes arabes s’écrivent sans voyelles brèves. Si votre entrée est entièrement vocalisée, parce qu’elle vient d’un dictionnaire, d’un manuel ou d’une source religieuse, retirer ces signes (U+064B à U+0652) a réduit notre paragraphe de 59 à 72 %. Gardez-les quand la tâche en dépend, comme l’enseignement ou la poésie. [La normalisation du texte arabe](https://broadrouter.com/fr/blog/arabic-text-normalization-search/) couvre les autres caractères à normaliser, et [les tokens par mot en arabe](https://broadrouter.com/fr/blog/tokens-per-word-arabic-english/) l’écart plus large avec l’anglais.

## Où le cache intervient-il ?

Le cache ne réduit pas le prompt. Il rend la partie répétée moins chère. Le guide du cache d’OpenAI indique que « the entire rendered prefix » (traduction : « tout le préfixe rendu ») doit correspondre et conseille de placer les instructions stables en premier. La [page de prix](https://inference.broadnet.ai/pricing?utm_source=broadrouter&utm_medium=referral&utm_campaign=fr-blog-reduce-prompt-tokens&utm_content=body) de BroadNet décrit l’entrée en cache comme « usually the repeated start of recent requests, such as a long system prompt » (traduction : « en général le début répété des requêtes récentes, comme un long prompt système »), sans rien à configurer, et sa documentation indique les succès dans `usage.prompt_tokens_details.cached_tokens`.

L’ordre est donc le suivant : raccourcir d’abord, puis rendre stable le préfixe raccourci. Prompt système et outils en premier, identiques à l’octet près à chaque appel ; l’historique ensuite, en ajout seul ; le nouveau message en dernier. Sur Qwen3.8 27B, l’entrée en cache coûte $0.0435 par million contre $0.175. [Structurer ses prompts pour le cache](https://broadrouter.com/fr/blog/prompt-structure-for-caching/) donne l’agencement et un test qui prouve la réutilisation du préfixe. Les tokens en cache comptent toujours dans la fenêtre de contexte.

## Comment mesurer votre propre prompt ?

Partez de la facture. Journalisez `usage.prompt_tokens` par point d’appel pendant une journée et trouvez le plus gros. Comparez ensuite des versions en local avec ce script, qui affiche les décomptes avant et après pour deux fichiers :

```python
# pip install tokenizers tiktoken huggingface_hub
import json, sys
import tiktoken
from huggingface_hub import hf_hub_download
from tokenizers import Tokenizer

def hf(repo, rev):
    return Tokenizer.from_file(hf_hub_download(repo, "tokenizer.json", revision=rev))

COUNTERS = {
    "Qwen3.8 27B": hf("Qwen/Qwen3.8-27B", "37561816e66b5b9153b1b64c10968c18c1e6f4a0").encode,
    "GPT o200k": tiktoken.get_encoding("o200k_base").encode,
}

def n(enc, text):
    out = enc(text)
    return len(out.ids if hasattr(out, "ids") else out)

def diff(before, after):
    for name, enc in COUNTERS.items():
        a, b = n(enc, before), n(enc, after)
        print(f"{name:12} {a:6} -> {b:6}  saved {a - b} ({100 * (a - b) / a:.0f}%)")

if __name__ == "__main__":
    diff(open(sys.argv[1], encoding="utf-8").read(), open(sys.argv[2], encoding="utf-8").read())
```

Appliqué à nos deux prompts système, il a affiché :

```text
Qwen3.8 27B     297 ->     95  saved 202 (68%)
GPT o200k       293 ->     86  saved 207 (71%)
```

Ajoutez les dépôts des autres modèles listés dans les sources pour comparer les quatre. Pour une vérification rapide dans le navigateur, le [diff de tokens de prompt](https://broadrouter.com/tools/prompt-token-diff/) compare deux versions côte à côte, et le [compteur de tokens](https://broadrouter.com/tools/token-counter/) en compte une. Après le déploiement, confirmez l’économie dans `usage.prompt_tokens`, qui inclut le template.

## La place de BroadNet Inference

BroadRouter est le site de BroadNet. BroadNet Inference facture les tokens de prompt au prix d’entrée de chaque modèle et lit les préfixes répétés depuis le cache au prix de l’entrée en cache quand le modèle en a un : des prompts plus courts comme des préfixes stables font donc baisser la facture. [Gemma 4 VL 26B](https://broadrouter.com/fr/models/gemma-4-vl-26b/) a un contexte de 32 768 tokens, où alléger compte pour que tout tienne, pas seulement pour le coût. Avec les forfaits DeepSeek V4.1 Flash, il n’y a pas de compteur de tokens, mais le contexte de 1 048 576 tokens s’applique toujours, et un prompt plus court répond toujours plus vite. Les prompts ne sont pas conservés après chaque requête.

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.

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

[Prompt système (system prompt)](https://broadrouter.com/fr/glossary/system-prompt/)

Le prompt système est le texte d’instructions qu’une application envoie à un modèle de langage avant la conversation, généralement sous forme de message au rôle system ou developer. Il fixe le rôle, les règles, le ton et le format de sortie du modèle, qui est censé le suivre même face à des messages contradictoires de l’utilisateur.

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

[Few-shot prompting (prompt avec exemples)](https://broadrouter.com/fr/glossary/few-shot-prompting/)

Le few-shot prompting est une technique où le prompt contient quelques exemples entrée-sortie résolus avant l’entrée réelle, pour qu’un modèle de langage en déduise la tâche et le format. Les poids du modèle ne changent pas ; le zero-shot n’utilise aucun exemple et le one-shot un seul.

[Tokens d’entrée en cache (cached input tokens)](https://broadrouter.com/fr/glossary/cached-input-tokens/)

Les tokens d’entrée en cache sont des tokens de prompt qu’un fournisseur de LLM a traités récemment et peut réutiliser depuis un cache au lieu de les recalculer, en général un préfixe répété comme un prompt système ou un document. Les fournisseurs les facturent moins cher que les nouveaux tokens d’entrée.

[Diacritiques arabes (tashkeel)](https://broadrouter.com/fr/glossary/arabic-diacritics/)

Les diacritiques arabes, ou tashkeel, sont de petits signes placés au-dessus ou au-dessous des lettres pour noter les voyelles brèves, les consonnes doublées et l’absence de voyelle. Ils sont facultatifs : la plupart des textes arabes, presse comprise, les omettent, et lecteurs comme logiciels déduisent les voyelles du contexte.

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

## Questions fréquentes

### Comment réduire le nombre de tokens de mon prompt ?

Mesurez d’abord : journalisez usage.prompt\_tokens et trouvez la plus grosse partie. Ensuite, dans l’ordre des économies que nous avons mesurées : n’envoyez que les outils nécessaires à l’étape, raccourcissez la formulation des outils et du prompt système, envoyez les tableaux en CSV plutôt qu’en JSON, limitez les exemples few-shot à ceux qui changent les résultats et résumez les anciens tours de conversation.

### Le JSON indenté utilise-t-il plus de tokens ?

Oui. Dans notre test, minifier 40 lignes de JSON indenté a économisé 34 à 38 % des tokens selon le tokenizer, et les envoyer en CSV 57 à 61 %. Dit autrement, le JSON indenté prenait 52 à 61 % de tokens de plus que le JSON minifié et 132 à 159 % de plus que le CSV. Les schémas d’outils font exception : les templates de chat les resérialisent, donc l’indentation de votre tableau tools n’atteint pas le modèle.

### Combien de tokens utilisent les définitions d’outils ?

Cela dépend de la formulation et du template du modèle. Nos 10 outils aux descriptions verbeuses ajoutaient environ 1 200 à 1 400 tokens à un prompt rendu sur DeepSeek V4.1 Flash, GLM 5.3 et Qwen3.8 27B. Trois outils aux descriptions courtes en ajoutaient environ 320 à 460.

### Les diacritiques arabes augmentent-ils le nombre de tokens ?

Beaucoup. Un paragraphe en arabe standard moderne de 31 mots prenait 62 à 78 tokens sans diacritiques et 151 à 267 tokens entièrement vocalisé, sur cinq tokenizers. La plupart des textes arabes s’écrivent sans eux : retirez-les donc de l’entrée, sauf si la tâche, comme la poésie ou l’enseignement, en a besoin.

### Le prompt caching vaut-il mieux que raccourcir le prompt ?

Les deux se complètent. Le cache rend un préfixe répété moins cher, mais il compte toujours dans la fenêtre de contexte et a toujours un prix. Raccourcissez d’abord, puis gardez le préfixe raccourci identique à l’octet près au début de chaque requête pour qu’il puisse être lu depuis le cache.

### Pourquoi mon décompte de tokens diffère-t-il du prompt\_tokens de l’API ?

L’API compte le prompt rendu : vos messages enveloppés dans le template de chat, plus les schémas d’outils dans le format propre au template. Un tokenizer appliqué à votre texte brut ne voit pas cela. Utilisez le tokenizer pour comparer des versions, et usage.prompt\_tokens pour la facture.

## À lire ensuite

-   [Budget de tokens d’un agent : où partent les tokens d’une boucle](https://broadrouter.com/fr/blog/agent-token-budget/)
-   [Compter les tokens avant d’envoyer une requête LLM](https://broadrouter.com/fr/blog/count-tokens-before-sending/)
-   [Structurer ses prompts pour que le préfixe soit mis en cache](https://broadrouter.com/fr/blog/prompt-structure-for-caching/)
-   [Tokens d’entrée en cache : réduire la facture d’une API LLM](https://broadrouter.com/fr/blog/cached-input-tokens-explained/)
-   [Tokens par mot, arabe ou anglais : pourquoi l’arabe coûte plus cher](https://broadrouter.com/fr/blog/tokens-per-word-arabic-english/)
-   [Gérer le contexte des agents longue durée avec une fenêtre de 1M](https://broadrouter.com/fr/blog/long-running-agent-context-management/)
-   [Réduire le coût LLM d’un agent de code : 10 leviers chiffrés](https://broadrouter.com/fr/blog/cut-coding-agent-llm-costs/)
-   [Mettre en cache les réponses d’API LLM : un cache exact en Python](https://broadrouter.com/fr/blog/cache-llm-responses-cut-cost/)
-   [Matériel GPU et serving de BroadNet, tels que BroadNet les décrit](https://broadrouter.com/fr/blog/broadnet-gpu-fleet-and-serving/)
-   [Intégrer la relecture humaine à votre workflow d’IA documentaire](https://broadrouter.com/fr/blog/document-review-queues/)
-   [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-reduce-prompt-tokens&utm_content=page-cta) ·

**Sources**

-   [Qwen/Qwen3.8-27B sur Hugging Face : tokenizer.json et chat\_template.jinja à la révision 37561816 (téléchargés le 2026-11-15)](https://huggingface.co/Qwen/Qwen3.8-27B)
-   [zai-org/GLM-5.3 sur Hugging Face : tokenizer.json et chat\_template.jinja à la révision ba32f8c1 (téléchargés le 2026-11-15)](https://huggingface.co/zai-org/GLM-5.3)
-   [deepseek-ai/DeepSeek-V4.1-Flash sur Hugging Face : tokenizer.json et chat\_template.jinja à la révision 314113f8 (téléchargés le 2026-11-15)](https://huggingface.co/deepseek-ai/DeepSeek-V4.1-Flash)
-   [google/gemma-4-26B-A4B-it sur Hugging Face : tokenizer.json à la révision 4d7ae498, base de Gemma 4 VL 26B chez BroadNet (vérifié le 2026-11-15)](https://huggingface.co/google/gemma-4-26B-A4B-it)
-   [tiktoken d’OpenAI sur GitHub : encodage o200k\_base, version 0.14.0 utilisée (vérifié le 2026-11-15)](https://github.com/openai/tiktoken)
-   [Guide du prompt caching d’OpenAI : contenu stable en premier, tout le préfixe rendu doit correspondre, les outils font partie du contexte en cache (vérifié le 2026-11-15)](https://developers.openai.com/api/docs/guides/prompt-caching)
-   [Page de prix de BroadNet Inference : l’entrée en cache est le début répété des requêtes récentes, facturé moins cher, sans configuration (vérifiée le 2026-11-15) (en anglais)](https://inference.broadnet.ai/pricing?utm_source=broadrouter&utm_medium=referral&utm_campaign=fr-blog-reduce-prompt-tokens&utm_content=sources)
-   [Référence de l’API de BroadNet Inference : tokens en cache indiqués dans le bloc usage, capacités des modèles (vérifiée le 2026-11-15) (en anglais)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=fr-blog-reduce-prompt-tokens&utm_content=sources)
