Cómo usar glm-5.3 mediante la API de hiapi: curl, Python y una solicitud funcional

Lo que vas a construir

Una integración funcional que llama a glm-5.3 a través de la API Chat Completions compatible con OpenAI de hiapi: una sola solicitud devuelve una respuesta real y explica el obstáculo más habitual al usar este modelo: sus tokens de razonamiento consumen tu presupuesto de max_tokens.

Requisitos previos: una clave de API de hiapi. Obtén una desde el panel: es una cadena sk-... y la misma clave sirve para todos los modelos habilitados en tu cuenta, no solo para este modelo.

Cada solicitud y respuesta que aparece a continuación se obtuvo ejecutándola realmente contra la API en producción en el momento de redactar este artículo.

Ejemplo mínimo funcional

glm-5.3 es un modelo de texto en el endpoint estándar de Chat Completions, no el flujo asíncrono /v1/tasks que hiapi usa para los modelos de imagen/vídeo/audio. Una solicitud, una respuesta, sin sondeo.

curl https://api.hiapi.ai/v1/chat/completions \
  -H "Authorization: Bearer sk-<your-api-key>" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "glm-5.3",
    "messages": [
      {"role": "user", "content": "Reply with exactly: OK"}
    ],
    "max_tokens": 200
  }'

Respuesta (recortada):

{
  "id": "8be5f07603f0407c90734e8b4c2f02f0",
  "object": "chat.completion",
  "model": "glm-5.3",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "OK",
        "reasoning_content": "The user wants me to reply with exactly \"OK\" ..."
      },
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 17,
    "completion_tokens": 35,
    "total_tokens": 52,
    "completion_tokens_details": { "reasoning_tokens": 32 }
  }
}

La misma llamada en Python, usando solo requests:

import requests

resp = requests.post(
    "https://api.hiapi.ai/v1/chat/completions",
    headers={"Authorization": "Bearer sk-<your-api-key>"},
    json={
        "model": "glm-5.3",
        "messages": [
            {"role": "user", "content": "Reply with exactly: OK"}
        ],
        "max_tokens": 200,
    },
    timeout=60,
)
resp.raise_for_status()
data = resp.json()
print(data["choices"][0]["message"]["content"])
print(data["usage"])

Como la estructura es compatible con OpenAI, este código también funciona sin cambios con los SDK oficiales de Python/JS de openai: solo tienes que apuntar el base_url a https://api.hiapi.ai/v1 y pasar tu clave de hiapi.

Patrones para producción

Los tokens de razonamiento se comen un presupuesto de max_tokens bajo

glm-5.3 siempre razona antes de responder: cada respuesta incluye el campo reasoning_content junto a content, y no hay ningún indicador en la solicitud para desactivarlo. Ese razonamiento cuenta para max_tokens antes que la respuesta visible. Si fijas el presupuesto demasiado bajo, obtendrás content: null y finish_reason: "length", porque el modelo gastó toda la cuota pensando y nunca llegó a redactar la respuesta:

{
  "choices": [{
    "message": { "content": null, "reasoning_content": "The user has given a very simple instruction: \"" },
    "finish_reason": "length"
  }],
  "usage": { "completion_tokens": 10, "completion_tokens_details": { "reasoning_tokens": 9 } }
}

Incluso con indicaciones sencillas, deja margen suficiente (200+ tokens es un mínimo seguro) y comprueba siempre finish_reason antes de confiar en content: "length" significa que la respuesta se truncó, quizá incluso antes de empezar.

Streaming

Establece "stream": true y lee Server-Sent Events. El razonamiento y el texto de la respuesta llegan como campos delta independientes: primero los fragmentos delta.reasoning_content, y luego delta.content cuando el modelo empieza a responder de verdad; el flujo termina en el último fragmento con finish_reason: "stop":

