Abrechnung und Kostenoptimierung — Grok Reasoning-Modelle

Aktualisiert am 3. November 2026: Die vorherigen Beispiele wiesen auf usage.prompt_tokens und usage.completion_tokens in Antworten der Responses API hin, die input_tokens, output_tokens und deren Details (cached_tokens, reasoning_tokens) offenlegen. Der Code verursachte einen AttributeError. Die Kostenverfolgung berücksichtigt nun zwischengespeicherte Eingaben, und der Rat, die Ausgabebegrenzung zu senken, um die Rechenleistung zu begrenzen, wurde korrigiert, da diese Begrenzung die Rechenleistung nicht erfasst. Quellen: Modelle und Preise · Best Practices.

Rechenleistungstokens auf Ihrer Rechnung

Die Abrechnung für Rechenleistungstokens ist ein kritischer Aspekt der Nutzung von xAI-Modellen. Diese Tokens werden zum Ausgabetoken-Tarif abgerechnet – dem höchsten Tarif – und unoptimierte Nutzung kann die Kosten schnell in die Höhe treiben, insbesondere bei hoher Rechenanstrengung bei grok-4.5.

Neu für 2026 und wichtig zu verstehen: Die Preisgestaltung ist gestaffelt. Der Preis pro Token hängt von der Größe des Anfragekontexts ab. Unter 200k Eingabetokens zahlen Sie den Standardtarif; darüber verdoppelt sich der Tarif.

Preise nach Modell (Juli 2026)

Preis pro Million Tokens.

Modell	Eingabe < 200k	Ausgabe < 200k	Eingabe ≥ 200k	Ausgabe ≥ 200k
grok-4.5	$2,00	$6,00	$4,00	$12,00
grok-4.20-0309-reasoning	$1,25	$2,50	$2,50	$5,00
grok-4.3	$1,25	$2,50	$2,50	$5,00
grok-build-0.1	$1,00	$2,00	$2,00	$4,00

Rechenleistungstokens werden zum Tarif der Spalte „Ausgabe” abgerechnet. Bei grok-4.5 unter 200k Kontext kostet jede Million Rechenleistungstokens $6,00; bei grok-4.20-0309-reasoning $2,50. Und wenn Ihr Prompt mehr als 200k Tokens umfasst, verdoppeln sich diese Beträge: $12,00 bzw. $5,00.

Kosten pro Anfrage verfolgen

Das usage-Objekt in der Antwort enthält Tokenzähler; einige xAI-API-Antworten können auch direkte Kostenfelder enthalten. Prüfen Sie das usage-Objekt, das von Ihrem Modell zurückgegeben wird, und konsultieren Sie die offizielle Dokumentation für verfügbare Felder. Andernfalls ist die manuelle Berechnung einfach:

response = client.responses.create(
    model="grok-4.5",
    input="Lösen Sie dieses dynamische Programmierungsproblem...",
    reasoning={"effort": "high"}
)

# grok-4.5-Tarife unter 200k Kontext-Token (Responses API zählt in Eingabe/Ausgabe)
usage = response.usage
input_cost = usage.input_tokens * 2.00 / 1_000_000
output_cost = usage.output_tokens * 6.00 / 1_000_000  # enthält Rechenleistung
total_cost = input_cost + output_cost

print(f"Eingabekosten: ${input_cost:.6f}")
print(f"Ausgabekosten: ${output_cost:.6f}")
print(f"Gesamtkosten: ${total_cost:.6f}")

Vorsicht: Diese Berechnung geht von einem Kontext unter 200k Tokens aus. In der Produktion muss Ihr Tracker den anwendbaren Tarif erkennen (siehe unten).

Strategien zur Kostenoptimierung

1. Anstrengung an die Aufgabe anpassen

Die erste und effektivste Optimierung besteht darin, das richtige Rechenleistungslevel bei grok-4.5 auszuwählen. Geringe Anstrengung kann deutlich weniger Rechenleistungstokens verbrauchen als hohe Anstrengung:

# Anfragen nach Komplexität sortieren
if complexity == "simple":
    effort = "low"      # kurze Rechenleistung
elif complexity == "medium":
    effort = "medium"   # mittlere Rechenleistung
else:
    effort = "high"     # tiefe Rechenleistung

Prüfen Sie die genauen Werte, die vom Parameter auf der offiziellen Modellseite akzeptiert werden.

2. Das richtige Modell verwenden

