Comment utiliser l'API Grok 4.3 ?

xAI a déployé Grok 4.3 par étapes : bêta le 17 avril 2026, accès API le 30 avril, puis disponibilité générale le 6 mai. Pour les développeurs, les changements à intégrer sont clairs : fenêtre de contexte d’un million de jetons, entrée vidéo native, raisonnement permanent, baisse de prix d’environ 40 % par rapport à Grok 4.20, et retrait de huit modèles Grok hérités le 15 mai. Si votre application utilise encore `grok-3` ou `grok-4`, planifiez la migration maintenant.

Essayez Apidog aujourd’hui

Ce guide montre comment appeler Grok 4.3 depuis votre code : endpoint, authentification, URL de base compatible OpenAI, reasoning_effort, entrée vidéo, appel de fonctions, migration et tests dans Apidog.

Pour le volet vocal de la même version, voir Comment utiliser Grok Voice gratuitement. Pour la comparaison avec le modèle vocal phare d’OpenAI, voir Grok Voice vs GPT-Realtime.

En bref

• Grok 4.3 est disponible depuis le 6 mai 2026.
• Huit modèles hérités seront retirés le 15 mai 2026.
• Tarification : 1,25 $ / million de jetons d’entrée, 2,50 $ / million de jetons de sortie, entrée en cache à 0,20 $ / million.
• Fenêtre de contexte : 1 000 000 de jetons.
• Entrée vidéo native.
• Raisonnement permanent.
• Effort de raisonnement : low, medium, high dans l’API. Par défaut : medium.
• Endpoint : https://api.x.ai/v1/chat/completions.
• URL de base compatible OpenAI : https://api.x.ai/v1.
• Débit annoncé : environ 159 jetons/seconde sur les niveaux standard.
• Indice d’intelligence : 53 selon Analyse Artificielle, 10e sur 146 modèles suivis.
• Utilisez Apidog pour rejouer vos requêtes, comparer les niveaux de raisonnement et conserver vos variables d’environnement.

Quoi de neuf dans Grok 4.3

Les changements les plus importants côté implémentation :

1. Baisse de prix

   • Entrée : -37,5 % par rapport à Grok 4.20.
   • Sortie : -58,3 %.
   • Entrée en cache : 0,20 $/M, utile pour les prompts système longs et stables.

2. Contexte d’un million de jetons

   • Pratique pour charger une base de code, un contrat long, des logs volumineux ou un historique d’agent.

3. Entrée vidéo native

   • Vous pouvez envoyer une URL vidéo directement dans le contenu du message.
   • Le modèle raisonne sur les images sans extraction manuelle de frames.

4. Raisonnement permanent

   • Grok 4.3 raisonne sur chaque requête.
   • reasoning_effort ajuste la profondeur, mais ne désactive pas le raisonnement.

5. Meilleure agentivité

   • xAI annonce +300 points Elo sur GDPval-AA par rapport à Grok 4.20.
   • Les workflows avec outils et appels multi-étapes devraient être plus fiables.

Prérequis

Avant d’appeler l’API, préparez :

• Un compte xAI Console sur console.x.ai.
• Une clé API avec facturation activée.
• Le SDK OpenAI ou le SDK xAI.
• Un client API pour tester et rejouer les requêtes.

Exportez votre clé API :

export XAI_API_KEY="xai-..."

Si vous travaillez en équipe, utilisez plutôt des variables d’environnement par environnement : dev, staging, prod.

Endpoint et authentification

Grok 4.3 utilise l’interface Chat Completions compatible OpenAI.

POST https://api.x.ai/v1/chat/completions

En-têtes requis :

Authorization: Bearer $XAI_API_KEY
Content-Type: application/json

L’URL de base à configurer dans le SDK est :

https://api.x.ai/v1

Appel minimal avec le SDK OpenAI en Python

Installez le SDK :

pip install openai

Puis créez un client avec base_url pointant vers xAI :

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["XAI_API_KEY"],
    base_url="https://api.x.ai/v1",
)

response = client.chat.completions.create(
    model="grok-4.3",
    messages=[
        {
            "role": "user",
            "content": "Résume les compromis entre GraphQL et REST en trois points."
        }
    ],
    reasoning_effort="medium",
)

print(response.choices[0].message.content)

Le changement principal pour migrer depuis OpenAI est donc :

base_url="https://api.x.ai/v1"
model="grok-4.3"

Appel minimal avec curl

curl https://api.x.ai/v1/chat/completions \
  -H "Authorization: Bearer $XAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "grok-4.3",
    "messages": [
      {
        "role": "system",
        "content": "Tu es un ingénieur backend senior."
      },
      {
        "role": "user",
        "content": "Analyse ce plan de requête SQL et identifie le goulot d’étranglement."
      }
    ],
    "reasoning_effort": "high"
  }'

