Ir al contenido principal
Español— Elegir un idioma
Menú

Modelos disponibles

Lección 12 de 14 Actualizado el 29 de julio de 2026 Desarrollador
En esta página
  1. Descubre los modelos disponibles
  2. Listar modelos
  3. Uso en la gestión de claves
  4. Listar endpoints de ACL
  5. Elige el modelo adecuado
  6. Script de comparación de modelos
  7. Supervisa nuevos modelos
  8. Combina modelos y analíticas
  9. Puntos clave

Descubre los modelos disponibles

Este endpoint responde a una pregunta que podrías asumir erróneamente que puedes resolver de memoria: qué modelos puede llamar realmente tu equipo y a qué precio hoy. La documentación pública describe el catálogo general; la API describe tu catálogo, incluidos los precios actuales.

La brecha entre ambos no es teórica. Los niveles evolucionan, los precios cambian y un ID copiado de una entrada de blog de hace seis meses genera un error de acceso difícil de diagnosticar. Acostúmbrate a consultar este endpoint en lugar de hacer suposiciones; es también lo que mantiene fiables tus scripts de comparación de costes con el tiempo. Esta información es esencial para elegir el modelo adecuado para tu caso de uso y tu presupuesto.

Listar modelos

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

La respuesta contiene para cada modelo:

  • ID: el nombre exacto que debes usar en las llamadas a la API (ej.: grok-4.20-0309-reasoning)
  • Cluster: el grupo de servidores que aloja el modelo
  • Pricing: precio por millón de tokens para entrada y salida
  • Capabilities: tamaño de contexto, soporte multimodal, etc.

Uso en la gestión de claves

Aquí es donde el endpoint se vuelve indispensable, no solo práctico. Una ACL que nombra un modelo inexistente —porque el formato del ID ha cambiado o el modelo se ha retirado— no falla de forma estruendosa: simplemente no autoriza nada, y acabas buscando el error en tu código. Verifica el ID en la fuente antes de fijarlo en una clave.

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

Si restringes una clave a modelos específicos, verifica primero que estén disponibles para tu equipo mediante este endpoint.

Listar endpoints de ACL

La misma lógica se aplica a los endpoints: la lista siguiente es la autorizada para componer tus ACL. También ofrece una visión útil del alcance real de una clave: una clave limitada a chat no puede generar incrustaciones ni procesar imágenes, independientemente de los modelos a los que haga referencia por lo demás.

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

Los endpoints disponibles son:

  • chat: conversaciones de texto (completados de chat)
  • embed: generación de incrustaciones
  • image: generación y análisis de imágenes
  • models: lista de modelos
  • sample: muestreo
  • tokenize: tokenización de texto
  • documents: procesamiento de documentos

Elige el modelo adecuado

Por caso de uso

Caso de usoModelo recomendadoPor qué
Razonamiento complejogrok-4.20-0309-reasoningCadena de pensamiento avanzada
Tareas simples, alto volumengrok-4.3Rápido, económico
Análisis de imágenesModelo multimodalSoporte de visión
Incrustaciones / RAGModelo de incrustacionesOptimizado para búsqueda

Por presupuesto

Compara las tarifas devueltas por la API en lugar de las que tienes en mente. La lógica de arbitraje es siempre la misma: una tarea de clasificación o extracción no obtiene ningún beneficio de un modelo de razonamiento, sin embargo pagas su precio en cada llamada, y este es precisamente el tipo de tarea que ejecutas miles de veces. El modelo de razonamiento es necesario para análisis complejos.

Script de comparación de modelos

import requests
import json

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

# Recuperar modelos
response = requests.get(
    f"{MANAGEMENT_API}/auth/teams/{TEAM_ID}/models",
    headers={"Authorization": f"Bearer {MGMT_KEY}"}
)

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

print(f"{'Model':<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}")

Supervisa nuevos modelos

El catálogo cambia varias veces al año, y los cambios más interesantes no son los nuevos modelos, sino las bajadas de precio en los antiguos. Una comprobación periódica que compare con el registro anterior señala ambos casos, y cuesta unas pocas líneas 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"

# Recuperar modelos actuales
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", [])}

# Comparar con caché
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"New models: {', '.join(new_models)}")
    if removed_models:
        print(f"Removed models: {', '.join(removed_models)}")

# Actualizar caché
with open(CACHE_FILE, "w") as f:
    json.dump(list(current_models), f)

Combina modelos y analíticas

La referencia cruzada final es lo que impulsa la decisión: por un lado, lo que cuesta cada modelo; por otro, cuánto lo utilizas. Un modelo caro y marginal no merece atención; un modelo caro que absorbe la mayor parte de tus solicitudes es el primer candidato al cambio, y esto es precisamente lo que este script pone de manifiesto en una línea.

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

# 2. Analizar uso por modelo
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. Comparar
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'Available models not used: {unused}')
"

Precios a fecha de 5 de agosto de 2026: los precios evolucionan regularmente; antes de cualquier cálculo presupuestario, verifica la tarifa actual en la página oficial de modelos y precios de xAI.

Puntos clave

  • GET /auth/teams/{teamId}/models lista los modelos con precios y capacidades
  • GET /auth/teams/{teamId}/endpoints lista los endpoints para las ACL
  • Usa esta información para crear claves de API con ACL precisas
  • Compara las tarifas para elegir el modelo más económico adecuado a tu uso
  • Supervisa regularmente los nuevos modelos disponibles