So verwendest du die grok-4.6 API: cURL, Python und eine funktionierende Anfrage

grok-4.6 ist ein auf Reasoning abgestimmtes Chat-Modell, das über die hiapi API verfügbar ist. Anders als die Bild- und Videomodelle von hiapi nutzt es keine asynchrone /v1/tasks-Pipeline – es ist eine synchrone, OpenAI-kompatible Chat-Completions-Schnittstelle, du erhältst also direkt eine normale HTTP-Antwort (oder einen SSE-Stream), ohne Polling. Dieser Artikel zeigt zuerst eine minimal funktionierende Anfrage und dann die Teile, die du im Produktivbetrieb wirklich brauchst: Streaming, Tool-Aufrufe, JSON-Modus und Fehlerbehandlung.

Was du vorbereiten musst

• Einen hiapi API-Schlüssel. Falls du noch keinen hast, hol dir einen im Dashboard – jede Anfrage unten benötigt ihn im Header Authorization: Bearer sk-....
• Einen beliebigen HTTP-Client. Die Beispiele verwenden curl und das Python-Paket requests; unabhängig von der Sprache ist die JSON-Struktur dieselbe.
• Kein SDK erforderlich. Das Anfrage-/Antwortformat von grok-4.6 orientiert sich eng an der OpenAI-Chat-Completions-Konvention, daher funktionieren OpenAI-kompatible Tools in der Regel, aber hiapi bietet einen eigenen Chat-Completions-Endpunkt statt eines proprietären Endpunkts – richte deinen Client auf https://api.hiapi.ai/v1/chat/completions und verwende die nackte Modell-ID grok-4.6.

Minimal funktionierende Anfrage

curl https://api.hiapi.ai/v1/chat/completions \
  -H "Authorization: Bearer $HIAPI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "grok-4.6",
    "messages": [
      {"role": "user", "content": "Erkläre in einem Satz, wozu ein Kalman-Filter dient."}
    ]
  }'

Eine erfolgreiche Antwort sieht so aus:

{
  "id": "b6c018d3-218e-9b06-aa12-5afc02e21b5c",
  "object": "chat.completion",
  "model": "grok-4.6",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "Ein Kalman-Filter schätzt den wahren Zustand eines Systems über die Zeit, indem es verrauschte Messwerte mit einem Prädiktionsmodell kombiniert und beide nach ihrer jeweiligen Unsicherheit gewichtet."
      },
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 24,
    "completion_tokens": 31,
    "total_tokens": 55
  }
}

Der Antworttext liegt in choices[0].message.content, wie bei jeder OpenAI-artigen Chat-API.

So sieht derselbe Aufruf in Python mit requests aus:

import os
import requests

resp = requests.post(
    "https://api.hiapi.ai/v1/chat/completions",
    headers={"Authorization": f"Bearer {os.environ['HIAPI_API_KEY']}"},
    json={
        "model": "grok-4.6",
        "messages": [
            {"role": "user", "content": "Erkläre in einem Satz, wozu ein Kalman-Filter dient."}
        ],
    },
    timeout=60,
)
resp.raise_for_status()
print(resp.json()["choices"][0]["message"]["content"])

Reasoning-Regler von grok-4.6

grok-4.6 ist ein Reasoning-Modell: Bevor es die endgültige Antwort schreibt, verwendet es zusätzliche Token zum „Nachdenken“, und diese Reasoning-Token werden als Ausgabe-Token abgerechnet (aktuelle Preise unter Preise). Du kannst die Denkmenge über reasoning_effort steuern, mit einem der Werte low, medium, high oder xhigh (wird es weggelassen, verwendet die API standardmäßig high):

curl https://api.hiapi.ai/v1/chat/completions \
  -H "Authorization: Bearer $HIAPI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "grok-4.6",
    "messages": [{"role": "user", "content": "Sag in fünf Wörtern Hallo."}],
    "reasoning_effort": "low"
  }'

Eine nicht gestreamte Antwort liefert den Reasoning-Verlauf des Modells in message.reasoning_content, getrennt vom endgültigen message.content. Für kurze Aufgaben mit niedriger Latenz kannst du auf low oder medium gehen; bei mehrstufigen Problemen tauschen high oder xhigh Latenz und Token gegen bessere Antworten ein.

Streaming-Antworten

Setze "stream": true, um die Antwort als Server-Sent Events zu lesen, statt auf die vollständige Completion zu warten:

