Comment fonctionne vraiment la facturation de l'API Anthropic

Réponse rapide : ce qui est réellement facturé

Anthropic facture l'API Claude par token, en mode prépayé. Vous achetez des crédits dans la console développeur, et chaque requête ponctionne ce solde sur trois compteurs : les tokens d'entrée (tout ce que vous envoyez), les tokens de sortie (tout ce que le modèle génère, y compris les tokens de réflexion), et le trafic de cache de prompt (les écritures sont facturées à 1.25x le tarif d'entrée, les lectures à 0.1x). Il n'existe pas d'abonnement pour l'API elle-même, et un abonnement Claude Pro ou Max n'inclut aucun crédit API. La sortie est le compteur le plus coûteux. Claude Sonnet 4.6 est affiché à $3.00 par million de tokens d'entrée et $15.00 par million de tokens de sortie, soit un écart de 5x. Claude Opus 4.7 est affiché à $5.00 en entrée et $25.00 en sortie. Si votre facture est plus élevée que prévu, vérifiez d'abord le volume de sortie et la croissance de l'historique de conversation avant toute autre chose.

Les trois compteurs : tokens d'entrée, de sortie et de cache

L'entrée couvre bien plus que le message de l'utilisateur. Le prompt système, l'historique complet de la conversation, les définitions d'outils, les résultats d'outils et les images comptent tous comme des tokens d'entrée sur chaque requête qui les inclut. La sortie couvre tout ce que le modèle renvoie, et sur les modèles capables de raisonnement, cela inclut des tokens de réflexion que vous n'affichez peut-être jamais à un utilisateur. Le cache de prompt est le troisième compteur, et celui que la plupart des équipes laissent inutilisé. Vous marquez un préfixe stable (un long prompt système, un document, une liste d'outils fixe) avec un point de rupture cache_control. La première requête paie une prime d'écriture de 1.25x le tarif d'entrée pour le cache par défaut de 5 minutes ; chaque requête qui réutilise le préfixe dans cette fenêtre le relit à 0.1x. Un cache d'une heure est aussi disponible, à un tarif d'écriture de 2x. Voici le tableau tarifaire complet des deux modèles Claude phares, aux prix officiels.

Un exemple détaillé : un chatbot, une journée

Prenons un chatbot de support sur Claude Sonnet 4.6 aux tarifs officiels : 10 000 requêtes par jour, chacune portant un prompt système de 2 000 tokens plus 1 500 tokens d'historique et de message utilisateur, avec une réponse de 500 tokens. Le tableau montre la même charge avec et sans mise en cache du prompt système. Sans mise en cache, la journée coûte $180.00, soit environ $5,400 par mois. La mise en cache du prompt système (en supposant environ 300 expirations de cache par jour sur la fenêtre de 5 minutes) réduit ce coût à environ $128 par jour, soit environ $3,840 par mois. Notez ce qui n'a pas bougé : le coût de sortie. La mise en cache ne touche que l'entrée, ce qui explique pourquoi la discipline sur la sortie compte plus que n'importe quel autre levier isolé.

Pourquoi les factures Anthropic surprennent les équipes

Quatre schémas expliquent la plupart des conversations du type « pourquoi la facture est-elle plusieurs fois supérieure à l'estimation ». 1. La sortie coûte 5x l'entrée, et la réflexion compte comme de la sortie. Les estimations s'ancrent sur le tarif d'entrée car c'est le chiffre annoncé en premier. Mais les réponses longues, le formatage verbeux et la réflexion étendue sont tous facturés au tarif de sortie. Un modèle qui réfléchit pendant 3 000 tokens avant de répondre en 500 facture 3 500 tokens de sortie pour ce qui ressemble à une réponse courte. 2. L'historique est refacturé à chaque tour. L'API est sans état, donc chaque tour renvoie l'intégralité de la conversation comme entrée. Une discussion de 20 tours en moyenne ne coûte pas 20 fois un tour unique ; elle coûte bien plus, car le tour 20 porte les 19 tours précédents comme entrée. Le coût d'entrée croît à peu près avec le carré de la longueur de la conversation, sauf si vous élaguez ou résumez. 3. Les abonnements et les crédits API sont séparés. Claude Pro et Max couvrent les applications Claude, pas l'API. Les équipes supposent que l'abonnement absorbe le trafic API, puis découvrent que la console a discrètement puisé dans un solde prépayé avec rechargement automatique activé. 4. Tout ce qui figure dans la requête est de l'entrée, et l'attribution est difficile. Les définitions d'outils, les résultats d'outils, les images et les prompts système sont facturés comme entrée sur chaque requête qui les inclut. Répartissez cela sur plusieurs clés API, environnements et fonctionnalités sans journalisation par clé, et personne ne peut dire quelle fonctionnalité a dépensé quoi avant que la facture n'arrive.

Facturation Anthropic vs OpenAI, côte à côte

