DEV Community

Cover image for Grok 4.3 API Nutzung: Eine Anleitung
Emre Demir
Emre Demir

Posted on • Originally published at apidog.com

Grok 4.3 API Nutzung: Eine Anleitung

xAI hat Grok 4.3 schrittweise ausgerollt: Beta am 17. April 2026, API-Zugang am 30. April und allgemeine Verfügbarkeit am 6. Mai. Für Entwickler sind vor allem vier Punkte relevant: ein 1.000.000-Token-Kontextfenster, native Videoeingabe, durchgängiges Reasoning und eine Preissenkung von ungefähr 40 % gegenüber Grok 4.20. Da acht ältere Grok-Modelle am 15. Mai eingestellt werden, sollten bestehende Integrationen mit grok-3- oder grok-4-Modellen jetzt migriert und getestet werden.

Probieren Sie Apidog noch heute aus

Dieser Leitfaden zeigt die praktische Integration von Grok 4.3: Endpunkt, Authentifizierung, OpenAI-kompatible base_url, reasoning_effort, Videoeingabe, Funktionsaufrufe und ein reproduzierbares Test-Setup in Apidog.

Für die Sprachseite derselben Veröffentlichung siehe Wie man Grok Voice kostenlos nutzt. Für den direkten Vergleich mit OpenAIs führendem Sprachmodell siehe Grok Voice vs. GPT-Realtime.

TL;DR

  • Grok 4.3 ist seit dem 6. Mai 2026 allgemein verfügbar. Acht ältere Modelle werden am 15. Mai 2026 eingestellt.
  • Preise: $1.25 pro 1M Eingabe-Tokens, $2.50 pro 1M Ausgabe-Tokens, zwischengespeicherte Eingabe $0.20 pro 1M.
  • Kontextfenster: 1M Tokens.
  • Neue Fähigkeit: native Videoeingabe.
  • Reasoning ist durchgängig aktiv und kann über reasoning_effort gesteuert werden: low, medium, high.
  • API-Endpunkt: https://api.x.ai/v1/chat/completions.
  • OpenAI-kompatibel: OpenAI SDK verwenden, base_url austauschen.
  • Durchsatz: ungefähr 159 Tokens/Sekunde auf Standard-Tiers.
  • Testen Sie Varianten mit Apidog, um Latenz, Antwortqualität und usage.reasoning_tokens zu vergleichen.

Was sich in Grok 4.3 geändert hat

Die wichtigsten Änderungen für Implementierungen:

  1. Niedrigere Kosten

    Die Eingabekosten sinken um 37,5 % gegenüber Grok 4.20, die Ausgabekosten um 58,3 %. Zwischengespeicherte Eingaben kosten jetzt 0,20 $ pro 1M Tokens. Das ist besonders relevant für stabile System-Prompts, große Kontextblöcke und wiederkehrende Agenten-Workflows.

  2. 1M-Token-Kontext

    Das Kontextfenster steigt von 256k auf 1M Tokens. Damit können Sie große Diffs, lange Dokumente, komplette Berichte oder längere Konversationshistorien in einer Anfrage verarbeiten.

  3. Native Videoeingabe

    Grok 4.3 kann Video-URLs direkt als Inhaltsblock verarbeiten. Sie müssen nicht zuerst manuell Frames extrahieren.

  4. Durchgängiges Reasoning

    Jede Anfrage nutzt mindestens low Reasoning. Über reasoning_effort steuern Sie, wie viel Reasoning-Zeit und Tokens das Modell investieren soll.

  5. Bessere agentische Workflows

    xAI nennt einen Gewinn von +300 Elo-Punkten auf GDPval-AA gegenüber Grok 4.20. In der Praxis ist das vor allem bei Tool-Auswahl, mehrstufigen Abläufen und Fehlererholung relevant.

Der Intelligenzindex von 53 (Artificial Analysis) platziert Grok 4.3 über dem Durchschnitt von 35 für seine Preisklasse und auf Platz 10 von 146 erfassten Modellen.

Voraussetzungen

