Tokens, contexte et fenêtre de contexte#

Le token est l'unité de facturation, de vitesse et de limite. Savoir les compter, c'est savoir piloter le coût.

Temps de lecture : 14 min | Niveau : Débutant / Intermédiaire

Ce que tu sauras faire après#

• Estimer à la louche le nombre de tokens d'un fichier avant de l'envoyer.
• Compter les tokens exactement avec l'API, gratuitement.
• Dire ce qui tient dans 200k et dans 1M tokens, et ce qui n'y tient pas.
• Calculer le coût d'un appel avant de le lancer.
• Découper un fichier trop gros au lieu de le tronquer bêtement.

1. Un token, c'est quoi exactement#

Définition Anthropic :

Tokens are the smallest individual units of a language model, and can correspond to words, subwords, characters, or even bytes (in the case of Unicode).

Et l'ordre de grandeur, toujours Anthropic : "For Claude, a token approximately represents 3.5 English characters, though the exact number can vary depending on the language used." Leur FAQ tarifaire donne une règle plus ronde : "1 token is approximately 4 characters or 0.75 words in English."

Google dit la même chose pour Gemini : "a token is equivalent to about 4 characters. 100 tokens is equal to about 60-80 English words."

Ordres de grandeur à retenir#

Les trois dernières lignes viennent directement de la page tarifaire Anthropic (section outil web fetch). Ce sont les seuls ordres de grandeur "fichier" publiés officiellement.

Et le français, et le code ?#

Point d'honnêteté : aucune des documentations officielles que j'ai lues ne publie de ratio caractères/token pour le français ou pour le code. Anthropic dit seulement que le nombre exact "can vary depending on the language used".

Ce qu'on sait de source sûre :

• Les accents sont des caractères Unicode, et la doc Anthropic précise que les tokens peuvent descendre au niveau de l'octet pour l'Unicode. Un mot accentué coûte donc en général plus de tokens que son équivalent anglais.
• Microsoft documente un effet mesurable sur les espaces : "Consecutive white spaces are treated as separate tokens, which can waste space." Donc du code mal indenté ou un JSON pretty-printed coûtent plus cher qu'un JSON compact.

Règle pratique : ne devine pas, compte. L'endpoint count_tokens (section 3) compte avec le tokenizer du modèle que tu lui passes : c'est la seule mesure fiable pour ton français et pour ton code.

Le tokenizer change entre générations#

Important pour les estimations de coût. Anthropic :

Claude 4.7 and later models and Claude Mythos Preview use a newer tokenizer. The same input text produces approximately 30 percent more tokens than on earlier models.

Traduction : si tu as estimé un coût sur un modèle ancien, recompte avant de migrer. La doc insiste : "Recount prompts against the model you plan to use rather than reusing counts measured against earlier models."

2. La fenêtre de contexte#

Définition Anthropic :

The "context window" refers to all the text a language model can reference when generating a response, including the response itself. [...] it represents a "working memory" for the model.

Ce qui compte dedans (tout)#

La doc est explicite :

Everything in the request counts toward the context window: the system prompt, every message in messages (including tool results, images, and documents), and your tool definitions. The output Claude generates for the turn, including its extended thinking, counts too.

Donc : ton prompt système + l'historique complet de la conversation + les résultats d'outils + les images + les PDF + la définition de tes outils + la réponse en cours. Si tu branches quinze serveurs MCP, leurs schémas d'outils mangent du contexte avant même que tu aies écrit un mot.

Les tailles actuelles#

D'après la page de comparaison des modèles Anthropic (consultée en septembre 2026) :

Deux précisions officielles :

• "For every model with a 1M-token context window, 1M is the default: you don't need a beta header". Plus besoin d'en-tête beta, contrairement à ce qu'on lisait en 2025.
• "A single request can include up to 600 images or PDF pages (100 for models with a 200k-token context window)."

Ce qui tient dans 200k et dans 1M#

La note de bas de tableau d'Anthropic donne les équivalences :

1M tokens is roughly 555k words or 2.5M Unicode characters on the current tokenizer (introduced with Claude Opus 4.7); models before it fit about 750k words in 1M tokens. 200k tokens is roughly 150k words.

En pratique, pour toi :

Le piège : plus de contexte n'est pas mieux#

