DEV Community

Cover image for Cómo Usar la API Grok 4.3: Guía y Tutorial
Roobia
Roobia

Posted on • Originally published at apidog.com

Cómo Usar la API Grok 4.3: Guía y Tutorial

xAI lanzó Grok 4.3 en etapas: beta el 17 de abril de 2026, acceso a la API el 30 de abril y disponibilidad general completa el 6 de mayo. La propuesta para desarrolladores es clara: ventana de contexto de 1,000,000 de tokens, entrada de video nativa, razonamiento siempre activo y una reducción de precio de aproximadamente el 40% frente a Grok 4.20. Ocho modelos Grok heredados se retiran el 15 de mayo, así que si usa grok-3 o grok-4, planifique la migración ahora.

Prueba Apidog hoy

Esta guía muestra cómo llamar a Grok 4.3 desde código: endpoint, autenticación, URL base compatible con OpenAI, reasoning_effort, entrada de video, llamada a funciones y una configuración reproducible en Apidog.

Para el aspecto de voz de la misma versión, consulte Cómo usar Grok Voice gratis. Para la comparación directa con el modelo de voz insignia de OpenAI, consulte Grok Voice vs GPT-Realtime.

TL;DR

  • Grok 4.3 tuvo disponibilidad general el 6 de mayo de 2026.
  • Ocho modelos heredados se retiran el 15 de mayo de 2026.
  • Precios:
    • $1.25 por 1M de tokens de entrada
    • $2.50 por 1M de tokens de salida
    • $0.20 por 1M de tokens de entrada en caché
  • Ventana de contexto: 1M de tokens.
  • Soporta entrada de video nativa.
  • El razonamiento está siempre activo.
  • reasoning_effort: low, medium, high. Valor por defecto: medium.
  • Endpoint: https://api.x.ai/v1/chat/completions.
  • URL base compatible con OpenAI: https://api.x.ai/v1.
  • Rendimiento anunciado: ~159 tokens/segundo en niveles estándar.
  • Índice de Inteligencia 53 según Análisis Artificial, puesto 10 de 146 modelos.
  • Use Apidog para guardar variantes de solicitud, comparar latencia y reproducir pruebas con distintas configuraciones de razonamiento.

Qué cambió en Grok 4.3

Las actualizaciones más relevantes para implementación son:

  1. Precio más bajo

    • Entrada: baja un 37.5% frente a Grok 4.20.
    • Salida: baja un 58.3%.
    • Entrada en caché: $0.20/1M, útil para prompts de sistema largos y estables.

  2. Contexto de 1M de tokens

    • Sube desde 256k en Grok 4.20.
    • Permite enviar bases de código medianas, contratos extensos, transcripts largos o historiales completos de conversación.

  3. Entrada de video nativa

    • Primera vez en la línea Grok.
    • Puede pasar una URL de video y pedir análisis sobre el contenido.

  4. Razonamiento siempre activo

    • Cada solicitud incluye razonamiento base.
    • reasoning_effort controla la profundidad, pero el modelo nunca baja de low.

  5. Mejor comportamiento agéntico

    • +300 puntos Elo en GDPval-AA frente a Grok 4.20.
    • Impacta especialmente en llamada a herramientas y flujos de varios pasos.

El Índice de Inteligencia de 53 según Análisis Artificial sitúa a Grok 4.3 por encima del promedio de 35 para su nivel de precio y en el décimo lugar de 146 modelos monitoreados.

Requisitos previos

Antes de hacer la primera llamada, prepare lo siguiente:

  • Una cuenta en la consola de xAI: console.x.ai.
  • Una clave API con facturación activa.
  • El SDK de OpenAI o el SDK de xAI.
  • Un cliente API para guardar y repetir solicitudes durante las pruebas.

Captura de consola o configuración

Exporte la clave API:

export XAI_API_KEY="xai-..."
Enter fullscreen mode Exit fullscreen mode

Si usa Windows PowerShell:

$env:XAI_API_KEY="xai-..."
Enter fullscreen mode Exit fullscreen mode

Endpoint y autenticación

Grok 4.3 usa la superficie de Chat Completions compatible con OpenAI.

POST https://api.x.ai/v1/chat/completions
Enter fullscreen mode Exit fullscreen mode

Encabezados requeridos:

