Comment utiliser l'API Grok 4.7 ? Réussissez votre premier appel en 5 minutes

TL;DR

• Grok 4.7 est le modèle textuel de xAI destiné au codage et aux tâches agentiques, désormais disponible sur HiAPI. Ouvrez la page du modèle pour discuter directement ; les nouveaux utilisateurs reçoivent 200 crédits à l'inscription.
• Prix sur la plateforme : $0.84 en entrée / $2.52 en sortie (par 1M tokens, lecture de cache $0.21), soit environ 20 % de réduction par rapport au prix officiel. Une requête de 2K en entrée + 1K en sortie coûte environ $0.0042 ; en se basant sur une requête moyenne de 3K tokens au total (environ $0.0084 par appel), $10 permettent environ 1200 appels.
• Appel le plus rapide : POST https://api.hiapi.ai/v1/chat/completions, avec model défini sur grok-4.7. Le code existant avec le SDK OpenAI ne nécessite que la modification de deux valeurs : base_url et model.

Qu'est-ce que Grok 4.7 et quelles sont ses nouveautés

Publié le 2026-09-21, Grok 4.7 est le modèle par défaut actuellement recommandé par xAI, axé sur le codage, les tâches agentiques et le travail intellectuel. Le score Terminal-Bench 4.0 annoncé officiellement passe de 20,3 % pour la 4.6 à 38,0 %, soit près du double (selon les chiffres auto-déclarés). Pour les intégrateurs, quatre changements méritent l'attention :

• Le codage et les tâches agentiques sont les scénarios phares : xAI l'a simultanément intégré à des outils de codage comme Cursor et GitHub Copilot ; la planification de tâches de longue durée est au cœur de cette version.
• Quatre niveaux de raisonnement : reasoning_effort prend en charge low / medium / high / xhigh, avec high par défaut ; le processus de réflexion est renvoyé séparément dans le champ reasoning_content, ce qui vous permet de décider de l'afficher ou non.
• Objet JSON + appel d'outils : response_format: {"type": "json_object"} force une sortie JSON valide ; les appels de fonctions utilisent le format standard OpenAI tools, sans emballage supplémentaire pour l'extraction structurée et les boucles d'agents.
• Contexte de 500K : une seule requête peut contenir une base de code complète ou de longs documents.

Résultat réel : un extrait de code d'analyse de données pandas

La sortie ci-dessous provient d'un test réel effectué avec Grok 4.7 sur HiAPI (le prompt complet se trouve via le lien ci-dessous). La tâche consistait à analyser des données de commandes e-commerce : GMV mensuel, top 20 des utilisateurs par dépenses cumulées, tendance du montant moyen de la première commande des nouveaux utilisateurs, avec created_at en type chaîne. Le modèle a terminé en 18,5 secondes, le code est complet et exécutable, et il a géré spontanément la conversion des dates de type chaîne :

# ---------- 0. Traitement des dates : chaîne vers datetime ----------
df["created_at"] = pd.to_datetime(df["created_at"], errors="coerce")
df = df.dropna(subset=["created_at", "amount", "user_id"])

# Ne compter que les commandes valides (ajuster les valeurs status selon le métier réel)
df_valid = df[df["status"] == "paid"].copy()

# ---------- 1. GMV et nombre de commandes par mois ----------
df_valid["month"] = df_valid["created_at"].dt.to_period("M")
monthly = (
    df_valid.groupby("month", as_index=False)
    .agg(GMV=("amount", "sum"), order_count=("order_id", "count"))
    .sort_values("month")
)

Ce test réel a consommé 3440 tokens en entrée et 1427 tokens en sortie, soit environ $0.007 au prix de la plateforme. Pour obtenir le même résultat, cliquez directement sur ce lien pour exécuter ce prompt sur la page du modèle →

Deux parcours pour démarrer

Parcours 1 : navigateur, 3 étapes, sans code

1. Ouvrez la page du modèle Grok 4.7, connectez-vous ou inscrivez-vous (200 crédits offerts aux nouveaux utilisateurs).
2. Collez votre prompt dans la zone de dialogue, par exemple en cliquant sur ce lien, le prompt est déjà prérempli.
3. Envoyez directement ; le quota est déduit selon l'utilisation réelle des tokens.

Parcours 2 : API, 3 étapes, intégration dans votre application

1. Créez une clé API dans la console HiAPI.
2. Remplacez YOUR_HIAPI_API_KEY dans la commande curl ci-dessous par votre clé, puis exécutez-la.
3. Fixez model sur grok-4.7, remplacez messages par vos entrées métier, et c'est terminé.

curl : premier appel

curl https://api.hiapi.ai/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_HIAPI_API_KEY" \
  -d '{
    "model": "grok-4.7",
    "messages": [
      {"role": "system", "content": "You are a senior backend engineer."},
      {"role": "user", "content": "Explain what a database connection pool is in two sentences."}
    ],
    "reasoning_effort": "high",
    "max_tokens": 2000
  }'

Dans la réponse, choices[0].message.content contient le texte final et reasoning_content le processus de réflexion ; usage.completion_tokens_details.reasoning_tokens vous indique séparément combien de tokens de raisonnement ont été consommés pour cette requête. Pour le streaming, ajoutez "stream": true et parsez les événements SSE.

Python : non-streaming + streaming

Pour le non-streaming, requests suffit :

import requests

resp = requests.post(
    "https://api.hiapi.ai/v1/chat/completions",
    headers={"Authorization": "Bearer YOUR_HIAPI_API_KEY"},
    json={
        "model": "grok-4.7",
        "messages": [
            {"role": "user", "content": "Write a Python function that merges two sorted lists into one sorted list."}
        ],
        "reasoning_effort": "medium",
        "max_tokens": 4000,
    },
    timeout=120,
)
resp.raise_for_status()
data = resp.json()
print(data["choices"][0]["message"]["content"])

