OpenAI SDK avec base_url xAI — Chat Completions : compatibilité OpenAI

Corrigé le 3 novembre 2026 d’après la référence Chat Completions de xAI : la compatibilité avec le SDK OpenAI n’est pas « 100 % » — plusieurs paramètres ne sont pas pris en charge par les modèles de raisonnement, sont ignorés par les modèles récents ou ne sont pris en charge par aucun modèle. Source : xAI, Chat Completions.

Utiliser le SDK OpenAI pour accéder à Grok

L’un des grands avantages de l’endpoint Chat Completions de xAI est sa compatibilité avec le SDK OpenAI. Vous pouvez utiliser le package openai que vous connaissez déjà, en changeant simplement le base_url pour pointer vers les serveurs xAI.

Cette approche est idéale si vous migrez une application existante depuis OpenAI vers Grok, ou si vous souhaitez pouvoir basculer entre fournisseurs avec un minimum de modifications.

Configuration

L’installation est la même que pour tout projet utilisant le SDK OpenAI :

pip install openai

La seule différence est la création du client, où vous spécifiez l’URL de base et la clé API xAI :

from openai import OpenAI

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

Les deux paramètres essentiels sont :

api_key : votre clé API xAI (pas une clé OpenAI)
base_url : https://api.x.ai/v1 — c’est ce qui redirige les requêtes vers xAI au lieu d’OpenAI

Appel identique à OpenAI

Une fois le client configuré, l’utilisation est la même qu’avec le SDK OpenAI standard — aux paramètres près que xAI ne prend pas en charge, détaillés plus bas :

import os
from openai import OpenAI

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

response = client.chat.completions.create(
    model="grok-4.20-0309-reasoning",
    messages=[
        {"role": "system", "content": "Tu es un assistant technique."},
        {"role": "user", "content": "Quelle est la différence entre TCP et UDP ?"}
    ],
    temperature=0.7,
    max_tokens=1000
)

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

La seule différence visible est le nom du modèle : grok-4.20-0309-reasoning au lieu de gpt-5.6 par exemple.

Streaming avec le SDK OpenAI

Le streaming fonctionne exactement de la même manière :

stream = client.chat.completions.create(
    model="grok-4.20-0309-reasoning",
    messages=[
        {"role": "user", "content": "Explique le concept de microservices."}
    ],
    stream=True
)

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

JavaScript / TypeScript

Le SDK OpenAI pour Node.js fonctionne de la même manière :

import OpenAI from "openai";

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

const response = await client.chat.completions.create({
  model: "grok-4.20-0309-reasoning",
  messages: [
    { role: "system", content: "Tu es un assistant utile." },
    { role: "user", content: "Bonjour, comment ca va ?" },
  ],
});

console.log(response.choices[0].message.content);

Notez que la propriété est baseURL (avec un U majuscule) en JavaScript, alors qu’elle est base_url en Python.

Basculer entre fournisseurs

L’intérêt principal de cette approche est de pouvoir changer de fournisseur avec une seule variable :

import os
from openai import OpenAI

provider = os.getenv("LLM_PROVIDER", "xai")

configs = {
    "xai": {
        "api_key": os.getenv("XAI_API_KEY"),
        "base_url": "https://api.x.ai/v1",
        "model": "grok-4.20-0309-reasoning"
    },
    "openai": {
        "api_key": os.getenv("OPENAI_API_KEY"),
        "base_url": "https://api.openai.com/v1",
        "model": "gpt-5.6"
    }
}

config = configs[provider]
client = OpenAI(api_key=config["api_key"], base_url=config["base_url"])

Cette architecture multi-fournisseurs est courante dans les applications de production qui souhaitent garder de la flexibilité.

Ce qui ne passe pas d’un fournisseur à l’autre

Compatible ne veut pas dire identique. La référence de l’endpoint chez xAI signale plusieurs paramètres que les modèles de raisonnement ne prennent pas en charge — frequency_penalty, presence_penalty (pas plus que grok-3) et stop — ; logprobs et top_logprobs sont ignorés sans erreur par grok-4.20 et les modèles plus récents, et logit_bias n’est pas pris en charge. Un code qui fixe ces paramètres pour OpenAI devra donc les retirer pour Grok — le cas des champs ignorés en silence est le plus traître, puisque rien ne vous signale qu’ils n’ont aucun effet. Les outils hébergés diffèrent aussi d’un fournisseur à l’autre : la recherche web d’OpenAI n’est pas celle de xAI. Enfin, xAI présente désormais Chat Completions comme un endpoint hérité et recommande l’API Responses (leçons 11 et 12).

Points clés à retenir

Le SDK OpenAI fonctionne avec xAI en changeant simplement base_url vers https://api.x.ai/v1
Les méthodes et le format de réponse sont les mêmes, mais certains paramètres ne sont pas pris en charge (frequency_penalty, presence_penalty, stop sur les modèles de raisonnement, logit_bias) ou sont ignorés (logprobs à partir de grok-4.20)
La clé API, le nom du modèle et les paramètres non pris en charge sont à adapter
Cette approche facilite la migration depuis OpenAI et permet de basculer entre fournisseurs
Le streaming et le typage du SDK OpenAI fonctionnent ; les outils hébergés, eux, sont propres à chaque fournisseur