Calculateur de coût API : tokens, cache et volume de requêtes

Quelles données faut-il au calculateur ?

Pour l'API texte, préparez sept entrées :

input_tokens_per_call
output_tokens_per_call
cache_write_tokens_per_miss
cache_read_tokens_per_hit
calls
cache_hit_rate
prices_per_1m_tokens

Vous voulez confronter la prévision à un appel réel ? Créez un compte BetterToken et une API Key, relevez les tarifs actuels sur la page de prix, puis faites une requête contrôlée. Comparez ensuite le modèle, le statut, l'input, l'output, les cache tokens applicables et la consommation dans le Dashboard : cela révèle les hypothèses à corriger.

Le caching varie selon le modèle et le protocole. Avant de remplir les champs, consultez la référence API BetterToken, OpenAI Prompt Caching ou Anthropic Prompt Caching.

Formule universelle

Notations :

I  — tokens d'input réguliers
O  — tokens d'output
W  — tokens de cache write / création
R  — tokens de cache read / mis en cache
Pi — prix d'input par 1 000 000 tokens
Po — prix d'output par 1 000 000 tokens
Pw — prix de cache write par 1 000 000 tokens
Pr — prix de cache read par 1 000 000 tokens

Coût d'un appel :

C = I / 1_000_000 × Pi
  + O / 1_000_000 × Po
  + W / 1_000_000 × Pw
  + R / 1_000_000 × Pr
  + Cextra

Cextra désigne les unités facturées à part : recherche web, images, audio, stockage, tools ou autres opérations. S'il n'y en a pas, la valeur vaut zéro. Si vous ignorez si un coût s'ajoute, laissez le champ inconnu et vérifiez la documentation ; zéro créerait une fausse précision.

L'erreur manuelle principale consiste à oublier la division par un million. Pour un prix par 1 000 000 tokens, divisez d'abord les tokens par 1_000_000, puis multipliez par le tarif.

Calculateur Python à copier

Ce script ne contient ni prix ni API Key. Il demande les valeurs et calcule un scénario. Le résultat utilise la même devise que les tarifs saisis.

from decimal import Decimal, InvalidOperation

MILLION = Decimal("1000000")

def read_decimal(label: str, *, allow_empty: bool = False) -> Decimal:
    raw = input(label).strip().replace(",", ".")
    if allow_empty and raw == "":
        return Decimal("0")
    try:
        value = Decimal(raw)
    except InvalidOperation as exc:
        raise SystemExit(f"Invalid number for {label!r}") from exc
    if value < 0:
        raise SystemExit(f"Negative value is not allowed for {label!r}")
    return value

input_tokens = read_decimal("Input tokens per call: ")
output_tokens = read_decimal("Output tokens per call: ")
cache_write_tokens = read_decimal("Cache write tokens per call: ")
cache_read_tokens = read_decimal("Cache read tokens per call: ")
calls = read_decimal("Number of calls: ")

price_input = read_decimal("Input price per 1M tokens: ")
price_output = read_decimal("Output price per 1M tokens: ")
price_cache_write = read_decimal("Cache write price per 1M tokens: ")
price_cache_read = read_decimal("Cache read price per 1M tokens: ")
extra_per_call = read_decimal("Extra cost per call (empty = 0): ", allow_empty=True)

per_call = (
    input_tokens / MILLION * price_input
    + output_tokens / MILLION * price_output
    + cache_write_tokens / MILLION * price_cache_write
    + cache_read_tokens / MILLION * price_cache_read
    + extra_per_call
)
total = per_call * calls

print(f"Cost per call: {per_call:.8f}")
print(f"Total cost:    {total:.8f}")
Afficher plus

Enregistrez le code sous api_cost_calculator.py et exécutez :

python3 api_cost_calculator.py

N'entrez pas de tokens réels dans les champs cache write/read si l'endpoint actuel ne sépare pas ces catégories. Transformez d'abord son usage en groupes mutuellement exclusifs pour ne pas compter le même token deux fois.

Tenir compte du taux de cache hit

Pour une série de requêtes, séparez les cache hits et les misses :

N     — nombre total d'appels
h     — taux de cache hit de 0 à 1
Nhits — N × h
Nmiss — N - Nhits
Chit  — coût d'un appel avec cache read
Cmiss — coût d'un appel sans hit ou avec cache write

