Calculateur de Coût des Tokens IA: Comment Estimer le Prix Réel d'un Agent en Production

Si vous lancez un agent IA en production sans calculer le coût des tokens à l'avance, vous allez recevoir une mauvaise surprise sur votre facture Anthropic ou OpenAI. Un seul agent mal optimisé peut brûler 500$ à 2000$ par mois sans que personne ne s'en aperçoive. Cet article vous donne les formules exactes, un calculateur Python fonctionnel, et les techniques d'optimisation qui font passer un coût de 0.012$ par requête à 0.0008$.

Pourquoi le Coût des Tokens Échappe à la Plupart des Équipes

La plupart des développeurs estiment le coût de leur agent IA en multipliant naïvement le prix affiché sur la page de pricing par le nombre de requêtes. C'est une erreur qui donne une estimation 3 à 10 fois trop basse.

Pourquoi? Parce qu'un agent IA moderne ne fait pas un seul appel par requête utilisateur. Un agent typique avec tool use effectue en moyenne 4 à 7 appels API par interaction:

• 1 appel initial avec le system prompt complet
• 2 à 5 appels de tool use (recherche, calcul, RAG)
• 1 appel final de synthèse
• Parfois 1 appel de retry si un outil échoue

Chaque appel renvoie l'intégralité de la conversation précédente comme tokens d'entrée. C'est cette accumulation qui explose la facture.

Le Calcul Réel d'un Tour de Conversation

Prenons un agent Claude Sonnet 4.6 avec un system prompt de 2000 tokens et un message utilisateur de 100 tokens. Voici ce qui se passe vraiment:

| Appel | Input tokens | Output tokens | Coût (Sonnet 4.6) |

|-------|--------------|---------------|-------------------|

| 1. Décision tool use | 2 100 | 80 | 0.0078$ |

| 2. Tool result + nouveau call | 2 400 | 120 | 0.0090$ |

| 3. Tool result + synthèse | 2 800 | 350 | 0.0137$ |

| Total | 7 300 | 550 | 0.0305$ |

Avec un tarif de 3$/million de tokens en input et 15$/million en output (prix Sonnet 4.6 au moment de l'écriture), une seule conversation coûte 3 cents. Multipliez par 10 000 conversations par jour: 300$/jour, ou 9 000$/mois.

La Formule Exacte du Calcul de Coût

Voici la formule générale que tout calculateur de coût de tokens IA devrait utiliser:

```

Coût total = Σ (input_tokens × prix_input + output_tokens × prix_output) sur tous les appels

+ Σ (cached_input_tokens × prix_cache_read) si prompt caching activé

+ Σ (cache_creation_tokens × prix_cache_write) première fois

```

Pour les modèles Anthropic, le prompt caching divise le coût des tokens en cache par 10 (lecture) mais ajoute un surcoût de 25% à l'écriture. C'est rentable dès le 2ème appel sur le même prompt.

Estimer le Nombre de Tokens Avant l'Appel

Avant même de faire un appel, vous pouvez estimer le nombre de tokens avec la règle suivante:

• Anglais: 1 token ≈ 4 caractères ou 0.75 mot
• Français: 1 token ≈ 3 caractères (les accents consomment plus)
• Code: 1 token ≈ 2-3 caractères (espaces, ponctuation fréquents)
• JSON: 1 token ≈ 2 caractères (très verbeux)

Pour une estimation précise, utilisez le tokenizer officiel:

```python

import anthropic

client = anthropic.Anthropic()

# Compter les tokens AVANT l'appel

response = client.messages.count_tokens(

model="claude-sonnet-4-6",

messages=[{"role": "user", "content": "Bonjour, calcule 2+2"}],

system="Tu es un assistant mathématique."

)

print(f"Tokens d'entrée estimés: {response.input_tokens}")

```

Pour OpenAI, utilisez tiktoken:

```python

import tiktoken

enc = tiktoken.encoding_for_model("gpt-4o")

tokens = enc.encode("Bonjour, calcule 2+2")

print(f"Nombre de tokens: {len(tokens)}")

```

Un Calculateur Python Prêt à l'Emploi

Voici un calculateur de coût de tokens IA complet que vous pouvez adapter à votre projet. Il supporte Claude, GPT-4, et Gemini, avec gestion du prompt caching.

```python

from dataclasses import dataclass

from typing import Literal

# Prix en $ par million de tokens (avril 2026)

PRICING = {

"claude-opus-4-7": {"input": 15.00, "output": 75.00, "cache_read": 1.50, "cache_write": 18.75},

"claude-sonnet-4-6": {"input": 3.00, "output": 15.00, "cache_read": 0.30, "cache_write": 3.75},

"claude-haiku-4-5": {"input": 0.80, "output": 4.00, "cache_read": 0.08, "cache_write": 1.00},

"gpt-4o": {"input": 2.50, "output": 10.00, "cache_read": 1.25, "cache_write": 0.00},

"gpt-4o-mini": {"input": 0.15, "output": 0.60, "cache_read": 0.075,"cache_write": 0.00},

"gemini-2.5-pro": {"input": 1.25, "output": 5.00, "cache_read": 0.31, "cache_write": 0.00},

}

@dataclass

class TokenUsage:

input_tokens: int

output_tokens: int

cache_read_tokens: int = 0

cache_write_tokens: int = 0

def compute_cost(model: str, usage: TokenUsage) -> dict:

if model not in PRICING:

raise ValueError(f"Modèle inconnu: {model}")

p = PRICING[model]

cost_input = (usage.input_tokens / 1_000_000) * p["input"]

cost_output = (usage.output_tokens / 1_000_000) * p["output"]

cost_cr = (usage.cache_read_tokens / 1_000_000) * p["cache_read"]

cost_cw = (usage.cache_write_tokens / 1_000_000) * p["cache_write"]

total = cost_input + cost_output + cost_cr + cost_cw

return {

"model": model,

"total_usd": round(total, 6),

"breakdown": {

"input": round(cost_input, 6),

"output": round(cost_output, 6),

"cache_read": round(cost_cr, 6),

"cache_write": round(cost_cw, 6),

}

}

# Exemple: agent avec 3 appels et prompt caching activé

agent_usage = [

TokenUsage(input_tokens=100, output_tokens=80, cache_read_tokens=2000, cache_write_tokens=0),

TokenUsage(input_tokens=300, output_tokens=120, cache_read_tokens=2000, cache_write_tokens=0),

TokenUsage(input_tokens=500, output_tokens=350, cache_read_tokens=2000, cache_write_tokens=0),

]

total = sum(compute_cost("claude-sonnet-4-6", u)["total_usd"] for u in agent_usage)

print(f"Coût total de la conversation: {total:.4f}$")

# Output: Coût total de la conversation: 0.0093$

```

Avec le caching activé, le même agent qui coûtait 0.0305$ tombe à 0.0093$ — soit 70% d'économies.