Wie verwende ich die Grok 4.7 API? In 5 Minuten zum ersten Aufruf

TL;DR

• Grok 4.7 ist das Textmodell von xAI für Coding und agentische Aufgaben und ist bereits auf HiAPI verfügbar. Öffne die Modellseite, um direkt zu chatten; neue Nutzer erhalten bei der Registrierung 200 Credits geschenkt.
• Plattformpreis $0.84 Input / $2.52 Output (pro 1M Tokens, Cache-Lesen $0.21), das sind ca. 58 % Rabatt auf den offiziellen Preis. Eine Anfrage mit 2K Input + 1K Output kostet ca. $0.0042; bei einer mittleren Anfrage mit insgesamt 3K Tokens (ca. $0.0084/Aufruf) schaffst du mit $10 etwa 1200 Aufrufe.
• Schnellster Aufruf: POST https://api.hiapi.ai/v1/chat/completions, model auf grok-4.7 setzen; bei bestehendem OpenAI-SDK-Code müssen nur base_url und model geändert werden.

Was ist Grok 4.7 und was ist neu

Das am 2026-09-21 veröffentlichte Grok 4.7 ist das aktuell standardmäßig empfohlene Modell von xAI und fokussiert auf Coding, agentische Aufgaben und Wissensarbeit. Die offiziell gemeldeten Terminal-Bench 4.0-Werte stiegen von 20,3 % bei 4.6 auf 38,0 %, also fast eine Verdopplung (laut eigener Angabe). Für Aufrufer sind vier Änderungen relevant:

• Coding und agentische Szenarien stehen im Fokus: xAI hat es zeitgleich in Coding-Tools wie Cursor und GitHub Copilot integriert; die Fähigkeit zur langfristigen Aufgabenplanung ist der Schwerpunkt dieser Version.
• Vier Reasoning-Stufen: reasoning_effort unterstützt low / medium / high / xhigh, Standard ist high; der Denkprozess wird separat über das Feld reasoning_content zurückgegeben, sodass du entscheiden kannst, ob du ihn anzeigst.
• JSON-Objekt + Tool-Aufrufe: response_format: {"type": "json_object"} erzwingt gültige JSON-Ausgabe; Funktionsaufrufe nutzen das standardmäßige OpenAI tools-Format, sodass strukturierte Extraktion und Agent-Schleifen ohne zusätzliche Verpackung funktionieren.
• 500K Kontext: Eine Anfrage kann eine komplette Codebasis oder große Dokumentenmengen aufnehmen.

Echtes Ergebnis: ein Stück pandas-Code zur Datenanalyse

Die folgende Ausgabe haben wir bei einem echten Lauf mit Grok 4.7 auf HiAPI erhalten (den vollständigen Prompt findest du über den Link unten). Aufgabe war die Analyse von E-Commerce-Bestelldaten: monatlicher GMV, Top 20 Nutzer nach kumuliertem Umsatz, Trend des durchschnittlichen Erstbestellwerts neuer Nutzer, wobei created_at ein String ist. Das Modell war in 18,5 Sekunden fertig, der Code ist vollständig lauffähig und die String-Datums-Konvertierung wurde proaktiv behandelt:

# ---------- 0. Datumsverarbeitung: String in datetime umwandeln ----------
df["created_at"] = pd.to_datetime(df["created_at"], errors="coerce")
df = df.dropna(subset=["created_at", "amount", "user_id"])

# Nur gültige Bestellungen zählen (status-Werte an das tatsächliche Geschäft anpassen)
df_valid = df[df["status"] == "paid"].copy()

# ---------- 1. GMV und Bestellanzahl pro Monat ----------
df_valid["month"] = df_valid["created_at"].dt.to_period("M")
monthly = (
    df_valid.groupby("month", as_index=False)
    .agg(GMV=("amount", "sum"), order_count=("order_id", "count"))
    .sort_values("month")
)

Bei diesem echten Lauf waren es 3440 Input-Tokens und 1427 Output-Tokens, nach Plattformpreis ca. $0.007. Wenn du das gleiche Ergebnis willst, klicke direkt auf diesen Prompt, um ihn einmal auf der Modellseite auszuführen →

Zwei Einstiegswege

