Comment utiliser l'API Grok 4.7 ?

Pour appeler Grok 4.7, envoyez une requête POST à https://api.x.ai/v1/responses avec "model": "grok-4.7" et votre clé xAI comme jeton Bearer. Il coûte 2 $ par million de jetons d'entrée, 0,50 $ par million de jetons d'entrée mis en cache et 6 $ par million de jetons de sortie pour les invites de moins de 200 000 jetons, avec une fenêtre contextuelle de 500 000 jetons. SpaceXAI (l'entreprise anciennement appelée xAI) l'a lancé le 21 septembre 2026 au même prix que Grok 4.6, de sorte que pour la plupart des intégrations existantes, la mise à niveau n'est qu'un changement d'une ligne.

Ci-dessous : la première requête, l'effort de raisonnement et son impact sur votre facture, le raisonnement chiffré, la mise en cache, le streaming, les outils, les limites de débit et une configuration de test réutilisable dans Apidog. Pour en savoir plus sur le modèle, lisez ce qu'est Grok 4.7 et ce qui a changé ; la référence officielle est la page Grok 4.7 dans la documentation xAI.

L'API Grok 4.7 en un coup d'œil

Étape 1 : Obtenir une clé et charger des crédits

Créez un compte sur console.x.ai, chargez-le avec des crédits (l'API est prépayée) et générez une clé. Notre guide des clés API Grok vous explique les écrans de la console. Gardez la clé hors de votre code :

export XAI_API_KEY="votre-clé-ici"

Étape 2 : Effectuer votre première requête

L'API Responses est le point d'accès principal et celui que chaque exemple de la documentation xAI utilise :

curl https://api.x.ai/v1/responses \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $XAI_API_KEY" \
  -d '{
    "model": "grok-4.7",
    "input": "Vérifiez cette fonction pour les bugs : function median(a){a.sort();return a[a.length/2]}"
  }'

L'API fonctionne avec le SDK OpenAI. Pointez le client vers l'URL de base de xAI et appelez responses.create :

import OpenAI from "openai";

const client = new OpenAI({
  apiKey: process.env.XAI_API_KEY,
  baseURL: "https://api.x.ai/v1",
});

const response = await client.responses.create({
  model: "grok-4.7",
  reasoning: { effort: "medium" },
  input: [
    { role: "system", content: "Vous êtes un réviseur backend senior." },
    { role: "user", content: "Trouvez le bug dans : function median(a){a.sort();return a[a.length/2]}" },
  ],
});

console.log(response.output_text);

Si vous préférez un autre client, le même modèle est grok-4.7 dans le SDK Python de xAI (xai_sdk), xai.responses('grok-4.7') dans le SDK Vercel AI, et xai/grok-4.7 dans LiteLLM. Deux notes de compatibilité : xAI qualifie désormais les Chat Completions de point d'accès hérité, et sa compatibilité avec le SDK Anthropic est entièrement obsolète. Le nouveau code devrait cibler /v1/responses.

Étape 3 : Choisir un niveau d'effort de raisonnement

Grok 4.7 raisonne toujours. Vous ne pouvez pas le désactiver, mais vous contrôlez l'intensité de sa réflexion avec reasoning.effort sur l'API Responses (reasoning_effort dans le SDK xAI) : low pour les appels d'outils sensibles à la latence, medium pour l'analyse et le contexte long, high (par défaut) pour les problèmes complexes en plusieurs étapes, et xhigh lorsque la qualité prime sur le temps de réponse.

Ce paramètre est le plus grand levier sur votre facture. La page de publication de SpaceXAI publie les résultats de CursorBench 4.0 par niveau d'effort, et l'écart est grand :

Passer de low à xhigh rapporte 13,2 points et coûte environ 3,8 fois plus cher par tâche, car le modèle écrit environ 4,5 fois plus de jetons de sortie. Commencez par medium et ne passez à un niveau supérieur que lorsque vos propres tests montrent que la qualité supplémentaire est importante.

Une contrainte supplémentaire : les modèles de raisonnement rejettent presencePenalty, frequencyPenalty et stop. Si un ancien wrapper envoie toujours l'un d'entre eux, la requête renvoie une erreur.

Étape 4 : Gérer le raisonnement chiffré dans les appels à plusieurs tours

C'est le changement de comportement le plus susceptible de vous surprendre. Sur l'API Responses, grok-4.7 renvoie toujours reasoning.encrypted_content, même si votre liste d'inclusion ne le demande pas. Vous ne pouvez pas lire le raisonnement, mais vous pouvez le faire progresser.

