Modèles accessibles

Découvrir les modèles disponibles

L’endpoint de liste des modèles vous permet de savoir exactement quels modèles votre équipe peut utiliser, avec leurs tarifs et capacités. 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-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

Les identifiants de modèles retournés par cet endpoint sont ceux à utiliser dans les ACLs lors de la création de clés :

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

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

L’endpoint complémentaire liste les types d’endpoints disponibles pour les ACLs :

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 pour optimiser vos coûts. Un modèle plus petit peut être suffisant pour des tâches de classification ou d’extraction simple, tandis que 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

xAI ajoute régulièrement de nouveaux modèles. Intégrez une vérification périodique pour être informé des nouveautés :

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

Croisez les données de modèles disponibles avec vos analytics d’utilisation pour identifier les modèles sous-utilisés ou sur-utilisés :

# 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}')
"

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