Weg eins: Browser, 3 Schritte, ohne Code

1. Öffne die Grok 4.7 Modellseite und melde dich an oder registriere dich (neue Nutzer erhalten 200 Credits).
2. Füge deinen Prompt in das Dialogfeld ein, zum Beispiel über diesen Link, bei dem der Prompt bereits automatisch eingefügt ist.
3. Direkt senden; das Guthaben wird nach tatsächlichem Token-Verbrauch abgebucht.

Weg zwei: API, 3 Schritte, Integration in deine App

1. Erstelle in der HiAPI-Konsole einen API-Key.
2. Ersetze YOUR_HIAPI_API_KEY im folgenden curl durch deinen Key und führe ihn aus.
3. Setze model fest auf grok-4.7, ersetze messages durch deine Geschäftsdaten, fertig.

curl: der erste Aufruf

curl https://api.hiapi.ai/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_HIAPI_API_KEY" \
  -d '{
    "model": "grok-4.7",
    "messages": [
      {"role": "system", "content": "You are a senior backend engineer."},
      {"role": "user", "content": "Explain what a database connection pool is in two sentences."}
    ],
    "reasoning_effort": "high",
    "max_tokens": 2000
  }'

In der Antwort ist choices[0].message.content der eigentliche Text und reasoning_content der Denkprozess; usage.completion_tokens_details.reasoning_tokens sagt dir separat, wie viele Tokens dieses Mal für das Reasoning verbraucht wurden. Für Streaming füge "stream": true hinzu und parse die SSE-Daten.

Python: nicht-streaming + Streaming

Für nicht-streaming reicht requests:

import requests

resp = requests.post(
    "https://api.hiapi.ai/v1/chat/completions",
    headers={"Authorization": "Bearer YOUR_HIAPI_API_KEY"},
    json={
        "model": "grok-4.7",
        "messages": [
            {"role": "user", "content": "Write a Python function that merges two sorted lists into one sorted list."}
        ],
        "reasoning_effort": "medium",
        "max_tokens": 4000,
    },
    timeout=120,
)
resp.raise_for_status()
data = resp.json()
print(data["choices"][0]["message"]["content"])

Beim Streaming sind zwei Dinge zu beachten: Das zuerst kommende delta.reasoning_content ist der Denkprozess, erst das spätere delta.content ist der eigentliche Text; usage steht nur im letzten Chunk (choices ist dann leer), und der Stream endet mit data: [DONE]:

import json
import requests

with requests.post(
    "https://api.hiapi.ai/v1/chat/completions",
    headers={"Authorization": "Bearer YOUR_HIAPI_API_KEY"},
    json={
        "model": "grok-4.7",
        "messages": [{"role": "user", "content": "Plan a Redis-based online presence system."}],
        "reasoning_effort": "high",
        "stream": True,
    },
    stream=True,
    timeout=300,
) as resp:
    resp.raise_for_status()
    for line in resp.iter_lines(decode_unicode=True):
        if not line or not line.startswith("data:"):
            continue
        payload = line[len("data:"):].strip()
        if payload == "[DONE]":
            break
        chunk = json.loads(payload)
        if not chunk["choices"]:
            print("\nusage:", chunk["usage"])  # nur der letzte Chunk enthält usage
            continue
        delta = chunk["choices"][0]["delta"]
        if delta.get("reasoning_content"):
            print(delta["reasoning_content"], end="", flush=True)
        elif delta.get("content"):
            print(delta["content"], end="", flush=True)

Parametertabelle

Feld	Erforderlich	Werte	Beschreibung
model	Ja	grok-4.7	Immer diese ID verwenden
messages	Ja	Nachrichtenarray im OpenAI-Format	Rollen system / user / assistant / tool werden alle unterstützt
reasoning_effort	Nein	low / medium / high / xhigh, Standard high	Reasoning-Intensität; der Denkprozess wird in reasoning_content zurückgegeben
max_tokens	Nein	Positive Ganzzahl	Obergrenze der Ausgabe, einschließlich Reasoning-Tokens; zu klein gesetzt, wird das Denken zuerst abgeschnitten
response_format	Nein	{"type": "json_object"}	Erzwingt gültiges JSON; geeignet für strukturierte Extraktion
tools	Nein	OpenAI function calling-Array	Tool-Aufrufe; mehrfache Rückgabe von Tool-Ergebnissen wird unterstützt
stream	Nein	true / false, Standard false	SSE-Streaming; usage steht im letzten Chunk

