Groq's edge is latency, not model choice: it serves open-weight models (OpenAI's gpt-oss, Qwen, Whisper, plus its own Compound agentic models) 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

The Free Plan covers about a dozen models, each with its own limits (quoted from Groq's rate-limits page, August 2026). The ones worth knowing:

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. 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 genuine outlier was groq/compound-mini at 250 requests/day but 70,000 tokens/minute. 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.

1. Speed — the 20B model is 4× faster than the 120B

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.

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:

Note the trade-off nobody mentions: compound-mini gives you a quarter of the daily requests but nearly 9× the tokens per minute. It's built for fewer, much larger calls — an agent doing web research, not a chat endpoint.

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).

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 qwen3.6-27b wrapping its JSON in prose instead of returning the bare object; 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.

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_tokens low (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)

1. Sign up at console.groq.com (email, GitHub, or Google).
2. Open API Keys in the sidebar and click Create API Key.
3. 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

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_tokens you 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, qwen3.6-27b) get 30 requests/minute and 1,000 requests/day, with 8K tokens/minute and 200K tokens/day. 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. qwen/qwen3.8-27b is the exception at 2M TPD. 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

• Free AI APIs in 2026: We Tested 10, Four Now Want a Card — 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: 18 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