Groq API Free Tier: What You Actually Get

In short

Groq's free tier gives you an API key without a credit card and access to every model in the catalogue, gated only by rate limits. Those limits are published per model on Groq's rate limits page: most chat models sit at 30 requests per minute, and the token budgets are where the real ceiling lives — 6,000 tokens per minute and 500,000 per day on llama-3.1-8b-instant, 12,000 per minute and only 100,000 per day on llama-3.3-70b-versatile. Speech models get 20 requests per minute. Limits are counted per organisation, not per key, so minting extra keys buys you nothing. The API is OpenAI-compatible, so switching an existing script means changing two lines. In practice the free tier is a genuinely good prototyping budget for short-prompt, high-frequency work — classification, routing, voice, chat replies — and completely unusable for long-context coding agents, which will burn a day's token quota in one request. As of July 2026.

What Groq is (and what it isn't)

Groq is an inference provider, not a model lab. It runs open-weight models (Llama, OpenAI's gpt-oss, Qwen, Whisper) on its own LPU hardware and sells the throughput: same weights you could run anywhere, returned much faster.

Two things people get wrong before they sign up. First, Groq is not Grok — Grok is xAI's model, different company, one letter apart. Second, Groq has no frontier model of its own. Nothing on the menu competes with Claude Opus or GPT-5 on hard reasoning. You're buying speed and price on mid-tier open weights, and that trade is either exactly right for your task or completely wrong.

The API speaks OpenAI's protocol: point your client at https://api.groq.com/openai/v1, set GROQ_API_KEY, done. A few fields are unsupported — logprobs, logit_bias, top_logprobs, messages[].name, and n must be 1 — and temperature=0 is silently converted to 1e-8, which matters if you relied on greedy decoding for reproducibility. Full list in the OpenAI compatibility docs.

Signing up and getting a key

Create an account at console.groq.com (email or SSO, no card), open the API Keys page, create a key and copy it immediately — you won't see it again. Then export GROQ_API_KEY=gsk_... and point any OpenAI SDK at the base URL above.

That's the whole flow, and it's the part every tutorial spends 800 words on. What's worth knowing instead: rate limits are enforced at the organisation level. A second key, or a second project, does not double your quota — share an account with a teammate and you share the same 30 RPM. And check the console's Limits page rather than any blog post, including this one; Groq changes per-model quotas without ceremony.

What the free tier really allows

Free-tier numbers Groq publishes for the models people actually reach for, as of July 2026. RPM = requests/minute, RPD = requests/day, TPM = tokens/minute, TPD = tokens/day.

Now do the arithmetic nobody does for you. llama-3.3-70b-versatile advertises a 131,072-token context window; its free-tier budget is 12,000 tokens per minute and 100,000 per day. A single request using even half that context window exceeds your entire daily allowance. The context number and the free-tier number describe two different products.

Milder version of the same trap: llama-3.1-8b-instant gives 14,400 requests per day but 6,000 tokens per minute. At 500 tokens in and out per call, you hit the token ceiling around 12 calls a minute, well before 30 RPM. Token budget is the binding constraint here, not request count.

Cross a limit and you get HTTP 429 with a retry-after header. Every response — not just the failures — carries x-ratelimit-remaining-requests and x-ratelimit-remaining-tokens, so a competent client backs off before it gets rejected rather than after.

Where the speed helps and where it doesn't

Groq's throughput is real, and on short generations it changes what feels possible. It also does nothing for a large class of work.

Speed pays off when the output is short and the user is waiting. Voice agents, where generation lag is audible. Streaming chat where the first token must land instantly. Classification, routing, tagging, extraction, reranking — thousands of small calls where the model's job is a decision, not an essay.

Speed pays off very little when:

• The context is long. Time-to-first-token on a 100K-token prompt is dominated by prefill — and on the free tier you can't send that prompt anyway.
• The bottleneck isn't the model. If your agent spends nine seconds on tool calls and a database round trip, shaving two seconds off generation is noise.
• You need frontier reasoning. A faster wrong answer is still wrong. On multi-step refactors, these models cost more in review time than they save in latency.
• You're running a coding agent. Claude Code and Cursor push tens of thousands of tokens per turn. The free tier's TPM budget makes that a non-starter, and even on paid tiers you're trading model quality for speed in the task least tolerant of it — see what vibe coding actually costs per month for where that money goes further.

One caveat: published throughput comes from the vendor, measured under the vendor's conditions. Treat it as an upper bound and measure your own p95 at your own prompt lengths before building a latency budget on it.

Models available and how they compare

The catalogue is open weights plus Groq's own agentic wrappers. Prices below are the paid per-million-token rates from Groq's pricing page as of July 2026 — worth reading even on the free tier, because they tell you what the day after launch costs.

Two observations. gpt-oss-120b at $0.15/$0.60 is cheaper than llama-3.3-70b-versatile on both sides — if you still default to Llama 70B out of habit, re-benchmark. And qwen3.6-27b carries a 5× output premium over its input price; on a model that emits long chains of thought, that line grows fast. groq/compound gives you web search and code execution without wiring your own tools, but its 250 requests/day free ceiling is the tightest on the board.

When you outgrow the free tier

Adding a card moves you to the Developer tier, which raises rate limits and unlocks Batch and Flex processing. Groq doesn't commit to one multiplier across models, so check your console's Limits page after upgrading.

Two discounts are worth designing around from day one. The Batch API is 50% off for asynchronous work with a 24-hour to 7-day completion window — if the job is "summarise 40,000 documents by Friday", that's the only sensible way to buy it. Prompt caching gives 50% off cached input tokens with no separate storage fee, so if you send the same long system prompt every request, put the stable part first.

On data handling, Groq's data policy states that inference requests are not retained by default; inputs and outputs may be temporarily logged only for reliability troubleshooting or abuse investigation, kept up to 30 days, with Zero Data Retention available to switch off even that. The policy reads the same for free and paid accounts — a fair point in Groq's favour, since several competitors do treat free-tier traffic differently.

Free tiers in this market churn constantly. Cerebras, long the volume champion on free daily tokens, now advertises $5 in credits instead of an open allowance, and Google no longer publishes fixed free-tier numbers in its docs — they're shown per project in AI Studio. Every free-tier comparison table, including this one, is a snapshot. If free-and-fast is the priority, our free AI coding stack covers what holds up and the Groq card in our arsenal tracks changes; if your data can't leave your machine, Ollama is the answer, not a faster cloud.

FAQ

Is the Groq API really free?

Yes: you get a working key with no credit card and no trial expiry, and you're charged nothing while you stay inside the published rate limits. It is not free in the sense of "run production on it" — the per-minute token budgets are low enough that real user traffic starts returning 429s.

What are Groq's free tier rate limits?

They're per model. Most chat models allow 30 requests per minute; the differentiator is tokens. llama-3.1-8b-instant gets 6,000 TPM and 500,000 tokens/day, llama-3.3-70b-versatile gets 12,000 TPM but only 100,000 tokens/day, and the gpt-oss models sit at 8,000 TPM and 200,000/day. Speech models are capped at 20 requests/minute. Always confirm against the console — these change.

Is Groq faster than OpenAI?

On the open-weight models Groq serves, published throughput is well above typical general-purpose GPU inference, and the difference is noticeable on short streamed responses. But it isn't like-for-like: you're not getting the same models. The right question is whether a fast mid-tier model does your job, not whether it beats a model you aren't using.

Can I use Groq with Claude Code or Cursor?

You can point OpenAI-compatible tooling at Groq, but on the free tier it won't work in practice — coding agents send tens of thousands of tokens per turn and the per-minute token budget stops you on the first request.

Does Groq train on my prompts?

Per its published data policy, inference requests are not retained by default, with temporary logging only for reliability troubleshooting and abuse investigation (up to 30 days) and Zero Data Retention available as an opt-in. The stated policy doesn't differ between free and paid accounts. Read the current terms yourself before sending sensitive data.