Fehler, die dir begegnen werden

Die häufigste Stolperfalle beim Migrieren von Code anderer Modelle: grok-4.7 unterstützt die drei Parameter frequency_penalty, presence_penalty und stop nicht; werden sie mitgeschickt, gibt es direkt einen 400-Fehler. reasoning_effort akzeptiert nur die vier Stufen low / medium / high / xhigh; bei einem falschen Wert gibt die Schnittstelle unverändert reasoning_effort: is outside allowed values zurück. Felder außerhalb des Protokolls lassen sich ebenfalls nicht übermitteln; als wir beim Testen ein nicht registriertes Feld hinzufügten, gab die Schnittstelle request.zz: unregistered public parameter zurück.

Die Lösung ist einfach: diese drei Parameter entfernen, die Stufe korrekt setzen und erneut senden. Bei anderen 4xx-Fehlern zuerst error.code prüfen und dann den Code ändern, nicht raten.

Vor dem Going-live beachten

• Reasoning-Tokens werden als Output abgerechnet. Eine Antwort der Stufe high kann einen Denkprozess von über zehntausend Tokens enthalten, die mit $2.52/M in die Rechnung eingehen. Bei einfachen Aufgaben reasoning_effort auf low oder medium zu senken, ist der direkteste Kostenschalter; usage.completion_tokens_details.reasoning_tokens lässt dich diese Zahl separat prüfen.
• Gesamtanfrage ab 200K springt in die nächste Preisstufe. Sobald der Prompt 200K Tokens erreicht (Vertragsschwelle 199.999), wird die gesamte Anfrage zum Langtextpreis abgerechnet: Input $1.68 / Output $5.04 / Cache-Lesen $0.42, also das Doppelte der regulären Stufe. Halte regulären Traffic unter 200K und stopfe nicht blind eine komplette Codebasis hinein.
• Cache-Lesen kostet nur ein Viertel des Normalpreises. Wiederholte lange System-Prompts und Gesprächspräfixe aus mehreren Runden lösen automatisch den Cache-Treffer aus; Cache-Lesen kostet $0.21/M (ein Viertel des Normalpreises von $0.84/M). Halte bei Agent-Schleifen das Präfix stabil, dann sieht die Rechnung deutlich besser aus.

Häufige Fragen

Wie wähle ich zwischen Grok 4.7 und Grok 4.6? Der Plattformpreis ist völlig gleich ($0.84/$2.52). Für komplexe Coding- und agentische Aufgaben nimm 4.7 (offiziell standardmäßig empfohlen); bei einfachen Aufgaben, bei denen du Tokens sparen willst, kannst du bei 4.6 bleiben. Eine ausführliche Gegenüberstellung findest du unter Grok 4.7 vs Grok 4.6.

Wird Streaming-Ausgabe unterstützt? Ja, standardmäßiges SSE. Beachte, dass usage nur im letzten Chunk zurückgegeben wird; die usage-Felder der vorherigen Chunks sind leer.

Muss ich für reasoning_content extra zahlen? Du musst keinen separaten Schalter aktivieren, aber die erzeugten Reasoning-Tokens zählen zur Output-Nutzung und werden zum Output-Preis abgerechnet; je höher die Stufe, desto höher die Rechnung.

Sind 500K Kontext das Input-Limit? 500K ist das gemeinsame Fenster für Input und Output zusammen. Wenn der Input nahe an 200K liegt, wird der Langtextpreis ausgelöst; Details siehe oben unter „Vor dem Going-live beachten“.

---

Wenn du tiefer einsteigen willst: Zur Preisrechnung siehe Wie viel kostet die Grok 4.7 API; 5 direkt kopierbare Szenario-Prompts findest du unter Grok 4.7 Prompt-Sammlung; die Verwendung der vorherigen Generation steht auf der Grok 4.6 Modellseite. Kopiere den obigen pandas-Prompt und starte deinen ersten Aufruf auf der Modellseite.