Como usar o glm-5.3 pela API do hiapi: curl, Python e uma requisição executável

O que você vai construir

Uma integração executável que chama o glm-5.3 pela API Chat Completions compatível com OpenAI do hiapi — uma única requisição já retorna uma conclusão real, além de explicar a armadilha mais comum ao usar esse modelo: seus tokens de raciocínio consomem o seu orçamento de max_tokens.

Pré-requisitos: uma chave de API do hiapi. Obtenha-a no dashboard — é apenas uma string sk-..., e a mesma chave serve para todos os modelos habilitados na sua conta, não apenas para este modelo.

Cada requisição e resposta abaixo foi obtida executando de fato a API em produção no momento em que este artigo foi escrito.

Exemplo mínimo executável

O glm-5.3 é um modelo de texto no endpoint padrão Chat Completions — não o fluxo assíncrono /v1/tasks que o hiapi usa para modelos de imagem/vídeo/áudio. Uma requisição, uma resposta, sem polling.

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
  }'

Resposta (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 }
  }
}

A mesma chamada em Python, usando apenas 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 a estrutura é compatível com OpenAI, esse código também funciona sem alterações com os SDKs oficiais openai de Python/JS — basta apontar o base_url para https://api.hiapi.ai/v1 e passar sua chave do hiapi.

Padrões para produção

Os tokens de raciocínio consomem um orçamento baixo de max_tokens

O glm-5.3 sempre pensa antes de responder — toda resposta carrega o campo reasoning_content ao lado de content, e não há flag na requisição para desativá-lo. Esse conteúdo de raciocínio conta para o max_tokens antes da resposta visível. Se você definir o orçamento baixo demais, receberá content: null e finish_reason: "length", porque o modelo gastou toda a cota pensando e nunca chegou à etapa de escrever a resposta:

{
  "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 } }
}

Mesmo com prompts simples, dê bastante margem (200+ tokens é um piso seguro) e sempre verifique o finish_reason antes de confiar no content — "length" indica que a resposta foi truncada, e pode até ter sido truncada antes mesmo de começar.

Saída em streaming

Defina "stream": true e leia os Server-Sent Events. O conteúdo de raciocínio e o texto da resposta chegam como campos delta separados — primeiro os blocos delta.reasoning_content, e depois os delta.content quando o modelo começa a responder de fato — e o stream termina no último bloco com 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"}]}

Se você for fazer streaming para uma UI, encaminhe reasoning_content e content para painéis diferentes em vez de concatená-los — eles não são o mesmo fluxo de texto.

Chamada de ferramentas

A chamada de funções segue a estrutura padrão da OpenAI. Declare tools e, quando o modelo decidir chamar uma ferramenta, o finish_reason virá como "tool_calls", com o array tool_calls preenchido (ele ainda raciocina primeiro, então o reasoning_content também 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"
}

Na próxima rodada, reenvie a mensagem tool_calls do assistente junto com uma mensagem de resultado com role: "tool", igual a qualquer integração compatível com OpenAI.

Tratamento de erros

Uma chave inválida ou ausente retorna HTTP 401, com uma estrutura de erro consistente — verifique o código de status antes de fazer o parse de 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 do modelo glm-5.3 — capacidades e disponibilidade atual
• Preços do hiapi — tarifas atuais por token
• Dashboard de chaves de API — crie e gerencie chaves
• Como usar o kimi-k3 pela API do hiapi — outro modelo de texto Chat Completions no hiapi
• Como usar o deepseek-v4.1-flash pela API do hiapi — o mesmo padrão de integração, um modelo diferente

Perguntas frequentes

O glm-5.3 suporta streaming? Sim — defina "stream": true e leia os blocos SSE. O conteúdo de raciocínio e o conteúdo da resposta são transmitidos como campos delta separados.

Por que o content da minha resposta é null? Quase sempre porque o orçamento de max_tokens é pequeno demais para cobrir tanto o raciocínio quanto a resposta. Verifique o finish_reason: "length" indica que a resposta foi truncada antes (ou durante) a resposta real. Aumente o max_tokens.

Posso desativar a etapa de raciocínio? Não é possível desativá-la por parâmetro de requisição — o glm-5.3 raciocina antes de cada resposta, e o reasoning_content sempre estará preenchido. Reserve orçamento para ele em vez de tentar desligá-lo.

O glm-5.3 suporta chamada de funções/ferramentas? Sim, usando a estrutura padrão tools / tool_calls da OpenAI, validada no endpoint em produção.

Posso usar o SDK oficial da OpenAI em vez de HTTP puro? Sim. Aponte o base_url do SDK para https://api.hiapi.ai/v1 e use sua chave sk-... do hiapi como API key — nenhuma outra alteração é necessária.

Como o glm-5.3 é cobrado? Por token, como os outros modelos de texto do hiapi. Consulte a página de preços para obter as tarifas atuais, em vez de confiar em um número específico deste artigo.