FR ▾

Calculateur de coût des tokens LLM : Formule et exemples

Un calculateur de coût des tokens LLM ne nécessite que deux nombres par requête, les tokens d'entrée et les tokens de sortie, et deux tarifs : 0,15 $ et 0,50 $ par 1M. Cette page vous donne la formule, le code à copier-coller et des exemples détaillés que vous pouvez vérifier à la main.

Mis à jour le

Calculatrice en verre avec des piles de cubes de tokens lumineux alimentant une balance

Aucune carte nécessaire. Après la connexion, réclamez 0,50 $ de crédit d'essai gratuit en un clic (une fois par personne).

Obtenir une clé API

Points clés

  • Coût = tokens d'entrée / 1 000 000 x $0,15 + tokens de sortie / 1 000 000 x $0,50.
  • Un prompt typique de 1 500 tokens avec une réponse de 400 tokens coûte $0,000425, donc $20 couvrent environ 47 000 requêtes de ce type.
  • L'historique de chat est renvoyé à chaque tour, donc les tokens d'entrée augmentent plus vite que la plupart des gens ne le pensent.
  • L'API renvoie les comptes exacts de tokens et votre solde, vous pouvez donc vérifier toute estimation.

La formule

Chaque requête sur cette API est facturée à partir de deux compteurs, et rien d'autre :

coût = tokens_d_entrée / 1 000 000 x 0,15 + tokens_de_sortie / 1 000 000 x 0,50

Les tokens d'entrée sont tout ce que vous envoyez : prompt système, historique de chat, documents collés et définitions d'outils. Les tokens de sortie sont ce que le modèle écrit en retour. Les tarifs sont de 0,15 $ par 1M de tokens d'entrée et de 0,50 $ par 1M de tokens de sortie. La sortie coûte un peu plus de trois fois le tarif d'entrée, donc une longue réponse coûte plus cher qu'un long prompt de même taille.

Il n'y a pas d'abonnement ni de prix par siège. Vous utilisez votre crédit prépayé, et le crédit n'expire jamais. Les requêtes échouées ou refusées ne sont pas facturées, donc votre calcul doit seulement couvrir les requêtes réussies.

Exemples détaillés vérifiables manuellement

Voici cinq tâches courantes, chacune calculée à partir de la formule. Utilisez-les comme repères pour estimer votre propre charge de travail.

RôleEntréeSortieCoût d'entréeCoût de sortieTotal
Réponse courte de chat2 000500$0,0003$0,00025$0,00055
Réponse du bot de support1 500400$0,000225$0,0002$0,000425
Chapitre d'histoire1 0003 000$0,00015$0,0015$0,00165
Résumé de long document80 0002 000$0 012$0 001$0 013
Fenêtre de contexte presque pleine98 0002 000$0,0147$0 001$0,0157

Le motif est facile à voir. Les tâches courtes coûtent une fraction de centime. Même une requête qui remplit presque la fenêtre de 100 000 tokens reste sous deux centimes. Ce qui s'accumule, c'est le volume, pas la taille.

Prenons la ligne du bot de support. À $0,000425 par requête, $20 de crédit paient environ 47 000 requêtes ($20 / $0,000425 = 47 058). Si vous gérez 30 000 requêtes de ce type par mois, la facture est de 30 000 x $0,000425 = $12,75.

Un calculateur à coller

Vous n'avez pas besoin d'un formulaire web pour cela. Quelques lignes de code font l'affaire et peuvent vivre dans vos propres outils.

Python

INPUT_PER_M = 0.15
OUTPUT_PER_M = 0.50

def cost_usd(input_tokens: int, output_tokens: int) -> float:
    return (input_tokens / 1_000_000) * INPUT_PER_M + (output_tokens / 1_000_000) * OUTPUT_PER_M

def requests_per_budget(budget_usd: float, input_tokens: int, output_tokens: int) -> int:
    return int(budget_usd / cost_usd(input_tokens, output_tokens))

print(f"{cost_usd(1500, 400):.6f}")           # 0.000425
print(requests_per_budget(20, 1500, 400))     # 47058

JavaScript

const IN_PER_M = 0.15;
const OUT_PER_M = 0.5;

