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é APIPoints 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ôle | Entrée | Sortie | Coût d'entrée | Coût de sortie | Total |
|---|---|---|---|---|---|
| Réponse courte de chat | 2 000 | 500 | $0,0003 | $0,00025 | $0,00055 |
| Réponse du bot de support | 1 500 | 400 | $0,000225 | $0,0002 | $0,000425 |
| Chapitre d'histoire | 1 000 | 3 000 | $0,00015 | $0,0015 | $0,00165 |
| Résumé de long document | 80 000 | 2 000 | $0 012 | $0 001 | $0 013 |
| Fenêtre de contexte presque pleine | 98 000 | 2 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)) # 47058JavaScript
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.0130Remplacez 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.
- 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 $.
- Élaguer l'historique. Conservez les derniers tours plus un résumé court en cours plutôt que tout le journal.
- Définissez
max_tokens. Il limite le côté sortie, qui a le taux le plus élevé. - 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.
