Groq API Free Tier: Real Limits, Every Free Model, and How Far It Actually Goes

Short answer: yes, the Groq API free tier is real, and it is enough to run a production feature — we do. A free Groq API key gets you every model on GroqCloud at 30 requests/minute (chat models), with per-model daily ceilings: 14,400 requests and 500K tokens/day on llama-3.1-8b-instant, 1,000 requests and 100K tokens/day on llama-3.3-70b-versatile, 200K tokens/day on the GPT-OSS models — all verified against Groq's rate-limit docs in August 2026. The catch nobody leads with: limits apply per organization, not per key, and for chat workloads the daily token ceiling binds long before the request count does.

This page is the free-tier reference we wished existed when we wired Groq into our own app. The AI tutor inside our course reader has run on Groq's free tier in production for months — llama-3.3-70b-versatile, no GPU on our server — so alongside the verified numbers you get the engineering that makes a 100K-token daily budget survive real users. All limits and model rosters below were retrieved from Groq's official docs in August 2026; Groq changes the roster quarterly, so treat their docs as the live source of truth.

---

What You Get Free (and Why It's Fast)

A free Groq account gets you an OpenAI-compatible API serving open-weight models at speeds no consumer GPU touches: Groq's own models page lists 560 tok/s for Llama 3.1 8B, ~500 tok/s for GPT-OSS 120B, and 280 tok/s for Llama 3.3 70B. For comparison, a very good local setup runs a 70B-class model at single-digit to low-double-digit tokens per second.

Groq is not "Grok" (xAI's chatbot). Groq is an inference company that builds its own chips — the LPU — and sells fast hosted inference for open-weight models. The business model is straightforward and worth understanding, because it explains why the free tier exists and persists: the free tier is the top of their sales funnel for the paid Developer tier. That has two practical consequences:

• The free tier is not a trial. It has no end date, and Groq's limit structure has been broadly stable — in all the months our integration has run on it, no limit change has broken us.
• It is capped hard enough that real products eventually pay. The caps are the product design, so plan around them from day one — that's most of this guide.

You interact with it exactly like any OpenAI-compatible endpoint, which means everything you've built for OpenAI, Ollama, or vLLM works with a base-URL swap.

---

The Real Rate Limits, Per Model

The free tier is four ceilings racing each other: requests/minute, requests/day, tokens/minute, and tokens/day — you are throttled by whichever you hit first. Here is the full free-tier table from Groq's rate-limit docs, retrieved August 2026 (Groq notes your account's limits page is authoritative for your org):

RPM/RPD = requests per minute/day · TPM/TPD = tokens per minute/day. Source: console.groq.com/docs/rate-limits, August 2026.

Three readings of that table that matter more than the table itself:

• For chat, TPD binds first, not RPD. The famous "14,400 requests a day" on the 8B sounds infinite, but 500K tokens/day divided by 14,400 requests is ~35 tokens per request — no real chat exchange is that small. At a realistic ~1,000 tokens per exchange, the 8B gives you roughly 500 exchanges/day and the 70B roughly 100. Budget in tokens, not requests.
• TPM is the burst ceiling. 12K TPM on the 70B means one long-context request (say a 10K-token document) consumes nearly a full minute of budget by itself. Long-context work on the free tier queues; it doesn't parallelize.
• Whisper is the sleeper. 28,800 audio-seconds/day is 8 hours of free transcription daily — for many side projects that's effectively unlimited speech-to-text.

---

Three Things People Get Wrong

Myth 1: "Make more API keys." Groq's docs are explicit: rate limits apply at the organization level, not per key, not per user. Every key in your account draws from the same budget, so key rotation gains you exactly nothing. (Making multiple accounts to evade limits is the kind of thing that gets platforms banned — don't build on that.)

Myth 2: "The limits are the same for every model." As the table shows, the spread is wide — the 8B has 5x the daily tokens of the 70B, and the agentic compound systems allow only 250 requests/day. Picking the model is picking your quota.

Myth 3: "Every prompt token counts against you." Not anymore. Groq's prompt caching is automatic (no code changes, no fee), gives cached input tokens a 50% price discount on paid tiers — and, the part that matters here: "cached tokens do not count towards your rate limits." It currently covers the GPT-OSS models (120B, 20B, safeguard), with more promised. Structure your prompts with the shared system prompt first and the variable part last, and on gpt-oss-120b a 2,000-token system prompt effectively stops existing for quota purposes after the first request. Cache hits are reported per-response in usage.prompt_tokens_details.cached_tokens.