const costUsd = (inputTokens, outputTokens) =>
  (inputTokens / 1e6) * IN_PER_M + (outputTokens / 1e6) * OUT_PER_M;

console.log(costUsd(80000, 2000).toFixed(4)); // 0.0130

Remplacez par vos propres moyennes. Si vous ne les connaissez pas encore, envoyez une centaine de requêtes réelles et faites la moyenne des nombres de tokens qui reviennent, comme indiqué dans la dernière section.

Charges de travail lourdes en entrée et en sortie

Les deux taux diffèrent, donc la forme de votre tâche compte autant que sa taille. Comparez deux charges de travail avec le même nombre de requêtes, 10 000 chacune.

  • Classification. Chaque requête envoie 3 000 tokens (instructions plus un texte à étiqueter) et reçoit 20 tokens en retour. Coût par requête : 3 000 / 1 000 000 x $0,15 = $0,00045, plus 20 / 1 000 000 x $0,50 = $0,00001, soit $0,00046. Pour 10 000 requêtes, cela fait $4,60.
  • Génération. Chaque requête envoie 300 tokens et reçoit 2 000 en retour. Coût par requête : $0,000045 pour l'entrée plus $0,001 pour la sortie, soit $0,001045. Pour 10 000 requêtes, cela fait $10,45.

La tâche de génération envoie un dixième de l'entrée et coûte tout de même plus du double, car les tokens de sortie dominent la facture. Pour les outils d'écriture, limitez la longueur de la réponse si possible. Pour les tâches d'extraction et d'étiquetage, réduisez le prompt et les instructions répétées.

Une tâche par lots, du début à la fin

Imaginons que vous deviez traiter 500 documents, chacun d'environ 6 000 tokens, et que vous souhaitiez un résumé de 500 tokens pour chacun. Entrée : 500 x 6 000 = 3 000 000 tokens, ce qui coûte 3 x 0,15 $ = 0,45 $. Sortie : 500 x 500 = 250 000 tokens, ce qui coûte 0,25 x 0,50 $ = 0,125 $. Le lot entier coûte 0,575 $. Avec une clé complète, vous pouvez exécuter 8 requêtes simultanément, ce qui permet de terminer la tâche rapidement ; une clé d'essai permet 2 requêtes à la fois.

Où les estimations se trompent : l'historique croissant

L'erreur la plus courante dans une estimation de coût est de traiter un chat comme une série de messages indépendants. Ce n'est pas le cas. Un modèle de chat n'a pas de mémoire, donc chaque tour renvoie toute la conversation jusqu'alors. Le côté entrée de la facture augmente avec chaque tour.

Voici un cas concret. Une session de jeu de rôle a un prompt système de 500 tokens. À chaque tour, l'utilisateur écrit 100 tokens et le modèle répond avec 300. Sur 20 tours, l'entrée pour le tour n est 500 + 400 x (n - 1) + 100 tokens.

  • Le tour 1 envoie 600 tokens, le tour 2 envoie 1 000, le tour 20 envoie 8 200.
  • Total des entrées sur 20 tours : 20 x 600 + 400 x (0 + 1 + ... + 19) = 12 000 + 400 x 190 = 88 000 tokens.
  • Total des sorties : 20 x 300 = 6 000 tokens.
  • Coût : 88 000 / 1 000 000 x $0,15 = $0,0132, plus 6 000 / 1 000 000 x $0,50 = $0,003, soit $0,0162.

Si vous aviez naïvement compté uniquement les nouveaux tokens (2 000 entrants, 6 000 sortants), vous auriez estimé 0,0033 $. Le chiffre réel est près de cinq fois supérieur. La solution est simple : modélisez l'historique dans votre estimation, ou limitez-le en élaguant les anciens tours. Dans les deux cas, la ligne d'entrée est celle à surveiller dans les longues conversations.

Moyens bon marché pour réduire le nombre

Si l'estimation semble plus élevée que prévu, il n'y a que quelques leviers, et chacun correspond directement à la formule.

  1. Raccourcissez le prompt système. Il est facturé à chaque appel. Réduire de 2 000 tokens à travers 100 000 requêtes supprime 200 000 000 de tokens d'entrée, soit 200 x 0,15 $ = 30 $.
  2. Élaguer l'historique. Conservez les derniers tours plus un résumé court en cours plutôt que tout le journal.
  3. Définissez max_tokens. Il limite le côté sortie, qui a le taux le plus élevé.
  4. Envoyez moins de contexte. Récupérez les deux paragraphes pertinents au lieu du fichier entier.