Bereiten Sie vor der ersten Anfrage diese Komponenten vor:

  • Ein xAI Console-Konto unter console.x.ai.
  • Einen API-Schlüssel, idealerweise projektbezogen für Produktionsumgebungen.
  • Das OpenAI SDK oder das xAI SDK.
  • Einen API-Client wie Apidog, damit Sie Requests versionieren, wiederholen und Varianten vergleichen können.

Exportieren Sie den Schlüssel lokal:

export XAI_API_KEY="xai-..."
Enter fullscreen mode Exit fullscreen mode

Endpunkt und Authentifizierung

Grok 4.3 wird über die OpenAI-kompatible Chat-Completions-Schnittstelle bereitgestellt.

POST https://api.x.ai/v1/chat/completions
Enter fullscreen mode Exit fullscreen mode

Die Header entsprechen dem üblichen Bearer-Token-Muster:

Authorization: Bearer $XAI_API_KEY
Content-Type: application/json
Enter fullscreen mode Exit fullscreen mode

Wenn Sie bereits das OpenAI SDK verwenden, müssen Sie in vielen Fällen nur base_url und model ändern.

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["XAI_API_KEY"],
    base_url="https://api.x.ai/v1",
)

response = client.chat.completions.create(
    model="grok-4.3",
    messages=[
        {
            "role": "user",
            "content": "Summarize the trade-offs of GraphQL vs REST in three bullets."
        }
    ],
    reasoning_effort="medium",
)

print(response.choices[0].message.content)
Enter fullscreen mode Exit fullscreen mode

Anfrageparameter

Die wichtigsten Parameter für Grok 4.3:

Parameter Typ Werte Hinweise
model string grok-4.3 Erforderlich.
messages array OpenAI-Nachrichtenstruktur Erforderlich. Unterstützt system, user, assistant.
reasoning_effort string low, medium, high Optional. Standard: medium.
max_tokens int 1–32768 Begrenzt die Ausgabe.
temperature float 0.0–2.0 Standard: 1.0.
top_p float 0.0–1.0 Nucleus Sampling.
stream bool true, false Server-Sent Events bei true.
tools array OpenAI-Tool-Struktur Für Funktionsaufrufe.
tool_choice string / object auto, none, spezifisches Tool Standard-OpenAI-Semantik.
response_format object { "type": "json_object" } Strukturierte Ausgabe.
seed int beliebig Für Reproduzierbarkeit bei temperature: 0.

Minimaler curl-Request:

curl https://api.x.ai/v1/chat/completions \
  -H "Authorization: Bearer $XAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "grok-4.3",
    "messages": [
      {
        "role": "system",
        "content": "You are a senior backend engineer."
      },
      {
        "role": "user",
        "content": "Review this query plan and flag the bottleneck."
      }
    ],
    "reasoning_effort": "high"
  }'
Enter fullscreen mode Exit fullscreen mode

Die Antwort folgt der OpenAI-Struktur:

{
  "choices": [
    {
      "message": {
        "role": "assistant",
        "content": "..."
      }
    }
  ],
  "usage": {
    "prompt_tokens": 123,
    "completion_tokens": 456,
    "reasoning_tokens": 78,
    "total_tokens": 657
  }
}
Enter fullscreen mode Exit fullscreen mode

Reasoning-Aufwand richtig wählen

reasoning_effort ist einer der wichtigsten Tuning-Parameter.

low

Geeignet für:

  • Klassifizierung
  • einfache Zusammenfassungen
  • FAQ-Antworten
  • Routing
  • einfache Extraktion

Beispiel:

response = client.chat.completions.create(
    model="grok-4.3",
    messages=[
        {
            "role": "user",
            "content": "Classify this ticket as billing, technical, or account."
        }
    ],
    reasoning_effort="low",
)
Enter fullscreen mode Exit fullscreen mode

medium

Geeignet für:

  • Kundenservice
  • einfache Tool-Nutzung
  • Datenanalyse
  • Standard-Agenten
  • strukturierte Antworten

