Sur l'API publique de xAI, avec un prompt de moins de 200 000 tokens, Grok 4.7 coûte 2 $ par million de tokens d'entrée, 0,50 $ par million d'entrée en cache et 6 $ par million de sortie. La ligne de contexte long est 4 $ / 1 $ / 12 $. Sur la page de tarifs de l'API, ouverte le 22 septembre 2026, ces trois chiffres et la ligne longue correspondent à Grok 4.6. Le prix affiché n'a pas bougé. La facture, elle, peut bouger.
Dans la même note de lancement, le graphique CursorBench 4.0 de xAI place une tâche Grok 4.7 à 1,58 $ en Low et 6,01 $ en Extra High. C'est un écart d'environ 3,8 fois sans toucher à la carte par token. Un utilisateur Cursor Ultra, en extra high et avec fast mode désactivé, l'a résumé ainsi : « Grok 4.7 is about 2.5 times as expensive as 4.6. » (r/cursor, 21 septembre 2026). Ensuite, Tabbit est un endroit pour essayer un parcours une fois le budget clair. D'abord, la carte.
Ce qu'il faut retenir
L'étiquette correspond à Grok 4.6. Le contexte court est 2 $ / 0,50 $ / 6 $ par million de tokens. À 200 000 tokens d'entrée, toute la requête passe à 4 $ / 1 $ / 12 $.
L'effort est le chiffre qui bouge. Les points CursorBench de xAI montrent 1,58 $, 3,49 $, 4,69 $ et 6,01 $ par tâche, de Low à Extra High. L'effort de raisonnement par défaut sur l'API est high.
Fast est une seconde carte, pas un slogan. Les tarifs Fast imprimés sont 4 $ / 1 $ / 12 $ sous 200 000 et 6 $ / 1,50 $ / 18 $ au-dessus. Fast concerne seulement Cursor et Grok Build, et il est hors de l'API publique.
Le seuil de Cursor est 256 000, pas 200 000. La page du modèle chez Cursor double les tarifs standard à la demande après 256 000 tokens d'entrée et place Fast à 500 000 en 6 $ / 1,50 $ / 18 $. La colonne d'écriture en cache est un tiret, pas un tarif séparé.
Il n'y a pas de remise Batch sur grok-4.7. La page du modèle dit que Batch API n'est pas pris en charge. Les appels d'outils, les 10 % de l'endpoint américain et les 0,05 $ d'infraction avant génération sont hors du prix titre.
Les tarifs d'un coup d'œil
Les montants ci-dessous sont des dollars par million de tokens, relevés sur la page de tarifs xAI le 22 septembre 2026. La vue d'ensemble de Grok 4.6 couvre le modèle précédent. Ce tableau ne parle que d'argent.
| Modèle | Contexte | Entrée courte | Cache court | Sortie courte | Entrée longue | Cache long | Sortie longue | Seuil de contexte long |
|---|---|---|---|---|---|---|---|---|
| grok-4.7 | 500k | 2,00 $ | 0,50 $ | 6,00 $ | 4,00 $ | 1,00 $ | 12,00 $ | ≥ 200 000 tokens |
| grok-4.6 | 500k | 2,00 $ | 0,50 $ | 6,00 $ | 4,00 $ | 1,00 $ | 12,00 $ | ≥ 200 000 tokens |
| grok-4.5 | 500k | 2,00 $ | 0,30 $ | 6,00 $ | 4,00 $ | 0,60 $ | 12,00 $ | ≥ 200 000 tokens |
| grok-build-0.1 | 256k | 1,00 $ | 0,20 $ | 2,00 $ | 2,00 $ | 0,40 $ | 4,00 $ | ≥ 200 000 tokens |
Les quatre chiffres de contexte court de grok-4.7 sont identiques à ceux de grok-4.6. La page précise la règle qui rend la seconde ligne importante : les modèles avec un tarif de contexte long facturent ces tarifs pour tous les tokens d'une requête dès que le prompt atteint le seuil. Dépasser 200 000 ne revalorise pas seulement le surplus.
La page de détail du modèle répète la carte courte — entrée 2,00 $, cache 0,50 $, sortie 6,00 $ — et un interrupteur « Higher context pricing » remplace ces chiffres par 4,00 $, 1,00 $ et 12,00 $. La fenêtre est de 500 000. Les efforts sont low, medium, high et xhigh, avec high par défaut. Batch API est marqué non pris en charge. La région vérifiée était us-east-1, avec 150 requêtes par seconde et 50 000 000 de tokens par minute sur cette page.
Le chiffre à garder : de 1,58 $ à 6,01 $ par tâche
Si vous ne gardez qu'un nombre, gardez l'écart, pas les 2 $. La note de lancement de Grok 4.7 dit que le modèle est « priced starting at $2 per million input tokens and $6 per million output tokens » et qu'une variante rapide a « twice the output speed at twice the price ». La vue de coût CursorBench 4.0 de la même page, lue sur les contrôles du graphique le 22 septembre 2026, est celle-ci :
| Effort Grok 4.7 | Score CursorBench 4.0 | Coût moyen par tâche |
|---|---|---|
| Extra High | 46,3 % | 6,01 $ |
| High | 43,9 % | 4,69 $ |
| Medium | 41,6 % | 3,49 $ |
| Low | 33,1 % | 1,58 $ |
Extra High coûte 3,8 fois Low pour 13,2 points de pourcentage de score sur ce graphique du fournisseur. La taille de l'échantillon, le harnais et les tokens qui composent le dollar ne figurent pas sur ces contrôles. Ce sont des coûts de tâche rapportés par xAI, pas une facture de la console API, et ils ne se comparent pas à un tarif brut par million de tokens.
C'est aussi pourquoi un « même prix que 4.6 » peut encore sembler cher. L'effort par défaut est high. Sur ce graphique, high est déjà à 4,69 $, contre 1,58 $ en Low. Le guide du raisonnement agentique sert à décider quand une boucle doit s'arrêter ; la leçon de prix est plus étroite : fixez le budget par tâche terminée, y compris l'effort que vous laissez actif.
Ce que « 2,5 fois plus cher » a mesuré
Dynamix86 a laissé une même tâche tourner deux jours sur Cursor Ultra, est passé de Grok 4.6 à Grok 4.7 à 22 h, heure d'Europe centrale, et a mesuré combien de temps durait chaque point de pourcentage du forfait. Les deux passages étaient en extra high, sans fast mode. Les tranches 4.7 faisaient 34, 55 et 38 minutes par point. Celles de 4.6, plus tôt ce jour-là, faisaient 133 et 101 minutes. L'auteur en a tiré environ 2,5 fois. La publication lit aussi un graphique Artificial Analysis comme 8,82 $ contre 3,53 $ par tâche. Traitez ces deux montants comme la lecture que l'auteur fait d'une capture. Cet article n'a pas remesuré ce graphique, et un pourcentage de quota Cursor n'est pas une ligne de l'API xAI.
Deux réponses restent sur le coût :
Vegetable-Piano-5313 a écrit : « so using standard grok 4.7 pretty much equals grok 4.6 in fast mode cost-wise i think ». Dynamix86 a répondu : « 25% more expensive than 4.6 fast mode even. » Aucun des deux ne publie le journal de tokens. Ils avertissent sur la consommation du forfait, ils ne publient pas une seconde carte officielle.
« Yep what an awful model release. Obviously benchmarks mean nothing anymore but the cost is clearly too high. » Cette phrase est la lecture du choc de prix. Elle ne nomme ni l'effort, ni fast mode, ni le nombre de tokens. Le graphique de lancement ci-dessus est la partie que l'on peut vérifier sans prendre la conclusion du commentaire pour un fait.
Les lignes qui ne sont pas dans le titre à 2 $
Le seuil de 200 000 s'applique à toute la requête. Un prompt de 199 000 tokens reste à 2 $ / 0,50 $ / 6 $. Un prompt de 200 000 déplace chaque token, sortie comprise, vers 4 $ / 1 $ / 12 $. La page de tarifs n'a pas de ligne « seulement le surplus ».
La ligne Fast imprimée en contexte long n'est pas le double de la ligne standard longue. La page dit que Grok 4.7 Fast est le même modèle sur une infrastructure plus rapide, « at twice the standard token rates », seulement dans Cursor et Grok Build, pas sur l'API publique, et pas dans le quota gratuit de Grok Build. Le tableau sous cette phrase est :
| Taille du prompt | Entrée Fast | Entrée en cache Fast | Sortie Fast |
|---|---|---|---|
| Sous 200 000 | 4,00 $ | 1,00 $ | 12,00 $ |
| À partir de 200 000 | 6,00 $ | 1,50 $ | 18,00 $ |
Sous 200 000, 4 $ / 1 $ / 12 $ est exactement 2 fois la carte courte. Au-dessus, 2 fois la carte longue donnerait 8 $ / 2 $ / 24 $. La ligne imprimée est 6 $ / 1,50 $ / 18 $ : 1,5 fois les tarifs standard de contexte long et 3 fois ceux de contexte court. Budgétez la ligne imprimée. Ne multipliez pas par deux la ligne standard longue pour l'appeler Fast.
Cursor utilise 256 000, et Fast est la vitesse par défaut à partir de Pro. La documentation Grok 4.7 de Cursor, ouverte le 22 septembre 2026, place l'usage standard à la demande à 2 $ d'entrée, 0,50 $ d'entrée en cache et 6 $ de sortie par million. Fast est 4 $ / 1 $ / 12 $. Après 256 000 tokens d'entrée, les requêtes standard valent 2 fois ces tarifs standard et les requêtes Fast 3 fois, jusqu'à 500 000. Les lignes du tableau sont Grok 4.7 à 2 $ / — / 0,50 $ / 6 $, Fast à 4 $ / — / 1 $ / 12 $, 500k à 4 $ / — / 1 $ / 12 $ et 500k Fast à 6 $ / — / 1,50 $ / 18 $. La colonne d'écriture en cache est un tiret. Cursor dit aussi que Fast est le palier de vitesse par défaut à partir de Pro, tandis que le forfait Start (Inde seulement) verrouille Grok 4.7 sur un effort medium et une vitesse standard. Un prompt de 220 000 tokens peut être en contexte long sur l'API xAI et rester standard dans Cursor.
Batch n'est pas le levier de remise. La page de tarifs donne 20 % seulement à grok-4.3 et aux variantes grok-4.20, et dit que les modèles non listés n'ont pas de remise batch. La page de grok-4.7 dit que Batch API n'est pas pris en charge. Attendre la nuit ne divise pas ce modèle par deux.
Les outils sont un second compteur. Les requêtes qui utilisent les outils serveur de xAI paient les tokens plus les invocations. La recherche web (web_search) et l'exécution de code coûtent 5 $ pour 1 000 appels. La recherche dans les collections coûte 2,50 $ pour 1 000. Les pièces jointes (attachment_search) coûtent 10 $ pour 1 000. Depuis le 21 septembre 2026 à 12 h PT, X Search coûte 5 $ pour 1 000 publications récupérées et 10 $ pour 1 000 profils utilisateur, à la place de 5 $ pour 1 000 appels. view_image, view_x_video et les outils MCP distants n'ont pas de frais d'invocation ; ils facturent des tokens. La recherche d'images fait partie de la recherche web.
L'endpoint américain est à 1,1 fois. Les requêtes vers https://us.api.x.ai/v1 sont facturées à 1,1 fois les tarifs mondiaux de tokens. Pour grok-4.7, la page imprime 2,20 $ / 0,55 $ / 6,60 $ sous 200 000 et 4,40 $ / 1,10 $ / 13,20 $ au-dessus. Le cache s'applique avant le multiplicateur. La page dit que cet endpoint couvre actuellement grok-4.7 et grok-4.6.
Le traitement prioritaire est un autre 2 fois, et seulement si la réponse le dit. Priority est facturé à 2 fois les tarifs standard sur les tokens d'entrée, de sortie, de cache et de raisonnement, le cache étant appliqué avant le multiplicateur. Vous payez le tarif prioritaire seulement quand la réponse confirme "service_tier": "priority". Il n'est pas disponible pour Batch, et Fast est un produit distinct de ce drapeau d'API.
L'échelle de la famille, et la ligne qui est vraiment moins chère
La ligne contre-intuitive n'est pas une nouvelle remise Grok 4.7. L'entrée en cache de Grok 4.5 est à 0,30 $, contre 0,50 $ sur 4.6 et 4.7, avec la même entrée à 2 $ et la même sortie à 6 $ sous 200 000. Si votre boucle dépend beaucoup du cache et que 4.5 suffit, la nouvelle carte est une hausse de la lecture en cache, pas une baisse. grok-build-0.1 vaut la moitié de 4.7 sur chaque chiffre de contexte court (1 $ / 0,20 $ / 2 $) et sa fenêtre est de 256 000, pas de 500 000. C'est un autre identifiant de modèle, pas un palier de raisonnement de 4.7.
L'autre point contre-intuitif est l'effort. Extra High n'a pas son propre prix d'entrée. Il dépense davantage de tokens de sortie au même tarif de 6 $. La documentation Cursor dit que les écarts entre xhigh, high, medium et low sont plus larges que sur Grok 4.6, et que les tâches plus dures réfléchissent plus longtemps. Laisser la valeur par défaut sur high est une décision d'achat.
Ce que vous payez encore quand le modèle refuse
Un refus n'est pas une ligne gratuite sur cette carte.
Si le système détecte une infraction aux règles d'usage avant la génération sur la Responses API, xAI facture 0,05 $ par requête.
Si la requête est jugée en infraction et que la génération a déjà tourné, cette génération est aussi facturée.
L'entrée en cache est une remise (0,50 $ au lieu de 2,00 $ sous 200 000). La carte texte n'a pas de prix séparé d'écriture en cache. La colonne d'écriture de Cursor est un tiret. L'entrée non mise en cache reste au tarif d'entrée complet.
Les nouvelles tentatives et les échecs qui ont produit des tokens restent de l'usage de tokens. La carte ne les efface pas.
Un abonnement de chat Grok, le quota d'un forfait Cursor et une facture API sont trois objets distincts. Cet article ne convertit pas le prix mensuel d'un forfait grand public en dollars d'API ; ce prix d'abonnement n'a pas été revérifié comme montant de paiement en direct le 22 septembre 2026.
Un commentaire Hacker News cite une page qui affirme que Grok 4.7 (xhigh) coûte « $0.00 per 1M input tokens » et « $0.00 per 1M output tokens », puis dit que le nom de domaine est « appropriately descriptive ». Un zéro sur un widget tiers n'est pas une baisse de prix. La carte API ci-dessus est celle qu'il faut budgéter.
Où le modèle tourne vraiment
La documentation Grok 4.7 liste l'API publique (grok-4.7), l'endpoint régional américain, Grok Build comme modèle par défaut de l'agent de code, Cursor sur tous les forfaits, et les passerelles OpenRouter, Vercel et Cloudflare. Les prix affichés des passerelles n'ont pas été réaudités pour cet article ; un extrait de recherche qui ne correspond pas à 2 $ / 6 $ n'est pas une raison d'abandonner la carte officielle.
Le groupe Cursor des forfaits personnels et d'équipe comprend Grok 4.7, Grok 4.6, Grok 4.5 et Composer 2.5. Ce groupe est un quota, pas une pile prépayée de tokens d'API. Fast par défaut à partir de Pro signifie qu'un forfait peut consommer la ligne Fast sans choix séparé à chaque tour.
Le niveau gratuit de Grok Build n'inclut pas Fast. La note de lancement dit aussi que l'on peut essayer Grok Build sur x.ai/build. « Try for free » sur cette page ne dit pas que les tokens de l'API grok-4.7 sont gratuits.
Deux budgets API déjà calculés
Ils n'utilisent que la carte xAI : pas d'outils, pas les 10 % américains, pas le drapeau de priorité, pas de nouvelles tentatives. C'est de l'arithmétique, pas une prévision.
Une réponse courte sur la carte par défaut, sous le seuil. 10 000 tokens d'entrée non mis en cache et 2 000 de sortie :
(10,000 × $2 + 2,000 × $6) / 1,000,000 = $0.032La même forme en Fast court imprimé vaut 0,064 $. La sortie vaut 3 fois l'entrée, donc un raisonnement long domine même si le prompt est petit.
Un prompt d'agent à froid qui dépasse 200 000. 250 000 tokens d'entrée non mis en cache et 8 000 de sortie. Les tarifs de contexte long s'appliquent à tout :
(250,000 × $4 + 8,000 × $12) / 1,000,000 = $1.096Les mêmes volumes, s'ils étaient encore facturés en contexte court, vaudraient 0,548 $. Le seuil est la différence. À 90 % d'entrée en cache, toujours sur la ligne longue :
(25,000 × $4 + 225,000 × $1 + 8,000 × $12) / 1,000,000 = $0.421Le Fast imprimé au-dessus de 200 000, à froid, est (250,000 × $6 + 8,000 × $18) / 1,000,000 = $1.644. Doubler la ligne standard longue inventerait 2,192 $. Utilisez 1,644 $.
Calcul local
Estimer la facture API mensuelle
Tarifs officiels xAI vérifiés le 22 septembre 2026. La sortie est comptée une fois et inclut le raisonnement. Vos saisies restent sur cette page.
Dès 200 000 tokens d'entrée, toute la requête passe au tarif long contexte. Fast suit la table imprimée, qui n'est pas le double plat de cette ligne. Hors outils, +10 % US, priorité, nouvelles tentatives et le seuil 256k de Cursor. Vérifier le tarif
Le calculateur reste dans le navigateur. Il bascule toute la requête vers les tarifs de contexte long à partir de 200 000 tokens d'entrée, et l'option Fast utilise la table Fast imprimée pour grok-4.7 seulement. grok-4.6 et grok-4.5 restent sur leurs lignes standard afin que l'écart de cache de 4.5 reste visible. Il ne modélise pas les frais d'outils, les 10 % américains, la priorité, les nouvelles tentatives ni le seuil de 256 000 de Cursor. Rouvrez la page officielle des tarifs avant de figer un budget.
Après la carte, un endroit pour faire tourner le modèle
Connaître la carte n'attache pas le modèle aux pages et aux fichiers déjà ouverts. Tabbit Browser est le client pour cette étape : le sélecteur de modèles, la page active et les fichiers locaux sont sur la même surface, donc comparer un parcours est une sélection, pas une nouvelle intégration de facturation.
La limite est le sens de cette section. Tabbit ne remplace pas la facture xAI et ne change pas la règle des 256 000 de Cursor. La page du modèle Grok 4.7 (English) liste le modèle et dit que sa présence dans Tabbit dépend du sélecteur en direct du compte. Les notes de prompts (English) et les notes de revue (English) retracent l'appel de l'API et la lecture des benchmarks publics. Ce n'est pas une facture Tabbit mesurée. Cet article n'a pas lancé de tâche chronométrée dans Tabbit, donc il n'affirme ni coût, ni latence, ni taux de réussite Tabbit.
Tabbit BrowserSi le travail est la session de navigateur elle-même, commencez par le guide du navigateur IA, la vue d'ensemble des navigateurs agentiques, ce qu'est un navigateur agentique et le guide d'automatisation du navigateur. La comparaison de navigateurs 2026 et les notes d'usage de Tabbit séparent le choix du client de la carte de tokens.
Quelle facture vous choisissez vraiment
| Charge | Ce qui domine la facture | Commencer ici | À surveiller |
|---|---|---|---|
| Appels API courts | Tokens de sortie à 6 $ / 1M | grok-4.7, effort low ou medium | L'effort par défaut est high |
| Prompts répétés sous 200 000 | Lectures en cache à 0,50 $ | API standard avec une clé de cache stable | Les lectures en cache de 4.5 sont à 0,30 $ si la qualité suffit |
| Prompts à 200 000 ou plus sur l'API | Le seuil de toute la requête | Restructurer, ou budgéter 4 $ / 12 $ | Ce n'est pas « seulement le surplus » |
| Le même prompt dans Cursor | La ligne de 256 000 et Fast par défaut | Vitesse standard sauf si la latence exige Fast | Pro et au-dessus sont en Fast par défaut |
| La latence avant le coût | Carte Fast imprimée | Fast de Cursor ou de Grok Build | Pas sur l'API publique ; pas de quota gratuit Grok Build |
| Agents riches en outils | 5 $ / 1 000 appels plus les tokens | Limiter recherche et exécution de code | La facturation X Search a changé le 21 septembre 2026 |
Verdict
Achetez Grok 4.7 quand la tâche est assez longue pour que l'effort supplémentaire mérite ses tokens, et achetez volontairement l'effort et la surface. La carte API reste celle de Grok 4.6. Sur ce graphique, Low est à 1,58 $ la tâche et Extra High à 6,01 $. Gardez les prompts sous 200 000 tokens sur l'API, sauf si vous avez déjà chiffré 4 $ / 12 $ pour toute la requête. Traitez Fast comme la table imprimée 4 $ / 1 $ / 12 $ et 6 $ / 1,50 $ / 18 $, et rappelez-vous que Cursor bascule à 256 000, pas à 200 000. Utilisez grok-4.5 ou grok-build-0.1 quand le cache moins cher ou la ligne à moitié prix suffit. N'attendez pas une remise Batch que la page du modèle dit inexistante.
Les articles de vue d'ensemble, de revue et d'alternatives de ce modèle ne sont pas encore publiés. D'ici là, l'article Grok 4.6, les notes du modèle (English) et les pages officielles ci-dessous sont la piste. Revoyez la carte avant un engagement mensuel ; le changement X Search sur cette même page de tarifs est daté du 21 septembre 2026.
Sources
Tarifs de l'API xAI : tarifs texte, table Fast, outils, liste Batch, endpoint américain, priorité, frais d'infraction ; vérifié le 22 septembre 2026
Page du modèle grok-4.7 : 2 $ / 0,50 $ / 6 $, interrupteur de contexte élevé, Batch non pris en charge, effort par défaut high
Documentation Grok 4.7 : identifiant, disponibilité de Fast, 10 % américains, lieux d'exécution ; dernière mise à jour le 21 septembre 2026
Introducing Grok 4.7 : prix de départ, phrase sur la variante rapide, points de coût CursorBench
Documentation Cursor Grok 4.7 : seuil de 256 000, Fast par défaut, lignes de tarifs ; ouverte le 22 septembre 2026
Traces communautaires, avec les conditions dans les légendes : r/cursor 1wmswj9, HN 49789558
Questions fréquentes
Combien coûte Grok 4.7 ?
Sur l'API xAI, vérifiée le 22 septembre 2026, grok-4.7 coûte 2 $ par million de tokens d'entrée, 0,50 $ par million d'entrée en cache et 6 $ par million de tokens de sortie quand le prompt reste sous 200 000 tokens. À partir de ce seuil, toute la requête passe à 4 $, 1 $ et 12 $. L'identifiant public du modèle est grok-4.7.
Grok 4.7 a-t-il le même prix que Grok 4.6 ?
Les lignes de contexte court et long correspondent à Grok 4.6 : 2 $/0,50 $/6 $ sous 200 000 tokens d'entrée, et 4 $/1 $/12 $ à partir de là. C'est le prix affiché. Le graphique CursorBench de xAI montre encore Grok 4.7 Extra High à 6,01 $ par tâche et Low à 1,58 $, donc l'effort change la facture sans changer la carte. Un utilisateur Cursor Ultra qui a chronométré une tâche a aussi estimé environ 2,5 fois la consommation de quota par rapport à Grok 4.6, en extra high et avec fast mode désactivé.
Quel est le prix du contexte long de Grok 4.7 ?
Sur l'API xAI, dès qu'un prompt atteint 200 000 tokens, chaque token de cette requête est facturé à 4 $ d'entrée, 1 $ d'entrée en cache et 12 $ de sortie par million. Cursor documente un autre seuil : l'usage standard à la demande double seulement après 256 000 tokens d'entrée, jusqu'à une fenêtre de 500 000. Ne mélangez pas les deux seuils.
Combien coûte Grok 4.7 Fast ?
La page de tarifs xAI liste Fast, disponible seulement dans Cursor et Grok Build, à 4 $/1 $/12 $ par million sous 200 000 tokens de prompt et à 6 $/1,50 $/18 $ au-dessus. Le texte dit aussi le double des tarifs standard. La ligne Fast imprimée en contexte long vaut 1,5 fois la ligne standard de contexte long, pas le double. Fast n'est pas sur l'API publique xAI et reste hors du quota gratuit de Grok Build.
L'API Batch réduit-elle Grok 4.7 ?
Non. La page du modèle grok-4.7 indique que Batch API n'est pas pris en charge. La page de tarifs accorde 20 % de remise par lot seulement à des modèles plus anciens, comme grok-4.3 et les variantes grok-4.20, et précise que les modèles absents de cette liste n'ont pas de remise batch.
Les outils et les refus coûtent-ils en plus ?
Les outils côté serveur se facturent en plus des tokens. La recherche web et l'exécution de code coûtent 5 $ pour 1 000 appels. Depuis le 21 septembre 2026 à 12 h PT, X Search coûte 5 $ pour 1 000 publications récupérées et 10 $ pour 1 000 profils utilisateur. Une requête Responses API jugée en infraction avant génération est facturée 0,05 $. Si la génération se termine puis enfreint les règles, les tokens restent facturés.