Authorization: Bearer $XAI_API_KEY
Content-Type: application/json
Enter fullscreen mode Exit fullscreen mode

La compatibilidad con OpenAI permite usar el SDK de OpenAI y cambiar solo la base_url.

Ejemplo en Python 

import os
from openai import OpenAI

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

response = client.chat.completions.create(
    model="grok-4.3",
    messages=[
        {
            "role": "user",
            "content": "Resume las diferencias entre GraphQL y REST en tres puntos."
        }
    ],
    reasoning_effort="medium",
)

print(response.choices[0].message.content)
Enter fullscreen mode Exit fullscreen mode

Ejemplo en Node.js 

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.3",
  messages: [
    {
      role: "user",
      content: "Resume las diferencias entre GraphQL y REST en tres puntos.",
    },
  ],
  reasoning_effort: "medium",
});

console.log(response.choices[0].message.content);
Enter fullscreen mode Exit fullscreen mode

Parámetros de la solicitud

Parámetro Tipo Valores Notas
model string grok-4.3 Obligatorio.
messages array OpenAI message shape Obligatorio. Soporta system, user y assistant.
reasoning_effort string low, medium, high Opcional. Por defecto: medium.
max_tokens int 1–32768 Limita la salida.
temperature float 0.0–2.0 Por defecto: 1.0.
top_p float 0.0–1.0 Muestreo de núcleo.
stream bool true, false Activa streaming vía server-sent events.
tools array OpenAI tool shape Para llamada a funciones.
tool_choice string/object auto, none o herramienta específica Semántica estándar de OpenAI.
response_format object { "type": "json_object" } Salida estructurada.
seed int any Útil para reproducibilidad con temperature: 0.

Primera solicitud con curl 

curl https://api.x.ai/v1/chat/completions \
  -H "Authorization: Bearer $XAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "grok-4.3",
    "messages": [
      {
        "role": "system",
        "content": "Eres un ingeniero backend senior."
      },
      {
        "role": "user",
        "content": "Revisa este plan de consulta y señala el cuello de botella."
      }
    ],
    "reasoning_effort": "high"
  }'
Enter fullscreen mode Exit fullscreen mode

La respuesta mantiene la forma estándar de OpenAI:

{
  "choices": [
    {
      "message": {
        "role": "assistant",
        "content": "..."
      }
    }
  ],
  "usage": {
    "prompt_tokens": 123,
    "completion_tokens": 456,
    "reasoning_tokens": 78,
    "total_tokens": 657
  }
}
Enter fullscreen mode Exit fullscreen mode

Cómo elegir reasoning_effort

Use el parámetro según el tipo de carga:

low

Úselo para:

  • Clasificación.
  • Extracción simple.
  • Resúmenes cortos.
  • Preguntas frecuentes.
  • Reformateo de texto.

Ejemplo:

{
  "model": "grok-4.3",
  "messages": [
    {
      "role": "user",
      "content": "Clasifica este ticket como billing, bug o feature request: ..."
    }
  ],
  "reasoning_effort": "low"
}
Enter fullscreen mode Exit fullscreen mode

medium

Úselo para:

  • Soporte al cliente.
  • Llamada a funciones.
  • Análisis de datos moderado.
  • Flujos de una o dos herramientas.
  • Tráfico general de producción.

Es el valor por defecto.

{
  "model": "grok-4.3",
  "messages": [
    {
      "role": "user",
      "content": "Analiza estos logs y sugiere la causa probable del error."
    }
  ],
  "reasoning_effort": "medium"
}
Enter fullscreen mode Exit fullscreen mode

high

Úselo para:

  • Agentes de varios pasos.
  • Revisión de código larga.
  • Matemáticas complejas.
  • Planificación.
  • Decisiones donde el error es costoso. 
{
  "model": "grok-4.3",
  "messages": [
    {
      "role": "user",
      "content": "Diseña un plan de migración de esta arquitectura monolítica a servicios separados."
    }
  ],
  "reasoning_effort": "high"
}
Enter fullscreen mode Exit fullscreen mode

El razonamiento siempre activo significa que no existe un modo “sin razonamiento”. Si necesita reducir latencia y tokens, use low.

Llamada a funciones

Grok 4.3 usa la forma estándar de herramientas compatible con OpenAI.

