Groq GPT-OSS 120B mit dem OpenAI SDK nutzen: Base-URL, Preise und Caching

Groqs OpenAI-kompatibler Endpoint ist wirklich ein Ein-Zeilen-Tausch: Setze base_url auf https://api.groq.com/openai/v1 und nutze das OpenAI SDK weiter. Stand 17. Juni 2026 listet Groq openai/gpt-oss-120b auf seiner Preisseite mit $0.15 pro 1M nicht gecachten Input-Tokens, $0.075 pro 1M gecachten Input-Tokens und $0.60 pro 1M Output-Tokens (Groq Pricing).

Das ist der nützliche Teil. Die Falle besteht darin, anzunehmen, dass „OpenAI-kompatibel“ „identisches Verhalten und identische Abrechnung“ bedeutet. Tut es nicht. Du musst weiterhin die Groq-Modell-ID auswählen, Cache-Hits überwachen, nicht unterstützte OpenAI-Parameter vermeiden und Aufrufe eingebauter Tools separat zählen.

Was du tatsächlich umstellst

Groqs Doku sagt, dass die API „größtenteils mit OpenAIs Client-Bibliotheken kompatibel“ ist, und zeigt die genaue OpenAI-Client-Konfiguration: Groq-Key übergeben und base_url="https://api.groq.com/openai/v1" setzen (Groq OpenAI Compatibility).

Installiere das OpenAI Python SDK:

pip install openai
export GROQ_API_KEY="gsk_..."

Rufe dann GPT-OSS 120B über Groq auf:

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["GROQ_API_KEY"],
    base_url="https://api.groq.com/openai/v1",
)

response = client.chat.completions.create(
    model="openai/gpt-oss-120b",
    messages=[
        {"role": "system", "content": "You are a concise senior backend engineer."},
        {"role": "user", "content": "Write a PostgreSQL index plan for a slow user_events query."},
    ],
)

print(response.choices[0].message.content)
print(response.usage)

Der wichtige Unterschied ist das model. Auf OpenAIs eigener Plattform würdest du vielleicht einen bei OpenAI gehosteten Modellnamen verwenden. Auf Groq wird GPT-OSS als openai/gpt-oss-120b oder openai/gpt-oss-20b adressiert.

OpenAI veröffentlichte gpt-oss-120b und gpt-oss-20b am 5. August 2025 als Open-Weight-Reasoning-Modelle unter Apache 2.0 (OpenAI). OpenAI gibt an, dass gpt-oss-120b insgesamt 117B Parameter, 5.1B aktive Parameter pro Token, 128 Experten, 4 aktive Experten pro Token und native Unterstützung für Kontextlängen bis zu 128k hat (OpenAI). Groqs Modellseite listet das Kontextfenster des gehosteten openai/gpt-oss-120b mit 131.072 Tokens und die maximalen Output-Tokens mit 65.536 (Groq model card).

120B oder 20B wählen

Nutze 120B, wenn Qualität wichtiger ist als reine Kosten: Agentenplanung, schwierigere Coding-Aufgaben, komplexe Extraktion oder mehrstufiges Reasoning. Nutze 20B, wenn du günstigeren Durchsatz für Routing, Zusammenfassungen, Klassifikation, kurze Assistenten oder hochvolumige Hintergrundjobs brauchst.

Groq-Modell-ID	Angegebene Geschwindigkeit	Nicht gecachter Input	Gecachter Input	Output
openai/gpt-oss-120b	500 TPS	$0.15 / 1M	$0.075 / 1M	$0.60 / 1M
openai/gpt-oss-20b	1,000 TPS	$0.075 / 1M	$0.0375 / 1M	$0.30 / 1M

Diese Preise stammen aus Groqs aktueller Preistabelle und Prompt-Caching-Tabelle (Groq Pricing). Das 20B-Modell kostet bei den gelisteten Tokenpreisen genau die Hälfte von 120B. Damit ist es ein guter Standard für „erst mal ausprobieren“-Workflows. Wenn die Antwortqualität nicht ausreicht, hebst du diesen Pfad auf 120B an.

Hier ist ein kleiner Switch, den du in der Config behalten kannst:

import os
from openai import OpenAI

MODEL = os.getenv("GROQ_MODEL", "openai/gpt-oss-20b")