Für gängige Aufgaben zur Rechenleistung kostet grok-4.20-0309-reasoning mit $2,50/M Ausgabe weniger als die Hälfte von grok-4.5 mit $6,00/M. Reservieren Sie das Flaggschiff-Modell für Aufgaben, die es wirklich benötigen. Für Code ist grok-build-0.1 mit $2,00/M Ausgabe noch wirtschaftlicher.

3. Unter der 200k-Token-Stufe bleiben

Die Preisstufe ist ein direkter Hebel: Eine Anfrage mit 250k Kontext-Token kostet das Doppelte pro Token im Vergleich zu einer Anfrage mit 150k. Bevor Sie einen massiven Kontext senden, fragen Sie sich, ob es nicht günstiger und effektiver wäre, ihn in mehrere kleinere Anfragen (oder eine Zwischenzusammenfassung) aufzuteilen.

4. Prompt-Caching nutzen

xAI bietet reduzierte Preise für Eingabetokens, die bereits im Cache liegen: Wiederholte Prompt-Vorabteile (Systemanweisungen, geteilter Kontext) kosten weniger, wenn sie von einer Anfrage zur nächsten wiederverwendet werden. Unter 200k Tokens kosten zwischengespeicherte Eingaben bei grok-4.5 $0,30 pro Million statt $2,00 und bei grok-4.20-0309-reasoning $0,20 statt $1,25 (Seite „Modelle und Preise”, November 2026). Strukturieren Sie Ihre Prompts mit stabilen Teilen am Anfang; der vom Cache bediente Anteil erscheint in usage.input_tokens_details.cached_tokens.

5. Die Ausgabebegrenzung dimensionieren

Die Ausgabebegrenzung (max_output_tokens in der Responses API, max_completion_tokens in Chat Completions) begrenzt nur die sichtbare Antwort: Rechenleistungstokens zählen nicht dazu. Das Senken dieser Begrenzung reduziert daher nicht die Rechenleistung; es birgt das Risiko, die Antwort lediglich abzuschneiden. Die xAI-Best Practices empfehlen, sie über die längste erwartete Antwort hinaus zu setzen oder ihren Standardwert von 128.000 Tokens zu belassen. Um die Rechenleistung zu reduzieren, senken Sie die Anstrengung bei Modellen, die dies akzeptieren, oder wählen Sie ein günstigeres Modell.

Kostenverfolgung in der Produktion

class CostTracker:
    # Tarife pro MTok: (Eingabe, zwischengespeicherte Eingabe, Ausgabe) nach Kontextstufe
    RATES = {
        "grok-4.5": {"low": (2.00, 0.30, 6.00), "high": (4.00, 0.60, 12.00)},
        "grok-4.20-0309-reasoning": {"low": (1.25, 0.20, 2.50), "high": (2.50, 0.40, 5.00)},
        "grok-build-0.1": {"low": (1.00, 0.20, 2.00), "high": (2.00, 0.40, 4.00)},
    }
    TIER_THRESHOLD = 200_000  # Eingabetokens

    def __init__(self):
        self.total_cost = 0
        self.request_count = 0

    def track(self, response, model="grok-4.5"):
        usage = response.usage  # Responses API Antwort
        details = usage.input_tokens_details
        cached = details.cached_tokens if details else 0
        tier = "high" if usage.input_tokens >= self.TIER_THRESHOLD else "low"
        rate_in, rate_cached, rate_out = self.RATES[model][tier]
        cost = (
            (usage.input_tokens - cached) * rate_in / 1e6
            + cached * rate_cached / 1e6
            + usage.output_tokens * rate_out / 1e6  # enthält Rechenleistung
        )
        self.total_cost += cost
        self.request_count += 1
        return cost

Preise vom 5. August 2026 — Preise ändern sich regelmäßig: Bevor Sie eine Budgetberechnung durchführen, überprüfen Sie das aktuelle Raster auf der offiziellen xAI-Modell- und Preisseite.

Kernaussagen

Rechenleistungstokens werden zum Ausgabetoken-Tarif abgerechnet
Die Preisgestaltung 2026 ist gestaffelt: Über 200k Kontext-Token verdoppelt sich der Preis pro Token
grok-4.5 kostet $2/$6 pro MTok unter 200k ($4/$12 darüber); grok-4.20-0309-reasoning kostet $1,25/$2,50 ($2,50/$5 darüber)
Die drei wichtigsten Hebel: Rechenleistungsanstrengung anpassen, das richtige Modell wählen, unter der 200k-Stufe bleiben
Verfolgen Sie Ihre Kosten pro Anfrage, unter Berücksichtigung des anwendbaren Tarifs