Résultat :

Ctotal = Nhits × Chit + Nmiss × Cmiss + Cextra_total

Pour la planification, arrondissez Nhits vers le bas et Nmiss vers le haut. Dans les logs réels, utilisez le nombre effectif de chaque type d'appel.

Trois scénarios plutôt qu'un seul chiffre

Scénario de base

Utilisez l'input et l'output médians des tâches récentes, le nombre d'appels attendu et le taux de cache hit observé. Sans historique, indiquez clairement qu'il s'agit d'hypothèses.

Scénario favorable

Long préfixe stable, taux de cache hit élevé, output limité et aucune erreur répétée. Il indique une borne basse, mais ne doit pas devenir une promesse budgétaire.

Pire cas

Ajoutez des cache misses, un output long, un retry limité et les tools facturés séparément. N'augmentez pas arbitrairement tous les paramètres : chaque hypothèse doit répondre à un risque réel du processus.

Consignez les résultats dans une feuille simple :

scenario, calls, hit_rate, input, output, write, read, extra, total
base,     ...,   ...,      ...,   ...,    ...,   ...,  ...,   ...
low,      ...,   ...,      ...,   ...,    ...,   ...,  ...,   ...
high,     ...,   ...,      ...,   ...,    ...,   ...,  ...,   ...

Évaluer un workflow d'agent

Une exécution visible d'agent n'équivaut pas toujours à un appel de modèle. Elle peut contenir planning, tool call, tool result, retry et réponse finale. Procédez ainsi :

1. réalisez une tâche de test sûre ;
2. comptez les appels API effectifs ;
3. groupez-les par modèle et catégorie d'usage ;
4. appliquez la formule à chaque groupe ;
5. ajoutez séparément les unités de tool ou de recherche ;
6. comparez le montant au Dashboard.

Ne multipliez pas le coût d'un appel arbitraire par le nombre d'utilisateurs si les longueurs de requête varient beaucoup. Utilisez plutôt plusieurs classes : question courte, revue de fichier, tâche d'agent.

Vérifier une prévision avec le réel

Après l'appel de test, rapprochez :

• heure et request status ;
• Model ID ;
• tokens d'input et d'output ;
• catégorie de cache ;
• nombre de retries ;
• consommation réelle ;
• devise et date du prix.

Un écart révèle généralement un tarif incorrect, un double comptage des cached tokens, un retry masqué ou une transaction facturable supplémentaire. Pour BetterToken, utilisez la page de prix actuelle, puis contrôlez l'entrée réelle du Dashboard ; ne recopiez pas d'anciens prix.

Limites du calculateur

La formule ne couvre que les catégories connues. Elle ne prédit ni changements de tarifs, ni prix futurs, ni routage dynamique, ni nombre d'étapes d'agent. Images, audio, recherche web, stockage et certains tools peuvent utiliser leurs propres unités.

Elle ne mesure pas non plus la qualité d'une réponse. Un appel moins cher qui doit être répété manuellement peut coûter davantage sur l'ensemble de la tâche ; cela se mesure par une expérience, pas avec un coefficient inventé.

FAQ

Que saisir si le cache n'est pas utilisé ?

Mettez cache write et cache read à zéro uniquement si l'endpoint n'a réellement pas utilisé de cache. Si la valeur est inconnue, vérifiez d'abord l'usage.

Dans quelle devise le résultat est-il affiché ?

Le résultat utilise la devise des tarifs et de extra_per_call saisis. Ne mélangez pas dollars et roubles sans taux de change explicite et daté.

Les cached tokens sont-ils inclus dans les input tokens ?

Cela dépend de la forme d'usage de l'API concernée. Consultez la documentation et transformez les champs en catégories mutuellement exclusives afin d'éviter le double comptage.

Comment calculer le coût mensuel ?

Calculez d'abord le coût d'une classe de tâches, puis multipliez par le nombre réel ou prévu d'appels. Créez des lignes séparées pour différents modèles et tâches, puis additionnez-les.

Pourquoi le débit réel est-il supérieur à l'estimation ?

Vérifiez l'output, les retries, les étapes d'agent, les cache misses et les tools supplémentaires. Rapprochez chaque ligne d'usage du Dashboard, pas seulement le total.