And the operational bit most tutorials skip: every response carries x-ratelimit-remaining-requests (daily) and x-ratelimit-remaining-tokens (per-minute), and a 429 includes retry-after. Read the headers; don't discover your quota by failing.

---

Every Free Model on GroqCloud (August 2026)

The roster in August 2026 is 15 models and systems: 6 production models, 2 agentic "compound" systems, and 7 previews — all reachable with a free key, though MiniMax M2.7 has no published free-tier limit row. From Groq's models page (speeds are Groq's published figures; context windows 131K on the chat models):

Our picks, having actually run bills-free inference through this roster:

• Default to openai/gpt-oss-120b for anything where answer quality matters: double the 70B's daily tokens, prompt caching exempts your system prompt from quota, and it's OpenAI's open-weight flagship — our full GPT-OSS breakdown covers what it can and can't do (and what it takes to run the same weights locally).
• llama-3.1-8b-instant for volume paths — classification, extraction, routing, autocomplete. 500K TPD at 560 tok/s is a lot of free work.
• llama-3.3-70b-versatile is what our tutor uses — a deliberate choice from before gpt-oss existed that we've kept because its instruction-following on course content has been consistently solid; see our Llama 3.3 70B page for the model itself.
• Don't build load-bearing features on preview models. The preview roster is exactly where the quarterly churn happens. Qwen3.6-27B is genuinely good (our review) — but treat any preview integration as disposable.

---

Setup in 5 Minutes

Create a key at console.groq.com/keys, export it, and you're one HTTP call from 500 tok/s. Verified against Groq's quickstart, August 2026:

export GROQ_API_KEY=gsk_your_key_here
pip install groq

Minimal Python (this is Groq's own quickstart shape):

import os
from groq import Groq

client = Groq(api_key=os.environ.get("GROQ_API_KEY"))

chat = client.chat.completions.create(
    model="llama-3.3-70b-versatile",
    messages=[{"role": "user", "content": "Explain LPUs in two sentences."}],
    max_tokens=350,
)
print(chat.choices[0].message.content)

Already have OpenAI-shaped code (or an Ollama/vLLM client)? Point it at Groq's compatibility endpoint — this is the entire migration:

import os, openai

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

Or raw curl, same endpoint:

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": "hello"}],
       "max_tokens": 100}'

Compatibility fine print from Groq's OpenAI-compat docs: logprobs, logit_bias, top_logprobs, and messages[].name aren't supported, n must be 1, and temperature: 0 is silently converted to 1e-8 — Groq recommends any float above 0 and ≤ 2. None of these have ever mattered for our integration, but if your eval harness relies on logprobs, it won't run here.

---

How We Run a Production Feature on the Free Tier

Our AI course tutor has served real students on Groq's free tier for months — one llama-3.3-70b-versatile key, zero inference bill, no GPU on our server. Every constant below is from our production code, and each one exists because of a line in the rate-limit table:

• Answers are capped at 350 output tokens. Output tokens are the most expensive thing you control, and an uncapped chatty model will happily burn 1,500 tokens saying what 300 could. 350 tokens ≈ 250 words — a full tutor answer.
• Context is trimmed to ~750 tokens. The naive version stuffed the whole course chapter (often 8K+ characters) into the system prompt. The shipped version sends the chapter's opening plus its summary with the middle elided — answer quality barely moved, token burn dropped ~60%.
• Conversation history is capped at 4 messages, 400 characters each. History is the silent quota killer: uncapped, every exchange re-sends the whole conversation and cost grows quadratically.
• Per-user limits sit in front of Groq's limits: 6 questions per 5 minutes, 40 per day. Groq's ceiling is org-wide, so one enthusiastic user can starve everyone else. Never expose a shared free quota directly to end users.
• Every call has a 15-second timeout and a fallback — if Groq errors or throttles, the request reroutes to a local Ollama model. The user sees a slightly slower answer, not a failure. That cloud-with-local-fallback pattern is worth stealing for any free-tier integration.