Flujo básico:

  1. Declare las herramientas en tools.
  2. Envíe la solicitud.
  3. Lea tool_calls.
  4. Ejecute la función en su backend.
  5. Devuelva el resultado con un mensaje role: "tool".
  6. Pida al modelo la respuesta final.

Declarar una herramienta 

tools = [
    {
        "type": "function",
        "function": {
            "name": "lookup_user",
            "description": "Busca un usuario por ID.",
            "parameters": {
                "type": "object",
                "properties": {
                    "user_id": {
                        "type": "string"
                    }
                },
                "required": ["user_id"]
            }
        }
    }
]
Enter fullscreen mode Exit fullscreen mode

Solicitar una llamada a herramienta 

response = client.chat.completions.create(
    model="grok-4.3",
    messages=[
        {
            "role": "user",
            "content": "Busca el usuario u_42 y dime su último inicio de sesión."
        }
    ],
    tools=tools,
    reasoning_effort="medium",
)

message = response.choices[0].message
tool_calls = message.tool_calls

print(tool_calls)
Enter fullscreen mode Exit fullscreen mode

Ejecutar la herramienta y devolver el resultado 

import json

def lookup_user(user_id: str):
    return {
        "user_id": user_id,
        "last_login": "2026-05-05T14:22:00Z"
    }

messages = [
    {
        "role": "user",
        "content": "Busca el usuario u_42 y dime su último inicio de sesión."
    },
    message,
]

for call in tool_calls:
    if call.function.name == "lookup_user":
        args = json.loads(call.function.arguments)
        result = lookup_user(args["user_id"])

        messages.append({
            "role": "tool",
            "tool_call_id": call.id,
            "content": json.dumps(result)
        })

final_response = client.chat.completions.create(
    model="grok-4.3",
    messages=messages,
    tools=tools,
    reasoning_effort="medium",
)

print(final_response.choices[0].message.content)
Enter fullscreen mode Exit fullscreen mode

La mejora de 300 puntos Elo en GDPval-AA se nota especialmente en flujos de herramientas: mejor selección de funciones, menos llamadas redundantes y mejor recuperación ante errores. Si prueba flujos MCP, consulte las pruebas de servidor MCP en Apidog.

Entrada de video

Grok 4.3 es el primer modelo Grok con entrada de video nativa. Envíe una URL de video dentro de un bloque de contenido.

response = client.chat.completions.create(
    model="grok-4.3",
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "text",
                    "text": "Describe qué ocurre en este clip y señala anomalías."
                },
                {
                    "type": "video_url",
                    "video_url": {
                        "url": "https://example.com/clip.mp4"
                    }
                }
            ]
        }
    ],
    reasoning_effort="medium",
)

print(response.choices[0].message.content)
Enter fullscreen mode Exit fullscreen mode

Notas prácticas:

  • Los tokens de video cuentan como entrada.
  • Los clips largos pueden consumir contexto rápidamente.
  • Recorte o reduzca la muestra si el costo importa.
  • No necesita extraer fotogramas clave manualmente; el modelo razona sobre el video de forma nativa.

Entrada de imágenes

Grok 4.3 también soporta imágenes. Use un bloque de contenido con URL de imagen.

response = client.chat.completions.create(
    model="grok-4.3",
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "text",
                    "text": "Identifica posibles problemas de accesibilidad en esta interfaz."
                },
                {
                    "type": "image_url",
                    "image_url": {
                        "url": "https://example.com/screenshot.png"
                    }
                }
            ]
        }
    ],
)

print(response.choices[0].message.content)
Enter fullscreen mode Exit fullscreen mode

Contexto de 1M de tokens

La ventana de contexto de 1M permite patrones que antes requerían chunking agresivo.

Casos comunes:

  • Revisión de código amplia
    • Envíe el diff, archivos modificados, salida del linter y notas de arquitectura.
  • QA sobre documentos largos
    • Inserte contratos, documentación técnica o transcripts completos.
  • Memoria de agente
    • Mantenga historiales largos de conversación para personalización.
  • Análisis de incidentes
    • Combine logs, métricas, timeline y postmortems anteriores.

Ejemplo de prompt para revisión de código:

Eres un revisor de código senior.

Contexto:
- Este cambio toca autenticación y facturación.
- Prioriza bugs de seguridad, condiciones de carrera y errores de compatibilidad.