Les deux fournisseurs mesurent de la même façon : par token, avec des tarifs distincts pour l'entrée et la sortie, et des crédits prépayés par défaut. Les différences qui comptent pour votre facture se situent dans la mécanique de cache et les contrôles de dépenses. La divergence pratique se situe dans la mise en cache. OpenAI applique la mise en cache des prompts automatiquement, sans frais d'écriture et avec une remise sur la portion mise en cache. Anthropic vous demande de placer vous-même des points de rupture cache_control, facture une prime d'écriture, et la rembourse avec des lectures bien moins chères à 0.1x le tarif d'entrée. Pour les charges avec des prompts longs et stables, la mise en cache Anthropic bien réalisée est le levier le plus puissant ; mal réalisée (un horodatage dans le prompt système, une liste d'outils instable), elle ne se déclenche jamais et vous payez le plein tarif plus les primes d'écriture.

Comment estimer votre coût API Anthropic avant la mise en production

Chaque réponse API inclut un objet usage avec les input_tokens et output_tokens exacts, plus cache_creation_input_tokens et cache_read_input_tokens quand la mise en cache est active. Cet objet est la vérité terrain. Les tokenizers côté client conçus pour d'autres fournisseurs sous-comptent les tokens Claude, donc ne les utilisez pas pour estimer. La procédure : envoyez quelques requêtes représentatives, lisez l'objet usage, et faites la moyenne des comptages. Puis appliquez la formule : coût = (input_tokens / 1 000 000 x tarif d'entrée) + (output_tokens / 1 000 000 x tarif de sortie), plus les termes d'écriture et de lecture de cache si vous mettez en cache. Multipliez par le volume quotidien attendu, et pour les produits multi-tours, ajoutez une marge de croissance car l'historique augmente l'entrée à chaque tour. Anthropic expose aussi un endpoint count_tokens si vous voulez les comptages avant d'envoyer quoi que ce soit.

curl https://api.anthropic.com/v1/messages \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "content-type: application/json" \
  -d '{
    "model": "claude-sonnet-4-6",
    "max_tokens": 1024,
    "messages": [{"role": "user", "content": "Summarize this ticket: ..."}]
  }'

# La réponse contient la vérité terrain pour votre modèle de coût :
# "usage": {"input_tokens": 2412, "output_tokens": 486,
#           "cache_read_input_tokens": 0, "cache_creation_input_tokens": 0}

Cinq façons de réduire votre facture API Anthropic

La cinquième tactique est celle où une passerelle trouve sa place. APIsRouter est une passerelle compatible OpenAI qui journalise le modèle, les tokens d'entrée, les tokens de sortie et le coût exact en dollars par requête, par clé API, de sorte que chaque fonctionnalité ou environnement obtient sa propre clé et sa propre ligne dans la vue d'usage. Elle affiche Claude Sonnet 4.6 à $2.40 en entrée et $12.00 en sortie par million de tokens, et Claude Opus 4.7 à $4.00 et $20.00, 20% sous le tarif officiel, facturé à la consommation sans abonnement ; une première recharge sur /topup est doublée. Rediriger une intégration existante du SDK OpenAI vers cette passerelle tient en deux lignes :

• Mettez en cache vos longs préfixes stables. Un prompt système ou un document qui se répète sur plusieurs requêtes est facturé à un dixième du tarif d'entrée à chaque lecture de cache après la première écriture.
• Élaguez l'historique et plafonnez max_tokens. Résumez ou supprimez les anciens tours au lieu de les renvoyer, et réglez max_tokens sur ce dont la tâche a réellement besoin, pour qu'une réponse qui s'emballe ne facture pas des milliers de tokens de sortie superflus.
• Routez par tâche, pas par habitude. Réservez Opus aux étapes qui en ont besoin et poussez la classification en masse, l'extraction et les brouillons vers des modèles moins chers comme deepseek-v4-flash ou glm-5.
• Regroupez en lot tout ce qui est asynchrone. L'API Batches traite les requêtes sous 24 heures à moitié prix, idéal pour les rattrapages, les évaluations et les tâches nocturnes.
• Placez une visibilité des coûts par clé devant votre trafic. La plupart des surprises de facturation sont des problèmes d'attribution : personne ne peut dire quelle fonctionnalité ou quel client a dépensé quoi avant que la facture n'arrive.

from openai import OpenAI

client = OpenAI(
    api_key="sk-APIsRouter-...",
    base_url="https://api.apisrouter.com/v1",
)

response = client.chat.completions.create(
    model="claude-sonnet-4-6",
    messages=[{"role": "user", "content": "Summarize this ticket: ..."}],
)

# Les comptages de tokens reviennent à chaque réponse ; la console de la
# passerelle enregistre en plus le coût exact de cette requête pour cette clé.
print(response.usage.prompt_tokens, response.usage.completion_tokens)

Questions fréquentes