Grok API Preise (2026): alle Modelle, Tool-Gebühren und Multiplikatoren
Die Grok API kostet ab $1.00 pro 1 Mio. Input-Tokens und $2.00 pro 1 Mio. Output-Tokens (grok-build-0.1). Das Flaggschiff grok-4.7 kostet bei Prompts unter 200K Tokens $2.00 Input, $0.50 gecachten Input und $6.00 Output pro 1 Mio. Tokens. Sobald ein Prompt 200K Tokens erreicht, gilt der Langkontext-Tarif für die gesamte Anfrage ($4 / $1 / $12 bei Grok 4.7). Alle Zahlen stammen von der offiziellen xAI-Preisseite und der Modellseite, geprüft am 20. Oktober 2026.
Dieser Leitfaden behandelt alle aktuellen Text-, Bild-, Video- und Sprachtarife, die fünf Multiplikatoren, die Ihre tatsächliche Rechnung verändern (langer Kontext, Priorität, US-Region, Batch und Tools), einen Kostenrechner mit Rechenbeispiel, den Preisvergleich von Grok mit GPT, Claude, Gemini und Qwen sowie lauffähige Beispiele in curl, Python und Node.
Grok API Preise auf einen Blick
| Punkt | Antwort (Stand: 20. Oktober 2026) |
|---|---|
| Günstigstes Textmodell | grok-build-0.1: $1.00 Input / $2.00 Output pro 1 Mio. Tokens |
| Flaggschiffmodell | grok-4.7: $2.00 Input / $0.50 gecacht / $6.00 Output pro 1 Mio. Tokens |
| Langkontext-Schwelle | 200K Prompt-Tokens; der höhere Tarif gilt für alle Tokens dieser Anfrage |
| Priority Processing | 2x Standardtarif für alle Token-Arten |
| US-Regional-Endpoint | https://us.api.x.ai/v1, abgerechnet mit 1.1x |
| Batch API | 20 % Rabatt auf Grok 4.3 und die Grok-4.20-Modelle; kein Rabatt auf andere |
| Tool Web Search / Code Execution | $5 pro 1.000 Aufrufe |
| Globale Base URL | https://api.x.ai/v1 |
Quelle: xAI-API-Preise, 20. Oktober 2026.
Preise der Grok-Textmodelle (pro 1 Mio. Tokens)
Die Preise sind globale Standardtarife in USD pro 1 Mio. Tokens aus der offiziellen Preistabelle, Stand 20. Oktober 2026.
| Modell | Kontextfenster | Prompt-Größe | Input | Gecachter Input | Output |
|---|---|---|---|---|---|
grok-4.7 |
500K | < 200K | $2.00 | $0.50 | $6.00 |
grok-4.7 |
500K | ≥ 200K | $4.00 | $1.00 | $12.00 |
grok-4.6 |
500K | < 200K | $2.00 | $0.50 | $6.00 |
grok-4.6 |
500K | ≥ 200K | $4.00 | $1.00 | $12.00 |
grok-4.5 |
500K | < 200K | $2.00 | $0.30 | $6.00 |
grok-4.5 |
500K | ≥ 200K | $4.00 | $0.60 | $12.00 |
grok-4.3 |
1M | < 200K | $1.25 | $0.20 | $2.50 |
grok-4.3 |
1M | ≥ 200K | $2.50 | $0.40 | $5.00 |
grok-4.20-0309-reasoning |
1M | < 200K | $1.25 | $0.20 | $2.50 |
grok-4.20-0309-non-reasoning |
1M | < 200K | $1.25 | $0.20 | $2.50 |
grok-4.20-multi-agent-0309 |
1M | < 200K | $1.25 | $0.20 | $2.50 |
grok-build-0.1 |
256K | < 200K | $1.00 | $0.20 | $2.00 |
grok-build-0.1 |
256K | ≥ 200K | $2.00 | $0.40 | $4.00 |
Auch die Grok-4.20-Modelle verdoppeln sich ab 200K Prompt-Tokens auf $2.50 / $0.40 / $5.00. Zwei Details, die die meisten Preisseiten übersehen:
- Grok 4.5 hat günstigere Cache-Reads als 4.6 und 4.7 ($0.30 statt $0.50 pro 1 Mio. bei kurzen Prompts). Wird Ihre Last von einem langen, wiederholten System-Prompt dominiert, kann 4.5 die neueren Modelle bei den effektiven Input-Kosten schlagen.
- Grok 4.3 hat ein Kontextfenster von 1 Mio. Tokens, ist aber günstiger als 4.7. Bei Arbeit mit langen Dokumenten, bei der Sie pro Anfrage unter 200K bleiben (mit Retrieval oder Chunking), kostet 4.3 beim Input 37,5 % und beim Output 58 % weniger als 4.7.
Die Modellseite von xAI empfiehlt Grok 4.7 (Entwicklerleitfaden) für Code und Chat und nennt Mai 2026 als Wissensstand. Aktivieren Sie also Such-Tools, wenn Sie aktuelle Fakten brauchen.
Preise für Grok Imagine (Bild und Video) und Sprache
Medienmodelle werden nicht pro Token abgerechnet. Tarife von der xAI-Preisseite, 20. Oktober 2026:
| Modell / Modus | Stückpreis |
|---|---|
grok-imagine-image |
$0.02 pro Bild |
grok-imagine-image-2.0 |
$0.04 pro Bild |
grok-imagine-image-quality |
$0.05 pro Bild |
grok-imagine-video-1.5-lite |
$0.020 pro Sekunde |
grok-imagine-video |
$0.050 pro Sekunde |
grok-imagine-video-1.5 |
$0.080 pro Sekunde |
Speech-to-Speech (grok-voice-3.0) |
$0.08 pro Minute ($4.80/Stunde) + $0.004 pro Texteingabe |
| Speech-to-Text | $0.10/Stunde (REST), $0.20/Stunde (Streaming) |
| Text-to-Speech | $15.00 pro 1 Mio. Zeichen |
Ein 10-Sekunden-Clip mit grok-imagine-video-1.5 kostet also $0.80, derselbe Clip mit dem 1.5-Lite-Modell $0.20. Batch-Anfragen für Bild und Video werden angenommen, aber zum Standardtarif abgerechnet.
Die fünf Multiplikatoren, die Ihre echte Grok-Rechnung verändern
1. Langkontext-Tarif (≥ 200K Prompt-Tokens)
Laut offizieller Regel wird eine Anfrage, deren Prompt die Schwelle erreicht, für alle Tokens der Anfrage zum höheren Tarif abgerechnet – nicht nur für die Tokens über 200K. Ein Prompt mit 199K Tokens an Grok 4.7 kostet rund $0.40 Input, einer mit 201K Tokens rund $0.80. Kürzen Sie den Verlauf oder rufen Sie weniger Chunks ab, um unter der Grenze zu bleiben.
2. Priority Processing (2x)
Priority Processing wird mit dem doppelten Standardtarif für Input-, gecachte, Output- und Reasoning-Tokens abgerechnet. Der Prioritätstarif fällt nur an, wenn die Antwort "service_tier": "priority" bestätigt. Er funktioniert nur mit Chat Completions und Responses, nicht mit Bild-, Video- oder Batch-Anfragen (Quelle, 20. Oktober 2026).
3. US-Regional-Endpoint (1.1x)
Aufrufe an https://us.api.x.ai/v1 führen die Inferenz in den USA aus und kosten 1.1x. Für Grok 4.7 ergibt das $2.20 / $0.55 / $6.60 pro 1 Mio. Tokens unter 200K und $4.40 / $1.10 / $13.20 darüber. Stand 20. Oktober 2026 sind auf diesem Endpoint nur grok-4.7 und grok-4.6 verfügbar.
4. Batch API (20 % Rabatt, ausgewählte Modelle)
Die Batch API gewährt 20 % Rabatt auf alle Token-Arten für grok-4.3, grok-4.20-0309-reasoning, grok-4.20-0309-non-reasoning und grok-4.20-multi-agent-0309. Grok 4.7, 4.6 und 4.5 haben keinen Batch-Rabatt. Die meisten Batch-Jobs sind innerhalb von 24 Stunden fertig und zählen nicht zu den Rate Limits (Batch-API-Dokumentation).
5. Serverseitige Tools
Agentische Anfragen (Tool-Übersicht) werden nach Tokens plus Tool-Aufrufen abgerechnet (Tool-Preise, 20. Oktober 2026):
| Tool | Preis |
|---|---|
Web Search (web_search) |
$5 pro 1.000 Aufrufe |
X Search (x_search) |
$5 pro 1.000 Posts, $10 pro 1.000 Profile |
| Code Execution | $5 pro 1.000 Aufrufe |
| Suche in Dateianhängen | $5 pro 1.000 Aufrufe |
| Collections-Suche (RAG) | $2.50 pro 1.000 Aufrufe |
| Remote-MCP-Tools | Nur Tokens |
X Search wird pro zurückgegebenem Element abgerechnet, einschließlich Eltern- und zitierter Posts. Ein einziger Thread-Abruf kann daher Dutzende abrechenbare Posts zählen. Speicher kostet extra: $0.025/GiB/Tag für Dateien und $0.10/GiB/Tag für Collections.
Außerdem gibt es eine Gebühr von $0.05 bei Verstößen gegen die Nutzungsrichtlinien für Anfragen, die in der Responses API vor der Generierung blockiert werden.
Grok 4.7 Fast: nicht in der öffentlichen API
Grok 4.7 Fast ist dasselbe Modell auf schnellerer Infrastruktur zum doppelten Standardtarif ($4 / $1 / $12 unter 200K). Laut xAI ist es nur in Cursor und Grok Build verfügbar, wird über deren Tarife abgerechnet und ist nicht in der öffentlichen xAI-API enthalten (Stand 20. Oktober 2026). Nennt eine Drittseite einen „Grok 4.7 Fast API-Preis“, beschreibt sie keinen öffentlichen xAI-Endpoint.
Grok-API-Kostenrechner
cost = (uncached_input / 1e6 × input_rate)
+ (cached_input / 1e6 × cached_rate)
+ (output / 1e6 × output_rate)
+ tool_calls × tool_rate
then × 2 for priority, × 1.1 for the US endpoint, × 0.8 for batch on eligible models
Beispiel: ein Support-Agent auf Grok 4.7 mit 1 Mio. Gesprächen pro Monat. Jedes Gespräch hat im Schnitt 6.000 Input-Tokens (davon 4.000 gecachter System-Prompt), 500 Output-Tokens und 0,2 Websuchen.
| Posten | Berechnung | Monatliche Kosten |
|---|---|---|
| Nicht gecachter Input | 2.000 Mio. Tokens × $2.00 | $4,000 |
| Gecachter Input | 4.000 Mio. Tokens × $0.50 | $2,000 |
| Output | 500 Mio. Tokens × $6.00 | $3,000 |
| Web Search | 200.000 Aufrufe × $0.005 | $1,000 |
| Summe | $10,000 |
Verlagert man dieselbe Last auf Grok 4.3 (gecacht $0.20, Input $1.25, Output $2.50), sinkt der Token-Anteil von $9,000 auf $4,550. Ob das eine Ersparnis ist, hängt von der Lösungsquote ab. Vergleichen Sie daher die Kosten pro gelöstem Gespräch, nicht pro Anfrage.
Hier eine kleine Python-Hilfsfunktion für Ihr Notebook:
RATES = { # USD per 1M tokens, xAI pricing page, Oct 20, 2026 (<200K prompt)
"grok-4.7": (2.00, 0.50, 6.00),
"grok-4.5": (2.00, 0.30, 6.00),
"grok-4.3": (1.25, 0.20, 2.50),
"grok-build-0.1": (1.00, 0.20, 2.00),
}
def grok_cost(model, uncached, cached, output, priority=False, us=False):
inp, cache, out = RATES[model]
if uncached + cached >= 200_000: # long-context tier applies to all tokens
inp, cache, out = inp * 2, cache * 2, out * 2
cost = (uncached * inp + cached * cache + output * out) / 1e6
return cost * (2 if priority else 1) * (1.1 if us else 1)
print(round(grok_cost("grok-4.7", 2000, 4000, 500), 6)) # 0.009
Die Langkontext-Verdopplung in der Funktion entspricht allen Modellen, die in der offiziellen Tabelle mit zwei Zeilen aufgeführt sind.
Grok vs. GPT, Claude, Gemini und Qwen: Preis pro 1 Mio. Tokens
Die Tabelle vergleicht die Listenpreise der Flaggschiff- und Fast-Klassen. Die Grok-Preise stammen von xAI, die übrigen sind die Listenpreise auf der Flatkey-Modellseite des jeweiligen Modells, alle geprüft am 20. Oktober 2026.
| Modell | Input | Gecachter Input | Output |
|---|---|---|---|
grok-4.7 |
$2.00 | $0.50 | $6.00 |
grok-4.3 |
$1.25 | $0.20 | $2.50 |
gpt-6-sol |
$2.00 | $0.20 | $10.00 |
claude-sonnet-5-5 |
$2.00 | $0.20 | $10.00 |
gemini-3.5-flash |
$1.50 | $0.15 | $9.00 |
qwen3.8-max |
$2.00 | $0.25 | $6.00 |
Ist die Grok API günstiger als die ChatGPT API? Bei Output-lastiger Arbeit ja: Der Output-Tarif von Grok 4.7 liegt mit $6.00 um 40 % unter dem Listenpreis von $10.00 für gpt-6-sol. Bei Cache-lastiger Arbeit ist es umgekehrt, denn Groks gecachter Input kostet mit $0.50 das 2,5-Fache. Rechnen Sie Ihren eigenen Token-Mix mit dem Rechner oben durch, bevor Sie entscheiden. Ausführlichere Vergleiche bieten unser Preisvergleich für AI-APIs und unser Leitfaden zu den Kosten der OpenAI API.
Grok-API-Key erstellen und den ersten Aufruf senden
- Melden Sie sich in der xAI-Konsole an, erstellen Sie ein Team und laden Sie Guthaben auf.
- Erstellen Sie einen API-Key, der auf die benötigten Modelle beschränkt ist, und speichern Sie ihn als
XAI_API_KEY. - Rufen Sie die Responses API (empfohlen) oder Chat Completions unter
https://api.x.ai/v1auf.
Ein Grok-Abo für Endkunden (SuperGrok, X Premium) enthält kein API-Guthaben: Die API wird separat pro Token über die Konsole abgerechnet.
curl -s https://api.x.ai/v1/responses \
-H "Authorization: Bearer $XAI_API_KEY" \
-H "Content-Type: application/json" \
-d '{"model": "grok-4.7", "input": "Summarize prompt caching in 3 bullets."}'
Grok neben anderen Modellen mit einem einzigen Flatkey-Key nutzen
Stand 20. Oktober 2026 führt das Flatkey-Modellverzeichnis die Bild- und Videomodelle Grok Imagine von xAI, aber nicht die Grok-Textmodelle. Rufen Sie Grok-Text daher direkt über api.x.ai auf. Viele Teams kombinieren das mit einem Router für alles andere: Ein einziger OpenAI-kompatibler Key unter https://router.flatkey.ai/v1 deckt GPT, Claude, Gemini, Qwen, DeepSeek, Kimi und GLM ab, und Sie können ohne zweite Integration von Grok auf jedes dieser Modelle ausweichen.
curl: gleicher Key, anderes Modell
for MODEL in gpt-6-sol claude-sonnet-5-5 qwen3.8-max; do
curl -s https://router.flatkey.ai/v1/chat/completions \
-H "Authorization: Bearer $FLATKEY_API_KEY" \
-H "Content-Type: application/json" \
-d "{\"model\": \"$MODEL\", \"messages\": [{\"role\": \"user\", \"content\": \"Say hi in 5 words\"}]}"
done
Python: zuerst Grok, Fallback über Flatkey
import os
from openai import OpenAI, APIError
grok = OpenAI(api_key=os.environ["XAI_API_KEY"], base_url="https://api.x.ai/v1")
flatkey = OpenAI(api_key=os.environ["FLATKEY_API_KEY"], base_url="https://router.flatkey.ai/v1")
ROUTES = [(grok, "grok-4.7"), (flatkey, "claude-sonnet-5-5"), (flatkey, "gpt-6-sol")]
def ask(prompt: str) -> str:
last_error = None
for client, model in ROUTES:
try:
r = client.chat.completions.create(
model=model, messages=[{"role": "user", "content": prompt}], timeout=30
)
return f"[{model}] " + r.choices[0].message.content
except APIError as e: # 429, 5xx, timeouts: try the next route
last_error = e
raise last_error
print(ask("Explain the Grok long-context price rule in one sentence."))
Node.js
import OpenAI from "openai";
const flatkey = new OpenAI({
apiKey: process.env.FLATKEY_API_KEY,
baseURL: "https://router.flatkey.ai/v1",
});
for (const model of ["qwen3.8-max", "gemini-3.5-flash"]) {
const r = await flatkey.chat.completions.create({
model,
messages: [{ role: "user", content: "One-line summary of batch APIs." }],
});
console.log(model, r.choices[0].message.content);
}
Details zur Einrichtung finden Sie im Flatkey-Schnellstart und im Leitfaden zu OpenAI-kompatiblen Base URLs. Die Flatkey-Preise stehen auf der Preisseite.
So senken Sie Ihre Grok-API-Rechnung
- Cachen Sie das statische Präfix. Bei Grok 4.7 ist gecachter Input 75 % günstiger als neuer Input ($0.50 statt $2.00).
- Bleiben Sie unter 200K Prompt-Tokens. Wer die Schwelle überschreitet, verdoppelt die Kosten jedes Tokens der Anfrage.
- Lassen Sie Offline-Jobs per Batch auf Grok 4.3 oder 4.20 laufen – mit 20 % Rabatt. Die 4.7-Familie hat keinen Batch-Rabatt.
- Nutzen Sie Priorität nur für nutzerseitige P95-Pfade. Sie verdoppelt die Rechnung.
- Begrenzen Sie Tool-Aufrufe. Legen Sie eine Höchstzahl an Suchen pro Anfrage fest und protokollieren Sie die Anzahl der X-Search-Elemente.
- Routen Sie nach Aufgabe. Schicken Sie Klassifizierung und Extraktion an günstigere Modelle und reservieren Sie Grok 4.7 für schwieriges Reasoning. Wie das geht, zeigen unsere Strategien zur Kostenoptimierung von AI-APIs und unser ROI-Leitfaden zu Prompt Caching.
- Behandeln Sie 429-Fehler richtig. Siehe LLM-Rate-Limits erklärt.
FAQ
Was kostet die Grok API?
Grok 4.7 kostet bei Prompts unter 200K Tokens $2.00 pro 1 Mio. Input-Tokens, $0.50 pro 1 Mio. gecachter Input-Tokens und $6.00 pro 1 Mio. Output-Tokens; ab 200K steigt der Preis auf $4 / $1 / $12. Das günstigste Textmodell, grok-build-0.1, kostet $1.00 / $0.20 / $2.00 (xAI-Preisseite, 20. Oktober 2026).
Ist die Grok API günstiger als die ChatGPT API?
Bei Output-lastigen Workloads liegen die $6 pro 1 Mio. Output-Tokens von Grok 4.7 unter dem Listenpreis von $10 für gpt-6-sol (Stand 20. Oktober 2026). Bei Cache-lastigen Workloads ist GPTs gecachter Tarif von $0.20 günstiger als Groks $0.50. Die Antwort hängt von Ihrem Mix aus Input, Output und Cache ab.
Gibt es die Grok API kostenlos?
xAI nennt auf der Preisseite keinen kostenlosen API-Tarif. Die API-Nutzung wird im Voraus bezahlt oder über die xAI-Konsole abgerechnet. Prüfen Sie in der Konsole, ob Ihr Team Aktionsguthaben hat.
Enthält ein Grok-Abo API-Zugang?
Nein. SuperGrok- und X-Premium-Abos gelten für die Grok-App für Endkunden. Die API-Nutzung wird separat pro Token in der xAI-Konsole abgerechnet.
Wie lautet die Base URL der Grok API?
Die globale Base URL ist https://api.x.ai/v1. Der US-Regional-Endpoint https://us.api.x.ai/v1 kostet 1.1x und unterstützt Grok 4.7 und 4.6.
Bietet Grok einen Batch-Rabatt?
Ja, 20 % auf Grok 4.3 und die Grok-4.20-Modelle. Grok 4.7, 4.6 und 4.5 haben keinen Batch-Rabatt (Stand 20. Oktober 2026).
Wie wird Video bei Grok Imagine abgerechnet?
Pro Sekunde Output: $0.020/s für Video 1.5 Lite, $0.050/s für grok-imagine-video und $0.080/s für Video 1.5.
Fazit
Für die meisten Text-Workloads sollten Sie rund $2 / $0.50 / $6 pro 1 Mio. Tokens für Grok 4.7 oder $1.25 / $0.20 / $2.50 für Grok 4.3 einplanen. Dann kommen Ihre Multiplikatoren hinzu: 2x für Priorität, 1.1x für die US-Region, 0.8x für Batch bei berechtigten Modellen und die Langkontext-Verdopplung ab 200K. Prüfen Sie vor jedem Budgetzyklus erneut die offizielle Preisseite und die Release Notes. Ist Grok eines von mehreren Modellen in Ihrem Stack, nutzen Sie für den Rest einen einzigen OpenAI-kompatiblen Key über Flatkey.
Zuletzt aktualisiert: 20. Oktober 2026 · Flatkey Team. Die Preise sind in USD angegeben und stammen aus den im Text verlinkten offiziellen Quellen.