medium ist der Standard und für den meisten Produktionsverkehr der erste sinnvolle Wert.

response = client.chat.completions.create(
    model="grok-4.3",
    messages=[
        {
            "role": "user",
            "content": "Analyze this API error log and suggest likely causes."
        }
    ],
    reasoning_effort="medium",
)
Enter fullscreen mode Exit fullscreen mode

high

Geeignet für:

  • mehrstufige Agenten
  • komplexe Code-Reviews
  • mathematische Aufgaben
  • Planungsaufgaben
  • Workflows mit mehreren Tool-Aufrufen 
response = client.chat.completions.create(
    model="grok-4.3",
    messages=[
        {
            "role": "user",
            "content": "Review this migration plan and identify hidden failure modes."
        }
    ],
    reasoning_effort="high",
)
Enter fullscreen mode Exit fullscreen mode

Wichtig: Reasoning ist in Grok 4.3 nicht vollständig deaktivierbar. Auch low führt einen grundlegenden Reasoning-Schritt aus.

Funktionsaufrufe verwenden

Grok 4.3 unterstützt die OpenAI-kompatible Tool-Struktur. Der Ablauf:

  1. Tool-Schema deklarieren.
  2. Anfrage mit tools senden.
  3. tool_calls aus der Antwort lesen.
  4. Tool serverseitig ausführen.
  5. Ergebnis als tool-Nachricht zurückgeben.

Beispiel:

tools = [
    {
        "type": "function",
        "function": {
            "name": "lookup_user",
            "description": "Look up a user by ID.",
            "parameters": {
                "type": "object",
                "properties": {
                    "user_id": {
                        "type": "string"
                    }
                },
                "required": ["user_id"],
            },
        },
    }
]

response = client.chat.completions.create(
    model="grok-4.3",
    messages=[
        {
            "role": "user",
            "content": "Find user u_42 and tell me their last login."
        }
    ],
    tools=tools,
    reasoning_effort="medium",
)

tool_calls = response.choices[0].message.tool_calls

for call in tool_calls:
    print(call.function.name)
    print(call.function.arguments)
Enter fullscreen mode Exit fullscreen mode

Danach führen Sie das Tool in Ihrer Anwendung aus und senden das Ergebnis zurück:

messages = [
    {
        "role": "user",
        "content": "Find user u_42 and tell me their last login."
    },
    response.choices[0].message,
    {
        "role": "tool",
        "tool_call_id": tool_calls[0].id,
        "content": '{"user_id":"u_42","last_login":"2026-05-01T13:45:00Z"}'
    }
]

final_response = client.chat.completions.create(
    model="grok-4.3",
    messages=messages,
    tools=tools,
    reasoning_effort="medium",
)

print(final_response.choices[0].message.content)
Enter fullscreen mode Exit fullscreen mode

Wenn Sie Tool-Abläufe isoliert testen möchten, beschreibt MCP-Servertests in Apidog eine passende Wiedergabe- und Testeinrichtung.

Videoeingabe

Grok 4.3 ist das erste Grok-Modell mit nativer Videoeingabe. Sie übergeben eine Video-URL als Inhaltsblock:

response = client.chat.completions.create(
    model="grok-4.3",
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "text",
                    "text": "Describe what happens in this clip and flag any anomalies."
                },
                {
                    "type": "video_url",
                    "video_url": {
                        "url": "https://example.com/clip.mp4"
                    }
                },
            ],
        }
    ],
    reasoning_effort="medium",
)

print(response.choices[0].message.content)
Enter fullscreen mode Exit fullscreen mode

Praktische Hinweise:

  • Video-Tokens zählen zu den Eingabe-Tokens.
  • Lange Clips verbrauchen den Kontext schnell.
  • Wenn Kosten relevant sind, kürzen oder komprimieren Sie Videos vor dem Senden.
  • Da das Modell nativ über Frames reasonen kann, müssen Sie keine eigenen Keyframes extrahieren.

1M-Token-Kontext praktisch nutzen