Archivos:
<pegar diff completo aquí>

Salida del linter:
<pegar salida aquí>

Responde con:
1. Riesgos críticos
2. Riesgos medios
3. Sugerencias no bloqueantes
4. Pruebas que faltan
Enter fullscreen mode Exit fullscreen mode

La entrada en caché a $0.20/1M hace viable mantener prompts de sistema grandes. Por ejemplo, un prompt estable de 400k tokens cuesta $0.08 por llamada en caché frente a $0.50 si se procesa como entrada nueva.

Migración desde modelos Grok heredados

Ocho modelos Grok heredados se retiran el 15 de mayo de 2026, 12:00 PM PT.

Si usa un modelo heredado, el cambio mínimo suele ser:

- model="grok-4"
+ model="grok-4.3"
Enter fullscreen mode Exit fullscreen mode

O en JSON:

{
-  "model": "grok-4"
+  "model": "grok-4.3"
}
Enter fullscreen mode Exit fullscreen mode

La mayoría de las llamadas siguen funcionando porque la forma de la solicitud no cambia.

Revise estos puntos antes de migrar

  1. Latencia

    • Grok 4.3 siempre razona.
    • Si dependía de una ruta rápida sin razonamiento, pruebe reasoning_effort: "low".

  2. Formato de salida

    • Grok 4.3 tiende a generar respuestas más estructuradas.
    • Si usa regex para postprocesamiento, vuelva a probar.

  3. Costos

    • El precio por token baja, pero el contexto más grande puede llevar a enviar más entrada.
    • Mida usage.prompt_tokens, usage.completion_tokens y usage.reasoning_tokens.

  4. Herramientas

    • Si usa function calling, valide que las llamadas generadas siguen coincidiendo con su contrato interno.

Para la comparación de precios completa de la línea OpenAI, consulte Precios de GPT-5.5. Para modelos de razonamiento cara a cara, consulte Cómo usar la API de GPT-5.5.

Pruebas en Apidog

Una forma práctica de validar Grok 4.3 es crear una colección con variantes controladas.

1. Cree un entorno

En Apidog, cree variables:

XAI_API_KEY = xai-...
BASE_URL = https://api.x.ai/v1
MODEL = grok-4.3
Enter fullscreen mode Exit fullscreen mode

2. Cree la solicitud base 

POST {{BASE_URL}}/chat/completions
Authorization: Bearer {{XAI_API_KEY}}
Content-Type: application/json
Enter fullscreen mode Exit fullscreen mode

Body:

{
  "model": "{{MODEL}}",
  "messages": [
    {
      "role": "system",
      "content": "Eres un ingeniero backend senior."
    },
    {
      "role": "user",
      "content": "Analiza este error de producción y sugiere la causa raíz: {{incident_log}}"
    }
  ],
  "reasoning_effort": "medium"
}
Enter fullscreen mode Exit fullscreen mode

3. Duplique la solicitud en tres variantes

Cree tres copias con el mismo prompt:

"reasoning_effort": "low"
Enter fullscreen mode Exit fullscreen mode 
"reasoning_effort": "medium"
Enter fullscreen mode Exit fullscreen mode 
"reasoning_effort": "high"
Enter fullscreen mode Exit fullscreen mode

Compare:

  • Latencia.
  • Calidad de respuesta.
  • usage.reasoning_tokens.
  • usage.total_tokens.
  • Costo estimado.

4. Compare contra otro proveedor

Puede crear otra variante cambiando:

BASE_URL = https://api.openai.com/v1
MODEL = gpt-5.5
Enter fullscreen mode Exit fullscreen mode

Así mantiene la misma estructura de prueba y cambia solo proveedor/modelo.

Descargue Apidog para ejecutar la comparación. Para una estrategia más amplia de pruebas de API, consulte Herramienta de pruebas de API para ingenieros de QA.

Captura de Apidog

Streaming

Para respuestas largas, active stream.

stream = client.chat.completions.create(
    model="grok-4.3",
    messages=[
        {
            "role": "user",
            "content": "Genera un plan técnico para migrar este servicio a una arquitectura event-driven."
        }
    ],
    reasoning_effort="medium",
    stream=True,
)

for event in stream:
    delta = event.choices[0].delta
    if delta.content:
        print(delta.content, end="")