Pour les conversations à plusieurs tours, transmettez les éléments de raisonnement de la réponse précédente sans modification dans l'entrée de la requête suivante. Cela maintient le raisonnement du modèle intact d'un tour à l'autre. Ne modifiez pas, ne coupez pas et ne réorganisez pas ces éléments. Si votre code filtre le tableau output pour ne conserver que les éléments message avant de construire le tour suivant, il écarte maintenant le contexte que Grok 4.7 s'attend à récupérer. Le comportement de Chat Completions reste inchangé.

Étape 5 : Optimiser la mise en cache

L'entrée en cache coûte 0,50 $ par million de jetons contre 2 $ pour une entrée fraîche, soit une réduction de 75 %. L'inconvénient : une frappe de cache nécessite que votre requête atterrisse sur un serveur qui détient déjà le préfixe. SpaceXAI "recommande fortement" de définir prompt_cache_key sur les appels de l'API Responses (ou l'en-tête x-grok-conv-id sur les Chat Completions). Cela achemine les requêtes d'une conversation vers le même serveur ; sans cela, xAI avertit que vous paierez souvent le prix total de l'entrée sur un serveur sans cache.

Organisez l'invite pour la réutilisation : invite système, schémas d'outils et documents de référence en premier, le nouveau message utilisateur en dernier. Tout ce qui change près du début rompt le préfixe et la réduction qui va avec.

Étape 6 : Diffuser les réponses en continu

Ajoutez "stream": true pour recevoir des événements envoyés par le serveur au lieu d'un seul corps JSON à la fin. Comme le raisonnement est toujours activé, le modèle peut réfléchir un certain temps avant le premier jeton de réponse, et un appel non-streaming semble bloqué ou déclenche un court délai d'attente HTTP. Grok 4.7 diffuse des résumés de raisonnement, ce qui vous permet d'afficher la progression pendant qu'il réfléchit.

Les appels de fonction sont l'exception : selon la documentation xAI, un appel de fonction arrive entièrement en un seul bloc. Analysez-le lorsque ce bloc arrive au lieu d'assembler les arguments à partir des deltas. Notre guide sur le test des API LLM qui diffusent en continu via SSE montre comment inspecter la séquence d'événements bruts dans Apidog.

Étape 7 : Ajouter des outils

L'appel de fonction utilise le format d'outil de l'API Responses. Vous décrivez la fonction, Grok renvoie un élément function_call, vous l'exécutez, et vous renvoyez un function_call_output avec l'call_id correspondant :

curl https://api.x.ai/v1/responses \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $XAI_API_KEY" \
  -d '{
    "model": "grok-4.7",
    "input": [{"role": "user", "content": "La commande 10482 a-t-elle déjà été expédiée ?"}],
    "tools": [{
      "type": "function",
      "name": "get_order_status",
      "description": "Rechercher le statut d'exécution d'une commande",
      "parameters": {
        "type": "object",
        "properties": { "order_id": {"type": "string"} },
        "required": ["order_id"]
      }
    }]
  }'

Les sorties structurées sont également prises en charge, de sorte que vous pouvez conformer la réponse finale à un schéma JSON.

Les outils côté serveur s'exécutent côté xAI : {"type": "web_search"}, recherche X et exécution de code. Ils facturent en plus des jetons : la recherche web coûte 5 $ par 1 000 appels, la recherche X 5 $ par 1 000 publications, et l'exécution de code 5 $ par 1 000 appels, de sorte qu'un agent qui effectue une recherche à chaque tour paie ces frais à chaque tour. La recherche web accepte allowed_domains et excluded_domains (jusqu'à cinq chacun). Sans outil de recherche, Grok 4.7 n'a pas de données en temps réel ; ses connaissances s'arrêtent en mai 2026.

Attention au seuil tarifaire des 200k

Le tableau des prix a deux lignes pour une raison. Une fois qu'une invite atteint 200 000 jetons, l'ensemble de la requête est facturé au tarif supérieur : 4 $ d'entrée, 1 $ en cache, 12 $ de sortie. Ce ne sont pas seulement les jetons au-delà de la limite qui coûtent plus cher.

Une invite de 190 000 jetons avec une réponse de 4 000 jetons coûte environ 0,40 $. Une invite de 210 000 jetons avec la même réponse coûte environ 0,89 $. Environ 10 % d'entrée en plus fait plus que doubler la facture.

Comptez les jetons avant d'envoyer, résumez l'historique à mesure qu'une conversation approche de la limite, et utilisez la compression de contexte de xAI pour les longues boucles d'agents. La partie la moins chère de la fenêtre de 500 000 jetons se termine à 200 000.

