¿Cómo usar la API de Grok 4.7? Haz tu primera llamada en 5 minutos

TL;DR

• Grok 4.7 es el modelo de texto de xAI orientado a codificación y tareas agénticas, ya disponible en HiAPI; abre la página del modelo y empieza a chatear directamente; los nuevos usuarios registrados reciben 200 créditos.
• Precio en la plataforma: $0.84 entrada / $2.52 salida (por 1M tokens, lectura de caché $0.21), aproximadamente un 58% de descuento sobre el precio oficial. Una solicitud de 2K de entrada + 1K de salida cuesta unos $0.0042; calculando con una solicitud media de 3K tokens totales (unos $0.0084 por vez), con $10 puedes hacer unas 1200 llamadas.
• La forma más rápida de llamar: POST https://api.hiapi.ai/v1/chat/completions, escribe grok-4.7 en model; tu código existente con el SDK de OpenAI solo necesita cambiar los valores base_url y model.

Qué es Grok 4.7 y qué trae de nuevo

Grok 4.7, lanzado el 2026-09-21, es el modelo predeterminado recomendado actualmente por xAI, centrado en codificación, tareas agénticas y trabajo de conocimiento. La puntuación oficial autodeclarada en Terminal-Bench 4.0 pasó del 20.3% de 4.6 al 38.0%, casi el doble (según cifras autodeclaradas). Para quienes lo integran, hay cuatro cambios que merecen atención:

• Codificación y agentic son los escenarios principales: la compañía también lo integró en herramientas de codificación como Cursor y GitHub Copilot; la capacidad de planificación de tareas de largo plazo es el punto clave de esta versión.
• Cuatro niveles de razonamiento: reasoning_effort admite low / medium / high / xhigh, por defecto high; el proceso de pensamiento se devuelve por separado en el campo reasoning_content, para que decidas si mostrarlo.
• Objetos JSON + llamadas a herramientas: response_format: {"type": "json_object"} fuerza una salida JSON válida; las llamadas a funciones usan el formato estándar tools de OpenAI, sin necesidad de envoltorios adicionales para extracción estructurada y bucles de agentes.
• Contexto de 500K: una sola solicitud puede contener un repositorio de código completo o grandes bloques de documentación.

Resultado real: un fragmento de código de análisis de datos con pandas

El siguiente resultado lo obtuvimos ejecutando Grok 4.7 en HiAPI (el prompt completo está en el enlace de abajo). La tarea era analizar datos de pedidos de comercio electrónico: GMV mensual, top 20 de usuarios por gasto acumulado y tendencia del importe medio del primer pedido de nuevos usuarios, con created_at como cadena de texto. El modelo tardó 18.5 segundos, el código es completo y ejecutable, y gestionó por iniciativa propia la conversión de fechas en formato cadena:

# ---------- 0. Tratamiento de fechas: convertir cadenas a datetime ----------
df["created_at"] = pd.to_datetime(df["created_at"], errors="coerce")
df = df.dropna(subset=["created_at", "amount", "user_id"])

# Contar solo pedidos válidos (ajusta los valores de status según tu negocio real)
df_valid = df[df["status"] == "paid"].copy()

# ---------- 1. GMV y número de pedidos por mes ----------
df_valid["month"] = df_valid["created_at"].dt.to_period("M")
monthly = (
    df_valid.groupby("month", as_index=False)
    .agg(GMV=("amount", "sum"), order_count=("order_id", "count"))
    .sort_values("month")
)

En esta ejecución real, la entrada fue de 3440 tokens y la salida de 1427 tokens, unos $0.007 al precio de la plataforma. Para obtener el mismo resultado, haz clic directamente en ejecutar este prompt en la página del modelo →

Dos rutas para empezar

Ruta uno: navegador, 3 pasos, sin código

1. Abre la página del modelo Grok 4.7 e inicia sesión o regístrate (los nuevos usuarios reciben 200 créditos).
2. Pega tu prompt en el cuadro de diálogo; por ejemplo, haz clic en este enlace y el prompt se rellenará automáticamente.
3. Envía directamente; el crédito se descuenta según el uso real de tokens.

Ruta dos: API, 3 pasos, intégrala en tu aplicación

1. Crea una API Key en la consola de HiAPI.
2. Sustituye YOUR_HIAPI_API_KEY en el curl de abajo por tu Key y ejecútalo.
3. Fija model en grok-4.7, cambia messages por tu entrada de negocio y listo.

curl: primera llamada

curl https://api.hiapi.ai/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_HIAPI_API_KEY" \
  -d '{
    "model": "grok-4.7",
    "messages": [
      {"role": "system", "content": "You are a senior backend engineer."},
      {"role": "user", "content": "Explain what a database connection pool is in two sentences."}
    ],
    "reasoning_effort": "high",
    "max_tokens": 2000
  }'

En la respuesta, choices[0].message.content es el texto principal y reasoning_content es el proceso de pensamiento; usage.completion_tokens_details.reasoning_tokens te indica por separado cuántos tokens consumió este razonamiento. Para streaming, añade "stream": true y analiza por SSE.

Python: sin streaming + con streaming

Sin streaming, basta con requests:

import requests

resp = requests.post(
    "https://api.hiapi.ai/v1/chat/completions",
    headers={"Authorization": "Bearer YOUR_HIAPI_API_KEY"},
    json={
        "model": "grok-4.7",
        "messages": [
            {"role": "user", "content": "Write a Python function that merges two sorted lists into one sorted list."}
        ],
        "reasoning_effort": "medium",
        "max_tokens": 4000,
    },
    timeout=120,
)
resp.raise_for_status()
data = resp.json()
print(data["choices"][0]["message"]["content"])