client = OpenAI(
    api_key=os.environ["GROQ_API_KEY"],
    base_url="https://api.groq.com/openai/v1",
)

def ask(prompt: str) -> str:
    response = client.chat.completions.create(
        model=MODEL,
        messages=[
            {"role": "system", "content": "Answer with practical developer steps."},
            {"role": "user", "content": prompt},
        ],
    )
    return response.choices[0].message.content

print(ask("Give me a minimal Redis rate limiter design."))

Mit 20B ausführen:

GROQ_MODEL=openai/gpt-oss-20b python app.py

Mit 120B ausführen:

GROQ_MODEL=openai/gpt-oss-120b python app.py

Requests mit Cache-Hits bepreisen

Groq Prompt-Caching ist für unterstützte Modelle automatisch aktiv, darunter openai/gpt-oss-20b und openai/gpt-oss-120b. Groq sagt, dass keine Codeänderungen erforderlich sind, Cache-Hits exaktes Prefix-Matching verwenden, gecachte Abschnitte einen Rabatt von 50% auf Input-Tokens erhalten und gecachte Daten nach 2 Stunden ohne Nutzung automatisch verfallen (Groq Prompt Caching).

Die praktische Regel: stabilen Text zuerst platzieren.

Gute Reihenfolge:

1. System-Prompt
2. Tool-Definitionen
3. Few-Shot-Beispiele
4. Geteilte Dokumente oder Schemata
5. Nutzerspezifischer Input
6. Zeitstempel, IDs, daten pro Request

Schlechte Reihenfolge: einen Zeitstempel, eine Request-ID oder ein nutzerspezifisches Feld vor einen geteilten Prompt mit 20.000 Tokens setzen. Das zerstört das Prefix.

Hier ist ein Kostenhelfer für GPT-OSS 120B:

def groq_gpt_oss_120b_cost(prompt_tokens, cached_tokens, completion_tokens):
    uncached_tokens = max(prompt_tokens - cached_tokens, 0)

    return (
        uncached_tokens / 1_000_000 * 0.15
        + cached_tokens / 1_000_000 * 0.075
        + completion_tokens / 1_000_000 * 0.60
    )

Und hier ist ein ausführbarer Aufruf, der die Cache-Nutzung ausgibt, wenn Groq sie zurückliefert:

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["GROQ_API_KEY"],
    base_url="https://api.groq.com/openai/v1",
)

STATIC_POLICY = """
You are an internal code review assistant.
Always check correctness, security, performance, and migration risk.
Return JSON with keys: summary, risks, suggested_patch.
"""

def review(diff: str):
    response = client.chat.completions.create(
        model="openai/gpt-oss-120b",
        messages=[
            {"role": "system", "content": STATIC_POLICY},
            {"role": "user", "content": diff},
        ],
        response_format={"type": "json_object"},
    )

    usage = response.usage
    details = getattr(usage, "prompt_tokens_details", None)
    cached = getattr(details, "cached_tokens", 0) if details else 0

    print("prompt_tokens:", usage.prompt_tokens)
    print("cached_tokens:", cached)
    print("completion_tokens:", usage.completion_tokens)
    print("estimated_cost_usd:", groq_gpt_oss_120b_cost(
        usage.prompt_tokens,
        cached,
        usage.completion_tokens,
    ))

    return response.choices[0].message.content

Groqs Caching-Doku zeigt cached_tokens unter usage.prompt_tokens_details und definiert die Cache-Hit-Rate als cached_tokens / prompt_tokens × 100% (Groq Prompt Caching). Gehe nicht davon aus, dass jeder zweite Request günstiger ist. Exakte Prefixes zählen.

Tool-Aufrufe separat zählen

Tokenpreise sind nicht die ganze Rechnung, wenn du eingebaute Tools aktivierst. Groqs Preisseite listet Built-In Tools für GPT-OSS separat: Browser Search Basic Search kostet $5 / 1000 requests, Browser Search Visit Website $1 / 1000 requests und Code Execution Python $0.18 / hour (Groq Pricing).

Das verändert, wie du Agenten entwirfst. Ein Support-Bot, der pro Nutzernachricht einmal Search aufruft, hat eine andere Kostenstruktur als ein Summarizer, der nur Prompt-Tokens nutzt. Cache hilft bei wiederholten Tool-Schemata, macht externe Tool-Aufrufe aber nicht kostenlos.