C'est écrit noir sur blanc dans la doc Anthropic :

A larger context window allows the model to handle more complex and lengthy prompts, but more context isn't automatically better. As token count grows, accuracy and recall degrade, a phenomenon known as context rot.

Le blog ingénierie d'Anthropic précise : "as the number of tokens in the context window increases, the model's ability to accurately recall information from that context decreases." Le modèle a un budget d'attention limité.

Conclusion opérationnelle : remplir 900k tokens parce que tu peux, c'est se tirer une balle dans le pied. Envoie le minimum pertinent.

3. Compter les tokens exactement (et gratuitement)#

Anthropic expose un endpoint dédié. Il est gratuit, avec une limite de débit propre (5 000 requêtes/minute au palier Start, 10 000 au palier Build, 20 000 au palier Scale).

import anthropic

client = anthropic.Anthropic()

with open("requete_lourde.sql", "r", encoding="utf-8") as f:
    sql = f.read()

reponse = client.messages.count_tokens(
    model="claude-opus-5-5",
    system="Tu es un expert PostgreSQL.",
    messages=[{"role": "user", "content": sql}],
)

print(reponse.json())

Sortie :

{ "input_tokens": 14 }

Trois limites documentées : c'est une estimation ("the actual number of input tokens used when creating a message might differ by a small amount") ; certains contenus sont refusés (outils serveur, connecteur MCP, blocs image ou document passés par url ou file — envoie-les en base64) ; et le comptage utilise le tokenizer du model que tu passes, donc passe le vrai modèle cible.

Côté Google, l'équivalent s'appelle aussi count_tokens, et le champ usage de la réponse donne le détail après coup (input, output, thinking, cache, tool-use).

4. Coût et latence#

Le coût, en une formule#

cout = (tokens_entree x prix_entree) + (tokens_sortie x prix_sortie)

Prix publics Anthropic par million de tokens (MTok), relevés en septembre 2026 :

Trois leviers documentés pour payer moins :

• Cache de prompt (prompt caching). Écriture 5 minutes = 1,25x le prix d'entrée, écriture 1 heure = 2x, lecture = 0,1x (0,05x sur Opus 5.5, 0,025x sur Fable 5.1). Anthropic précise : "caching pays off after one cache read for the 5-minute duration (1.25x write), or after two cache reads for the 1-hour duration (2x write)". Si tu renvoies le même schéma de base à chaque appel, mets-le en cache.
• Batch API : 50 % de réduction sur l'entrée et la sortie, en asynchrone. Parfait pour classer 10 000 tickets ou enrichir un référentiel la nuit.
• Pas de surcoût long contexte sur les modèles 4.6 et suivants : "A 900k-token request is billed at the same per-token rate as a 9k-token request."

Attention, le cache ne libère pas de place : "Cached prompt prefixes still occupy the context window: prompt caching changes what you pay for those tokens, not whether they count."

La latence#

Deux métriques officielles : la latence ("the time it takes for the model to respond to a given prompt") et le TTFT, time to first token ("the time it takes for a language model to generate the first token of its output"). Facteurs cités par Anthropic : taille du modèle, matériel, réseau, complexité du prompt et de la réponse. En clair, un prompt de 500k tokens ne coûte pas seulement plus cher, il répond aussi plus lentement.

5. Quand le fichier est trop gros : cinq stratégies#

Ce qui se passe si tu dépasses#

If the input alone already exceeds the model's context window, the API returns a 400 invalid_request_error ("prompt is too long") on every model.

Et si l'entrée passe mais que la génération atteint la limite, sur les modèles 4.5 et plus récents la requête s'arrête avec stop_reason: "model_context_window_exceeded".

Stratégie 1 : n'envoie pas la donnée, envoie le schéma#

Le cas le plus fréquent en data. Tu n'as presque jamais besoin des 2 millions de lignes.

import pandas as pd

df = pd.read_csv("ventes_2026.csv")

contexte = f"""
COLONNES ET TYPES
{df.dtypes.to_string()}

NOMBRE DE LIGNES
{len(df)}

5 LIGNES D'EXEMPLE
{df.head(5).to_markdown(index=False)}

VALEURS MANQUANTES PAR COLONNE
{df.isna().sum().to_string()}
"""