Con streaming, ten en cuenta dos cosas: el delta.reasoning_content que llega primero es el proceso de pensamiento, y el delta.content posterior es el texto principal; usage solo viene en el último chunk (choices vacío) y termina con data: [DONE]:

import json
import requests

with requests.post(
    "https://api.hiapi.ai/v1/chat/completions",
    headers={"Authorization": "Bearer YOUR_HIAPI_API_KEY"},
    json={
        "model": "grok-4.7",
        "messages": [{"role": "user", "content": "Plan a Redis-based online presence system."}],
        "reasoning_effort": "high",
        "stream": True,
    },
    stream=True,
    timeout=300,
) as resp:
    resp.raise_for_status()
    for line in resp.iter_lines(decode_unicode=True):
        if not line or not line.startswith("data:"):
            continue
        payload = line[len("data:"):].strip()
        if payload == "[DONE]":
            break
        chunk = json.loads(payload)
        if not chunk["choices"]:
            print("\nusage:", chunk["usage"])  # solo el último chunk trae usage
            continue
        delta = chunk["choices"][0]["delta"]
        if delta.get("reasoning_content"):
            print(delta["reasoning_content"], end="", flush=True)
        elif delta.get("content"):
            print(delta["content"], end="", flush=True)

Tabla de parámetros

Campo	Obligatorio	Valor	Descripción
model	Sí	grok-4.7	Escribe siempre este ID
messages	Sí	Array de mensajes en formato OpenAI	Admite los roles system / user / assistant / tool
reasoning_effort	No	low / medium / high / xhigh, por defecto high	Intensidad de razonamiento; el proceso de pensamiento se devuelve en reasoning_content
max_tokens	No	Entero positivo	Límite de salida, incluye los reasoning tokens; si lo pones demasiado bajo, se truncará primero el razonamiento
response_format	No	{"type": "json_object"}	Fuerza una salida JSON válida; ideal para extracción estructurada
tools	No	Array de function calling de OpenAI	Llamadas a herramientas; admite devolución de resultados tool en varios turnos
stream	No	true / false, por defecto false	Streaming SSE; usage en el último chunk

Errores que encontrarás

El tropiezo más habitual al migrar código desde otros modelos: grok-4.7 no admite los tres parámetros frequency_penalty, presence_penalty ni stop; si los incluyes, devuelve directamente 400. reasoning_effort solo acepta los cuatro niveles low / medium / high / xhigh; con un valor incorrecto, la interfaz devuelve tal cual reasoning_effort: is outside allowed values; tampoco se pueden enviar campos fuera del protocolo: al sondear añadimos un campo no registrado y la interfaz devolvió request.zz: unregistered public parameter.

La solución es sencilla: elimina esos tres parámetros, escribe bien el nivel y vuelve a enviar. Para otros 4xx, revisa primero error.code antes de tocar el código; no adivines.

Antes de pasar a producción

• Los reasoning tokens se facturan como salida. En el nivel high, una respuesta puede incluir decenas de miles de tokens de proceso de pensamiento, que se facturan a $2.52/M. Para tareas simples, bajar reasoning_effort a low o medium es el interruptor de ahorro más directo; usage.completion_tokens_details.reasoning_tokens te permite verificar esa cifra por separado.
• Una solicitud completa de 200K cambia de tarifa. Cuando el prompt alcanza los 200K tokens (umbral contractual 199,999), toda la solicitud se factura a precio de texto largo: entrada $1.68 / salida $5.04 / lectura de caché $0.42, el doble de la tarifa normal. Mantén el tráfico habitual por debajo de 200K y no metas un repositorio entero sin pensar.
• La lectura de caché cuesta solo un cuarto del precio normal. Los system prompts largos repetidos y los prefijos de conversaciones de varios turnos aciertan automáticamente en caché; la lectura de caché cuesta $0.21/M (un cuarto del precio normal de $0.84/M). Al construir bucles de agentes, mantén estable el prefijo y la factura mejorará notablemente.

Preguntas frecuentes

¿Cómo elegir entre Grok 4.7 y Grok 4.6? El precio en la plataforma es exactamente igual ($0.84/$2.52). Para codificación compleja y tareas agénticas, elige 4.7 (recomendación oficial por defecto); para tareas simples en las que quieras ahorrar tokens, puedes quedarte con 4.6. Consulta la comparación detallada en Grok 4.7 vs Grok 4.6.

¿Admite salida en streaming? Sí, SSE estándar. Ten en cuenta que usage solo se devuelve en el último chunk; el usage de los chunks anteriores está vacío.

¿reasoning_content cuesta extra? No hay que activar ningún interruptor adicional, pero los reasoning tokens que genera cuentan en el uso de salida y se facturan a precio de salida, así que cuanto mayor sea el nivel, más abultada será la factura.

¿Los 500K de contexto son el límite de entrada? 500K es la ventana total de entrada más salida. Cuando la entrada se acerca a 200K se activa el precio de texto largo; consulta «Antes de pasar a producción» más arriba.

---

Para profundizar: consulta el cálculo de precios en Cuánto cuesta la API de Grok 4.7, 5 prompts de escenarios listos para copiar en Recetario de prompts de Grok 4.7, y el uso de la generación anterior en la página del modelo Grok 4.6. Copia el prompt de pandas de arriba y ejecuta tu primera llamada en la página del modelo.