Parcourir les aide-mémoire · Ingénierie IA pour les données
Coût LLM et budget de tokens
Estimez et maîtrisez le coût d’une charge de travail LLM avec des formules simples par requête, par jour et par mois, des budgets de tokens, le choix du niveau de modèle, la mise en cache, le batch et la supervision.
Sur cette page
- Problème
- Réponse rapide
- Formules de coût
- Pourquoi les prix évoluent
- Code / commandes
- 1. Estimer le coût d’une requête
- 2. Projeter le coût quotidien et mensuel
- 3. Utiliser des percentiles, pas seulement des moyennes
- 4. Inclure nouvelles tentatives, escalades et tokens de raisonnement
- 5. Vérifier le débit face aux limites
- 6. Fixer un budget de tokens par requête
- 7. Plafonner la sortie
- 8. Ajouter des budgets par utilisateur et par session
- 9. Ajouter des budgets de workflow
- 10. Choisir le niveau de modèle selon la tâche
- 11. Séparer les charges batch et interactives
- 12. Estimer l’effet de la mise en cache
- 13. Superviser le coût en continu
- Interpréter le résultat
- Points à vérifier
- Erreurs fréquentes
- 1. Coder les prix en dur
- 2. Estimer à partir de la seule requête moyenne
- 3. Ignorer les tokens de sortie
- 4. Oublier nouvelles tentatives et escalades
- 5. Budgéter uniquement au mois
- 6. Supposer que le cache fait toujours économiser
- 7. Prendre le modèle le moins cher sans mesurer la qualité
- Notes de production
- Liste de contrôle
- Étape suivante
- Pour aller plus loin
Problème
Vous devez répondre à des questions comme :
- Combien coûtera cette fonctionnalité LLM par mois ?
- Que devient le coût si l’usage double ?
- Quelle fonctionnalité, quel utilisateur ou quel pipeline fait monter la dépense ?
- Comment empêcher un workflow de consommer tout le budget ?
- Un modèle moins cher, un cache ou un traitement batch vaut-il la peine ?
Le coût d’un LLM dépend de l’usage : tokens, volume de requêtes, choix du modèle, nouvelles tentatives et mise en cache. Et les prix eux-mêmes évoluent dans le temps.
Réponse rapide
request_cost = (input_tokens × input_rate)
+ (output_tokens × output_rate)
monthly_cost = average_request_cost × requests_per_month
Les tarifs sont généralement exprimés par million de tokens. Lisez-les dans la configuration, pas dans le code ni dans la documentation, car ils changent.
Pour maîtriser le coût :
- Journalisez les tokens et le coût estimé de chaque requête.
- Fixez un budget de tokens par requête et un plafond de tokens de sortie.
- Ajoutez des budgets par utilisateur, par session et par exécution de workflow.
- Routez le travail simple vers des modèles moins chers.
- Traitez en batch ce qui n’est pas interactif, quand le fournisseur le propose.
- Ne mettez en cache que là où les entrées se répètent.
- Alertez sur le rythme de consommation du budget, pas seulement sur la facture mensuelle.
Formules de coût
| Grandeur | Formule |
|---|---|
| Tokens par requête | input_tokens + output_tokens |
| Coût par requête | input_tokens × input_rate + output_tokens × output_rate |
| Avec entrée en cache | uncached_input × input_rate + cached_input × cached_input_rate + output_tokens × output_rate |
| Requêtes par jour | requests_per_minute × active_minutes_per_day (ou d’après les journaux) |
| Requêtes effectives | requests × (1 + retry_rate) |
| Coût par jour | average_request_cost × effective_requests_per_day |
| Coût par mois | cost_per_day × days_in_month |
| Tokens par minute | requests_per_minute × average_tokens_per_request |
La façon dont les tokens en cache sont comptés et facturés dépend du fournisseur : certains les incluent dans les tokens d’entrée, d’autres les déclarent à part, et certains facturent l’écriture dans le cache. Vérifiez les champs d’usage de l’API que vous appelez.
Pourquoi les prix évoluent
- Les fournisseurs publient de nouveaux modèles et changent le prix des anciens.
- Les prix diffèrent selon la taille du modèle et entre entrée, sortie et entrée en cache.
- Les offres batch, prioritaires ou régionales peuvent avoir d’autres tarifs.
- Votre propre usage change : prompts plus longs, nouvelles fonctionnalités, plus d’utilisateurs.
Donc :
- gardez les tarifs dans une configuration versionnée (une « grille tarifaire »), pas dans le code
- stockez le coût estimé et la version de la grille avec chaque requête journalisée
- réestimez à chaque changement de modèle, de prompt ou de trafic
Code / commandes
1. Estimer le coût d’une requête
from dataclasses import dataclass
@dataclass(frozen=True)
class Rates:
"""Prix par million de tokens. À charger depuis la configuration : les prix des fournisseurs changent."""
input_per_m: float
output_per_m: float
cached_input_per_m: float | None = None
def request_cost(rates: Rates, input_tokens: int, output_tokens: int, cached_input_tokens: int = 0) -> float:
"""Coût d'une requête. `input_tokens` inclut `cached_input_tokens`."""
uncached = input_tokens - cached_input_tokens
cached_rate = rates.cached_input_per_m if rates.cached_input_per_m is not None else rates.input_per_m
return (
uncached * rates.input_per_m
+ cached_input_tokens * cached_rate
+ output_tokens * rates.output_per_m
) / 1_000_000
2. Projeter le coût quotidien et mensuel
def monthly_cost(avg_request_cost: float, requests_per_day: float, days: int = 30, retry_rate: float = 0.0) -> float:
return avg_request_cost * requests_per_day * (1 + retry_rate) * days
example = Rates(input_per_m=1.00, output_per_m=4.00) # chiffres d'illustration, pas des prix réels
cost = request_cost(example, input_tokens=1_500, output_tokens=400)
print(round(cost, 6)) # 0.0031
print(round(monthly_cost(cost, requests_per_day=50_000))) # 4650
Exemple chiffré avec ces tarifs d’illustration :
| Étape | Valeur |
|---|---|
| Entrée | 1 500 tokens × 1,00 / 1M = 0,0015 |
| Sortie | 400 tokens × 4,00 / 1M = 0,0016 |
| Coût par requête | 0,0031 |
| 50 000 requêtes/jour | 155 par jour |
| 30 jours | 4 650 par mois |
Notez que 400 tokens de sortie coûtent plus que 1 500 tokens d’entrée quand le tarif de sortie est plus élevé. La longueur de la sortie compte.
3. Utiliser des percentiles, pas seulement des moyennes
Quelques requêtes très longues (gros documents, longues conversations, boucles d’agents) peuvent dominer le coût.
SELECT DISTINCT
feature,
PERCENTILE_CONT(0.5) WITHIN GROUP (ORDER BY input_tokens + output_tokens) OVER (PARTITION BY feature) AS p50_tokens,
PERCENTILE_CONT(0.95) WITHIN GROUP (ORDER BY input_tokens + output_tokens) OVER (PARTITION BY feature) AS p95_tokens,
MAX(input_tokens + output_tokens) OVER (PARTITION BY feature) AS max_tokens
FROM llm_usage_log
WHERE requested_at >= DATEADD(day, -7, SYSUTCDATETIME());
Budgétez pour le p95, pas pour la requête moyenne.
4. Inclure nouvelles tentatives, escalades et tokens de raisonnement
Le coût réel par tâche réussie dépasse le coût par appel quand :
- une sortie invalide est relancée
- les cas en échec sont escaladés vers un modèle plus grand
- le modèle facture ses tokens de raisonnement comme sortie
- un agent fait plusieurs appels par demande utilisateur
cost_per_successful_task = total_cost_of_all_calls / tasks_completed_successfully
5. Vérifier le débit face aux limites
tokens_per_minute = requests_per_minute × average_tokens_per_request
requests_per_minute = trafic de pointe, pas la moyenne quotidienne
Comparez les deux avec les limites de requêtes et de tokens de votre fournisseur. Un rattrapage batch peut atteindre la limite de tokens par minute bien avant le budget de coût.
6. Fixer un budget de tokens par requête
Estimez l’entrée avant l’appel et réservez la place pour la sortie maximale :
class BudgetExceeded(Exception):
pass
def check_request_budget(estimated_input: int, max_output: int, request_budget: int) -> None:
worst_case = estimated_input + max_output
if worst_case > request_budget:
raise BudgetExceeded(f"la requête peut utiliser {worst_case} tokens ; le budget est de {request_budget}")
Quand la vérification échoue, réduisez le contexte (historique, récupération) avant l’appel, ou refusez avec une erreur claire.
7. Plafonner la sortie
- Fixez un plafond de tokens de sortie pour chaque appel.
- Dimensionnez-le d’après les longueurs observées plus une marge, pas d’après le maximum du modèle.
- Traitez une réponse tronquée comme un échec (JSON invalide, texte coupé) et journalisez-la.
8. Ajouter des budgets par utilisateur et par session
def remaining_tokens(daily_limit: int, used_today: int) -> int:
return max(daily_limit - used_today, 0)
Stockez l’usage par utilisateur et par session (par exemple dans une table indexée par utilisateur et date), vérifiez-le avant chaque appel et renvoyez un message clair quand le budget est épuisé. Cela limite aussi les abus sur les points d’accès publics.
9. Ajouter des budgets de workflow
Pour les pipelines et les agents, budgétez l’exécution, pas seulement l’appel :
- nombre maximal d’appels par exécution
- nombre maximal de tokens par exécution
- coût maximal par exécution
- condition d’arrêt quand le budget est atteint, avec sauvegarde des résultats partiels
class RunBudget:
def __init__(self, max_tokens: int, max_calls: int):
self.max_tokens, self.max_calls = max_tokens, max_calls
self.tokens = self.calls = 0
def charge(self, input_tokens: int, output_tokens: int) -> None:
self.calls += 1
self.tokens += input_tokens + output_tokens
if self.tokens > self.max_tokens or self.calls > self.max_calls:
raise BudgetExceeded(f"exécution arrêtée après {self.calls} appels et {self.tokens} tokens")
10. Choisir le niveau de modèle selon la tâche
| Tâche | Niveau habituel |
|---|---|
| Classification, étiquetage, extraction courte | Modèle plus petit et moins cher |
| Résumés de contenus à structure connue | Modèle petit ou intermédiaire |
| Raisonnement en plusieurs étapes, analyse ambiguë | Modèle plus grand ou modèle de raisonnement |
| Analyse déterministe, mise en forme, calcul | Pas de modèle : code, SQL ou règles |
Mesurez la qualité à chaque niveau : un modèle moins cher qui échoue souvent peut coûter plus par tâche réussie.
11. Séparer les charges batch et interactives
| Interactif | Batch | |
|---|---|---|
| Latence | Les secondes comptent | Minutes ou heures acceptables |
| Volume | Par pics | Important, planifiable |
| Leviers de coût | Prompts plus courts, modèles plus petits, cache | API batch quand elles existent, exécution hors pointe, lots plus gros par appel |
| Budget | Par utilisateur / session | Par exécution / par jour |
Exécutez les rattrapages et les jobs d’enrichissement comme des charges batch, avec leur propre budget.
12. Estimer l’effet de la mise en cache
expected_input_cost = (1 - hit_rate) × uncached_cost + hit_rate × cached_cost
- Le cache de résultats économise toute la requête en cas de succès, mais seulement si des entrées identiques se répètent.
- La mise en cache de prompt/préfixe, quand elle existe, réduit le coût des préfixes répétés ; règles et prix varient.
- Mesurez le taux de succès réel avant de compter les économies.
13. Superviser le coût en continu
Stockez le coût estimé avec chaque requête :
SELECT
CAST(requested_at AS date) AS usage_date,
feature,
SUM(input_tokens) AS input_tokens,
SUM(output_tokens) AS output_tokens,
SUM(estimated_cost) AS estimated_cost
FROM llm_usage_log
WHERE requested_at >= DATEADD(day, -30, SYSUTCDATETIME())
GROUP BY CAST(requested_at AS date), feature
ORDER BY usage_date, estimated_cost DESC;
Rapprochez régulièrement ces chiffres des données de facturation du fournisseur : votre estimation ne vaut que ce que vaut votre grille tarifaire.
Interpréter le résultat
| Signal | Signification probable |
|---|---|
| Le coût augmente plus vite que les requêtes | Les prompts, l’historique ou les sorties s’allongent |
| Le coût de sortie domine | Réponses verbeuses ou sans plafond |
| Une fonctionnalité domine | Optimisez ou budgétez-la en premier |
| p95 très au-dessus du p50 | Quelques requêtes longues pilotent le coût : plafonnez-les |
| Coût par tâche réussie très supérieur au coût par appel | Nouvelles tentatives ou escalades |
| L’estimation diffère de la facture | Grille tarifaire obsolète, appels non journalisés ou comptage des tokens en cache |
Points à vérifier
- Des requêtes sans plafond de tokens de sortie.
- Des fonctionnalités sans responsable ni budget.
- Des appels non journalisés (scripts, notebooks, expérimentations).
- Des rattrapages qui consomment les limites de l’interactif.
- Des rafales de nouvelles tentatives après un déploiement.
- Une grille tarifaire plus ancienne que la version actuelle du modèle.
Erreurs fréquentes
1. Coder les prix en dur
Les prix changent. Gardez-les dans la configuration, avec une version et une date d’effet.
2. Estimer à partir de la seule requête moyenne
Les requêtes de longue traîne et les boucles d’agents dominent la dépense réelle.
3. Ignorer les tokens de sortie
La sortie est souvent plus chère par token que l’entrée.
4. Oublier nouvelles tentatives et escalades
Le coût par appel n’est pas le coût par tâche réussie.
5. Budgéter uniquement au mois
Un job qui s’emballe peut dépenser le budget d’un mois en quelques heures. Utilisez des limites par exécution, par utilisateur et par jour.
6. Supposer que le cache fait toujours économiser
Il ne fait économiser que si les entrées ou préfixes se répètent, et certains fournisseurs facturent l’écriture en cache.
7. Prendre le modèle le moins cher sans mesurer la qualité
Les mauvaises réponses ont aussi un coût : reprises, escalades et perte de confiance.
Notes de production
- Tenez une grille tarifaire versionnée par modèle ; journalisez sa version avec chaque requête.
- Appliquez les budgets dans le code avant d’appeler le modèle, pas après la facture.
- Alertez sur le rythme de consommation quotidien et sur les pics inhabituels par fonctionnalité.
- Donnez à chaque fonctionnalité LLM un responsable et un budget.
- Séparez expérimentations et production (clés ou projets distincts) pour voir leurs coûts séparément.
- Revoyez le coût après chaque changement de prompt, de modèle ou de trafic.
- Journalisez les comptes de tokens et les coûts, pas les prompts bruts, quand ils contiennent des données sensibles.
Liste de contrôle
- Les tarifs viennent d’une configuration versionnée.
- Chaque requête journalise tokens d’entrée, de sortie et en cache, modèle et coût estimé.
- Chaque appel a un plafond de tokens de sortie.
- Des budgets existent par requête, par utilisateur/session et par exécution.
- Les tokens par minute en pointe respectent les limites du fournisseur.
- Le niveau de modèle est choisi par tâche et mesuré.
- Le batch est séparé de l’interactif.
- Le taux de succès du cache est mesuré avant d’annoncer des économies.
- Les estimations sont rapprochées de la facturation.
Ce contenu vous a-t-il été utile ?
Que pourrions-nous améliorer ?
Merci — cela m’aide à améliorer Javi Builds.
Restez au courant
Recevez uniquement les nouvelles de Javi Builds qui vous intéressent.
Consultez votre boîte de réception
Je vous ai envoyé un lien de confirmation. Votre abonnement sera actif après confirmation.