Tokens, contexte, coûts : comprendre la facturation des LLM

Vous utilisez ChatGPT, Claude ou un autre modèle d'IA et vous voyez des termes comme « tokens », « contexte 200K » ou « $3/million tokens » sans vraiment comprendre ce que ça signifie ? Vous n'êtes pas seul. La facturation des LLM (Large Language Models) repose sur des concepts simples une fois qu'on les maîtrise, mais qui restent obscurs pour beaucoup d'utilisateurs.

Dans ce guide complet, on va tout décortiquer : ce qu'est un token, comment fonctionne la fenêtre de contexte, comment les coûts sont calculés, et surtout comment optimiser vos dépenses pour tirer le maximum de l'IA sans exploser votre budget.

🔤 C'est quoi un token ?

La brique de base des LLM

Un token n'est pas un mot. Ce n'est pas non plus un caractère. C'est une unité intermédiaire que le modèle utilise pour « lire » et « écrire » du texte.

Concrètement, un tokenizer (algorithme de découpage) divise le texte en morceaux appelés sous-mots (subwords). Voici comment ça fonctionne :

Les règles de base à retenir

• En anglais : 1 token ≈ 4 caractères ≈ 0.75 mot
• En français : 1 token ≈ 3 caractères ≈ 0.5 mot (le français est ~30% plus « cher » en tokens)
• Les espaces comptent (souvent attachés au mot suivant)
• Les chiffres sont souvent découpés individuellement
• Le code est généralement efficace en tokens (mots-clés courts)
• Les caractères spéciaux et emojis peuvent coûter plusieurs tokens chacun

Pourquoi le français coûte plus cher

Les tokenizers sont principalement entraînés sur du texte anglais. Résultat : les mots anglais courants sont souvent un seul token, alors que leurs équivalents français sont découpés en plusieurs morceaux.

# Exemple avec le tokenizer de GPT-4
"The cat is on the table"     → 7 tokens
"Le chat est sur la table"    → 8 tokens

"Understanding"               → 1 token
"Compréhension"               → 3 tokens

"I need to automate this"     → 6 tokens
"J'ai besoin d'automatiser"  → 9 tokens

💡 Astuce : pour compter précisément vos tokens, utilisez l'outil tiktoken d'OpenAI ou le tokenizer en ligne d'Anthropic.

Les différents tokenizers

Chaque famille de modèles utilise son propre tokenizer :

Un même texte peut donc donner un nombre de tokens différent selon le modèle utilisé. C'est important pour estimer les coûts !

📐 La fenêtre de contexte : votre mémoire de travail

Qu'est-ce que le contexte ?

La fenêtre de contexte (context window) représente la quantité maximale de texte qu'un modèle peut « voir » en une seule fois. Elle inclut :

