Facturation et optimisation des coûts

Les tokens de raisonnement sur votre facture

La facturation des tokens de raisonnement est un aspect critique de l’utilisation des modèles xAI. Ces tokens sont facturés au tarif des tokens de sortie — le tarif le plus élevé — et une utilisation non optimisée peut rapidement faire grimper les coûts, surtout avec un effort de raisonnement élevé sur grok-4.5.

Nouveauté 2026 à bien comprendre : la tarification est à palier. Le prix par token dépend de la taille du contexte de la requête. Sous 200k tokens de prompt, vous payez le tarif standard ; au-delà, le tarif double.

Tarification par modèle (juillet 2026)

Prix par million de tokens.

Les tokens de raisonnement sont facturés au tarif de la colonne « Sortie ». Avec grok-4.5 sous 200k de contexte, chaque million de tokens de raisonnement coûte 6,00 $ ; avec grok-4.20-0309-reasoning, 2,50 $. Et si votre prompt dépasse 200k tokens, ces montants doublent : 12,00 $ et 5,00 $.

Suivre le coût de chaque requête

L’objet usage de la réponse contient les compteurs de tokens ; certaines réponses de l’API xAI peuvent aussi inclure des champs de coût directs. Inspectez l’objet usage renvoyé par votre modèle et consultez la documentation officielle pour les champs disponibles. À défaut, le calcul manuel reste simple :

response = client.responses.create(
    model="grok-4.5",
    input="Résolvez ce problème de programmation dynamique...",
    reasoning={"effort": "high"}
)

# Tarifs grok-4.5 sous 200k tokens de contexte
input_cost = response.usage.prompt_tokens * 2.00 / 1_000_000
output_cost = response.usage.completion_tokens * 6.00 / 1_000_000
total_cost = input_cost + output_cost

print(f"Coût entrée : ${input_cost:.6f}")
print(f"Coût sortie : ${output_cost:.6f}")
print(f"Coût total : ${total_cost:.6f}")

Attention : ce calcul suppose un contexte sous 200k tokens. En production, votre tracker doit détecter le palier applicable (voir plus bas).

Stratégies d’optimisation des coûts

1. Adapter l’effort à la tâche

La première et plus efficace optimisation est de choisir le bon niveau d’effort de raisonnement sur grok-4.5. Un effort faible peut consommer nettement moins de tokens de raisonnement qu’un effort élevé :

# Tri des requêtes par complexité
if complexite == "simple":
    effort = "low"      # réflexion brève
elif complexite == "moyen":
    effort = "medium"   # réflexion intermédiaire
else:
    effort = "high"     # réflexion approfondie

Vérifiez les valeurs exactes acceptées par le paramètre sur la page officielle des modèles.

2. Utiliser le bon modèle

Pour les tâches de raisonnement courantes, grok-4.20-0309-reasoning à 2,50 $/M en sortie coûte moins de la moitié de grok-4.5 à 6,00 $/M. Réservez le modèle phare aux tâches qui le nécessitent vraiment. Pour le code, grok-build-0.1 à 2,00 $/M en sortie est encore plus économique.

3. Rester sous le palier des 200k tokens

Le palier tarifaire est un levier direct : une requête à 250k tokens de contexte coûte deux fois plus cher par token qu’une requête à 150k. Avant d’envoyer un contexte massif, demandez-vous si un découpage en plusieurs requêtes plus petites (ou un résumé intermédiaire) ne serait pas à la fois moins cher et plus efficace.

4. Exploiter le cache de prompts

xAI propose une tarification réduite pour les tokens d’entrée déjà en cache : les préfixes de prompt répétés (instructions système, contexte partagé) coûtent moins cher lorsqu’ils sont réutilisés d’une requête à l’autre. Structurez vos prompts avec les parties stables en tête et consultez la page officielle des tarifs pour les taux de réduction en vigueur par modèle.

5. Limiter la longueur de sortie

Définissez un plafond de tokens de sortie raisonnable (max_output_tokens ou équivalent selon l’API utilisée) pour éviter les raisonnements excessivement longs sur des questions simples.

Suivi budgétaire en production

class CostTracker:
    # Tarifs par MTok : (entrée, sortie) selon le palier de contexte
    RATES = {
        "grok-4.5": {"low": (2.00, 6.00), "high": (4.00, 12.00)},
        "grok-4.20-0309-reasoning": {"low": (1.25, 2.50), "high": (2.50, 5.00)},
        "grok-build-0.1": {"low": (1.00, 2.00), "high": (2.00, 4.00)},
    }
    TIER_THRESHOLD = 200_000  # tokens de prompt

    def __init__(self):
        self.total_cost = 0
        self.request_count = 0

    def track(self, response, model="grok-4.5"):
        tier = "high" if response.usage.prompt_tokens >= self.TIER_THRESHOLD else "low"
        rate_in, rate_out = self.RATES[model][tier]
        cost = (
            response.usage.prompt_tokens * rate_in / 1e6 +
            response.usage.completion_tokens * rate_out / 1e6
        )
        self.total_cost += cost
        self.request_count += 1
        return cost

Tarifs relevés le 5 août 2026 — les prix évoluent régulièrement : avant tout calcul de budget, vérifiez la grille en vigueur sur la page officielle des modèles et tarifs xAI.

Points clés à retenir

• Les tokens de raisonnement sont facturés au tarif des tokens de sortie
• La tarification 2026 est à palier : au-delà de 200k tokens de contexte, le prix par token double
• grok-4.5 coûte 2 $/6 $ par MTok sous 200k (4 $/12 $ au-delà) ; grok-4.20-0309-reasoning coûte 1,25 $/2,50 $ (2,50 $/5 $ au-delà)
• Les trois leviers principaux : adapter l’effort de raisonnement, choisir le bon modèle, rester sous le palier des 200k
• Suivez vos coûts requête par requête en tenant compte du palier applicable