La réponse suit la forme OpenAI :

{
  "choices": [
    {
      "message": {
        "role": "assistant",
        "content": "..."
      }
    }
  ],
  "usage": {
    "prompt_tokens": 0,
    "completion_tokens": 0,
    "reasoning_tokens": 0,
    "total_tokens": 0
  }
}

Paramètres de requête utiles

Choisir le bon reasoning_effort

Utilisez reasoning_effort comme un levier de coût, de latence et de qualité.

low

À utiliser pour :

• classification ;
• résumé court ;
• extraction de champs ;
• Q&R simple ;
• transformation de texte.

Exemple :

response = client.chat.completions.create(
    model="grok-4.3",
    messages=[
        {
            "role": "user",
            "content": "Classe ce ticket : bug, question ou demande de fonctionnalité."
        }
    ],
    reasoning_effort="low",
)

medium

À utiliser par défaut pour :

• support client ;
• analyse de données ;
• appels de fonctions simples ;
• génération de contenu technique ;
• workflows d’agent en une étape.

response = client.chat.completions.create(
    model="grok-4.3",
    messages=[
        {
            "role": "user",
            "content": "Analyse ces logs et propose la cause la plus probable."
        }
    ],
    reasoning_effort="medium",
)

high

À réserver aux tâches coûteuses ou sensibles :

• revue de code complexe ;
• agents multi-étapes ;
• raisonnement mathématique ;
• planification ;
• diagnostic avec plusieurs hypothèses.

response = client.chat.completions.create(
    model="grok-4.3",
    messages=[
        {
            "role": "user",
            "content": "Voici un diff complet. Identifie les risques de régression et propose des tests."
        }
    ],
    reasoning_effort="high",
)

Même avec low, Grok 4.3 conserve un raisonnement de base. Ne l’utilisez donc pas comme un mode “sans raisonnement”, mais comme un mode de raisonnement réduit.

Streaming

Pour afficher la réponse au fur et à mesure :

stream = client.chat.completions.create(
    model="grok-4.3",
    messages=[
        {
            "role": "user",
            "content": "Explique comment optimiser une API REST lente."
        }
    ],
    reasoning_effort="medium",
    stream=True,
)

for chunk in stream:
    delta = chunk.choices[0].delta
    if delta.content:
        print(delta.content, end="")

Ce mode est préférable pour les interfaces utilisateur où la latence perçue compte.

Sortie JSON structurée

Pour forcer une réponse JSON :

response = client.chat.completions.create(
    model="grok-4.3",
    messages=[
        {
            "role": "user",
            "content": "Extrait le nom, le rôle et le niveau de priorité de ce ticket."
        }
    ],
    response_format={"type": "json_object"},
    temperature=0,
)

print(response.choices[0].message.content)

Exemple de prompt plus robuste :

messages = [
    {
        "role": "system",
        "content": "Réponds uniquement avec un objet JSON valide."
    },
    {
        "role": "user",
        "content": """
Ticket :
Alice, responsable infra, signale que l’API de paiement échoue en production.
Priorité élevée.

Retourne :
{
  "name": string,
  "role": string,
  "priority": "low" | "medium" | "high"
}
"""
    }
]

Appel de fonctions

Grok 4.3 accepte le format d’outils compatible OpenAI.

Déclarez une fonction :

tools = [
    {
        "type": "function",
        "function": {
            "name": "lookup_user",
            "description": "Recherche un utilisateur par ID.",
            "parameters": {
                "type": "object",
                "properties": {
                    "user_id": {
                        "type": "string",
                        "description": "Identifiant utilisateur interne."
                    }
                },
                "required": ["user_id"],
            },
        },
    }
]

Appelez le modèle :

response = client.chat.completions.create(
    model="grok-4.3",
    messages=[
        {
            "role": "user",
            "content": "Trouve l’utilisateur u_42 et indique sa dernière connexion."
        }
    ],
    tools=tools,
    tool_choice="auto",
    reasoning_effort="medium",
)

message = response.choices[0].message
tool_calls = message.tool_calls

print(tool_calls)

Ensuite :

1. lisez tool_calls ;
2. exécutez la fonction côté serveur ;
3. renvoyez le résultat au modèle avec un message de rôle tool.

Exemple de boucle simplifiée :

messages = [
    {
        "role": "user",
        "content": "Trouve l’utilisateur u_42 et indique sa dernière connexion."
    }
]

first_response = client.chat.completions.create(
    model="grok-4.3",
    messages=messages,
    tools=tools,
    reasoning_effort="medium",
)

