On this page
Groq's edge is latency, not model choice: it serves open-weight models (OpenAI's gpt-oss, Qwen, Whisper) on Language Processing Units built for inference. If your app is real-time — chat, voice, an agent — that speed is the whole point. Below: the free models, the limits, working code, and how it compares.
Free Models and Rate Limits
On September 29, 2026 Groq's /models endpoint listed 11 models for a free key, but only four of them are chat models — and all four answered a test call that day: openai/gpt-oss-120b, openai/gpt-oss-20b, qwen/qwen3.8-27b and allam-2-7b. The rest are speech (Whisper, Orpheus text-to-speech) and safety classifiers (prompt-guard, gpt-oss-safeguard). Limits below are quoted from Groq's rate-limits page, checked September 29, 2026:
| Model | Free RPM | Free RPD | TPM / TPD | Use it for |
|---|---|---|---|---|
| openai/gpt-oss-120b | 30 | 1,000 | 8K / 200K | General use when quality matters |
| openai/gpt-oss-20b | 30 | 1,000 | 8K / 200K | Fast responses, lighter tasks |
| qwen/qwen3.8-27b | 30 | 1,000 | 8K / 200K | Multilingual, coding |
| whisper-large-v3-turbo | 20 | 2,000 | — | Speech-to-text |
allam-2-7b (an Arabic-focused model) answered our test call but has no row on the Free Plan limits table, so we can't quote its quota. Gone since August: qwen/qwen3.6-27b and the groq/compound / groq/compound-mini agentic models appear neither in /models nor on the limits page any more, and qwen/qwen3.8-27b's daily token budget, which was 2M in August, is now listed at 200K like the others.
Expect these to move. Re-running the same request on a different day and from a different machine gave us figures between roughly 480 and 640 tok/s for gpt-oss-120b — shared free capacity fluctuates with load. The ranking between models held steady, so treat the numbers as a band rather than a constant, and don't design around one specific figure.
Where did the Llama models go? Every Groq tutorial you'll find online opens with model="llama-3.3-70b-versatile", and that string no longer works on a self-serve key. As of August 2026 Groq's catalog lists both llama-3.3-70b-versatile and llama-3.1-8b-instant as Enterprise — the price and rate-limit columns read "Contact Sales" instead of a number, and neither appears on the Free Plan table at all — still true when we re-checked /models on September 29, 2026. The only Meta models left on the free tier are the two llama-prompt-guard safety classifiers (22M and 86M parameters), which classify prompts and cannot hold a conversation. Substitute openai/gpt-oss-120b.
One number to unlearn: the 14,400 requests/day figure that still circulates for Groq now applies only to the tiny llama-prompt-guard safety classifiers, not to anything you'd chat with. Chat models sit at 30 RPM / 1,000 RPD. Limits are per model and reset every 24 hours; check live values on the Groq Console.
What the live headers actually returned. Rather than trust the table above, we read the x-ratelimit-* headers Groq sends back on a real call (August 2026). Every chat model we tested — including qwen3.8-27b — reported 1,000 requests/day and 8,000 tokens/minute. The one outlier at the time was groq/compound-mini at 250 requests/day but 70,000 tokens/minute (no longer listed as of September 29, 2026). If a quota matters to your build, read the headers on your own key: they're the only source that reflects what your account really gets.
We benchmarked every free Groq model: speed, quota, capability
Groq quotes 300–800 tokens/second, but that's one number for a whole catalog. So we ran our own benchmark against each free model — measuring three things that actually decide which one you pick: how fast it generates, what quota you really get, and what it can do. Measured August 2026 from a US runner, using each API's own token counts. Two of the models in these tables — qwen/qwen3.6-27b and groq/compound-mini — have since been removed from the free tier (checked September 29, 2026); their rows are kept as history, and qwen/qwen3.8-27b is the Qwen model to use now.
1. Speed — the 20B model is about twice as fast as the 120B
| Model | Generation speed | What that means |
|---|---|---|
| openai/gpt-oss-20b | ~1,100 tok/s | Twice the 120B, and above Groq's own quoted range |
| openai/gpt-oss-120b | ~525 tok/s | The quality default, still ~5× a typical GPU API |
| qwen/qwen3.8-27b | ~498 tok/s | Newer Qwen, multilingual |
| groq/compound-mini | ~498 tok/s | Agentic model with built-in web search (removed since) |
| qwen/qwen3.6-27b | ~476 tok/s | Older Qwen (removed since) |
The headline here isn't the 120B — it's that gpt-oss-20b generates around 1,100 tokens/second, roughly twice its bigger sibling. If your task is simple (classification, tagging, extraction, short replies), the small model isn't a compromise; it's a different speed class entirely.
Re-tested 2026-10-11
We re-ran the same harness on 11 October 2026 — three rounds, one streaming request per model per round, through a proxy from Asia rather than the US runner used in August. Same method: throughput is completion tokens ÷ generation time after the first token.
| Model | Round 1 | Round 2 | Round 3 | Median | August |
|---|---|---|---|---|---|
| openai/gpt-oss-20b | 813 tok/s | 885 tok/s | 839 tok/s | 839 tok/s | ~1,100 tok/s |
| qwen/qwen3.8-27b | 563 tok/s | 445 tok/s | 544 tok/s | 544 tok/s | ~498 tok/s |
| openai/gpt-oss-120b | 454 tok/s | 353 tok/s | 261 tok/s | 353 tok/s | ~525 tok/s |
Time to first token was 0.7–1.2 s for the gpt-oss models and 0.7–2.4 s for Qwen. Two things moved since August: gpt-oss-120b came in a third slower (and varied by almost 2× between rounds), and Qwen overtook it. gpt-oss-20b is still the fastest model on the free tier, at about 2.4× the 120B. The same day we also confirmed the rest of this page on a live key: /models listed the same 11 models, all three chat models returned x-ratelimit-limit-requests: 1000 and x-ratelimit-limit-tokens: 8000, llama-3.3-70b-versatile and llama-3.1-8b-instant both returned 404 model_not_found, and all three chat models passed all four capability tasks below (Qwen's long-context run had to be repeated once after our proxy dropped the connection). One limit the headers above do not show: when we ran Aider on qwen/qwen3.8-27b the same day, Groq returned 429 … output tokens per minute (OTPM): Limit 1000 three times. Qwen's free tier caps output at 1,000 tokens a minute on top of the 8,000 TPM, so one long reply a minute is about all it will give you.
2. Quota — read from the API's own rate-limit headers
Instead of quoting the docs, we read the x-ratelimit-* headers the API returns and derived the real windows:
| Model | Requests/day | Tokens/minute |
|---|---|---|
| gpt-oss-120b / gpt-oss-20b / qwen3.8-27b | 1,000 | 8,000 |
| groq/compound-mini (removed since) | 250 | 70,000 |
In August, compound-mini gave you a quarter of the daily requests but nearly 9× the tokens per minute — built for fewer, much larger calls, like an agent doing web research. It no longer appears on the free tier, so every chat model you can call today shares the same 1,000 RPD / 8,000 TPM shape.
3. Capability — four pass/fail tasks, not vibes
We gave every model the same four jobs and checked the output programmatically: return strictly valid JSON (instruction following), write a working Python function, answer in Chinese only, and find one value buried in 120 lines of noise (long-context retrieval).
| Model | Strict JSON | Code | Chinese | Long context | Score |
|---|---|---|---|---|---|
| openai/gpt-oss-120b | ✅ | ✅ | ✅ | ✅ | 4/4 |
| openai/gpt-oss-20b | ✅ | ✅ | ✅ | ✅ | 4/4 |
| qwen/qwen3.8-27b | ✅ | ✅ | ✅ | ✅ | 4/4 |
| groq/compound-mini (removed since) | ✅ | ✅ | ✅ | ✅ | 4/4 |
| qwen/qwen3.6-27b (removed since) | ❌ | ✅ | ✅ | ✅ | 3/4 |
The useful signal: gpt-oss-20b passes everything the 120B does on these tasks while running about twice as fast — so for structured, well-defined work the small model is often the right default. The one failure was the now-removed qwen3.6-27b wrapping its JSON in prose instead of returning the bare object; its replacement, qwen/qwen3.8-27b, passed all four. If you're piping output straight into code, that difference matters more than a few tokens per second.
Method: one streaming request per model, temperature 0.3, 500-token cap; throughput = completion_tokens ÷ generation time (excluding time to first token), from the API's own usage field. Quotas derived from live x-ratelimit-* headers. Capability = programmatic pass/fail, no subjective scoring. Harness is open source; your numbers will vary with prompt and load.
What can you actually build with it?
A fast free key only matters if it maps to real projects. Here's what each free model is genuinely good for — and where the 1,000-requests-a-day ceiling actually bites.
| Model | Reach for it when you're… |
|---|---|
| gpt-oss-120b | Doing anything where quality matters — drafting or rewriting text, summarizing long documents, answering over your own docs (RAG), writing code, or powering an agent's reasoning step. This is the default. |
| gpt-oss-20b | High-volume, well-defined work — classification, tagging, extracting fields from messy text, short summaries. Our benchmark says this is the sweet spot: ~2× the speed of the 120B (2.4× on 2026-10-11) and it still passed all four capability tests. |
| qwen/qwen3.8-27b | Working in Chinese or other languages, or on code. Same 1,000-requests/day ceiling as the gpt-oss models. |
| whisper-large-v3-turbo | Transcribing audio to text (speech-to-text), free. |
Things that fit comfortably inside the free tier:
- A real-time chatbot or support assistant — Groq's speed is what makes replies feel instant.
- The reasoning step of an agent, if you cap
max_tokenslow (OpenClaw, LangGraph, CrewAI — see the OpenClaw section below). It is a poor fit as an agent's primary model: tool schemas alone eat most of the 8,000 TPM budget. - Batch text jobs: summarize a folder of articles, classify tickets, pull structured data out of emails — just stay under 1,000 requests/day, or spread the run across days.
- A voice app: Whisper for speech-to-text, then gpt-oss for the reply.
- Coding help in your editor, or a script that reviews diffs.
Where it doesn't fit: anything public-facing at volume. 1,000 requests/day is about one power user, or a few dozen light ones — perfect for personal tools, prototypes, and automation, but not a launched product with real traffic. For that, add a paid tier or a second provider.
Get a Key (No Credit Card)
- Sign up at console.groq.com (email, GitHub, or Google).
- Open API Keys in the sidebar and click Create API Key.
- Copy it immediately — it's shown only once.
Using the Groq API (Python)
Install the SDK and make a basic chat completion:
pip install groq
from groq import Groq
client = Groq(api_key="YOUR_GROQ_API_KEY")
response = client.chat.completions.create(
model="openai/gpt-oss-120b",
messages=[
{"role": "system", "content": "You are a helpful coding assistant."},
{"role": "user", "content": "Write a Python function to check if a string is a palindrome"}
]
)
print(response.choices[0].message.content)
Groq's speed is most obvious when streaming — tokens arrive almost instantly:
stream = client.chat.completions.create(
model="openai/gpt-oss-20b",
messages=[{"role": "user", "content": "Explain async/await in Python"}],
stream=True
)
for chunk in stream:
delta = chunk.choices[0].delta.content
if delta:
print(delta, end="", flush=True)
Drop-in OpenAI replacement
Groq is fully OpenAI-compatible. If you already use the OpenAI SDK, change two lines — the key and the base URL:
from openai import OpenAI
client = OpenAI(
api_key="YOUR_GROQ_API_KEY",
base_url="https://api.groq.com/openai/v1"
)
response = client.chat.completions.create(
model="openai/gpt-oss-120b",
messages=[{"role": "user", "content": "Summarize REST vs GraphQL"}]
)
print(response.choices[0].message.content)
JSON mode (response_format={"type": "json_object"}) forces structured output for pipelines, and a Node.js SDK (npm install groq-sdk) mirrors the same API.
Connect Groq to OpenClaw
Pairing Groq's speed with OpenClaw gives you a free AI agent with sub-second responses. Quick setup:
npm install -g openclaw@latest
openclaw onboard
Select Groq as the provider and paste your key. For manual config, add a Groq provider block to ~/.openclaw/openclaw.json:
{
"models": {
"mode": "merge",
"providers": {
"groq": {
"baseUrl": "https://api.groq.com/openai/v1",
"apiKey": "YOUR_GROQ_API_KEY",
"api": "openai-completions",
"models": [
{ "id": "openai/gpt-oss-120b", "name": "GPT-OSS 120B (Groq)",
"contextWindow": 6000, "maxTokens": 1500 },
{ "id": "openai/gpt-oss-20b", "name": "GPT-OSS 20B (Groq)",
"contextWindow": 6000, "maxTokens": 1500 }
]
}
}
},
"agents": {
"defaults": { "model": { "primary": "groq/openai/gpt-oss-120b" } }
}
}
Those numbers look small on purpose. The free tier bills the max_tokens you declare against its 8,000 TPM budget, not the tokens the model actually returns. We measured it on 2026-09-01: a 20-token prompt with max_tokens: 8192 is rejected with 413 — "Limit 8000, Requested 8271" before a single token is generated. Declaring maxTokens: 8192 here, as most tutorials do, means every request fails — and OpenClaw reports that 413 as "Context overflow", which sends you looking for an oversized system prompt that does not exist. Keep the ceiling low and let the harness trim.
Groq vs Other Free AI APIs
| Feature | Groq | Google Gemini | DeepSeek |
|---|---|---|---|
| Speed | 300–800 tok/s | ~100 tok/s | ~50–80 tok/s |
| Default free model | gpt-oss-120b | Gemini 3.5 Flash | None (prepaid only) |
| Context | 128K | 1M | 128K |
| Free RPD | 1,000 (chat models) | Not published — shown only in AI Studio | None — top-up required |
| Multimodal | Vision (limited) | Text+Image+Audio+Video | Text only |
| Best for | Real-time apps | Complex tasks | Coding, reasoning |
Reach for Groq when latency matters: real-time chat, voice pipelines (STT → LLM → TTS), developer CLIs, code-review bots in CI. For long context or multimodal work, Gemini wins; for deep reasoning on long documents, DeepSeek is a better fit.
Limitations to Know
- Open-weight models only — no GPT-4o, Claude, or Gemini; Groq runs open models exclusively.
- Text-first — vision exists but is limited to specific preview models, and there's no image generation.
- Tight TPM, counted before generation — 8,000 tokens/minute on the chat models, and the budget is charged against the
max_tokensyou declare rather than what comes back. It is a shared rolling window, not a per-model allowance, so a model that passes one call can 413 a minute later. - No fine-tuning on the free tier.
Frequently Asked Questions
Does Groq require a credit card?
No. Sign up with an email, GitHub, or Google account and create a key — there's no billing setup for the free tier.
Is Groq OpenAI-compatible?
Yes. Point the OpenAI SDK at https://api.groq.com/openai/v1 with your Groq key and existing chat-completion code works unchanged.
How many requests can I make for free?
Chat models (gpt-oss-120b, gpt-oss-20b, qwen/qwen3.8-27b) get 30 requests/minute and 1,000 requests/day, with 8K tokens/minute and 200K tokens/day (Groq's rate-limits page, checked September 29, 2026). The daily token cap is usually what stops you first: 200K TPD spread over 1,000 requests is only 200 tokens per call, so a typical 2K-token exchange exhausts the day at around 100 requests. Whisper gets 2,000/day. The higher 14,400/day figure belongs only to the prompt-guard classifiers. Limits reset every 24 hours.
Why is Groq so much faster than other APIs?
It runs inference on custom LPU hardware rather than general-purpose GPUs, delivering 300–800 tokens/second versus roughly 50–100 for typical GPU providers.
Related Reads on Free AI APIs
- Best Free AI APIs: Which Ones Still Work, Tested — see how Groq stacks up against the field
- Google Gemini Free API Tested: 34s to First Token — Groq's main rival for free volume
- OpenRouter Free Tier Tested: 16 Free Models, One API Key — when you need model variety over raw speed
- DeepSeek API Is No Longer Free: We Checked the Balance — better fit for long-form reasoning than Groq
- MCP: Connect AI Agents to Any Tool or API — wire Groq into a real agent stack