So verwendest du glm-5.3 über die hiapi API: curl, Python und eine lauffähige Anfrage

Was du erstellen wirst

Eine lauffähige Integration, die glm-5.3 über die OpenAI-kompatible Chat Completions API von hiapi aufruft – eine einzige Anfrage liefert ein echtes Completion-Ergebnis, zudem wird die Stolperfalle erklärt, die bei der Nutzung dieses Modells praktisch am häufigsten auftritt: Seine Reasoning-Tokens verbrauchen dein max_tokens-Budget.

Voraussetzungen: ein hiapi API-Key. Hol ihn dir im Dashboard – er ist einfach ein sk-...-String, und derselbe Key funktioniert für alle in deinem Konto aktivierten Modelle, nicht nur für dieses.

Jede Anfrage und jede Antwort im Folgenden wurde beim Verfassen dieses Artikels tatsächlich gegen die Live-API ausgeführt.

Minimales lauffähiges Beispiel

glm-5.3 ist ein Textmodell am Standard-Chat-Completions-Endpunkt – nicht der asynchrone /v1/tasks-Ablauf, den hiapi für Bild-/Video-/Audiomodelle verwendet. Eine Anfrage, eine Antwort, kein 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
  }'

Antwort (gekürzt):

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

Derselbe Aufruf in Python, nur mit 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"])

Da die Struktur mit OpenAI kompatibel ist, funktioniert dieser Code unverändert auch mit den offiziellen openai Python-/JS-SDKs – setze einfach base_url auf https://api.hiapi.ai/v1 und übergib deinen hiapi-Key.

Muster für den Produktionseinsatz

Reasoning-Tokens zehren ein zu knappes max_tokens-Budget auf

glm-5.3 denkt immer, bevor es antwortet – jede Antwort trägt neben content das Feld reasoning_content, und es gibt kein Request-Flag, um das abzuschalten. Dieser Reasoning-Inhalt zählt vor der sichtbaren Antwort gegen max_tokens. Setzt du das Budget zu niedrig, erhältst du content: null und finish_reason: "length", weil das Modell sein gesamtes Kontingent fürs Denken verbraucht hat und nie dazu kam, die Antwort zu schreiben:

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

Gib selbst bei einfachen Prompts großzügig Spielraum (200+ Token ist eine sichere Untergrenze) und prüfe immer finish_reason, bevor du content vertraust – "length" bedeutet, dass die Antwort abgeschnitten wurde, möglicherweise sogar, bevor sie überhaupt begonnen hat.

Streaming

Setze "stream": true und lies Server-Sent Events. Reasoning-Inhalt und Antworttext kommen als getrennte Delta-Felder an – zuerst Blöcke von delta.reasoning_content, dann delta.content, sobald das Modell mit der eigentlichen Antwort beginnt – und der Stream endet mit finish_reason: "stop" beim letzten Block:

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

Wenn du in eine UI streamst, leite reasoning_content und content in getrennte Bereiche statt sie aneinanderzuhängen – sie sind nicht derselbe Textstrom.

Tool-Aufrufe

Function Calling folgt der Standard-OpenAI-Struktur. Deklariere tools, und wenn das Modell entscheidet, ein Tool aufzurufen, kommt finish_reason als "tool_calls" zurück, zusammen mit einem befüllten tool_calls-Array (es denkt trotzdem vorher, daher erscheint auch reasoning_content):

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

Spiele in der nächsten Runde die tool_calls-Nachricht des Assistenten zusammen mit einer Ergebnisnachricht mit role: "tool" zurück – wie bei jeder OpenAI-kompatiblen Integration.

Fehlerbehandlung

Ein ungültiger oder fehlender Key liefert HTTP 401 mit einer einheitlichen Fehlerstruktur – prüfe den Statuscode, bevor du choices parst:

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

Verwandte Ressourcen

• glm-5.3-Modellseite – Fähigkeiten und aktuelle Verfügbarkeit
• hiapi-Preise – aktuelle Tarife pro Token
• API-Key-Dashboard – Keys erstellen und verwalten
• So verwendest du kimi-k3 über die hiapi API – ein weiteres Chat-Completions-Textmodell auf hiapi
• So verwendest du deepseek-v4.1-flash über die hiapi API – dasselbe Integrationsmuster, anderes Modell

Häufige Fragen

Unterstützt glm-5.3 Streaming? Ja – setze "stream": true und lies die SSE-Blöcke. Reasoning-Inhalt und Antwortinhalt werden als getrennte Delta-Felder gestreamt.

Warum ist content in meiner Antwort null? Fast immer, weil das max_tokens-Budget zu klein ist, um sowohl Reasoning als auch Antwort abzudecken. Prüfe finish_reason: "length" bedeutet, dass die Antwort vor (oder während) der eigentlichen Antwort abgeschnitten wurde. Erhöhe max_tokens.

Kann ich den Reasoning-Schritt deaktivieren? Nicht über einen Request-Parameter – glm-5.3 denkt vor jeder Antwort, und reasoning_content wird immer befüllt. Plane Budget dafür ein, statt zu versuchen, es abzuschalten.

Unterstützt glm-5.3 Function- bzw. Tool-Aufrufe? Ja, mit der Standard-OpenAI-Struktur tools / tool_calls, verifiziert gegen den Live-Endpunkt.

Kann ich das offizielle OpenAI-SDK statt rohem HTTP verwenden? Ja. Setze die base_url des SDK auf https://api.hiapi.ai/v1 und verwende deinen hiapi-sk-...-Key als API-Key – keine weiteren Änderungen nötig.

Wie wird glm-5.3 abgerechnet? Pro Token, wie bei anderen hiapi-Textmodellen auch. Sieh dir die Preise für die aktuellen Tarife an, statt dich auf eine Zahl in diesem Artikel zu verlassen.