Deux points à noter pour le streaming : les premiers delta.reasoning_content correspondent au processus de réflexion, et seul le delta.content qui suit est le texte final ; usage n'apparaît que dans le dernier chunk (choices vide), et le flux se termine par data: [DONE] :

import json
import requests

with requests.post(
    "https://api.hiapi.ai/v1/chat/completions",
    headers={"Authorization": "Bearer YOUR_HIAPI_API_KEY"},
    json={
        "model": "grok-4.7",
        "messages": [{"role": "user", "content": "Plan a Redis-based online presence system."}],
        "reasoning_effort": "high",
        "stream": True,
    },
    stream=True,
    timeout=300,
) as resp:
    resp.raise_for_status()
    for line in resp.iter_lines(decode_unicode=True):
        if not line or not line.startswith("data:"):
            continue
        payload = line[len("data:"):].strip()
        if payload == "[DONE]":
            break
        chunk = json.loads(payload)
        if not chunk["choices"]:
            print("\nusage:", chunk["usage"])  # usage n'apparaît que dans le dernier chunk
            continue
        delta = chunk["choices"][0]["delta"]
        if delta.get("reasoning_content"):
            print(delta["reasoning_content"], end="", flush=True)
        elif delta.get("content"):
            print(delta["content"], end="", flush=True)

Tableau des paramètres

Champ	Obligatoire	Valeurs	Description
model	Oui	grok-4.7	Indiquez toujours cet ID
messages	Oui	Tableau de messages au format OpenAI	Les rôles system / user / assistant / tool sont pris en charge
reasoning_effort	Non	low / medium / high / xhigh, par défaut high	Intensité du raisonnement ; le processus de réflexion est renvoyé dans reasoning_content
max_tokens	Non	Entier positif	Limite de sortie, incluant les tokens de raisonnement ; une valeur trop basse tronque d'abord le raisonnement
response_format	Non	{"type": "json_object"}	Force une sortie JSON valide, adapté à l'extraction structurée
tools	Non	Tableau OpenAI function calling	Appel d'outils, avec prise en charge du renvoi de résultats tool sur plusieurs tours
stream	Non	true / false, par défaut false	Streaming SSE ; usage se trouve dans le dernier chunk

Erreurs que vous rencontrerez

Le piège le plus fréquent lors de la migration de code depuis d'autres modèles : grok-4.7 ne prend pas en charge les trois paramètres frequency_penalty, presence_penalty et stop, et leur présence déclenche directement une erreur 400. reasoning_effort n'accepte que les quatre niveaux low / medium / high / xhigh ; une valeur incorrecte renvoie tel quel reasoning_effort: is outside allowed values ; les champs hors protocole ne passent pas non plus : lors de nos tests, l'ajout d'un champ non enregistré a renvoyé request.zz: unregistered public parameter.

La solution est simple : supprimez ces trois paramètres, corrigez le niveau, puis renvoyez. Pour les autres erreurs 4xx, consultez d'abord error.code avant de modifier le code, ne devinez pas.

À vérifier avant la mise en production

• Les tokens de raisonnement sont facturés comme des tokens de sortie. Au niveau high, une réponse peut inclure un processus de réflexion de plusieurs dizaines de milliers de tokens, facturés à $2.52/M. Pour les tâches simples, réduire reasoning_effort à low ou medium est le levier d'économie le plus direct ; usage.completion_tokens_details.reasoning_tokens permet de vérifier ce nombre séparément.
• Le seuil de 200K pour la requête entière change de tarif. Lorsque le prompt atteint 200K tokens (seuil contractuel 199 999), toute la requête est facturée au tarif longue durée : entrée $1.68 / sortie $5.04 / lecture de cache $0.42, soit le double du tarif normal. Maintenez le trafic courant sous 200K et évitez d'y injecter sans réfléchir une base de code entière.
• La lecture de cache ne coûte qu'un quart du prix normal. Les longs system prompts répétés et les préfixes de conversations multi-tours bénéficient automatiquement du cache, à $0.21/M (un quart du prix normal de $0.84/M). Lors de boucles d'agents, gardez le préfixe stable et votre facture s'en ressentira nettement.

Questions fréquentes

Grok 4.7 ou Grok 4.6, comment choisir ? Le prix sur la plateforme est identique ($0.84/$2.52). Pour le codage complexe et les tâches agentiques, choisissez 4.7 (recommandation officielle par défaut) ; pour les tâches simples où vous voulez économiser des tokens, vous pouvez rester sur 4.6. Comparatif détaillé dans Grok 4.7 vs Grok 4.6.

La sortie en streaming est-elle prise en charge ? Oui, SSE standard. Notez que usage n'est renvoyé que dans le dernier chunk ; les champs usage des chunks précédents sont vides.

reasoning_content est-il facturé en supplément ? Aucun interrupteur spécifique n'est nécessaire, mais les tokens de raisonnement générés sont comptés dans l'utilisation de sortie et facturés au prix de sortie ; plus le niveau est élevé, plus la facture est élevée.

Le contexte de 500K correspond-il à la limite d'entrée ? 500K est la fenêtre totale entrée plus sortie. Lorsque l'entrée approche 200K, le tarif longue durée s'applique ; voir la section « À vérifier avant la mise en production » ci-dessus.

---

Pour aller plus loin : pour le calcul des prix, consultez Combien coûte l'API Grok 4.7 ; pour 5 prompts de scénarios directement copiables, consultez Le recueil de prompts Grok 4.7 ; pour l'usage de la génération précédente, voir la page du modèle Grok 4.6. Copiez le prompt pandas ci-dessus et lancez votre premier appel sur la page du modèle.