curl -N https://api.hiapi.ai/v1/chat/completions \
  -H "Authorization: Bearer $HIAPI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "grok-4.6",
    "messages": [{"role": "user", "content": "Zähle von 1 bis 5."}],
    "stream": true
  }'

Jede Zeile ist ein Datenblock data: {...}. Reasoning-Token werden über choices[0].delta.reasoning_content gestreamt, danach werden die Antwort-Token über choices[0].delta.content gestreamt, und der Stream endet mit dem Literal data: [DONE]:

data: {"id":"...","object":"chat.completion.chunk","choices":[{"index":0,"delta":{"reasoning_content":"Auflisten"},"finish_reason":null}]}

data: {"id":"...","object":"chat.completion.chunk","choices":[{"index":0,"delta":{"content":"1, 2"},"finish_reason":null}]}

data: {"id":"...","object":"chat.completion.chunk","choices":[{"index":0,"delta":{},"finish_reason":"stop"}]}

data: [DONE]

In Python kann requests den Stream Zeile für Zeile durchlaufen:

import json
import requests

with requests.post(
    "https://api.hiapi.ai/v1/chat/completions",
    headers={"Authorization": f"Bearer {os.environ['HIAPI_API_KEY']}"},
    json={
        "model": "grok-4.6",
        "messages": [{"role": "user", "content": "Zähle von 1 bis 5."}],
        "stream": True,
    },
    stream=True,
    timeout=60,
) as resp:
    for line in resp.iter_lines():
        if not line or not line.startswith(b"data: "):
            continue
        payload = line[len(b"data: "):]
        if payload == b"[DONE]":
            break
        chunk = json.loads(payload)
        delta = chunk["choices"][0]["delta"]
        if "content" in delta:
            print(delta["content"], end="", flush=True)

Tool-Aufrufe

grok-4.6 unterstützt Funktionsaufrufe im OpenAI-Stil: Übergib ein tools-Array und lass das Modell über tool_choice: "auto" selbst entscheiden, wann es ein Tool aufruft.

curl https://api.hiapi.ai/v1/chat/completions \
  -H "Authorization: Bearer $HIAPI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "grok-4.6",
    "messages": [{"role": "user", "content": "Wie ist das Wetter in Tokio?"}],
    "tools": [
      {
        "type": "function",
        "function": {
          "name": "get_weather",
          "description": "Ruft das aktuelle Wetter einer Stadt ab",
          "parameters": {
            "type": "object",
            "properties": {"city": {"type": "string"}},
            "required": ["city"]
          }
        }
      }
    ],
    "tool_choice": "auto"
  }'

Wenn das Modell beschließt, das Tool aufzurufen, gibt finish_reason den Wert "tool_calls" zurück, und die Argumente kommen als JSON-String an, den du selbst parsen musst:

{
  "choices": [
    {
      "message": {
        "role": "assistant",
        "tool_calls": [
          {
            "id": "call_...",
            "type": "function",
            "function": {"name": "get_weather", "arguments": "{\"city\":\"Tokyo\"}"}
          }
        ]
      },
      "finish_reason": "tool_calls"
    }
  ]
}

Führe deine Funktion aus, hänge dann eine Nachricht mit role: "tool" (mit dem Ausführungsergebnis und der passenden tool_call_id) an messages an und schicke die Konversation erneut, um die endgültige Antwort in natürlicher Sprache zu erhalten.

JSON-Modus

Wenn du die Antwort parsen möchtest, ohne einen Tool-Aufruf-Roundtrip zu machen, kannst du response_format setzen:

curl https://api.hiapi.ai/v1/chat/completions \
  -H "Authorization: Bearer $HIAPI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "grok-4.6",
    "messages": [
      {"role": "system", "content": "Antworte bitte mit einem JSON-Objekt, das die beiden Schlüssel \"city\" und \"country\" enthält."},
      {"role": "user", "content": "Wo steht der Eiffelturm?"}
    ],
    "response_format": {"type": "json_object"}
  }'

message.content wird als JSON-String zurückgegeben (weiterhin im normalen Chat-Completions-Umschlag), den du auf deiner Seite mit json.loads(...) parst. Weise das Modell im Prompt unbedingt an, tatsächlich JSON zu erzeugen – response_format erzwingt das Ausgabeformat, baut aber kein Schema für dich.

Praxis im Produktivbetrieb