assistant_message = first_response.choices[0].message
messages.append(assistant_message)

for call in assistant_message.tool_calls:
    if call.function.name == "lookup_user":
        result = {
            "user_id": "u_42",
            "last_login": "2026-05-05T14:22:00Z"
        }

        messages.append({
            "role": "tool",
            "tool_call_id": call.id,
            "content": json.dumps(result)
        })

final_response = client.chat.completions.create(
    model="grok-4.3",
    messages=messages,
    tools=tools,
)

print(final_response.choices[0].message.content)

Le gain de 300 points Elo sur GDPval-AA devrait surtout se voir sur ce type de workflow : meilleurs choix d’outils, moins d’appels redondants, meilleure récupération après erreur. Pour tester des flux d’outils plus complexes, voir le test de serveur MCP dans Apidog.

Entrée vidéo

Grok 4.3 est le premier modèle Grok avec entrée vidéo native.

Exemple :

response = client.chat.completions.create(
    model="grok-4.3",
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "text",
                    "text": "Décris ce qui se passe dans cette vidéo et signale toute anomalie."
                },
                {
                    "type": "video_url",
                    "video_url": {
                        "url": "https://example.com/clip.mp4"
                    }
                }
            ],
        }
    ],
    reasoning_effort="medium",
)

print(response.choices[0].message.content)

Points à surveiller :

• les jetons vidéo sont comptés comme entrée ;
• les longues vidéos peuvent consommer rapidement le contexte ;
• découpez ou sous-échantillonnez si le coût est critique ;
• vous n’avez pas besoin d’extraire manuellement les images clés.

Entrée image

Grok 4.3 prend aussi en charge les images.

response = client.chat.completions.create(
    model="grok-4.3",
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "text",
                    "text": "Analyse cette capture d’écran et identifie le problème UX principal."
                },
                {
                    "type": "image_url",
                    "image_url": {
                        "url": "https://example.com/screenshot.png"
                    }
                }
            ]
        }
    ]
)

Utiliser le contexte d’un million de jetons

La fenêtre d’un million de jetons est utile si vous structurez correctement l’entrée.

Cas d’usage pratiques :

• Revue de code

  • Ajoutez le diff.
  • Ajoutez les fichiers modifiés.
  • Ajoutez la sortie du linter et des tests.
  • Demandez une revue orientée risques.

• Q&R documentaire

  • Insérez un contrat, une documentation interne ou un rapport long.
  • Posez des questions ciblées.
  • Demandez des citations ou sections pertinentes si nécessaire.

• Mémoire d’agent

  • Conservez un historique de conversations.
  • Résumez périodiquement les anciennes interactions.
  • Gardez les faits utilisateur stables dans un bloc cacheable.

Exemple de structure de prompt pour une revue de code :

Tu es un reviewer backend senior.

Objectif :
- Identifier les bugs probables.
- Identifier les régressions de performance.
- Proposer des tests manquants.
- Ne pas commenter le style sauf si cela affecte la maintenabilité.

Contexte :
<architecture>
...
</architecture>

Diff :
<diff>
...
</diff>

Logs CI :
<ci_logs>
...
</ci_logs>

L’entrée en cache à 0,20 $/M rend les prompts système longs plus viables. Par exemple, une base stable de 400k jetons coûte 0,08 $ par appel en cache, contre 0,50 $ si elle est facturée comme nouvelle entrée.

Migration depuis Grok 3 et Grok 4

Huit modèles Grok hérités seront retirés le 15 mai 2026 à 12h00 PT.

Migration minimale :

- model="grok-4.20"
+ model="grok-4.3"

Ou :

- model="grok-3"
+ model="grok-4.3"

La plupart des appels continuent de fonctionner car le format Chat Completions reste compatible.

Vérifiez toutefois deux points.

1. reasoning_effort

Certains modèles hérités ne prenaient pas ce paramètre en charge.

Avec Grok 4.3 :

reasoning_effort="low"

est le choix le plus proche d’un chemin rapide, mais le raisonnement n’est pas désactivé.

2. Format de sortie

Grok 4.3 peut produire des réponses plus structurées que Grok 4.20. Si votre pipeline dépend de regex fragiles, testez vos parsers avant de basculer en production.

Pour comparer avec les prix OpenAI, voir Tarification de GPT-5.5. Pour un autre guide d’intégration API, voir Comment utiliser l’API GPT-5.5.

Tester Grok 4.3 dans Apidog

Le workflow de test recommandé :

1. Créez un environnement Apidog.
2. Ajoutez les variables :
   • XAI_API_KEY
   • BASE_URL = https://api.x.ai/v1