Enter fullscreen mode Exit fullscreen mode

Use streaming cuando:

  • La salida sea larga.
  • La experiencia de usuario necesite respuesta progresiva.
  • Quiera reducir tiempo percibido hasta el primer token.

Salida JSON estructurada

Para integraciones backend, use response_format.

response = client.chat.completions.create(
    model="grok-4.3",
    messages=[
        {
            "role": "user",
            "content": "Extrae prioridad, categoría y resumen de este ticket: ..."
        }
    ],
    response_format={
        "type": "json_object"
    },
    temperature=0,
)

print(response.choices[0].message.content)
Enter fullscreen mode Exit fullscreen mode

Ejemplo de salida esperada:

{
  "priority": "high",
  "category": "billing",
  "summary": "El usuario no puede completar el pago por un error de validación."
}
Enter fullscreen mode Exit fullscreen mode

Límites de velocidad

Los límites dependen del nivel configurado en la consola de xAI. Van desde unos pocos miles de solicitudes por minuto en niveles iniciales hasta cientos de miles en niveles empresariales.

Puntos importantes:

  • Consulte los límites exactos en el panel de xAI.
  • Los ~159 tokens/segundo son velocidad de salida por stream, no throughput agregado.
  • Las solicitudes concurrentes escalan dentro del límite de su nivel.
  • Si supera el límite, la API devuelve 429.

Ejemplo de manejo básico con backoff:

import time
from openai import RateLimitError

for attempt in range(5):
    try:
        response = client.chat.completions.create(
            model="grok-4.3",
            messages=[
                {
                    "role": "user",
                    "content": "Resume este documento."
                }
            ],
        )
        break
    except RateLimitError:
        wait = 2 ** attempt
        time.sleep(wait)
Enter fullscreen mode Exit fullscreen mode

Checklist de producción

Antes de mover tráfico real a Grok 4.3:

  • [ ] Cambie base_url a https://api.x.ai/v1.
  • [ ] Cambie model a grok-4.3.
  • [ ] Defina reasoning_effort explícitamente.
  • [ ] Mida usage.reasoning_tokens.
  • [ ] Valide outputs si usa regex o parsers estrictos.
  • [ ] Pruebe function calling con casos felices y errores.
  • [ ] Active streaming para respuestas largas.
  • [ ] Use caché cuando el prompt de sistema sea estable.
  • [ ] Configure reintentos para 429.
  • [ ] Migre antes del 15 de mayo si usa modelos heredados.

Preguntas frecuentes

¿Grok 4.3 es compatible con OpenAI de principio a fin?

Para Chat Completions, sí. Puede usar el SDK de OpenAI, cambiar base_url y cambiar model. Function calling, salida estructurada y streaming usan formas compatibles.

¿Soporta la API de Responses?

La superficie de xAI es Chat Completions actualmente. La API de Responses es de OpenAI.

¿Cuál es el límite de contexto real?

1,000,000 de tokens. Aun con el precio reducido, las entradas largas cuestan dinero real. Use caché si su prompt es estable.

¿Cómo afecta el razonamiento siempre activo a la latencia?

La latencia hasta el primer token puede ser superior a modelos sin razonamiento. A cambio, Grok 4.3 transmite salida a ~159 tokens/segundo y mejora en cargas donde la precisión importa.

¿Puedo usar Grok 4.3 con Grok Voice?

Sí. El agente de voz grok-voice-think-fast-1.0 llama a Grok 4.3 internamente cuando razona. También puede llamar a Grok 4.3 directamente desde un loop de voz construido con TTS y STT.

¿Qué pasa con llamadas antiguas a Grok 3 o Grok 4 después del 15 de mayo?

Fallarán con un 410 por modelo retirado. Migre antes de la fecha límite.

¿Grok 4.3 soporta imágenes?

Sí. Además de video, puede enviar imágenes usando un bloque image_url.

Conclusión

Grok 4.3 combina menor precio, contexto de 1M, razonamiento siempre activo y video nativo. Para equipos que ya usan una interfaz compatible con OpenAI, la migración suele ser un cambio de base_url y model, no una reescritura completa.

La ruta más rápida: cree tres variantes en Apidog con reasoning_effort en low, medium y high, ejecute sus prompts reales, mida latencia y tokens, y migre antes del 15 de mayo.

Top comments (0)