1. Le system prompt (instructions de base)
2. L'historique de conversation (messages précédents)
3. Le message de l'utilisateur (votre question)
4. La réponse du modèle (ce qu'il génère)

Tout ça doit tenir dans la fenêtre. Si ça dépasse → le modèle « oublie » les messages les plus anciens.

L'évolution spectaculaire des fenêtres de contexte

Pour mettre en perspective : 200K tokens, c'est environ un roman de 500 pages. 1M tokens, c'est toute l'œuvre de Harry Potter.

Contexte long : avantages et pièges

✅ Avantages d'un grand contexte :
- Analyser des documents entiers (contrats, rapports, code source)
- Maintenir de longues conversations sans perte de mémoire
- Fournir beaucoup d'exemples (few-shot learning)

⚠️ Pièges à éviter :
- Plus de contexte = plus cher (vous payez TOUS les tokens en input)
- "Lost in the middle" : les modèles ont tendance à moins bien utiliser les informations au milieu d'un long contexte
- Latence : plus le contexte est long, plus la réponse est lente
- Ce n'est pas de la mémoire : chaque requête re-traite tout le contexte depuis zéro

# Impact du contexte sur le coût (Claude Opus 4)
# Prix input : $15/million tokens

Conversation courte (2K tokens)  → $0.03
+ Document 50 pages (30K tokens) → $0.45
+ Historique long (100K tokens)  → $1.50
Contexte max (200K tokens)       → $3.00

# Et ça, c'est JUSTE l'input, à chaque message !

Stratégies pour gérer le contexte

1. Résumé glissant : résumer périodiquement la conversation pour libérer de l'espace
2. RAG (Retrieval Augmented Generation) : chercher uniquement les infos pertinentes au lieu de tout envoyer
3. Chunking intelligent : découper les documents et n'envoyer que les parties utiles
4. System prompts concis : chaque mot du system prompt est re-envoyé à chaque message

💰 Comment sont calculés les coûts

Le modèle input/output

La facturation des API de LLM repose sur un principe simple :

• Tokens en input (ce que vous envoyez) : prix X par million de tokens
• Tokens en output (ce que le modèle génère) : prix Y par million de tokens
• L'output coûte toujours plus cher que l'input (souvent 3 à 5x plus)

Pourquoi l'output coûte plus ? Parce que la génération demande beaucoup plus de calcul que la simple « lecture » de l'input.

Formule de calcul

Coût total = (tokens_input × prix_input / 1M) + (tokens_output × prix_output / 1M)

# Exemple concret :
# Modèle : Claude Sonnet 4 ($3 input / $15 output par million)
# Vous envoyez : 2 000 tokens (question + contexte)
# Le modèle répond : 500 tokens

Coût = (2000 × 3 / 1000000) + (500 × 15 / 1000000)
Coût = $0.006 + $0.0075
Coût = $0.0135 (≈ 1.3 centimes)

Coûts cachés à surveiller

• System prompt : envoyé à CHAQUE requête, il s'accumule vite
• Historique de conversation : grandit à chaque échange
• Retries : si votre app retente automatiquement, vous payez double
• Streaming : même coût que non-streaming, mais la latence perçue diminue
• Images/fichiers : convertis en tokens (une image peut coûter 1K-10K tokens)
• Thinking/reasoning tokens : les modèles « penseurs » (o1, Claude with thinking) génèrent des tokens de réflexion facturés

📊 Tableau comparatif des prix 2026

Voici les prix actuels des principaux modèles (en dollars par million de tokens) :

Modèles Premium (raisonnement avancé)

Modèles Intermédiaires (meilleur rapport qualité/prix)

Modèles Économiques (volume élevé)

⚠️ Note : ces prix évoluent rapidement. Vérifiez toujours les prix actuels sur les sites officiels. Les prix ci-dessus reflètent les tarifs de début 2026.

Coût par tâche type

Pour aller plus loin sur ce sujet, consultez notre guide Claude, GPT, Gemini, Llama : quel modèle choisir en 2026 ?.

Pour mieux visualiser, voici le coût estimé de tâches courantes :

Pour aller plus loin sur ce sujet, consultez notre guide Utiliser des modèles gratuits sans sacrifier la qualité.

🧮 Calculer son budget mensuel

Méthode simple

# Calcul rapide de budget mensuel
def calculer_budget(
    requetes_par_jour: int,
    tokens_input_moy: int,
    tokens_output_moy: int,
    prix_input_par_m: float,
    prix_output_par_m: float
) -> float:
    """Retourne le coût mensuel estimé en dollars."""
    cout_par_requete = (
        (tokens_input_moy * prix_input_par_m / 1_000_000) +
        (tokens_output_moy * prix_output_par_m / 1_000_000)
    )
    return cout_par_requete * requetes_par_jour * 30

# Exemple : développeur utilisant Claude Sonnet 4
budget = calculer_budget(
    requetes_par_jour=50,
    tokens_input_moy=3000,
    tokens_output_moy=1000,
    prix_input_par_m=3.0,    # Claude Sonnet 4
    prix_output_par_m=15.0
)
print(f"Budget mensuel estimé : ${budget:.2f}")
# → Budget mensuel estimé : $36.00

Profils types de consommation

💡 12 astuces pour réduire vos coûts

1. Choisir le bon modèle pour chaque tâche

Ne prenez pas un Ferrari pour aller acheter du pain. Utilisez un modèle économique pour les tâches simples et réservez les modèles premium pour les cas complexes.

# Routing intelligent par complexité
def choisir_modele(tache: str) -> str:
    taches_simples = ["classification", "extraction", "reformulation"]
    taches_moyennes = ["résumé", "rédaction", "code_simple"]
    taches_complexes = ["analyse", "raisonnement", "code_complexe"]

    if tache in taches_simples:
        return "haiku-3.5"      # $0.80/$4 par M
    elif tache in taches_moyennes:
        return "sonnet-4"       # $3/$15 par M
    else:
        return "opus-4"         # $15/$75 par M

2. Optimiser vos prompts

Un prompt concis mais précis coûte moins cher qu'un prompt verbeux. Éliminez les répétitions et les instructions inutiles.

3. Utiliser le caching (prompt caching)

Claude et GPT supportent le prompt caching : si vous envoyez le même system prompt ou contexte répétitivement, les tokens cachés coûtent jusqu'à 90% moins cher.

# Prix avec caching (Claude)
Sans cache : $3/M input
Avec cache  : $0.30/M (tokens cachés) + $3.75/M (écriture cache)
Économie sur requêtes répétitives : jusqu'à 90%

4. Limiter l'historique de conversation

Ne gardez pas 100 messages d'historique. Résumez régulièrement ou ne gardez que les N derniers échanges.

5. Utiliser des modèles open-source en self-hosting

Pour du volume important, héberger Llama 3.3 ou Mistral sur votre propre GPU peut être bien plus rentable que les API.

6. Batching (regroupement de requêtes)

OpenAI et Anthropic proposent des batch APIs avec 50% de réduction pour les tâches non-urgentes.

7. Structured output pour réduire l'output

Demander du JSON structuré au lieu de texte libre réduit significativement les tokens en output.

# ❌ Réponse verbeuse (~200 tokens)
"Le sentiment de ce texte est positif. En effet, l'auteur
utilise des mots comme 'excellent', 'formidable'..."

# ✅ Réponse structurée (~20 tokens)  
{"sentiment": "positif", "score": 0.92, "mots_cles": ["excellent", "formidable"]}

8. Pré-filtrer avec des modèles légers

Utilisez un modèle économique pour filtrer/classifier, puis envoyez uniquement les cas pertinents au modèle premium.

9. Mettre en place des limites de dépenses

Toutes les API proposent des spending limits. Configurez-les pour éviter les surprises.

10. Monitorer sa consommation

Utilisez les dashboards de votre provider ou des outils comme OpenRouter pour suivre vos dépenses en temps réel.

11. Compresser les documents avant envoi

Résumez ou extrayez les parties pertinentes d'un document avant de l'envoyer au LLM, plutôt que d'envoyer le document entier.

12. Utiliser un routeur de modèles

Des services comme OpenRouter permettent de basculer facilement entre modèles et de comparer les prix.

🔧 Outils pratiques pour gérer ses tokens

Compter ses tokens

# Avec tiktoken (OpenAI)
import tiktoken

enc = tiktoken.encoding_for_model("gpt-4o")
text = "Bonjour, comment calculer mes tokens ?"
tokens = enc.encode(text)
print(f"Nombre de tokens : {len(tokens)}")  # → 11
print(f"Tokens : {tokens}")
print(f"Décodés : {[enc.decode([t]) for t in tokens]}")

# Avec anthropic (Claude)
from anthropic import Anthropic
client = Anthropic()
count = client.count_tokens("Votre texte ici")
print(f"Tokens Claude : {count}")

Surveiller ses dépenses avec OpenRouter

OpenRouter est un routeur multi-modèles qui offre un dashboard centralisé pour suivre vos coûts sur tous les providers :

# Voir sa consommation via l'API OpenRouter
curl https://openrouter.ai/api/v1/auth/key \
  -H "Authorization: Bearer $OPENROUTER_API_KEY"

# Réponse inclut : usage, limit, rate limits

Intégration avec OpenClaw

Si vous utilisez OpenClaw comme agent IA, la gestion des tokens est automatique. OpenClaw supporte le routing intelligent via OpenRouter et vous pouvez configurer des limites par session.

🎯 Résumé : les points clés

La facturation des LLM peut sembler complexe au premier abord, mais elle repose sur des mécanismes simples et prévisibles. En comprenant ces mécanismes et en appliquant les astuces de ce guide, vous pouvez facilement diviser vos coûts par 5 à 10 sans sacrifier la qualité.

Le plus important : ne payez pas pour la puissance dont vous n'avez pas besoin. Un modèle économique bien prompté bat souvent un modèle premium mal utilisé.

📚 Articles liés

• Qu'est-ce qu'OpenClaw ? — Comprendre l'agent IA qui gère vos tokens automatiquement
• OpenRouter : le routeur multi-modèles — Comparer et optimiser les coûts entre providers
• Configurer OpenClaw — Paramétrer les limites et le routing de modèles
• Claude d'Anthropic — Tout savoir sur les modèles Claude et leurs tarifs
• Automatiser sa vie avec l'IA — Utiliser l'IA au quotidien sans exploser son budget