Tarifs de l'API Grok (2026) : tous les modèles, frais d'outils et multiplicateurs
Les tarifs de l'API Grok commencent à $1.00 par million de tokens en entrée et $2.00 par million de tokens en sortie (grok-build-0.1), tandis que le modèle phare grok-4.7 coûte $2.00 en entrée, $0.50 en entrée mise en cache et $6.00 en sortie par million de tokens pour les prompts de moins de 200K tokens. Dès qu'un prompt atteint 200K tokens, le tarif contexte long s'applique à toute la requête ($4 / $1 / $12 pour Grok 4.7). Tous les chiffres ci-dessous proviennent de la page officielle des tarifs xAI et de la page des modèles, vérifiées le 20 octobre 2026.
Ce guide couvre tous les tarifs actuels texte, image, vidéo et voix, les cinq multiplicateurs qui modifient votre facture réelle (contexte long, priorité, région US, Batch et outils), un calculateur de coûts avec un exemple détaillé, la comparaison de prix entre Grok et GPT, Claude, Gemini et Qwen, ainsi que des exemples exécutables en curl, Python et Node.
Les tarifs de l'API Grok en un coup d'œil
| Élément | Réponse (au 20 octobre 2026) |
|---|---|
| Modèle texte le moins cher | grok-build-0.1 : $1.00 en entrée / $2.00 en sortie par 1M tokens |
| Modèle phare | grok-4.7 : $2.00 en entrée / $0.50 en cache / $6.00 en sortie par 1M tokens |
| Seuil de contexte long | 200K tokens de prompt ; le tarif supérieur s'applique à tous les tokens de la requête |
| Traitement prioritaire | 2x les tarifs standard sur tous les types de tokens |
| Endpoint régional US | https://us.api.x.ai/v1, facturé 1.1x |
| Batch API | 20 % de remise sur Grok 4.3 et les modèles Grok 4.20 ; aucune remise sur les autres |
| Outil Web Search / Code Execution | $5 pour 1 000 appels |
| URL de base mondiale | https://api.x.ai/v1 |
Source : tarifs de l'API xAI, 20 octobre 2026.
Tarifs des modèles texte Grok (par million de tokens)
Les prix sont les tarifs mondiaux standard en USD par million de tokens, issus du tableau officiel au 20 octobre 2026.
| Modèle | Fenêtre de contexte | Taille du prompt | Entrée | Entrée en cache | Sortie |
|---|---|---|---|---|---|
grok-4.7 |
500K | < 200K | $2.00 | $0.50 | $6.00 |
grok-4.7 |
500K | ≥ 200K | $4.00 | $1.00 | $12.00 |
grok-4.6 |
500K | < 200K | $2.00 | $0.50 | $6.00 |
grok-4.6 |
500K | ≥ 200K | $4.00 | $1.00 | $12.00 |
grok-4.5 |
500K | < 200K | $2.00 | $0.30 | $6.00 |
grok-4.5 |
500K | ≥ 200K | $4.00 | $0.60 | $12.00 |
grok-4.3 |
1M | < 200K | $1.25 | $0.20 | $2.50 |
grok-4.3 |
1M | ≥ 200K | $2.50 | $0.40 | $5.00 |
grok-4.20-0309-reasoning |
1M | < 200K | $1.25 | $0.20 | $2.50 |
grok-4.20-0309-non-reasoning |
1M | < 200K | $1.25 | $0.20 | $2.50 |
grok-4.20-multi-agent-0309 |
1M | < 200K | $1.25 | $0.20 | $2.50 |
grok-build-0.1 |
256K | < 200K | $1.00 | $0.20 | $2.00 |
grok-build-0.1 |
256K | ≥ 200K | $2.00 | $0.40 | $4.00 |
Les modèles Grok 4.20 doublent aussi à $2.50 / $0.40 / $5.00 à partir de 200K tokens de prompt. Deux détails que la plupart des pages de tarifs oublient :
- Grok 4.5 a des lectures de cache moins chères que 4.6 et 4.7 ($0.30 contre $0.50 par million sur les prompts courts). Si votre charge est dominée par un long prompt système répété, 4.5 peut battre les modèles plus récents en coût d'entrée effectif.
- Grok 4.3 dispose d'une fenêtre de contexte de 1M tokens, mais coûte moins cher que 4.7. Pour le travail sur de longs documents où vous restez sous 200K par requête (grâce à la recherche ou au découpage), 4.3 coûte 37,5 % de moins en entrée et 58 % de moins en sortie que 4.7.
La page des modèles de xAI recommande Grok 4.7 (guide développeur) pour le code et le chat et indique une date limite de connaissances en mai 2026 : activez les outils de recherche lorsque vous avez besoin d'informations à jour.
Tarifs de Grok Imagine (image et vidéo) et de la voix
Les modèles multimédias ne sont pas facturés au token. Tarifs de la page des tarifs xAI, 20 octobre 2026 :
| Modèle / mode | Prix unitaire |
|---|---|
grok-imagine-image |
$0.02 par image |
grok-imagine-image-2.0 |
$0.04 par image |
grok-imagine-image-quality |
$0.05 par image |
grok-imagine-video-1.5-lite |
$0.020 par seconde |
grok-imagine-video |
$0.050 par seconde |
grok-imagine-video-1.5 |
$0.080 par seconde |
Voix vers voix (grok-voice-3.0) |
$0.08 par minute ($4.80/heure) + $0.004 par entrée texte |
| Voix vers texte | $0.10/heure (REST), $0.20/heure (streaming) |
| Texte vers voix | $15.00 par million de caractères |
Un clip de 10 secondes sur grok-imagine-video-1.5 coûte donc $0.80, et le même clip sur le modèle 1.5 Lite coûte $0.20. Les requêtes Batch pour l'image et la vidéo sont acceptées, mais facturées au tarif standard.
Les cinq multiplicateurs qui changent votre facture Grok
1. Tarif contexte long (≥ 200K tokens de prompt)
La règle officielle : une requête dont le prompt atteint le seuil est facturée au tarif supérieur pour tous les tokens de la requête, et pas seulement pour ceux au-delà de 200K. Un prompt de 199K tokens envoyé à Grok 4.7 coûte environ $0.40 en entrée ; un prompt de 201K tokens coûte environ $0.80. Réduisez l'historique ou récupérez moins de fragments pour rester sous la limite.
2. Traitement prioritaire (2x)
Priority Processing est facturé 2x les tarifs standard sur les tokens d'entrée, en cache, de sortie et de raisonnement. Le tarif prioritaire n'est facturé que si la réponse confirme "service_tier": "priority". Il fonctionne uniquement avec Chat Completions et Responses, pas avec les requêtes image, vidéo ou Batch (source, 20 octobre 2026).
3. Endpoint régional US (1.1x)
Les appels à https://us.api.x.ai/v1 exécutent l'inférence aux États-Unis et coûtent 1.1x. Pour Grok 4.7, cela donne $2.20 / $0.55 / $6.60 par million de tokens sous 200K, et $4.40 / $1.10 / $13.20 au-delà. Au 20 octobre 2026, seuls grok-4.7 et grok-4.6 sont disponibles sur cet endpoint.
4. Batch API (20 % de remise, modèles sélectionnés)
La Batch API applique 20 % de remise sur tous les types de tokens pour grok-4.3, grok-4.20-0309-reasoning, grok-4.20-0309-non-reasoning et grok-4.20-multi-agent-0309. Grok 4.7, 4.6 et 4.5 n'ont pas de remise Batch. La plupart des jobs Batch se terminent en 24 heures et ne comptent pas dans les limites de débit (documentation de la Batch API).
5. Outils côté serveur
Les requêtes agentiques (présentation des outils) sont facturées en tokens plus les appels d'outils (tarifs des outils, 20 octobre 2026) :
| Outil | Prix |
|---|---|
Web Search (web_search) |
$5 pour 1 000 appels |
X Search (x_search) |
$5 pour 1 000 posts, $10 pour 1 000 profils |
| Code Execution | $5 pour 1 000 appels |
| Recherche dans les fichiers joints | $5 pour 1 000 appels |
| Recherche dans les Collections (RAG) | $2.50 pour 1 000 appels |
| Outils MCP distants | Tokens uniquement |
X Search est facturé par élément renvoyé, y compris les posts parents et cités : récupérer un seul fil peut donc compter des dizaines de posts facturables. Le stockage est en sus : $0.025/Gio/jour pour les fichiers et $0.10/Gio/jour pour les Collections.
Il existe aussi des frais de $0.05 pour violation des règles d'utilisation pour les requêtes bloquées avant génération dans la Responses API.
Grok 4.7 Fast : absent de l'API publique
Grok 4.7 Fast est le même modèle sur une infrastructure plus rapide, à 2x les tarifs standard ($4 / $1 / $12 sous 200K). xAI indique qu'il est disponible uniquement dans Cursor et Grok Build, facturé via ces offres, et non sur l'API publique de xAI (au 20 octobre 2026). Si une page tierce cite un « prix de l'API Grok 4.7 Fast », elle ne décrit pas un endpoint public de xAI.
Calculateur de coûts de l'API Grok
cost = (uncached_input / 1e6 × input_rate)
+ (cached_input / 1e6 × cached_rate)
+ (output / 1e6 × output_rate)
+ tool_calls × tool_rate
then × 2 for priority, × 1.1 for the US endpoint, × 0.8 for batch on eligible models
Exemple : un agent de support sur Grok 4.7, 1 million de conversations par mois. Chaque conversation compte en moyenne 6 000 tokens d'entrée (dont 4 000 de prompt système en cache), 500 tokens de sortie et 0,2 recherche web.
| Poste | Calcul | Coût mensuel |
|---|---|---|
| Entrée hors cache | 2 000M tokens × $2.00 | $4,000 |
| Entrée en cache | 4 000M tokens × $0.50 | $2,000 |
| Sortie | 500M tokens × $6.00 | $3,000 |
| Web Search | 200 000 appels × $0.005 | $1,000 |
| Total | $10,000 |
Passer la même charge sur Grok 4.3 (cache $0.20, entrée $1.25, sortie $2.50) fait baisser la part tokens de $9,000 à $4,550. Qu'il s'agisse d'une économie dépend du taux de résolution : comparez le coût par conversation résolue, pas par requête.
Voici une petite fonction Python à coller dans un notebook :
RATES = { # USD per 1M tokens, xAI pricing page, Oct 20, 2026 (<200K prompt)
"grok-4.7": (2.00, 0.50, 6.00),
"grok-4.5": (2.00, 0.30, 6.00),
"grok-4.3": (1.25, 0.20, 2.50),
"grok-build-0.1": (1.00, 0.20, 2.00),
}
def grok_cost(model, uncached, cached, output, priority=False, us=False):
inp, cache, out = RATES[model]
if uncached + cached >= 200_000: # long-context tier applies to all tokens
inp, cache, out = inp * 2, cache * 2, out * 2
cost = (uncached * inp + cached * cache + output * out) / 1e6
return cost * (2 if priority else 1) * (1.1 if us else 1)
print(round(grok_cost("grok-4.7", 2000, 4000, 500), 6)) # 0.009
Le doublement contexte long de la fonction correspond à tous les modèles présentés sur deux lignes dans le tableau officiel.
Grok vs GPT, Claude, Gemini et Qwen : prix par million de tokens
Le tableau compare les tarifs catalogue des gammes phares et rapides. Les tarifs Grok proviennent de xAI ; les autres sont les prix catalogue affichés sur la page de chaque modèle chez Flatkey, tous vérifiés le 20 octobre 2026.
| Modèle | Entrée | Entrée en cache | Sortie |
|---|---|---|---|
grok-4.7 |
$2.00 | $0.50 | $6.00 |
grok-4.3 |
$1.25 | $0.20 | $2.50 |
gpt-6-sol |
$2.00 | $0.20 | $10.00 |
claude-sonnet-5-5 |
$2.00 | $0.20 | $10.00 |
gemini-3.5-flash |
$1.50 | $0.15 | $9.00 |
qwen3.8-max |
$2.00 | $0.25 | $6.00 |
L'API Grok est-elle moins chère que l'API ChatGPT ? Pour les charges à forte sortie, oui : le tarif de sortie de $6.00 de Grok 4.7 est 40 % inférieur aux $10.00 catalogue de gpt-6-sol. Pour les charges à fort cache, c'est l'inverse, car le tarif d'entrée en cache de Grok, $0.50, est 2,5 fois plus élevé. Faites passer votre propre répartition de tokens dans le calculateur ci-dessus avant de décider. Pour aller plus loin, consultez notre comparatif des prix des API d'IA et notre guide des coûts de l'API OpenAI.
Obtenir une clé API Grok et faire votre premier appel
- Connectez-vous à la console xAI, créez une équipe et ajoutez des crédits.
- Créez une clé API limitée aux modèles nécessaires et enregistrez-la sous
XAI_API_KEY. - Appelez la Responses API (recommandée) ou Chat Completions sur
https://api.x.ai/v1.
Un abonnement grand public Grok (SuperGrok, X Premium) n'inclut pas de crédits API : l'API est facturée séparément, au token, via la console.
curl -s https://api.x.ai/v1/responses \
-H "Authorization: Bearer $XAI_API_KEY" \
-H "Content-Type: application/json" \
-d '{"model": "grok-4.7", "input": "Summarize prompt caching in 3 bullets."}'
Utiliser Grok avec d'autres modèles grâce à une seule clé Flatkey
Au 20 octobre 2026, l'annuaire des modèles Flatkey référence les modèles image et vidéo Grok Imagine de xAI, mais pas les modèles texte Grok : appelez donc Grok texte directement sur api.x.ai. Beaucoup d'équipes l'associent à un routeur pour tout le reste : une seule clé compatible OpenAI sur https://router.flatkey.ai/v1 couvre GPT, Claude, Gemini, Qwen, DeepSeek, Kimi et GLM, et vous pouvez basculer de Grok vers n'importe lequel d'entre eux sans seconde intégration.
curl : même clé, autre modèle
for MODEL in gpt-6-sol claude-sonnet-5-5 qwen3.8-max; do
curl -s https://router.flatkey.ai/v1/chat/completions \
-H "Authorization: Bearer $FLATKEY_API_KEY" \
-H "Content-Type: application/json" \
-d "{\"model\": \"$MODEL\", \"messages\": [{\"role\": \"user\", \"content\": \"Say hi in 5 words\"}]}"
done
Python : Grok d'abord, Flatkey en secours
import os
from openai import OpenAI, APIError
grok = OpenAI(api_key=os.environ["XAI_API_KEY"], base_url="https://api.x.ai/v1")
flatkey = OpenAI(api_key=os.environ["FLATKEY_API_KEY"], base_url="https://router.flatkey.ai/v1")
ROUTES = [(grok, "grok-4.7"), (flatkey, "claude-sonnet-5-5"), (flatkey, "gpt-6-sol")]
def ask(prompt: str) -> str:
last_error = None
for client, model in ROUTES:
try:
r = client.chat.completions.create(
model=model, messages=[{"role": "user", "content": prompt}], timeout=30
)
return f"[{model}] " + r.choices[0].message.content
except APIError as e: # 429, 5xx, timeouts: try the next route
last_error = e
raise last_error
print(ask("Explain the Grok long-context price rule in one sentence."))
Node.js
import OpenAI from "openai";
const flatkey = new OpenAI({
apiKey: process.env.FLATKEY_API_KEY,
baseURL: "https://router.flatkey.ai/v1",
});
for (const model of ["qwen3.8-max", "gemini-3.5-flash"]) {
const r = await flatkey.chat.completions.create({
model,
messages: [{ role: "user", content: "One-line summary of batch APIs." }],
});
console.log(model, r.choices[0].message.content);
}
Pour la configuration, consultez le démarrage rapide Flatkey et le guide des URL de base compatibles OpenAI. Les prix Flatkey figurent sur la page des tarifs.
Comment réduire votre facture de l'API Grok
- Mettez en cache le préfixe statique. Sur Grok 4.7, l'entrée en cache est 75 % moins chère que l'entrée normale ($0.50 contre $2.00).
- Restez sous 200K tokens de prompt. Franchir le seuil double le coût de chaque token de la requête.
- Passez les jobs hors ligne en Batch sur Grok 4.3 ou 4.20 pour 20 % de remise. La famille 4.7 n'a pas de remise Batch.
- Réservez la priorité aux chemins P95 exposés aux utilisateurs. Elle double la facture.
- Plafonnez les appels d'outils. Fixez un nombre maximal de recherches par requête et journalisez le nombre d'éléments X Search.
- Routez selon la tâche. Confiez la classification et l'extraction à des modèles moins chers et gardez Grok 4.7 pour le raisonnement complexe. Nos stratégies d'optimisation des coûts des API d'IA et notre guide du ROI du prompt caching expliquent comment faire.
- Gérez correctement les erreurs 429. Voir les limites de débit des LLM expliquées.
FAQ
Combien coûte l'API Grok ?
Grok 4.7 coûte $2.00 par million de tokens en entrée, $0.50 par million de tokens en entrée mise en cache et $6.00 par million de tokens en sortie pour les prompts de moins de 200K tokens, puis $4 / $1 / $12 à partir de 200K. Le modèle texte le moins cher, grok-build-0.1, coûte $1.00 / $0.20 / $2.00 (page des tarifs xAI, 20 octobre 2026).
L'API Grok est-elle moins chère que l'API ChatGPT ?
Pour les charges à forte sortie, les $6 par million de tokens de sortie de Grok 4.7 sont inférieurs aux $10 catalogue de gpt-6-sol au 20 octobre 2026. Pour les charges à fort cache, le tarif en cache de GPT, $0.20, est moins cher que les $0.50 de Grok. La réponse dépend de votre répartition entrée/sortie/cache.
L'API Grok est-elle gratuite ?
xAI n'affiche pas d'offre API gratuite sur sa page des tarifs. L'utilisation de l'API est prépayée ou facturée via la console xAI. Vérifiez dans votre console si votre équipe dispose de crédits promotionnels.
Un abonnement Grok inclut-il l'accès à l'API ?
Non. Les abonnements SuperGrok et X Premium couvrent l'application Grok grand public. L'utilisation de l'API est facturée séparément, au token, dans la console xAI.
Quelle est l'URL de base de l'API Grok ?
L'URL de base mondiale est https://api.x.ai/v1. L'endpoint régional US, https://us.api.x.ai/v1, coûte 1.1x et prend en charge Grok 4.7 et 4.6.
Grok propose-t-il une remise Batch ?
Oui, 20 % sur Grok 4.3 et les modèles Grok 4.20. Grok 4.7, 4.6 et 4.5 n'ont pas de remise Batch (au 20 octobre 2026).
Comment la vidéo Grok Imagine est-elle facturée ?
À la seconde de sortie : $0.020/s pour Video 1.5 Lite, $0.050/s pour grok-imagine-video et $0.080/s pour Video 1.5.
En résumé
Pour la plupart des charges texte, prévoyez environ $2 / $0.50 / $6 par million de tokens sur Grok 4.7, ou $1.25 / $0.20 / $2.50 sur Grok 4.3. Ajoutez ensuite vos multiplicateurs : 2x pour la priorité, 1.1x pour la région US, 0.8x pour le Batch sur les modèles éligibles et le doublement contexte long à 200K. Revérifiez la page officielle des tarifs et les notes de version avant chaque cycle budgétaire. Si Grok n'est qu'un des modèles de votre stack, gardez une seule clé compatible OpenAI pour le reste via Flatkey.
Dernière mise à jour : 20 octobre 2026 · Flatkey Team. Les prix sont en USD et proviennent des sources officielles citées dans le texte.