Das 1M-Kontextfenster ist besonders nützlich, wenn Sie bisher Chunking, Retrieval oder manuelles Zusammenführen einsetzen mussten.

Typische Muster:

Code-Review über große Diffs 

System:
You are a senior backend reviewer. Focus on correctness, security, and migration risks.

User:
Here is the full diff:
<diff>

Here are the affected files:
<files>

Here is the CI output:
<logs>

Return:
1. Critical issues
2. Risky assumptions
3. Suggested fixes
Enter fullscreen mode Exit fullscreen mode

Dokumenten-QA

Sie können lange Verträge, technische Spezifikationen oder Berichte direkt in den Prompt aufnehmen und gezielte Fragen stellen:

Based only on the document below, list all clauses that affect data retention.

<full document>
Enter fullscreen mode Exit fullscreen mode

Agenten-Kontext

Für länger laufende Agenten können Sie mehr Verlauf im Kontext halten, statt aggressive Zusammenfassungen zu erzwingen.

Zwischengespeicherte Eingaben reduzieren die Kosten bei stabilen Prompts deutlich. Ein stabiler System-Prompt mit 400.000 Tokens kostet bei zwischengespeicherter Eingabe 0,08 $ pro Aufruf statt 0,50 $ bei regulärer Eingabe.

Migration von älteren Grok-Modellen

Acht ältere Grok-Modelle werden am 15. Mai 2026, 12:00 Uhr PT eingestellt. Wenn Ihre Anwendung noch grok-3- oder ältere grok-4-Varianten nutzt, planen Sie mindestens diese Schritte:

  1. Modellnamen auf grok-4.3 ändern.
  2. base_url auf https://api.x.ai/v1 setzen, falls noch nicht geschehen.
  3. Testfälle mit echten Produktionsprompts ausführen.
  4. Latenz und usage.reasoning_tokens vergleichen.
  5. Regex- oder Parser-Nachbearbeitung erneut validieren.

Beispiel für eine minimale Migration:

 response = client.chat.completions.create(
-    model="grok-4.20",
+    model="grok-4.3",
     messages=messages,
+    reasoning_effort="medium",
 )
Enter fullscreen mode Exit fullscreen mode

Achten Sie besonders auf zwei Punkte:

  • Reasoning-Latenz: Grok 4.3 führt immer Reasoning aus. Wenn Ihr vorheriger Pfad auf sehr niedrige Latenz optimiert war, testen Sie reasoning_effort="low".
  • Ausgabeformat: Grok 4.3 erzeugt tendenziell strukturiertere Antworten. Wenn Ihre Nachbearbeitung stark auf Regex basiert, testen Sie alle erwarteten Antwortvarianten.

Für Preisvergleiche mit OpenAI-Modellen siehe GPT-5.5-Preise. Für eine ähnliche API-Integration siehe Wie man die GPT-5.5 API verwendet.

Testen in Apidog

Ein pragmatisches Test-Setup in Apidog:

  1. Erstellen Sie eine Umgebung mit:

    • XAI_API_KEY
    • BASE_URL = https://api.x.ai/v1

  2. Legen Sie einen Request an:

POST {{BASE_URL}}/chat/completions
Authorization: Bearer {{XAI_API_KEY}}
Content-Type: application/json
Enter fullscreen mode Exit fullscreen mode
  1. Verwenden Sie diesen Body: 
{
  "model": "grok-4.3",
  "messages": [
    {
      "role": "system",
      "content": "You are a senior backend engineer."
    },
    {
      "role": "user",
      "content": "Review this API design and identify production risks."
    }
  ],
  "reasoning_effort": "{{REASONING_EFFORT}}"
}
Enter fullscreen mode Exit fullscreen mode

  1. Erstellen Sie drei Varianten:

    • REASONING_EFFORT = low
    • REASONING_EFFORT = medium
    • REASONING_EFFORT = high

  2. Vergleichen Sie:

    • Antwortqualität
    • Latenz
    • usage.prompt_tokens
    • usage.completion_tokens
    • usage.reasoning_tokens
    • usage.total_tokens

  3. Optional: Erstellen Sie eine vierte Variante mit OpenAI-Base-URL, um bei identischem Prompt ein Vergleichsmodell zu testen.