• Behandle die dokumentierten Fehlercodes. Ein falscher oder fehlender Schlüssel liefert HTTP 401 mit dem Response-Body {"error":{"code":"permission_denied","message":"...","request_id":"...","type":"hiapi_error"}}. Unzureichendes Guthaben liefert 402; eine ungültige Modell-ID oder ein falsch formatiertes Argument liefert 400. Prüfe zuerst den Statuscode und protokolliere die request_id aus dem Fehler-Response-Body – genau diese Information brauchst du, wenn du ein Problem melden musst.
• Nutze Backoff-Retries bei 429 und 503. hiapi setzt Rate-Limits pro Konto durch; 429 bedeutet, dass du das Limit überschritten hast, 503 bedeutet, dass das Modell vorübergehend nicht verfügbar ist. Für beide eignet sich ein begrenzter exponentieller Backoff-Retry (z. B. 1 Sekunde, 2 Sekunden, 4 Sekunden, dann nach einigen Versuchen aufgeben) statt einer engen Schleife.
• Setze Request-Timeouts. Bei Reasoning-Stärke high oder xhigh dauert es deutlich länger als bei low; setze das Client-Timeout passend zur verwendeten Stärke statt einer einzigen globalen Konstante.
• Bevorzuge in jeder benutzernahen Anwendung Streaming. Nicht gestreamte Aufrufe blockieren, bis die vollständige Antwort (einschließlich aller Reasoning-Token) bereit ist; Streaming schickt die ersten Token sofort an deine UI und erlaubt dir, einen „Denkt nach“-Status anzuzeigen, solange die reasoning_content-Deltas vor der endgültigen Antwort eintreffen.
• Hardcode keine Schlüssel. Lade sie aus Umgebungsvariablen oder einem Secret Manager, niemals aus der Versionsverwaltung – die Beispiele oben lesen aus genau diesem Grund aus $HIAPI_API_KEY / os.environ["HIAPI_API_KEY"].

Die vollständige Parameterreferenz (einschließlich jedes von grok-4.6 akzeptierten Felds) findest du auf der Modellseite und in der grok-4.6-Dokumentation.

Häufige Fragen

Ist grok-4.6 auf hiapi mit dem OpenAI SDK kompatibel? Die Anfrage- und Antwortstrukturen folgen der OpenAI-Chat-Completions-Konvention (messages, choices[0].message.content, Streaming-Deltas, Tool-Aufrufe), daher sollten die meisten OpenAI-kompatiblen Tools, die das Überschreiben von Basis-URL und Modell-ID erlauben, funktionieren. Richte die Basis-URL auf https://api.hiapi.ai/v1 und verwende grok-4.6 als Modell-ID.

Warum ist meine Antwort langsamer als bei anderen Modellen? grok-4.6 verwendet vor der Antwort Token für ein internes Reasoning, und diese Token werden als Ausgabe-Token abgerechnet. Für latenzempfindliche Aufrufe senke reasoning_effort auf low oder medium oder wechsle zu Streaming, damit du nicht auf die gesamte Antwort auf einmal warten musst.

Was bedeutet reasoning_content, und kann ich es vor dem Nutzer verbergen? Es ist der interne Reasoning-Verlauf des Modells, der getrennt von content zurückgegeben wird (beim Streaming als delta.reasoning_content). Du kannst es in deiner UI problemlos weglassen – nur content ist die endgültige Antwort.

Ich habe 401 und permission_denied erhalten – was ist schiefgelaufen? Dein Authorization-Header fehlt, ist falsch formatiert, oder der Schlüssel ist ungültig/widerrufen. Prüfe erneut, ob du Authorization: Bearer sk-... sendest und einen gültigen Schlüssel aus dem Dashboard verwendest.

Kann ich Funktionsaufrufe und JSON-Modus von grok-4.6 im selben Request gleichzeitig verwenden? tools/tool_choice und response_format sind voneinander unabhängige Parameter und können gleichzeitig gesetzt werden, aber wenn das Modell beschließt, ein Tool aufzurufen, ist finish_reason in dieser Runde "tool_calls" und message.content kann leer sein – behandle zuerst den Tool-Aufruf und fordere dann in einer Folgerunde die endgültige Antwort im JSON-Format an.

Wie kontrolliere ich die Kosten? Reasoning-Token zählen zu den Ausgabe-Token, daher variieren die Kosten mit reasoning_effort und der Antwortlänge. Schau vor dem Ausführen aufwändiger Aufgaben auf der Preisseite nach den aktuellen Token-Preisen.