Groq gibt jedem Konto einen Free-Plan-Schlüssel für seinen OpenAI-kompatiblen Endpunkt, und dieser Schlüssel funktioniert, sobald du dich anmeldest. Was die Leute aus der Fassung bringt, ist nicht der Zugang, sondern die Einhaltung der Limits, sobald deine App das Modell tatsächlich aufruft. Groq veröffentlicht in seinen Dokumenten Free-Plan-Zahlen pro Modell, aber diese Zahlen ändern sich, und dein eigenes Konto kann abweichen. Die zuverlässige Gewohnheit ist, deine Kontoeinstellungen zu überprüfen und dann bei jedem Aufruf die Antwort-Header zu lesen, da sich Limits mitten in einer Sitzung ändern können.
Probiere Apidog noch heute aus
Diese Anleitung behandelt das Abrufen eines Schlüssels, das Ausrichten eines Standard-OpenAI-Clients auf Groqs Endpunkt und den Teil, den die meisten „Free-Tier“-Beiträge überspringen: deine Limits in Echtzeit zu überwachen, anstatt sie durch einen 429 in der Produktion zu entdecken. Dann verwandelt dein Coding-Agent diese Überprüfung in einen Apidog-CLI-Test, sodass sie wiederholbar ist und nicht ein einmaliger curl-Befehl, den du vergisst.
TL;DR
Groq betreibt zwei Tarife: Free Plan und Developer Plan. Ratenlimits gelten auf Organisationsebene (nicht pro Benutzer), du erreichst zuerst die Obergrenze, die unter Anfragen, Token oder Tagesobergrenzen zuerst kommt, und zwischengespeicherte Token zählen nicht gegen dich. Groq veröffentlicht Free-Plan-Zahlen pro Modell, aber die Zahlen, die für dein Konto gelten, findest du auf der Limits-Seite in deiner Konsole. Die zuverlässige Vorgehensweise ist, sie bei jedem Aufruf aus den x-ratelimit-*-Antwort-Headern zu lesen, anstatt einer Tabelle zu vertrauen, die sich ohne Vorankündigung ändern kann.
Einen Schlüssel erhalten und den Endpunkt aufrufen
Erstelle ein Konto unter console.groq.com und generiere einen Schlüssel auf der Schlüsselseite. Groq stellt diesen Schlüssel über eine OpenAI-kompatible API bereit. Wenn du also schon einmal das OpenAI-SDK aufgerufen hast, kennst du die Form. Richte die Basis-URL auf Groq statt auf OpenAI und lass alles andere gleich:
curl https://api.groq.com/openai/v1/chat/completions \
-H "Authorization: Bearer $GROQ_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "llama-3.1-8b-instant",
"messages": [{"role": "user", "content": "Summarize this ticket in one sentence."}]
}'
Oder mit dem offiziellen Python-OpenAI-Client:
import os
from openai import OpenAI
client = OpenAI(
[REDACTED CREDENTIAL],
base_url="https://api.groq.com/openai/v1",
)
response = client.chat.completions.create(
model="llama-3.3-70b-versatile",
messages=[{"role": "user", "content": "List three causes of API timeout errors."}],
)
print(response.choices[0].message.content)
Groqs OpenAI-Kompatibilitätsdokumente weisen auf ein paar Lücken hin, die du kennen solltest, bevor du vorhandenen Code übernimmst: logprobs, logit_bias, top_logprobs und messages[].name geben alle einen 400-Fehler zurück, n muss 1 sein, wenn du es setzt, und eine Temperatur von 0 wird in einen winzigen positiven Float umgewandelt anstelle einer echten Greedy-Dekodierung.
Free Plan vs Developer Plan
Groqs eigene Formulierung ist direkt: „Upgrade auf den Developer-Plan, um höhere Limits, Batch- und Flex-Verarbeitung und mehr zu erhalten.“ Der Free Plan ist das, womit jeder neue Schlüssel beginnt, und er ist wirklich brauchbar für Tests und kleine Nebenprojekte.
Hier ist, was der Free Plan für einige Modelle erlaubt, gemäß Groqs Rate-Limits-Dokumentation mit Stand vom 15.09.2026:
| Modell | RPM | RPD | TPM | TPD | Audio |
|---|---|---|---|---|---|
groq/compound |
30 | 250 | 70K | - | - |
openai/gpt-oss-120b |
30 | 1K | 8K | 200K | - |
openai/gpt-oss-20b |
30 | 1K | 8K | 200K | - |
whisper-large-v3 |
20 | 2K | - | - | 7.2K ASH / 28.8K ASD |
Dieselbe Seite hat einen Developer-Plan-Tab mit höheren Obergrenzen für jedes Modell, plus Batch- und Flex-Verarbeitung. Behandle die obige Tabelle als Momentaufnahme, da Groq diese Zahlen ohne Vorankündigung ändern kann. Deine eigenen Zahlen findest du auf der Limits-Seite in deinen Kontoeinstellungen: Vertraue dieser Seite mehr als dieser hier, wenn sie nicht übereinstimmen.
Zwei Richtliniendetails sind wichtiger als die reinen Zahlen. Ratenlimits gelten „auf Organisationsebene, nicht für einzelne Benutzer“, sodass fünf Personen, die eine Groq-Organisation teilen, ein gemeinsames Limit haben, nicht fünf separate. Und „zwischengespeicherte Token zählen nicht zu deinen Ratenlimits“, was bedeutet, dass eine gut zwischengespeicherte Prompt-Struktur dir mehr echten Durchsatz verschafft, als die Schlagzeilenzahl vermuten lässt.
Modelle, die man kennen sollte, bevor man ein Limit erreicht
| Das Limit, das zählt, hängt davon ab, welches Modell du aufrufst. Groqs Textmodelle und Compound-Systeme laufen mit einem Kontext von 131.072 [REDACTED CREDENTIAL] Modell-ID | Typ |
|---|---|
llama-3.1-8b-instant |
Schneller Allzwecktext |
llama-3.3-70b-versatile |
Größerer Allzwecktext |
openai/gpt-oss-120b |
Open-Weight-Reasoning-Modell |
openai/gpt-oss-20b |
Kleineres Open-Weight-Reasoning-Modell |
groq/compound |
Agentisches System |
groq/compound-mini |
Leichteres agentisches System |
Die Whisper-Modelle, whisper-large-v3 und whisper-large-v3-turbo, passen nicht in diese Tabelle. Es sind Audio-Transkriptionsmodelle, und Groq misst ihren Durchsatz in Audio-Sekunden pro Stunde und pro Tag (ASH/ASD) neben ihren eigenen RPM- und RPD-Obergrenzen, nicht in Token.
Jedes Modell hat seine eigenen RPM-, RPD- und Token-Obergrenzen, also gehe nicht davon aus, dass die Limits von llama-3.1-8b-instant für openai/gpt-oss-120b gelten.
Lies die Rate-Limit-Header, anstatt zu raten
Jede Antwort von api.groq.com enthält eine Reihe von Headern, die dir genau sagen, wo du stehst, ohne dass du die Konsole besuchen musst:
-
x-ratelimit-limit-requestsundx-ratelimit-limit-tokens, deine Obergrenze für das aktuelle Fenster -
x-ratelimit-remaining-requestsundx-ratelimit-remaining-tokens, was jetzt noch übrig ist -
x-ratelimit-reset-requestsundx-ratelimit-reset-tokens, wann das Fenster zurückgesetzt wird -
retry-after, gesendet bei einem 429, der dir sagt, wie lange du warten sollst
Lies x-ratelimit-remaining-tokens nach jedem Aufruf und du hast eine Live-Anzeige, keine statische Zahl, die du einmal nachgeschaut und dann vergessen hast. Hier ist eine schnelle Überprüfung mit cURL, die nur die Header ausgibt:
curl -sD - https://api.groq.com/openai/v1/chat/completions \
-H "Authorization: Bearer $GROQ_API_KEY" \
-H "Content-Type: application/json" \
-d '{"model": "llama-3.1-8b-instant", "messages": [{"role": "user", "content": "hi"}]}' \
-o /dev/null | grep -i ratelimit
Führe das ein paar Mal in einer Schleife gegen ein gesprächiges Testskript aus und du wirst sehen, wie x-ratelimit-remaining-tokens herunterzählt. Wenn deine App jemals Backoff-Logik benötigt, lies unseren Leitfaden zur Implementierung von API-Ratenbegrenzung für Muster, die einen retry-after-Header respektieren, anstatt eine Verzögerung zu raten.
Lass deinen Coding-Agenten die Überprüfung mit Apidog CLI ausführen
Das curl-und-grep-Tänzchen von Hand zu machen, funktioniert für eine Debugging-Sitzung. Es skaliert nicht für ein Team, und niemand führt vor jedem Deployment einen einmaligen Shell-Befehl erneut aus. Übergib die Überprüfung stattdessen deinem Coding-Agenten: Mit Apidog CLI schreibt er den Test einmal und führt ihn aus, wann immer du fragst. Richte es einmal ein:
npm install -g apidog-cli@latest
apidog login --with-token <YOUR_TOKEN>
npx -y skills add https://apidog.com # pick your agent when prompted
Das Token stammt von Apidog unter Kontoeinstellungen, API-Zugriffstoken. Gib dann dem Agenten einen Prompt:
Use Apidog CLI on project <id>. Create a Groq environment with base URL
https://api.groq.com/openai/v1 and add POST /chat/completions with Bearer [REDACTED]
from {{GROQ_API_KEY}}. Create one test case per model we run in production
(llama-3.1-8b-instant, openai/gpt-oss-120b) that asserts status 200 and fails
when x-ratelimit-remaining-tokens drops below 10% of x-ratelimit-limit-tokens.
Put both cases in a "Groq limits" test suite, run it, and report the headers.
Die Befehle, die er ausführt, abgeglichen mit Apidog CLI 2.2.7:
apidog environment create Groq --project <id> --base-url https://api.groq.com/openai/v1
apidog endpoint create --project <id> --file groq-chat.json
apidog cli-schema validate test-case-create --file groq-8b-case.json
apidog test-case create --project <id> --file groq-8b-case.json
apidog test-suite create --project <id> --name "Groq limits"
apidog run --test-suite <suiteId> --project <id> -e <envId> \
--env-var "GROQ_API_KEY=$GROQ_API_KEY" -r cli,junit
Ein schrumpfendes Budget zeigt sich jetzt als fehlgeschlagener Test statt als Überraschungs-429 während einer Demo. Setze diese letzte Zeile in deinen Pre-Deploy-CI-Job, wie in unserem Leitfaden zur Apidog CLI CI/CD-Pipeline, oder bitte den Agenten um ein apidog scheduled-task create, das die Suite auf einem Runner nach Cron-Zeitplan ausführt. Das ist umso wichtiger angesichts von Groqs Pooling auf Organisationsebene: Ein Teammitglied, das einen Batch-Job ausführt, kann das gemeinsame Budget aufbrauchen, das dein Produktionsendpunkt eine Stunde später benötigt. Es ist dieselbe Idee wie in unserem Beitrag zum Testen einer API auf GPT-Ratenlimits.
Was zu tun ist, wenn du tatsächlich das Limit erreichst
Wenn ein 429 zurückkommt, respektiere retry-after, anstatt sofort erneut zu versuchen. Eine enge Wiederholungsschleife gegen ein Anfrage-Limit verbraucht nur dein verbleibendes Budget schneller und verschiebt das Reset-Fenster weiter nach hinten. Wenn du dies in einen Produktionsdienst statt in ein Testskript einbaust, führt unser vollständiger Leitfaden zum Fehler „Rate Limit Exceeded“ durch Backoff-Strategien, die bei verschiedenen Anbietern funktionieren, nicht nur bei Groq.
Wenn du beim Free Plan konsequent an die Obergrenze stößt, ist die schnellste Lösung das Upgrade auf den Developer Plan, auf den Groq in seinen Dokumenten direkt verweist. Die zweitschnellste Lösung, besonders für einen Prototyp, ist die Verteilung des Datenverkehrs auf mehr als einen Anbieter. Unsere Zusammenstellung von OpenRouter-Alternativen behandelt andere Endpunkte, die es wert sind, für genau diese Situation in der Hinterhand zu haben.
FAQ
Hat Groq einen kostenlosen Tarif für seine API? Ja. Jedes neue Konto beginnt mit dem Free Plan und hat Zugriff auf den OpenAI-kompatiblen Endpunkt. Groq veröffentlicht Beispiel-Free-Plan-Limits für mehrere Modelle, aber die Obergrenzen, die tatsächlich für dein Konto gelten, findest du auf der Limits-Seite in deinen Konsoleneinstellungen.
Wie überprüfe ich mein aktuelles Groq-Ratenlimit? Auf zwei Arten: Öffne die Limits-Seite in deinen Kontoeinstellungen oder lies die Header x-ratelimit-limit-requests und x-ratelimit-limit-tokens in einer beliebigen API-Antwort. Die Header spiegeln das tatsächliche Limit deines Kontos im Moment des Aufrufs wider, was zuverlässiger ist als eine Zahl, die du einmal gesehen und dir gemerkt hast.
Was passiert, wenn ich das Groq-Ratenlimit überschreite? Du erhältst eine 429-Antwort mit einem retry-after-Header, der dir sagt, wie viele Sekunden du warten sollst. Lies unseren Leitfaden zum Überschreiten des Ratenlimits, um dies im Code zu behandeln, anstatt eine Verzögerung zu raten.
Zählen zwischengespeicherte Token gegen mein Groq-Ratenlimit? Nein. Groq gibt direkt an, dass zwischengespeicherte Token nicht zu deinen Ratenlimits zählen. Eine Prompt-Struktur, die eine zwischengespeicherte Systemnachricht wiederverwendet, erzielt also mehr echten Durchsatz, als das rohe Token-Limit vermuten lässt.
Gilt das Groq-Ratenlimit pro Benutzer oder pro Organisation? Pro Organisation. Jeder Schlüssel unter derselben Groq-Organisation teilt sich einen Pool von Anfragen und Token, sodass das Skript eines Teammitglieds das Budget aufbrauchen kann, das deine Produktions-App benötigt.
Welche Groq-Modelle haben das größte Kontextfenster? llama-3.1-8b-instant, llama-3.3-70b-versatile, openai/gpt-oss-120b, openai/gpt-oss-20b und die Compound-Systeme laufen alle mit 131.072 Token Kontext. Die Whisper-Modelle sind Audio-Transkription, kein Text, daher misst Groq ihre Limits stattdessen in Audiodauer. Die Ratenlimits unterscheiden sich von Modell zu Modell, selbst innerhalb desselben Kontextfensters, also überprüfe jedes einzeln.
Was das für dich bedeutet
Der kostenlose Weg, die Groq API zu nutzen, ist keine geheime Zahl, sondern eine Gewohnheit. Hole dir einen Schlüssel, richte den OpenAI-kompatiblen Endpunkt darauf aus und lies bei jedem Aufruf die Antwort-Header, anstatt einer Zahl zu vertrauen, die du in einem Blogbeitrag gefunden hast – diesen eingeschlossen.
Lass deinen Coding-Agenten diese Überprüfung einmal mit Apidog CLI erstellen, mit einer Assertion auf verbleibende Token für jedes Modell, und sie läuft von da an bei jedem Deployment. Die Einrichtung dauert weniger Zeit als das Lesen des restlichen Groq-Dokumentation. Für eine tiefere Abdeckung des Testens einer KI-API-Schicht unter Last ist unser Leitfaden zu den besten API-Testtools für KI-Agenten ein guter nächster Schritt.
Top comments (0)