The arithmetic that makes it work: a worst-case tutor request is ~1,600 input tokens (trimmed context + history + question) plus 350 out — call it 2,000 tokens. Against the 70B's 100K TPD, that's a floor of ~50 worst-case answers a day, and most real requests are far lighter, so the practical capacity is roughly double that. For a feature used by a slice of logged-in students each day, it fits — with the per-user caps as the pressure valve. If your feature is the product rather than a supporting feature, skip ahead to the limitations section, because this budget will not stretch to that.

---

How Far Does the Free Tier Actually Get You?

Rule of thumb: the free tier comfortably covers development, side projects, and one well-budgeted production feature — and stops there. Concretely, using the August 2026 numbers:

The coding-assistant row deserves a sentence, because "free Groq backend" is the standard advice in every free-AI-coding-stack roundup: it works, but one agentic task that reads a few files can eat a third of the 70B's daily tokens. Fine for occasional use; a heavy afternoon will 429. That's a workload where local inference wins the math fast.

When you outgrow the tier, the exit ramp is Groq's pay-as-you-go Developer tier — higher limits plus batch and flex processing, per-token prices on groq.com/pricing. The upgrade needs zero code changes, which is honestly the best argument for prototyping on Groq in the first place.

---

Honest Limitations

The free tier's real costs are paid in things other than money. Before you build on it:

• Your data leaves your machine. Every prompt — user questions, document contents, code — goes to Groq's cloud. For a course tutor that's fine; for client documents, medical notes, or proprietary code it may be disqualifying. That's the boundary where we route work to a private OpenAI-compatible endpoint on our own hardware instead.
• The model roster churns quarterly. The limits structure has been stable, but models — especially previews — get deprecated on Groq's schedule, not yours. Pin your model ID, subscribe to their deprecation notices, and keep the model name in config, not code.
• Org-level limits don't scale with your users. Ten users share the same 100K TPD as one. There is no per-user isolation on the free tier; you build it yourself (see our caps above).
• No long-context headroom. 131K context windows, but 6-12K TPM: the window is bigger than the minute. Feeding a 50K-token document is technically possible and practically a five-minute stall.
• You can't tune anything. No fine-tuning your own weights, no custom quantization, no sampler surgery. The models are excellent and exactly as-is. When you want control, the same GPT-OSS and Llama weights run free on your own hardware.

None of these are complaints — for $0 the deal is extraordinary. They're the walls you'll eventually touch, listed so you touch them on purpose.

---

Groq Free vs Running It Local

Use both — they're good at opposite things. The honest comparison, since we operate both sides daily:

Our routing rule after months of running the hybrid: Groq for latency-sensitive, low-volume, non-sensitive requests; local for volume, privacy, and anything that must exist in five years. A llama-3.1-8b-instant-class model runs well on an 8GB consumer GPU — our 8GB VRAM model picks show exactly what that card can serve locally, without any request counter ticking. And if you need an always-on endpoint with real throughput, self-hosting vLLM is the grown-up version of this whole conversation.

---

Verdict

Groq's free tier is the best free LLM API you can get a key for in five minutes — as long as you read the token column, not the request column.

1. Sign up and budget in TPD. 500K tokens/day (8B), 200K (GPT-OSS), 100K (70B). The "14,400 requests" headline is real but almost never the number that stops you.
2. Default to gpt-oss-120b. Best free-token quality, and prompt caching makes your system prompt quota-free.
3. One org-wide budget: put your own per-user caps and a local fallback in front of it. That's the entire difference between our tutor running for months and it dying its first busy afternoon.
4. Prototype on Groq, plan your exit. The OpenAI-compatible endpoint means moving to paid Groq — or to your own GPU — is a base-URL change, not a rewrite.

Free, fast, and capped is a genuinely great deal — provided you build like the cap is coming, because it is.

---

Sources

• Groq rate-limit documentation — all free-tier RPM/RPD/TPM/TPD figures, org-level policy, header names (retrieved August 2026)
• Groq models catalog — roster, context windows, and Groq's published tok/s figures (August 2026)
• Groq quickstart and OpenAI-compatibility docs — setup code, base URL, unsupported parameters
• Groq prompt-caching docs — automatic caching, 50% cached-token discount, rate-limit exemption
• Our own production integration — the tutor token budgets, per-user caps, and fallback behavior described above are from the code we run

---

FAQ