Comprendre les tokens et la facturation des IA (sans exploser son budget)

À la fin de ce tuto, tu sauras estimer le coût d'un appel à une IA avant de le lancer, lire une facture d'API, et appliquer cinq réflexes qui peuvent diviser ta note par deux ou plus. On va même chiffrer un exemple complet de bout en bout.

Durée : 12 min. Aucun prérequis technique — utile dès que tu passes des abonnements (ChatGPT Plus…) aux API pour brancher une IA dans tes outils.

Qu'est-ce qu'un token, vraiment

Un modèle ne lit pas des mots, mais des morceaux de mots appelés tokens. Les ordres de grandeur à retenir :

• 1 token ≈ 4 caractères en anglais, un peu moins en français.
• 1 token ≈ 0,75 mot en moyenne.
• 1 page (~500 mots) ≈ 650 à 750 tokens.

Quelques exemples concrets de découpage :

• « le » → 1 token
• « automatisation » → 3-4 tokens (les mots longs sont découpés)
• « 👍 » ou un caractère accentué → souvent 2-3 tokens
• du code et du JSON → plus de tokens que du texte courant (la ponctuation compte)

Tu n'as pas à compter à la main : la plupart des plateformes ont un « tokenizer » en ligne et affichent l'usage après chaque appel.

Le point que tout le monde rate : tu paies l'entrée ET la sortie

Chaque appel facture deux choses :

• Les tokens d'entrée (input) : tout ce que tu envoies — ta question, mais aussi le contexte, les documents joints, l'historique de la conversation, les instructions système.
• Les tokens de sortie (output) : la réponse générée par le modèle.

Deux conséquences que les débutants découvrent sur leur facture :

1. La sortie coûte généralement plus cher que l'entrée (souvent 4 à 5× le prix par token).
2. L'entrée gonfle vite : si tu renvoies tout l'historique d'une longue conversation à chaque message, tu repaies ce contexte à chaque fois.

Exemple chiffré de bout en bout

Prenons un cas concret : un assistant qui résume des articles. Tu lui envoies un article de 1 000 mots et tu veux un résumé de 100 mots.

Entrée  : instructions (50 mots) + article (1000 mots) ≈ 1050 mots ≈ 1400 tokens
Sortie  : résumé (100 mots)                            ≈ 130 tokens

Imaginons un tarif d'exemple de 1 € / million de tokens en entrée et 3 € / million en sortie (les tarifs réels varient selon le modèle — vérifie la page de prix du fournisseur) :

Entrée : 1400 tokens × (1 € / 1 000 000)  = 0,0014 €
Sortie :  130 tokens × (3 € / 1 000 000)  = 0,0004 €
Total par résumé                          ≈ 0,0018 €

Un résumé coûte ~0,2 centime. Anodin… jusqu'à ce que tu en fasses 10 000 par mois : ~18 €. Et si tu envoies par erreur 10 articles de contexte « au cas où » à chaque appel, ton entrée est multipliée par 10 — et ta facture aussi.

Les trois pièges qui font exploser la facture

1. Le contexte répété. Une app qui rappelle 20 pages de documentation à chaque requête refacture ces 20 pages à chaque appel. Solution : n'envoyer que le passage pertinent (c'est tout l'intérêt du RAG, sujet d'un autre tuto).

2. Le gros modèle par défaut. Utiliser le modèle le plus puissant pour trier des emails, c'est payer une Ferrari pour aller chercher le pain. Les petits modèles coûtent souvent 10 à 50× moins cher et suffisent largement pour le tri, la classification, l'extraction simple.

3. Les réponses trop longues. Sans limite, le modèle peut produire des pavés — que tu paies. Demande explicitement « en 3 phrases » quand ça suffit.

Les 5 réflexes pour garder la maîtrise

1. Fixe une limite de sortie (max_tokens dans les appels API). C'est un plafond dur : le modèle s'arrête là.
2. Choisis le plus petit modèle qui fait le travail correctement. Teste le petit d'abord, monte en gamme seulement si la qualité ne suffit pas.
3. N'envoie que le contexte utile, jamais tout « au cas où ».
4. Surveille ton tableau de bord d'usage les premiers jours — toutes les plateformes en ont un, avec le détail entrée/sortie.
5. Mets en cache ce qui se répète : certaines API facturent les portions de prompt déjà vues à un tarif très réduit (souvent ~10 % du prix). Si tu réutilises le même gros préambule, active le cache.

Vérifie sur tes propres prompts

Avant d'industrialiser, prends un appel réel et regarde le champ usage renvoyé par l'API : il détaille input_tokens et output_tokens (et souvent les tokens lus en cache). Multiplie par le tarif du modèle, projette sur ton volume mensuel. Tu sauras en 5 minutes si ton usage est viable — avant de recevoir la facture.

À retenir

Un token, c'est environ 4 caractères. Tu paies ce que tu envoies et ce que le modèle répond, la sortie étant la plus chère. Les coûts explosent à cause des contextes longs répétés et des modèles surdimensionnés. Limite la sortie, choisis la bonne taille de modèle, n'envoie que l'utile, surveille ton usage, et mets en cache ce qui se répète. Le seul chiffre qui compte, c'est le tien : mesure sur tes propres appels.