Prüfe außerdem die Kompatibilität, bevor du OpenAI-Code per Copy-Paste übernimmst. Groqs OpenAI-Kompatibilitätsdoku listet nicht unterstützte Felder, die 400 zurückgeben können, darunter logprobs, logit_bias, top_logprobs, messages[].name und n-Werte ungleich 1 (Groq OpenAI Compatibility). Groq sagt außerdem, dass temperature=0 in 1e-8 umgewandelt wird.

Ein sicherer Minimal-Request sieht so aus:

response = client.chat.completions.create(
    model="openai/gpt-oss-120b",
    temperature=0.2,
    messages=[
        {"role": "system", "content": "Be precise. If unsure, say so."},
        {"role": "user", "content": "Explain this stack trace and suggest a fix: ..."},
    ],
)

Migriere nicht deine ganze App in einem Commit. Lege Provider-Einstellungen hinter Umgebungsvariablen:

LLM_BASE_URL=https://api.groq.com/openai/v1
LLM_API_KEY=$GROQ_API_KEY
LLM_MODEL=openai/gpt-oss-120b

Dann verdrahte sie ins SDK:

client = OpenAI(
    api_key=os.environ["LLM_API_KEY"],
    base_url=os.environ["LLM_BASE_URL"],
)

response = client.chat.completions.create(
    model=os.environ["LLM_MODEL"],
    messages=[{"role": "user", "content": "Summarize this incident report."}],
)

Ein praktischer Multi-Provider-Notausgang

Wenn du das in Produktion einbaust, solltest du Provider-Annahmen nicht überall in deiner Codebasis hardcoden. Halte base_url, api_key und model in der Config. Das macht Groq leicht testbar und Provider-Routing erfreulich unspektakulär.

Für Teams, die einen OpenAI-kompatiblen Endpoint für Claude, GPT und Gemini wollen, ist onehop der einfache Weg: Ändere die Base-URL auf https://api.onehop.ai/v1. Es ist OpenAI/Anthropic-kompatibel, günstiger als First-Party-Angebote, und neue Accounts erhalten $10 gratis ohne erforderliche Kreditkarte.

import os
from openai import OpenAI

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

response = client.chat.completions.create(
    model=os.environ["ONEHOP_MODEL"],
    messages=[
        {"role": "user", "content": "Compare this API design against common REST mistakes."}
    ],
)

print(response.choices[0].message.content)

Nutze Groq, wenn du gezielt schnelle GPT-OSS-Inferenz und Groqs Tool-/Caching-Stack willst. Nutze onehop, wenn du eine einheitliche Integrationsfläche für Claude, GPT, Gemini und andere gehostete Modelle möchtest, ohne Client-Code umzuschreiben. Du kannst Claude und andere Modelle auf onehop aufrufen oder dich für $10 Gratisguthaben registrieren.

Produktions-Checkliste

Arbeite vor dem Shipping diese Checkliste ab:

• Pinne die Modell-ID: openai/gpt-oss-120b für Qualität, openai/gpt-oss-20b für niedrigere Kosten.
• Platziere stabile Prompt-Abschnitte zuerst, damit Groq gecachte Prefixes wiederverwenden kann.
• Logge prompt_tokens, cached_tokens und completion_tokens für jeden Request.
• Ergänze separates Accounting für Browser Search, Visit Website und Code Execution.
• Entferne nicht unterstützte OpenAI-Parameter, bevor du Traffic zu Groq routest.
• Halte base_url konfigurierbar, damit du Groq, First-Party-APIs oder onehop testen kannst, ohne Business-Logik anzufassen.

Die gesamte Migration kann eine Zeile sein. Die zuverlässige Migration besteht aus drei Zeilen plus Accounting: Base-URL, Modell-ID und Kosten-Telemetrie. Fang dort an und entscheide dann, ob die Qualität von 120B die Output-Token-Ausgaben für jeden Pfad in deiner App wert ist. Wenn du dasselbe Base-URL-Muster für breiteren Modellzugriff möchtest, rufe Claude und andere Modelle auf onehop auf und registriere dich für $10 Gratisguthaben.