3. Créez une requête POST.
4. Utilisez l’URL :
   • {{BASE_URL}}/chat/completions
5. Ajoutez les en-têtes :
   • Authorization: Bearer {{XAI_API_KEY}}
   • Content-Type: application/json
6. Créez trois variantes de body :
   • reasoning_effort: "low"
   • reasoning_effort: "medium"
   • reasoning_effort: "high"
7. Exécutez les trois variantes.
8. Comparez :
   • contenu de réponse ;
   • latence ;
   • usage.prompt_tokens ;
   • usage.completion_tokens ;
   • usage.reasoning_tokens ;
   • usage.total_tokens.

Body de base :

{
  "model": "grok-4.3",
  "messages": [
    {
      "role": "system",
      "content": "Tu es un ingénieur backend senior."
    },
    {
      "role": "user",
      "content": "Analyse cette erreur API et propose un plan de debug."
    }
  ],
  "reasoning_effort": "medium"
}

Téléchargez Apidog pour exécuter la comparaison. Pour une stratégie de test API plus large, voir Outil de test API pour les ingénieurs QA.

Limites de débit

Les limites dépendent du niveau de votre compte dans la console xAI.

À retenir :

• les niveaux de base commencent à quelques milliers de requêtes par minute ;
• les niveaux entreprise montent beaucoup plus haut ;
• les chiffres exacts doivent être vérifiés dans la console ;
• le débit annoncé de 159 jetons/seconde correspond à la vitesse de sortie par flux, pas à un total agrégé.

En cas de dépassement, l’API renvoie un 429 avec un en-tête retry-after.

Implémentez un backoff exponentiel :

import time
from openai import RateLimitError

def call_with_retry(fn, max_retries=5):
    for attempt in range(max_retries):
        try:
            return fn()
        except RateLimitError:
            sleep_seconds = min(2 ** attempt, 30)
            time.sleep(sleep_seconds)

    raise RuntimeError("Limite de débit persistante après plusieurs tentatives")

Checklist de migration production

Avant de remplacer un modèle existant par grok-4.3 :

• [ ] Remplacer le nom du modèle.
• [ ] Configurer base_url="https://api.x.ai/v1".
• [ ] Ajouter reasoning_effort.
• [ ] Tester low, medium, high sur des prompts réels.
• [ ] Mesurer latence et tokens.
• [ ] Vérifier les parsers de sortie.
• [ ] Tester les appels de fonctions.
• [ ] Tester les limites de débit.
• [ ] Ajouter un retry sur 429.
• [ ] Surveiller les coûts liés au contexte long.
• [ ] Migrer avant le 15 mai 2026.

FAQ

Grok 4.3 est-il compatible OpenAI ?

Oui pour Chat Completions. Vous pouvez utiliser le SDK OpenAI, changer base_url, puis utiliser model="grok-4.3".

Prend-il en charge l’API Responses ?

L’interface xAI mentionnée ici est Chat Completions. L’API Responses reste propre à OpenAI.

Quelle est la limite de contexte réelle ?

1 000 000 de jetons.

Le raisonnement permanent augmente-t-il la latence ?

Oui, la latence du premier jeton peut être plus élevée que sur des modèles sans raisonnement. En contrepartie, Grok 4.3 diffuse la sortie à environ 159 jetons/seconde.

Puis-je utiliser Grok 4.3 avec Grok Voice ?

Oui. L’agent vocal grok-voice-think-fast-1.0 appelle Grok 4.3 en arrière-plan lorsqu’il raisonne. Vous pouvez aussi appeler Grok 4.3 directement dans une boucle vocale construite avec TTS et STT.

Que se passe-t-il avec mes anciens appels Grok 3 ou Grok 4 après le 15 mai ?

Ils échoueront avec un 410 indiquant que le modèle est retiré. Migrez avant la date limite.

Grok 4.3 prend-il en charge les images ?

Oui. Envoyez une URL d’image dans un bloc de contenu, avec une structure similaire à celle utilisée pour les modèles compatibles OpenAI.

Conclusion

Grok 4.3 est une mise à jour importante pour les développeurs : prix en baisse, contexte d’un million de jetons, raisonnement permanent, entrée vidéo native et compatibilité OpenAI via Chat Completions.

Le chemin le plus court pour valider la migration :

1. remplacez l’URL de base par https://api.x.ai/v1 ;
2. utilisez model="grok-4.3" ;
3. testez reasoning_effort avec low, medium et high ;
4. mesurez latence, qualité et tokens ;
5. migrez avant le 15 mai.

Automatisez ces variantes dans Apidog, rejouez vos vrais prompts et comparez les résultats avant le passage en production.