DEV Community

Cover image for Comment utiliser l'API Grok 4.3 ?
Antoine Laurent
Antoine Laurent

Posted on • Originally published at apidog.com

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-..."
Enter fullscreen mode Exit fullscreen mode

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
Enter fullscreen mode Exit fullscreen mode

En-têtes requis :

Authorization: Bearer $XAI_API_KEY
Content-Type: application/json
Enter fullscreen mode Exit fullscreen mode

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

https://api.x.ai/v1
Enter fullscreen mode Exit fullscreen mode

Appel minimal avec le SDK OpenAI en Python

Installez le SDK :

pip install openai
Enter fullscreen mode Exit fullscreen mode

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)
Enter fullscreen mode Exit fullscreen mode

Le changement principal pour migrer depuis OpenAI est donc :

base_url="https://api.x.ai/v1"
model="grok-4.3"
Enter fullscreen mode Exit fullscreen mode

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"
  }'
Enter fullscreen mode Exit fullscreen mode

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
  }
}
Enter fullscreen mode Exit fullscreen mode

Paramètres de requête utiles

Paramètre Type Valeurs Usage
model string grok-4.3 Obligatoire.
messages array Format OpenAI Obligatoire. Rôles : system, user, assistant.
reasoning_effort string low, medium, high Contrôle la profondeur du raisonnement. Par défaut : medium.
max_tokens int 1–32768 Limite la taille de sortie.
temperature float 0.0–2.0 Contrôle la variabilité. Par défaut : 1.0.
top_p float 0.0–1.0 Échantillonnage par noyau.
stream bool true / false Active le streaming SSE.
tools array Format outils OpenAI Déclare les fonctions appelables.
tool_choice string / object auto, none, outil spécifique Contrôle le choix d’outil.
response_format object { "type": "json_object" } Force une sortie JSON structurée.
seed int any Utile pour la reproductibilité avec temperature: 0.

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",
)
Enter fullscreen mode Exit fullscreen mode

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",
)
Enter fullscreen mode Exit fullscreen mode

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",
)
Enter fullscreen mode Exit fullscreen mode

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="")
Enter fullscreen mode Exit fullscreen mode

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)
Enter fullscreen mode Exit fullscreen mode

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"
}
"""
    }
]
Enter fullscreen mode Exit fullscreen mode

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"],
            },
        },
    }
]
Enter fullscreen mode Exit fullscreen mode

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)
Enter fullscreen mode Exit fullscreen mode

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)
Enter fullscreen mode Exit fullscreen mode

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)
Enter fullscreen mode Exit fullscreen mode

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"
                    }
                }
            ]
        }
    ]
)
Enter fullscreen mode Exit fullscreen mode

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>
Enter fullscreen mode Exit fullscreen mode

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"
Enter fullscreen mode Exit fullscreen mode

Ou :

- model="grok-3"
+ model="grok-4.3"
Enter fullscreen mode Exit fullscreen mode

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"
Enter fullscreen mode Exit fullscreen mode

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"
}
Enter fullscreen mode Exit fullscreen mode

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")
Enter fullscreen mode Exit fullscreen mode

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.

Top comments (0)