Tu passes de 400 Mo à quelques centaines de tokens, et le modèle a tout ce qu'il faut pour écrire le code de transformation.

Stratégie 2 : découpe (chunking)#

Découpe le fichier en morceaux qui ont un sens (un modèle dbt, une fonction, une table), traite chaque morceau séparément, puis agrège. Ne découpe jamais au milieu d'une requête SQL ou d'une fonction.

Stratégie 3 : récupération juste à temps#

Anthropic décrit ce pattern : l'agent garde "lightweight identifiers (file paths, stored queries, web links, etc.)" et va chercher le contenu au moment où il en a besoin. Concrètement : donne au modèle l'arborescence du dépôt, pas le contenu des 800 fichiers.

Stratégie 4 : compaction#

Anthropic propose une compaction côté serveur qui résume automatiquement le début de la conversation quand on approche de la limite (en beta sur les modèles 4.6 et suivants). Définition du blog ingénierie : "taking a conversation nearing the context window limit, summarizing its contents, and reinitiating a new context window with the summary".

Stratégie 5 : sous-agents#

Toujours d'Anthropic : "specialized sub-agents [handling] focused tasks with clean context windows". L'agent principal garde la stratégie, chaque sous-agent explore avec un contexte propre et ne renvoie qu'un résumé court.

6. Templates prêts à copier-coller#

Template A : faire analyser un gros fichier sans l'envoyer#

CONTEXTE
Je travaille sur un fichier [NOM_DU_FICHIER] de [TAILLE] lignes, trop gros pour etre envoye.
Voici uniquement sa structure.

SCHEMA
[COLLE_ICI_LA_SORTIE_DE_df.dtypes]

ECHANTILLON (5 lignes)
[COLLE_ICI_df.head(5).to_markdown()]

STATISTIQUES
- Lignes totales : [NB_LIGNES]
- Valeurs manquantes : [RESUME_DES_NA]

TACHE
[CE_QUE_TU_VEUX, ex: ecris la fonction de nettoyage pandas]

CONTRAINTE
Ne suppose aucune colonne qui n'est pas dans le schema ci-dessus.
Si une colonne te manque, demande-la.

Template B : découpage d'un gros traitement#

Je vais te donner [NOMBRE] morceaux de [TYPE_DE_CONTENU], un par message.

Pour chaque morceau :
1. Produis uniquement [SORTIE_ATTENDUE_PAR_MORCEAU].
2. Ne resume pas les morceaux precedents.
3. Attends le morceau suivant sans commenter.

Quand j'ecris TERMINE, produis la synthese finale au format [FORMAT_FINAL].

Morceau 1 sur [NOMBRE] :
[CONTENU]

À retenir#

• 1 token vaut environ 3,5 à 4 caractères anglais, environ 0,75 mot. Pour le français et le code, aucun ratio officiel n'est publié : compte avec l'API.
• Tout compte dans la fenêtre : prompt système, historique, résultats d'outils, images, définitions d'outils, et la réponse en cours.
• Les modèles Claude actuels ont 1M tokens de contexte (200k pour Haiku 4.5), avec 128k tokens de sortie maximum.
• 1M tokens vaut environ 555 000 mots ; 200k tokens environ 150 000 mots.
• Remplir la fenêtre dégrade la précision (context rot). Envoie le minimum pertinent.
• count_tokens est gratuit. Le tokenizer des modèles 4.7 et suivants produit environ 30 % de tokens en plus : recompte avant de migrer.
• Cache de prompt (lecture à 0,1x) et Batch API (moitié prix) sont les deux leviers de coût les plus simples.

Sources#

• Anthropic — Context windows
• Anthropic — Models overview (tailles de contexte, sorties max)
• Anthropic — Token counting
• Anthropic — Pricing (coûts, cache, batch, long contexte)
• Anthropic — Glossaire (tokens, latence, TTFT)
• Anthropic — Effective context engineering for AI agents
• Google — Gemini API : Tokens
• Microsoft Learn — Prompt engineering techniques (espaces et efficacité)
• openai/tiktoken - code d'exemple sur le comptage des tokens en local ; tiktoken/_educational.py affiche le découpage en couleur.
• karpathy/minbpe - code d'exemple sur l'algorithme BPE qui fabrique les tokens ; commence par lecture.md.