Laden Sie Apidog herunter, um diese Varianten als wiederholbare API-Tests zu speichern. Für eine breitere Teststrategie siehe API-Testtool für QA-Ingenieure.

Ratenbegrenzungen und Backoff

Die konkreten Tier-Limits ändern sich und sollten in der xAI-Konsole geprüft werden. xAI nennt ungefähr 159 Tokens/Sekunde als Ausgabegeschwindigkeit pro Stream. Das ist nicht dasselbe wie ein globaler Aggregatdurchsatz.

Wenn Sie ein Rate Limit erreichen, gibt die API einen 429-Fehler mit retry-after zurück. Implementieren Sie exponentiellen Backoff:

import time
from openai import RateLimitError

def call_with_backoff(fn, max_retries=5):
    delay = 1

    for attempt in range(max_retries):
        try:
            return fn()
        except RateLimitError:
            if attempt == max_retries - 1:
                raise

            time.sleep(delay)
            delay *= 2
Enter fullscreen mode Exit fullscreen mode

Verwendung:

response = call_with_backoff(
    lambda: client.chat.completions.create(
        model="grok-4.3",
        messages=[
            {
                "role": "user",
                "content": "Summarize this incident report."
            }
        ],
        reasoning_effort="medium",
    )
)
Enter fullscreen mode Exit fullscreen mode

FAQ

Ist Grok 4.3 Ende-zu-Ende OpenAI-kompatibel?

Für Chat Completions: ja. Sie können das OpenAI SDK verwenden, base_url ändern und model="grok-4.3" setzen. Funktionsaufrufe, strukturierte Ausgabe und Streaming folgen der OpenAI-kompatiblen Form.

Unterstützt Grok 4.3 die Responses API?

Die xAI-Schnittstelle ist aktuell Chat Completions. Die Responses API ist nur für OpenAI verfügbar.

Was ist das tatsächliche Kontextlimit?

1.000.000 Tokens. Lange Eingaben verursachen auch bei 1,25 $ pro 1M Tokens reale Kosten. Verwenden Sie Caching, wenn große Promptteile stabil bleiben.

Wie beeinflusst Reasoning die Latenz?

Die Latenz bis zum ersten Token kann höher sein als bei Modellen ohne Reasoning. Danach streamt Grok 4.3 mit ungefähr 159 Tokens/Sekunde. Für Genauigkeits- und Agenten-Workloads ist der Trade-off häufig sinnvoll.

Kann ich Grok 4.3 mit Grok Voice verwenden?

Ja. Der Sprachagent grok-voice-think-fast-1.0 ruft Grok 4.3 im Hintergrund auf, wenn Reasoning benötigt wird. Sie können Grok 4.3 auch direkt aus einer eigenen Sprachschleife mit TTS- und STT-Komponenten aufrufen.

Was passiert mit alten Grok-3- oder Grok-4-Aufrufen nach dem 15. Mai?

Sie schlagen mit einem 410-Fehler fehl, weil das Modell eingestellt wurde. Migrieren Sie vorher auf grok-4.3.

Unterstützt Grok 4.3 Bildeingabe?

Ja. Zusätzlich zur neuen Videoeingabe können Sie Bild-URLs als Inhaltsblock übergeben, analog zur OpenAI-kompatiblen Form.

Zusammenfassung

Grok 4.3 ist für Entwickler vor allem wegen OpenAI-kompatibler Integration, 1M-Kontext, durchgängigem Reasoning, nativer Videoeingabe und niedrigeren Kosten interessant. Für bestehende Grok-Integrationen ist die Migration meist klein: model ändern, optional reasoning_effort setzen und reale Prompts erneut testen.

Der schnellste Validierungspfad: Legen Sie in Apidog drei Varianten mit low, medium und high an, messen Sie Latenz und usage.reasoning_tokens, und migrieren Sie vor dem 15. Mai.

Top comments (0)