Aucune de ces méthodes ne nécessite un modèle différent ou un plan différent. Ce sont des modifications de vos propres prompts.

Transformer le coût par requête en budget

Une fois que vous connaissez le coût d'une requête typique, la planification est une multiplication. Notez trois nombres : requêtes par jour, tokens d'entrée moyens, tokens de sortie moyens. Calculez le coût quotidien avec la fonction ci-dessus, puis multipliez par 30.

Pour les recharges, les chiffres utiles sont les suivants. Tout montant entier de $20 à $500 convient. Le bonus ajoute du crédit sur les montants plus élevés : +5% à partir de $50 donne $52,50, +10% à partir de $100 donne $110, et +15% à partir de $200 donne $230. Le taux par token ne change jamais, vous recevez simplement plus de crédit pour le même paiement. Vous pouvez payer avec de la crypto (USDT sur TRC20, USDC sur Base). Le paiement par carte n'est plus disponible.

Gardez une marge. Le trafic réel est plus irrégulier qu'une moyenne, et une seule fonctionnalité qui envoie soudainement de longs documents peut doubler vos tokens d'entrée. La page tarifs présente les taux actuels et les options de rechargement en un seul endroit.

Une projection mensuelle

Supposons qu'un assistant de support gère 2 000 conversations par jour, une requête chacune, avec le profil d'entrée de 1 500 tokens et de sortie de 400 tokens du tableau. Le coût quotidien est de 2 000 x $0,000425 = $0,85. Sur un mois de 30 jours, cela fait $25,50. Une recharge de $50, qui bénéficie du bonus +5% et donne $52,50 de crédit, durerait un peu plus de deux mois à ce rythme. Refaites la somme avec vos propres moyennes et ajoutez la marge de croissance avant de choisir un montant de recharge.

Vérifiez votre estimation par rapport aux chiffres réels

Une estimation n'est bonne que si ses entrées le sont, alors mesurez. Chaque réponse inclut un objet usage avec les nombres de tokens réels du prompt et de la complétion. Les en-têtes de réponse incluent également X-Balance-USD, votre crédit restant après la requête, ce qui vous permet de confirmer le coût au cent près.

from openai import OpenAI

client = OpenAI(base_url="https://api.llmtokenprices.com/v1", api_key="YOUR_API_KEY")

raw = client.chat.completions.with_raw_response.create(
    model="uncensored",
    messages=[{"role": "user", "content": "Write two sentences about the sea."}],
)
r = raw.parse()
print("balance:", raw.headers.get("X-Balance-USD"))
print(r.usage.prompt_tokens, r.usage.completion_tokens)

Exécutez un lot de requêtes représentatives, additionnez les chiffres d'utilisation et comparez avec la baisse du solde. Si les deux concordent, votre calculateur est juste et vous pouvez planifier avec. Si vous n'avez pas encore de clé, la page clé API offre 0,50 $ de crédit d'essai gratuit après l'inscription, ce qui est largement suffisant pour ce test. Les détails de configuration sont dans le démarrage rapide.

Questions et réponses

Y a-t-il un abonnement ou des frais mensuels ?

Non. Vous payez à l'usage à partir d'un crédit prépayé à 0,15 $ par 1M de tokens d'entrée et 0,50 $ par 1M de tokens de sortie.

Les requêtes échouées sont-elles facturées ?

Non. Les requêtes échouées ou refusées ne sont pas facturées.

Le crédit expire-t-il ?

Non. Le crédit n'expire jamais, et il n'y a pas d'abonnement.

Comment les bonus modifient-ils le calcul ?

Les bonus ajoutent du crédit, pas une réduction sur le tarif. Un rechargement de 100 $ donne 110 $ de crédit, un rechargement de 200 $ donne 230 $, et le prix par token reste le même.

Votre clé n'est qu'à un formulaire d'ici

Créez un compte, copiez la clé, modifiez l'URL de base. C'est toute la configuration.

Obtenir une clé API