Modèles accessibles

Découvrir les modèles disponibles

Cet endpoint répond à une question qu’on croit à tort pouvoir traiter de mémoire : quels modèles votre équipe peut réellement appeler, et à quel prix aujourd’hui. La documentation publique décrit le catalogue général ; l’API décrit votre catalogue, tarifs en vigueur compris.

L’écart entre les deux n’est pas théorique. Les gammes évoluent, les prix bougent, et un identifiant recopié depuis un article de blog vieux de six mois produit une erreur d’accès difficile à diagnostiquer. Prenez l’habitude d’interroger cet endpoint plutôt que de supposer — c’est aussi ce qui rend vos scripts de comparaison de coûts fiables dans le temps. C’est une information essentielle pour choisir le bon modèle selon votre cas d’usage et votre budget.

Lister les modèles

curl "https://management-api.x.ai/auth/teams/$TEAM_ID/models" \
  -H "Authorization: Bearer $MANAGEMENT_API_KEY"

La réponse contient pour chaque modèle :

• Identifiant : le nom exact à utiliser dans les appels API (ex: grok-4.20-0309-reasoning)
• Cluster : le groupe de serveurs hébergeant le modèle
• Tarifs : prix par million de tokens en entrée et en sortie
• Capacités : taille de contexte, support multimodal, etc.

Utilisation dans la gestion des clés

C’est ici que l’endpoint devient indispensable plutôt que pratique. Une ACL qui nomme un modèle inexistant — parce que l’identifiant a changé de forme ou que le modèle a été retiré — n’échoue pas bruyamment : elle n’autorise simplement rien, et vous cherchez l’erreur du côté de votre code. Vérifiez l’identifiant à la source avant de le figer dans une clé.

{
  "acls": [
    "api-key:model:grok-4.20-0309-reasoning",
    "api-key:model:grok-4.3"
  ]
}

Si vous restreignez une clé à des modèles spécifiques, vérifiez d’abord qu’ils sont disponibles pour votre équipe via cet endpoint.

Lister les endpoints ACL

Le même raisonnement vaut pour les endpoints : la liste ci-dessous est celle qui fait autorité pour composer vos ACLs. Elle donne aussi une lecture utile du périmètre réel d’une clé — une clé limitée à chat ne pourra ni générer d’embeddings ni traiter d’images, quels que soient les modèles qu’elle référence par ailleurs.

curl "https://management-api.x.ai/auth/teams/$TEAM_ID/endpoints" \
  -H "Authorization: Bearer $MANAGEMENT_API_KEY"

Les endpoints disponibles sont :

• chat : conversations textuelles (chat completions)
• embed : génération d’embeddings
• image : génération et analyse d’images
• models : liste des modèles
• sample : échantillonnage
• tokenize : tokenisation de texte
• documents : traitement de documents

Choisir le bon modèle

Par cas d’usage

Par budget

Comparez les tarifs retournés par l’API plutôt que ceux que vous avez en tête. Le raisonnement d’arbitrage est toujours le même : une tâche de classification ou d’extraction ne tire aucun bénéfice d’un modèle de raisonnement, alors qu’elle en paie le prix à chaque appel — et c’est précisément ce type de tâche qu’on exécute des milliers de fois. Le modèle de raisonnement est nécessaire pour des analyses complexes.

Script de comparaison des modèles

import requests
import json

MANAGEMENT_API = "https://management-api.x.ai"
MGMT_KEY = "xai-mgmt-..."
TEAM_ID = "team-..."

# Récupérer les modèles
response = requests.get(
    f"{MANAGEMENT_API}/auth/teams/{TEAM_ID}/models",
    headers={"Authorization": f"Bearer {MGMT_KEY}"}
)

models = response.json().get("models", [])

print(f"{'Modèle':<35} {'Input ($/M)':<15} {'Output ($/M)':<15}")
print("-" * 65)

for model in models:
    name = model.get("id", "N/A")
    input_price = model.get("inputPrice", "N/A")
    output_price = model.get("outputPrice", "N/A")
    print(f"{name:<35} {input_price:<15} {output_price:<15}")

Surveiller les nouveaux modèles

Le catalogue bouge plusieurs fois par an, et les changements les plus intéressants ne sont pas les nouveaux modèles mais les baisses de prix sur les anciens. Une vérification périodique qui compare avec le relevé précédent vous signale les deux, et coûte quelques lignes de cron.

import requests
import json
import os

MANAGEMENT_API = "https://management-api.x.ai"
MGMT_KEY = "xai-mgmt-..."
TEAM_ID = "team-..."
CACHE_FILE = "/tmp/xai_models_cache.json"

# Récupérer les modèles actuels
response = requests.get(
    f"{MANAGEMENT_API}/auth/teams/{TEAM_ID}/models",
    headers={"Authorization": f"Bearer {MGMT_KEY}"}
)
current_models = {m["id"] for m in response.json().get("models", [])}

# Comparer avec le cache
if os.path.exists(CACHE_FILE):
    with open(CACHE_FILE) as f:
        cached_models = set(json.load(f))

    new_models = current_models - cached_models
    removed_models = cached_models - current_models

    if new_models:
        print(f"Nouveaux modèles : {', '.join(new_models)}")
    if removed_models:
        print(f"Modèles retirés : {', '.join(removed_models)}")

# Mettre à jour le cache
with open(CACHE_FILE, "w") as f:
    json.dump(list(current_models), f)

Combiner modèles et analytics

Le croisement final est celui qui produit une décision : d’un côté ce que chaque modèle coûte, de l’autre combien vous l’utilisez. Un modèle cher et marginal ne mérite pas d’attention ; un modèle cher qui absorbe l’essentiel de vos requêtes est le premier candidat au changement, et c’est ce que ce script fait apparaître en une ligne.

# 1. Lister les modèles disponibles
curl -s "https://management-api.x.ai/auth/teams/$TEAM_ID/models" \
  -H "Authorization: Bearer $MANAGEMENT_API_KEY" > /tmp/models.json

# 2. Analyser l'utilisation par modèle
curl -s -X POST "https://management-api.x.ai/v1/billing/teams/$TEAM_ID/usage" \
  -H "Authorization: Bearer $MANAGEMENT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "analyticsRequest": {
      "timeRange": {
        "startTime": "2026-03-01 00:00:00",
        "endTime": "2026-04-01 00:00:00",
        "timezone": "UTC"
      },
      "timeUnit": "MONTH",
      "values": [{"name": "tokens", "aggregation": "SUM"}],
      "groupBy": ["model"]
    }
  }' > /tmp/usage.json

# 3. Comparer
python3 -c "
import json
with open('/tmp/models.json') as f:
    available = {m['id'] for m in json.load(f).get('models', [])}
with open('/tmp/usage.json') as f:
    used = {p.get('model') for p in json.load(f).get('dataPoints', [])}
unused = available - used
if unused:
    print(f'Modèles disponibles non utilisés : {unused}')
"

Tarifs relevés le 5 août 2026 — les prix évoluent régulièrement : avant tout calcul de budget, vérifiez la grille en vigueur sur la page officielle des modèles et tarifs xAI.

Points clés à retenir

• GET /auth/teams/{teamId}/models liste les modèles avec tarifs et capacités
• GET /auth/teams/{teamId}/endpoints liste les endpoints pour les ACLs
• Utilisez ces informations pour créer des clés API avec des ACLs précises
• Comparez les tarifs pour choisir le modèle le plus économique adapté à votre usage
• Surveillez régulièrement les nouveaux modèles disponibles