Limites de débit et 429

Les limites évoluent avec vos dépenses cumulées et correspondent à celles de Grok 4.6 :

Les jetons mis en cache sont pris en compte dans les jetons par minute. Dépassez les limites et vous obtiendrez une erreur HTTP 429. Réessayez avec un délai d'attente exponentiel et un jitter au lieu de marteler le point d'accès ; notre guide sur les erreurs de dépassement de limite de débit couvre les modèles.

Migration depuis Grok 4.6

La plupart des intégrations nécessitent un seul changement : grok-4.6 devient grok-4.7. Le prix, la fenêtre contextuelle, les limites de débit et les niveaux d'effort sont identiques. Retestez trois points avant de déplacer le trafic de production :

• Gestion des tours multiples. Confirmez que votre code transmet les éléments de raisonnement chiffrés sans modification.
• Jetons par tâche. Un nouveau modèle de base, plus grand, modifie le nombre de jetons requis par une tâche, même au même tarif par jeton. Mesurez vos invites réelles.
• Mappage d'effort. La documentation de Cursor indique que les niveaux d'effort sont plus distincts que dans Grok 4.6, de sorte qu'un itinéraire réglé sur medium peut se comporter différemment.

Notre guide de l'API Grok 4.6 reste valable pour tout ce qui n'a pas changé. Deux notes : https://us.api.x.ai/v1 maintient l'inférence aux États-Unis pour une prime de 10 %, et Grok 4.7 Fast (2x prix) n'est disponible que dans Cursor et Grok Build, pas dans l'API publique.

Tester l'API Grok 4.7 dans Apidog

Une requête enregistrée et répétable vaut mieux qu'une commande curl dans l'historique de votre shell lorsque vous comparez les niveaux d'effort ou vérifiez une mise à niveau.

1. Créez un environnement dans Apidog avec base_url défini sur https://api.x.ai/v1 et XAI_API_KEY stockée comme variable secrète. Ajoutez un second environnement pour le point d'accès américain si vous en avez besoin.
2. Enregistrez la requête : POST {{base_url}}/responses avec un en-tête Authorization: Bearer {{XAI_API_KEY}} et votre invite réelle dans le corps.
3. Ajoutez des assertions : le statut est 200, model est égal à grok-4.7, usage existe et output contient un élément message. Cela détecte une clé incorrecte, un ID de modèle incorrect ou une forme de réponse modifiée avant que votre application ne le fasse.
4. Clonez-le par niveau d'effort (low, medium, high, xhigh) et exécutez les quatre comme un scénario de test unique. Vous obtenez le temps de réponse et l'utilisation des jetons côte à côte pour votre invite, pas ceux d'un benchmark.
5. Simulez le point d'accès une fois que la forme de la réponse est stable, afin que le travail frontend puisse continuer sans dépenser de crédits.

Lorsque le prochain modèle sera livré, changez une variable et relancez. Téléchargez Apidog pour le configurer.

FAQ

Quel est l'ID du modèle Grok 4.7 ? grok-4.7. Sur les plateformes partenaires, c'est spacexai/grok-4.7 (Passerelle AI de Vercel) et x-ai/grok-4.7 (OpenRouter).

Combien coûte l'API Grok 4.7 ? 2 $ par million de jetons d'entrée, 0,50 $ en cache, et 6 $ de sortie pour les invites de moins de 200 000 jetons, et le double à partir de 200 000 et plus. Il n'y a pas de réduction par lots pour le 4.7.

Puis-je désactiver le raisonnement ? Non. Utilisez l'effort low pour les réponses les plus rapides et les moins chères.

Existe-t-il une API Grok 4.7 gratuite ? L'API de xAI fonctionne avec des crédits prépayés. Notre guide sur comment utiliser Grok 4.7 gratuitement couvre les voies gratuites qui existent.

Comment Grok 4.7 se compare-t-il à GPT-6 Sol et Claude Opus 5.5 ? Il a le prix de sortie le plus bas des trois et est en retrait par rapport à Opus 5.5 sur les benchmarks de codage rapportés par les deux fournisseurs. La comparaison à trois voies contient les chiffres.

Commencez par une requête enregistrée

Envoyez la requête curl ci-dessus, puis enregistrez-la dans Apidog avec des assertions et un scénario de niveau d'effort. Vous obtiendrez un coût de référence par tâche sur vos propres invites avant de déplacer le trafic. Pour choisir un niveau d'effort par défaut, lisez ensuite l'analyse des benchmarks de Grok 4.7.