Combien coûte l'inférence LLM ? 4 scénarios décortiqués avec de vrais calculs

Combien coûte l'inférence LLM ? 4 scénarios décortiqués avec de vrais calculs

En mars 2023, GPT-4 coûtait 30 $ par million de tokens en entrée. Trois ans plus tard, GPT-5.6 traite le même million pour 10 $. Claude Opus 4.5 se situe à 15 $. Le plancher ? Deux centimes. Cela représente un écart de 1 500x entre l'option la moins chère et la plus coûteuse pour exactement la même unité de travail. Le coût d'inférence LLM, c'est la facture récurrente que vous payez chaque fois qu'un modèle entraîné lit votre entrée et génère une sortie, facturée au million de tokens par tous les grands fournisseurs. Les modèles économiques tournent entre 0,02 $ et 0,30 $ par million de tokens en entrée. Les modèles frontier facturent 15 $ à 75 $ pour le même volume. Cet écart compte, car c'est votre charge de travail, pas votre ambition, qui détermine la gamme dont vous avez réellement besoin.

À retenir :

• Les modèles économiques coûtent 0,02 $ à 0,30 $ par million de tokens en entrée ; les modèles frontier vont de 15 $ à 75 $ (juillet 2026).
• Les tokens en sortie coûtent 3 à 5 fois plus cher que les tokens en entrée, car la génération est séquentielle, pas parallèle.
• Un chatbot de support traitant 50 000 conversations coûte environ 9 $ à 420 $/mois selon la gamme du modèle.
• Les prix de l'inférence ont chuté d'environ 10x par an ; Gartner prévoit une baisse de 90 % d'ici 2030.

Quel est le coût d'inférence LLM par million de tokens ?

La tarification de l'inférence LLM suit une structure à trois niveaux en juillet 2026. Les modèles économiques de fournisseurs comme Google (Gemini 2.5 Flash) et les options open source (Llama 4, Qwen 3) facturent 0,02 $ à 0,30 $ par million de tokens en entrée. Les modèles de gamme intermédiaire (GPT-4.1, Claude Sonnet 4) se situent entre 0,55 $ et 15 $. Les modèles de raisonnement frontier (o3, Claude Opus 4.5) commandent 15 $ à 75 $. Chaque fournisseur publie ces tarifs sur ses pages officielles (OpenAI, Anthropic), et PricePerToken.com suit plus de 300 modèles dans une grille mise à jour en continu.

En juillet 2026, vous pouvez traiter un million de tokens en entrée pour deux centimes, ou payer soixante-quinze dollars pour le même million sur un modèle frontier.