curl https://api.hiapi.ai/v1/chat/completions \
  -H "Authorization: Bearer sk-<your-api-key>" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "glm-5.3",
    "messages": [{"role": "user", "content": "Count to 3."}],
    "max_tokens": 200,
    "stream": true
  }'

data: {"choices":[{"delta":{"role":"assistant","content":"","reasoning_content":null},"finish_reason":null}]}

data: {"choices":[{"delta":{"content":null,"reasoning_content":"The"},"finish_reason":null}]}

data: {"choices":[{"delta":{"content":"1, ","reasoning_content":null},"finish_reason":null}]}

data: {"choices":[{"delta":{"content":"2, 3.","reasoning_content":null},"finish_reason":null}]}

data: {"choices":[{"delta":{},"finish_reason":"stop"}]}

Si haces streaming hacia una UI, dirige reasoning_content y content a paneles distintos en lugar de concatenarlos: no son el mismo flujo de texto.

Llamada a herramientas

La llamada a funciones sigue la estructura estándar de OpenAI. Declara tools y, cuando el modelo decide llamar a una herramienta, finish_reason se devuelve como "tool_calls" con un array tool_calls rellenado (el modelo sigue razonando primero, así que reasoning_content también aparece):

{
  "message": {
    "role": "assistant",
    "content": null,
    "reasoning_content": "The user wants to know the weather in Paris. I have a tool available for that. Let me call it.",
    "tool_calls": [{
      "id": "call_12e21fe488f046bc9edb4488",
      "type": "function",
      "function": { "name": "get_weather", "arguments": "{\"city\": \"Paris\"}" }
    }]
  },
  "finish_reason": "tool_calls"
}

En la siguiente ronda, reproduce el mensaje tool_calls del asistente junto con un mensaje de resultado con role: "tool", igual que en cualquier integración compatible con OpenAI.

Gestión de errores

Una clave no válida o ausente devuelve HTTP 401 con una estructura de error coherente: comprueba el código de estado antes de analizar choices:

{
  "error": {
    "code": "permission_denied",
    "message": "This API key is invalid. Check that it is correct or use another API key and try again.",
    "type": "hiapi_error"
  }
}

Recursos relacionados

• Página del modelo glm-5.3: capacidades y disponibilidad actual
• Precios de hiapi: tarifas actuales por token
• Panel de claves de API: crear y gestionar claves
• Cómo usar kimi-k3 mediante la API de hiapi: otro modelo de texto de Chat Completions en hiapi
• Cómo usar deepseek-v4.1-flash mediante la API de hiapi: el mismo patrón de integración, con otro modelo

Preguntas frecuentes

¿glm-5.3 admite streaming? Sí: establece "stream": true y lee los fragmentos SSE. El razonamiento y el contenido de la respuesta se transmiten como campos delta independientes.

¿Por qué content es null en mi respuesta? Casi siempre se debe a que el presupuesto de max_tokens es demasiado pequeño para cubrir tanto el razonamiento como la respuesta. Comprueba finish_reason: "length" significa que la respuesta se truncó antes (o durante) la respuesta real. Aumenta max_tokens.

¿Puedo desactivar el paso de razonamiento? No se puede desactivar mediante parámetros de la solicitud: glm-5.3 razona antes de cada respuesta y reasoning_content siempre se rellena. Reserva presupuesto para ello en lugar de intentar desactivarlo.

¿glm-5.3 admite llamadas a funciones/herramientas? Sí, usa la estructura estándar de OpenAI tools / tool_calls, verificada contra el endpoint en producción.

¿Puedo usar el SDK oficial de OpenAI en lugar de HTTP sin procesar? Sí. Apunta el base_url del SDK a https://api.hiapi.ai/v1 y usa tu clave sk-... de hiapi como clave de API: no hace falta ningún otro cambio.

¿Cómo se factura glm-5.3? Por tokens, igual que los demás modelos de texto de hiapi. Consulta los precios para conocer las tarifas actuales en lugar de fiarte de una cifra concreta de este artículo.