Facturation et optimisation des coûts — Modèles de raisonnement Grok

Corrigé le 3 novembre 2026 : les exemples lisaient usage.prompt_tokens et usage.completion_tokens sur des réponses de l’API Responses, qui exposent input_tokens, output_tokens et leurs détails (cached_tokens, reasoning_tokens) : le code levait AttributeError. Le suivi des coûts tient désormais compte de l’entrée en cache, et le conseil de baisser le plafond de sortie pour limiter le raisonnement est corrigé, ce plafond ne comptant pas le raisonnement. Sources : Models and Pricing · Best practices.

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.

Modèle	Entrée < 200k	Sortie < 200k	Entrée ≥ 200k	Sortie ≥ 200k
grok-4.5	$2.00	$6.00	$4.00	$12.00
grok-4.20-0309-reasoning	$1.25	$2.50	$2.50	$5.00
grok-4.3	$1.25	$2.50	$2.50	$5.00
grok-build-0.1	$1.00	$2.00	$2.00	$4.00

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 (l'API Responses compte en input/output)
usage = response.usage
input_cost = usage.input_tokens * 2.00 / 1_000_000
output_cost = usage.output_tokens * 6.00 / 1_000_000  # raisonnement compris
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. Sous 200k tokens, l’entrée en cache coûte par exemple 0,30 $ le million au lieu de 2,00 $ avec grok-4.5, et 0,20 $ au lieu de 1,25 $ avec grok-4.20-0309-reasoning (page Models and Pricing, novembre 2026). Structurez vos prompts avec les parties stables en tête ; la part servie par le cache se lit dans usage.input_tokens_details.cached_tokens.

5. Dimensionner le plafond de sortie

Le plafond de sortie (max_output_tokens dans l’API Responses, max_completion_tokens en Chat Completions) ne limite que la réponse visible : les tokens de raisonnement n’y comptent pas. Le baisser ne réduit donc pas la réflexion, il risque seulement de couper la réponse. Les bonnes pratiques de xAI conseillent de le fixer au-dessus de la plus longue réponse attendue, ou de laisser sa valeur par défaut de 128 000 tokens. Pour réduire le raisonnement, baissez l’effort sur les modèles qui l’acceptent, ou choisissez un modèle moins cher.

Suivi budgétaire en production

class CostTracker:
    # Tarifs par MTok : (entrée, entrée en cache, sortie) selon le palier de contexte
    RATES = {
        "grok-4.5": {"low": (2.00, 0.30, 6.00), "high": (4.00, 0.60, 12.00)},
        "grok-4.20-0309-reasoning": {"low": (1.25, 0.20, 2.50), "high": (2.50, 0.40, 5.00)},
        "grok-build-0.1": {"low": (1.00, 0.20, 2.00), "high": (2.00, 0.40, 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"):
        usage = response.usage  # réponse de l'API Responses
        details = usage.input_tokens_details
        cached = details.cached_tokens if details else 0
        tier = "high" if usage.input_tokens >= self.TIER_THRESHOLD else "low"
        rate_in, rate_cached, rate_out = self.RATES[model][tier]
        cost = (
            (usage.input_tokens - cached) * rate_in / 1e6
            + cached * rate_cached / 1e6
            + usage.output_tokens * rate_out / 1e6  # raisonnement compris
        )
        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