Les remises sur les entrées en cache réduisent votre facture de 50 à 90 % sur les prompts répétés (la mise en cache des prompts réduit les coûts d'entrée explique le mécanisme). Pour la grille en direct de 300 modèles avec les tarifs actuels de chaque fournisseur, consultez notre tableau complet des prix par token.

Qu'est-ce qui détermine le coût d'inférence LLM ? Les 4 composantes

Votre facture d'inférence se décompose en quatre postes de coûts : le temps de calcul GPU par token, la mémoire pour les poids du modèle et le cache KV, l'asymétrie entrée/sortie qui rend la génération plus chère que la lecture, et les frais généraux d'infrastructure (électricité, refroidissement, réseau). Comprendre quelle composante domine votre charge de travail vous indique où l'optimisation est rentable.

Calcul : temps GPU par token

Chaque token traverse chaque couche du modèle. Un modèle de 70 milliards de paramètres en FP16 nécessite environ 140 GFLOPs par token. La quantification en INT4 ramène ce chiffre à environ 35 GFLOPs. Le guide de benchmarking d'inférence de NVIDIA détaille la formule complète du TCO : amortissement du matériel, électricité et frais généraux opérationnels, divisés par le nombre de tokens servis.

Mémoire : poids du modèle + cache KV

Un modèle de 70 milliards de paramètres en FP16 occupe environ 140 Go de VRAM rien que pour les poids. Le cache KV grossit avec la longueur du contexte et la taille des lots simultanés. Avec un contexte de 128K et 32 requêtes simultanées, vous pouvez consommer 80 Go supplémentaires. C'est pourquoi les besoins en VRAM par modèle pèsent autant dans les décisions d'auto-hébergement.

Asymétrie entre entrée et sortie

Les tokens en sortie coûtent 3 à 5 fois plus cher que les tokens en entrée parce que le modèle les génère un par un, dans l'ordre. Il ne peut pas paralléliser comme il le fait pour lire votre prompt.

Voici la version simple : la lecture de votre prompt de 2 000 tokens (la phase de « préremplissage ») traite tous les tokens simultanément sur les cœurs du GPU. La génération de 500 tokens en sortie (la phase de « décodage ») produit un token par étape, chacun dépendant du précédent. Le GPU reste largement inactif en attendant la bande passante mémoire entre les étapes. Ce temps d'inactivité, c'est ce que vous payez au tarif de sortie, 3 à 5 fois supérieur.

Frais généraux d'infrastructure

Électricité, refroidissement, réseau, et les GPU qui tournent à vide entre les requêtes. La documentation d'optimisation de Hugging Face explique comment le batching continu et le décodage spéculatif extraient davantage de tokens par heure-GPU du même matériel, réduisant directement cette part de frais généraux.

Quel est le coût d'inférence LLM pour 4 charges de travail réelles ?

Un chatbot de support typique coûte 9 $ à 420 $/mois, un pipeline RAG tourne entre 168 $ et 3 360 $/mois, un assistant de code pour 200 développeurs facture 123 $ à 2 078 $/mois, et le traitement de documents par lots se situe entre 240 $ et 6 400 $/mois. L'écart dépend presque entièrement du choix de la gamme de modèle. Nous avons construit ces quatre scénarios à partir des volumes de tokens de nos déploiements clients, tarifés sur les pages officielles de juillet 2026. Chaque chiffre ci-dessous est reproductible : les hypothèses de tokens multipliées par les tarifs publiés. Notre analyse, pas les affirmations des fournisseurs.

Chatbot de support client : 50 000 conversations/mois

Conversation moyenne : 800 tokens en entrée (prompt système + messages utilisateur + contexte récupéré), 400 tokens en sortie. Volume mensuel : 50 000 conversations = 40 millions de tokens en entrée, 20 millions en sortie.

• Choix économique (Gemini 2.5 Flash) : 40 M × 0,075 $/M + 20 M × 0,30 $/M = 9 $/mois. Presque suspectement bon marché.
• Choix intermédiaire (Claude Sonnet 4) : 40 M × 3 $/M + 20 M × 15 $/M = 420 $/mois.

Pour un bot de support traitant les tickets de niveau 1, le modèle économique gère correctement 90 % des requêtes. Routez les 10 % difficiles vers la gamme intermédiaire avec un classifieur.

Pipeline RAG : 10 000 requêtes/jour

Requête moyenne : 3 200 tokens en entrée (fragments récupérés + prompt système + question utilisateur), 600 tokens en sortie. Par mois : 300 000 requêtes = 960 millions de tokens en entrée, 180 millions en sortie.

• Choix économique (Llama 4 Scout via API) : 960 M × 0,10 $/M + 180 M × 0,40 $/M = 168 $/mois.
• Choix intermédiaire (GPT-4.1) : 960 M × 2 $/M + 180 M × 8 $/M = 3 360 $/mois.

La charge RAG est gourmande en entrée, donc les remises sur les entrées en cache frappent fort ici. Avec 70 % de mise en cache des prompts, la gamme intermédiaire tombe à environ 2 100 $/mois.

Assistant de code : 200 développeurs

Session moyenne : 4 500 tokens en entrée (contexte de fichiers + conversation), 1 200 tokens en sortie. Hypothèse : 15 requêtes/développeur/jour, 22 jours ouvrés = 66 000 requêtes/mois = 297 millions en entrée, 79 millions en sortie.

• Choix économique (Qwen 3 32B) : 297 M × 0,20 $/M + 79 M × 0,80 $/M = 123 $/mois.
• Choix intermédiaire (Claude Sonnet 4) : 297 M × 3 $/M + 79 M × 15 $/M = 2 078 $/mois.

Les développeurs repèrent vite les lacunes de qualité. Pour le code, la gamme intermédiaire est généralement le plancher. Les modèles économiques fonctionnent pour les suggestions de type autocomplétion, mais peinent sur les refactorisations multi-fichiers.

Traitement de documents par lots : 1 million de documents/mois

Document moyen : 2 000 tokens en entrée, 300 tokens en sortie (extraction, classification, synthèse). Par mois : 2 milliards en entrée, 300 millions en sortie.

• Choix économique (Gemini 2.5 Flash) : 2 Md × 0,075 $/M + 300 M × 0,30 $/M = 240 $/mois.
• Choix intermédiaire (GPT-4.1) : 2 Md × 2 $/M + 300 M × 8 $/M = 6 400 $/mois.

À ce volume, l'écart de prix de 27x entre les gammes représente une ligne budgétaire de 6 160 $/mois. Les modèles économiques gèrent bien l'extraction structurée. Pour le dimensionnement matériel si vous envisagez d'auto-héberger ce volume, consultez les besoins en VRAM par modèle.

def monthly_cost(input_tokens, output_tokens, requests, price_in, price_out):
    """Estimate monthly LLM inference cost.
    
    Args:
        input_tokens: avg input tokens per request
        output_tokens: avg output tokens per request
        requests: monthly request volume
        price_in: $/M input tokens
        price_out: $/M output tokens
    """
    total_in = input_tokens * requests / 1_000_000
    total_out = output_tokens * requests / 1_000_000
    return (total_in * price_in) + (total_out * price_out)

# Example: support chatbot on Claude Sonnet 4
cost = monthly_cost(
    input_tokens=800,
    output_tokens=400,
    requests=50_000,
    price_in=3.00,
    price_out=15.00
)
print(f"${cost:,.2f}/month")  # $420.00/month

API ou auto-hébergement : quand chacun gagne-t-il ?

L'API gagne en dessous d'environ 20 000 requêtes/jour ou quand votre équipe manque d'expérience en infrastructure ML. L'auto-hébergement gagne au-dessus de 200 000 requêtes/jour avec un taux d'utilisation GPU soutenu supérieur à 50 %. Le seuil de rentabilité, selon l'analyse d'Introl, se situe autour de 50 000 à 80 000 requêtes/jour pour un modèle de classe 70 milliards de paramètres sur un seul nœud H100. En dessous de ce seuil, l'efficacité multi-tenant du fournisseur d'API bat le calcul de votre matériel mono-tenant.

Quand l'API gagne

Vous livrez en jours, pas en semaines. Pas de salaire d'ingénieur ML (180 000 $ à 250 000 $/an), pas d'astreinte pour les pannes GPU, pas de planification de capacité. Pour la plupart des équipes de moins de 50 ingénieurs, l'API est le bon choix par défaut. Point final.

Quand l'auto-hébergement gagne

Vous avez dépassé 200 000 requêtes/jour, votre charge de travail est prévisible, et vous employez déjà des spécialistes en infrastructure ML. Les modèles open source (Llama 4, Qwen 3, Mistral) tournent sur votre matériel au coût de l'électricité plus l'amortissement. Les benchmarks vLLM vs SGLang montrent des écarts de débit de 15 à 30 % selon la forme de la charge de travail, ce qui compte à cette échelle.

Le seuil de rentabilité

L'auto-hébergement ne gagne qu'au-dessus d'environ 50 % d'utilisation GPU soutenue. En dessous, vous payez pour du silicium inactif. Les coûts humains cachés (temps d'ingénierie ML, astreintes, mises à jour de modèles, correctifs de sécurité) sont la vraie raison pour laquelle la plupart des équipes restent sur l'API même quand le calcul GPU brut semble favorable. Si vous vous auto-hébergez, déployer des modèles sur Modal supprime la couche de gestion d'infrastructure tout en gardant les coûts par token sous les tarifs API.

Les coûts cachés que personne ne budgétise

La dépense brute en tokens représente 60 à 80 % de votre facture réelle. Le reste se cache dans six lignes budgétaires qui n'apparaissent jamais dans un calculateur de prix. Prévoyez 20 à 40 % de plus en sus de votre estimation de tokens pour les couvrir.

• Outils de monitoring et d'observabilité : 200 $ à 1 500 $/mois. Tableaux de bord de consommation de tokens, suivi de latence, attribution des coûts par fonctionnalité. Un stack d'observabilité LLM se rembourse dès la première fois que vous détectez une régression de prompt avant qu'elle ne grille votre budget.
• Nouvelles tentatives et réexécutions après échec : 3 à 8 % des requêtes échouent ou nécessitent une nouvelle tentative (timeouts, limites de débit, sorties mal formées). C'est 3 à 8 % de votre facture de tokens, dépensés pour ne rien produire.
• Heures d'itération en prompt engineering : 20 à 60 heures par trimestre à 100 $-200 $/heure de coût d'ingénierie chargé. Chaque ajustement de prompt relance des lots de tests.
• Évaluation et tests de régression : 100 $ à 800 $/mois de dépense en tokens pour les suites d'évaluation automatisées. Vous payez le modèle pour qu'il se note lui-même.
• Redondance multi-régions : 1,5 à 2 fois le coût d'infrastructure si vous avez besoin d'un basculement entre régions pour la latence ou la conformité.
• Pénalités de latence au démarrage à froid : Les déploiements GPU serverless (Modal, AWS Lambda) facturent le temps d'inactivité. Les démarrages à froid ajoutent 2 à 8 secondes et vous facturent la montée en température.

La règle empirique : multipliez votre estimation brute de tokens par 1,3 pour un budget réaliste. Multipliez par 1,4 si vous êtes dans un secteur réglementé avec des frais de conformité.

Pourquoi l'inférence LLM ne cesse-t-elle de devenir moins chère ?

Les prix de l'inférence LLM ont chuté d'environ 10x par an depuis 2023. Une charge de travail qui coûtait 1 000 $/mois en 2024 coûte aujourd'hui environ 100 $. Trois forces conduisent cette baisse : les améliorations matérielles (NVIDIA Blackwell FP4, Google TPU v6), la pression concurrentielle (DeepSeek, les modèles open source qui déclenchent des guerres de prix), et l'optimisation logicielle (décodage spéculatif, batching continu, quantification). Gartner prévoit que les coûts d'inférence baisseront encore de 90 % d'ici 2030, même si c'est une projection, pas une garantie.

Le suivi des prix d'Epoch AI documente cette baisse avec des données concrètes. L'analyse « LLMflation » d'a16z a forgé le terme et cadré les implications économiques : l'inférence se déprécie plus vite que toute catégorie de calcul antérieure.

Coût d'entraînement vs coût d'inférence

Entraîner un modèle frontier coûte 50 M$ à 200 M$ (une seule fois). L'inférence pour ce même modèle, tous utilisateurs confondus, coûte 5 M$ à 50 M$ par an selon l'échelle. Pour la plupart des équipes, le rapport est de 10 à 100x : l'entraînement coûte 10 à 100 fois ce que coûte une année d'inférence. Mais l'entraînement est une dépense d'investissement ponctuelle. L'inférence est la facture d'exploitation récurrente qui croît avec le nombre d'utilisateurs. Vous ne payez pas l'entraînement, sauf si vous construisez un modèle de fondation. Vous payez l'inférence chaque jour.

La ligne budgétaire énergie

Un NVIDIA H100 consomme environ 700 W en charge. À 0,10 $/kWh (moyenne américaine), cela fait 0,07 $ par heure-GPU. Un modèle de 70 milliards de paramètres sur un seul H100 génère environ 2 000 tokens en sortie/seconde en lot. Sur une heure : 7,2 millions de tokens. Coût électrique par million de tokens en sortie : environ 0,01 $. Notre calcul, étiqueté comme tel. L'énergie représente 1 à 3 % de votre facture API mais 8 à 15 % du TCO en auto-hébergement. Elle pèse davantage si vous exploitez vos propres GPU dans une région où l'électricité est chère (l'Allemagne à 0,30 $/kWh triple ce chiffre).

L'enseignement pratique : les prix baissent assez vite pour qu'un engagement de 12 mois sur une gamme de modèle précise soit risqué. Réévaluez chaque trimestre. Les 12 façons de réduire votre facture LLM couvrent les manœuvres tactiques que vous pouvez mener dès maintenant pendant que la tendance macro fait le gros du travail.

Comment estimer VOTRE coût d'inférence ?

Estimez votre coût d'inférence LLM mensuel en quatre étapes : comptez les tokens par requête, multipliez par le volume mensuel, appliquez le tarif de la gamme, puis ajoutez 20 à 40 % de frais généraux. D'après notre expérience de dimensionnement de budgets d'inférence pour des clients, la plupart des équipes sautent l'étape quatre et se demandent pourquoi leur facture réelle dépasse l'estimation d'un tiers. Voici le processus que nous utilisons.

1. Comptez les tokens par requête. Enregistrez vos moyennes de tokens en entrée (prompt système + contexte + message utilisateur) et en sortie (réponse du modèle) sur plus de 100 requêtes réelles. Ne devinez pas. Mesurez.
2. Multipliez par le volume mensuel. Requêtes/jour × 30 = requêtes mensuelles. Multipliez par vos comptes de tokens par requête.
3. Appliquez le tarif de la gamme. Multipliez le total des tokens en entrée par le tarif $/M en entrée du modèle. Idem pour la sortie. Additionnez.
4. Ajoutez 20 à 40 % de frais généraux. Nouvelles tentatives, évaluations, itération sur les prompts, monitoring. C'est ce chiffre qui va dans votre budget, pas l'étape 3.

def estimate_monthly_budget(avg_input_tokens, avg_output_tokens,
                            requests_per_day, price_in, price_out,
                            overhead_pct=0.30):
    """Full monthly budget estimate with overhead."""
    monthly_requests = requests_per_day * 30
    raw_cost = monthly_cost(
        avg_input_tokens, avg_output_tokens,
        monthly_requests, price_in, price_out
    )
    return raw_cost * (1 + overhead_pct)

# RAG pipeline: 10K queries/day on GPT-4.1
budget = estimate_monthly_budget(
    avg_input_tokens=3200,
    avg_output_tokens=600,
    requests_per_day=10_000,
    price_in=2.00,
    price_out=8.00,
    overhead_pct=0.30
)
print(f"${budget:,.0f}/month")  # $4,368/month

Une fois votre chiffre établi, les outils de gateway LLM routent le trafic vers le modèle le moins cher qui satisfait votre barre de qualité. Une gateway avec sélection de modèle par requête peut réduire votre coût mixte de 30 à 50 % sans toucher à vos prompts.

Questions fréquemment posées

L'inférence LLM est-elle coûteuse ?

Cela dépend de l'échelle et du choix de modèle. Un million de tokens en entrée coûte 0,02 $ sur Gemini 2.5 Flash ou 75 $ sur un modèle de raisonnement frontier. Pour une petite application traitant 10 000 requêtes/jour, comptez 50 $ à 400 $/mois. Pour des charges d'entreprise à plus d'un million de requêtes/jour, les budgets vont de 5 000 $ à 40 000 $/mois. Le coût unitaire est faible ; le volume fait grimper l'addition.

Combien représente 1 million de tokens en LLM ?

Un million de tokens équivaut à environ 750 000 mots, soit une dizaine de romans complets. En juillet 2026, traiter 1 million de tokens en entrée coûte 0,02 $ (gamme économique) à 75 $ (gamme frontier). Les tokens en sortie pour le même volume vont de 0,06 $ à 300 $. La plupart des charges de production se situent dans la gamme intermédiaire : 2 $ à 15 $ par million de tokens en entrée.

Pourquoi l'inférence IA est-elle si chère ?

L'inférence exige de faire passer chaque token à travers des milliards de paramètres de modèle sur des GPU qui coûtent 25 000 $ à 40 000 $ pièce. La phase de décodage génère les tokens séquentiellement, laissant les cœurs GPU inactifs entre les étapes. Vous payez pour du matériel spécialisé, l'électricité, le refroidissement, et l'équipe d'ingénieurs du fournisseur qui maintient la stack de service en fonctionnement 24h/24, 7j/7.

Les coûts d'inférence IA baissent-ils ?

Oui, d'environ 10x par an depuis 2023. GPT-4 a été lancé à 30 $/60 $ par million de tokens (entrée/sortie). Une capacité équivalente coûte aujourd'hui 2 $ à 10 $. Les données d'Epoch AI confirment cette trajectoire chez tous les fournisseurs. Gartner prévoit encore 90 % de baisse d'ici 2030, portée par les améliorations matérielles et la pression concurrentielle des modèles open source.

Quel est le coût d'inférence LLM en 2026 ?

Modèles économiques : 0,02 $ à 0,30 $ par million de tokens en entrée. Gamme intermédiaire : 0,55 $ à 15 $. Frontier : 15 $ à 75 $. Une charge de production typique (chatbot de support, pipeline RAG ou assistant de code) coûte 150 $ à 4 000 $/mois sur des modèles de gamme intermédiaire. Les modèles économiques gèrent les tâches à gros volume et faible complexité pour 10 à 30 fois moins cher.

Quelle est la différence entre coût d'entraînement et coût d'inférence ?

L'entraînement est la dépense ponctuelle pour apprendre un modèle à partir de zéro : 50 M$ à 200 M$ pour un modèle frontier, nécessitant des milliers de GPU pendant des mois. L'inférence est le coût récurrent d'utilisation de ce modèle entraîné : faire passer des entrées pour obtenir des sorties, facturé au token. Pour la plupart des équipes, l'inférence est la seule facture qu'elles paient. L'entraînement concerne les entreprises qui construisent des modèles de fondation.

Comment calculer le coût d'inférence LLM pour mon application ?

Multipliez la moyenne de tokens en entrée par requête par votre volume mensuel de requêtes, puis par le tarif $/M en entrée du modèle. Répétez pour les tokens en sortie. Additionnez les deux. Ajoutez 30 % pour les nouvelles tentatives, les évaluations et les frais généraux de monitoring. Les extraits Python de cet article automatisent le calcul. Mesurez les vrais comptes de tokens plutôt que deviner ; les journaux de plus de 100 requêtes donnent une moyenne fiable.

Les tokens en sortie coûtent-ils plus cher que les tokens en entrée ?

Oui, généralement 3 à 5 fois plus. Le traitement en entrée (préremplissage) parallélise sur tous les tokens simultanément, utilisant pleinement les cœurs GPU. La génération en sortie (décodage) produit un token à la fois, chacun dépendant du précédent. Le GPU attend la bande passante mémoire entre les étapes. Les fournisseurs tarifent la sortie plus haut pour refléter cette efficacité matérielle moindre.

L'inférence auto-hébergée est-elle moins chère que l'API ?

Uniquement au-dessus d'environ 200 000 requêtes/jour avec un taux d'utilisation GPU soutenu supérieur à 50 %. En dessous, l'efficacité multi-tenant des fournisseurs d'API bat votre matériel mono-tenant. L'auto-hébergement ajoute aussi des coûts cachés : salaires d'ingénieurs ML (180 000 $ à 250 000 $/an), astreintes, mises à jour de modèles et correctifs de sécurité. La plupart des équipes de moins de 50 ingénieurs devraient rester sur l'API.

L'inférence LLM consomme-t-elle beaucoup d'énergie ?

Un GPU H100 consomme environ 700 W en charge. À 0,10 $/kWh, cela fait 0,07 $/heure-GPU, soit environ 0,01 $ par million de tokens en sortie pour un modèle de 70 milliards de paramètres. L'énergie représente 1 à 3 % d'une facture API mais 8 à 15 % du TCO en auto-hébergement. Dans les régions où l'électricité est chère (Allemagne, 0,30 $/kWh), la part de l'énergie triple et affecte sensiblement l'économie de l'auto-hébergement.

L'essentiel à retenir

Quatre chiffres à mémoriser : 0,02 $ (plancher économique par million de tokens en entrée), 3 à 5x (prime de sortie par rapport à l'entrée), 20 à 40 % (frais généraux à ajouter au calcul brut des tokens), et 10x (baisse annuelle des prix depuis 2023). Votre facture réelle dépend du volume, de la gamme de modèle, et de l'agressivité avec laquelle vous mettez en cache, regroupez en lots et routez le trafic.

Chez Techsy, notre équipe dimensionne des budgets d'inférence et choisit des gammes de modèles pour des clients B2B qui exploitent des charges LLM en production. Si vous voulez un second regard sur votre modèle de coûts, obtenez une consultation gratuite.