Groq vs Cerebras vs Gemini Free API: Limits and Speed, Tested

On this page
  1. Status on September 29, 2026
  2. Speed, measured from a US server
  3. Same model, two providers: Groq vs Cerebras
  4. Which to use
  5. Get your keys
  6. One client for all three
  7. OpenClaw: Groq and Gemini in one config
  8. Caveats
  9. FAQ
  10. Verdict
Quick answer: Of the three, only Groq is free with no card and no expiry: 30 requests/minute and 1,000 requests/day per chat model. Cerebras is now a trial — $5 of credit that expires after 30 days, and only after you add a payment method. Gemini is free with no card and gives you a 1M-token context window plus image, audio and video input, but Google no longer publishes its free limits and its main Flash model often returns 503. Groq and Cerebras now serve the same two models (gpt-oss-120b and a Qwen 3.8 27B), so between those two the choice is about limits and cost, not model quality. Everything below was checked on September 29, 2026.

This page used to compare Llama 3.3 70B on Groq and Cerebras against Gemini 2.5 Flash. None of those are callable on a new free key any more: Groq and Cerebras dropped Llama, and every gemini-2.5-* ID now returns 404 for new users. So we re-checked all three from scratch: which models answer, what each free tier actually allows, and how fast they are from a US server.

Status on September 29, 2026

GroqCerebrasGoogle Gemini
Free without a card?YesNo — payment method required firstYes
Does the free access expire?NoYes — $5 credit, 30 daysNo
Chat models that answeredopenai/gpt-oss-120b, openai/gpt-oss-20b, qwen/qwen3.8-27b, allam-2-7bLists gpt-oss-120b and qwen-3.8-27b (we can't call them without a card)gemini-3.5-flash-lite, gemini-3.5-flash (often 503), gemini-3.1-flash-lite, gemini-3-flash-preview
Free limits30 RPM, 1,000 req/day, 8K tokens/min, 200K tokens/day per chat modelTrial: 5 RPM, 30K tokens/min, 1M tokens/dayNot published — shown per project in AI Studio
Context window131K (gpt-oss)65K on the trial (131K paid)1,048,576 tokens
Image / audio / video inputNoImages on Qwen (preview)Yes
OpenAI-compatible endpointYesYesYes (/v1beta/openai/)

Sources: Groq's rate-limits page and /models; Cerebras' rate-limits page, model list and change log; for Gemini, one call to every listed model from a free key created in September 2026 (details in our Gemini free API test).

Speed, measured from a US server

We ran our open benchmark on a GitHub Actions runner in the US on September 29, 2026: one streamed request per model, the same ~250-word prompt, speed computed from the API's own token counts.

Provider / modelFirst tokenGeneration speedSource
Groq openai/gpt-oss-20b0.35 s694 tok/sOur test
Groq openai/gpt-oss-120b2.7 s470 tok/sOur test
Groq qwen/qwen3.8-27b1.4 s468 tok/sOur test
Gemini gemini-3.5-flash-lite0.83 s278 tok/sOur test
Gemini gemini-3.5-flash— (streaming failed; one blocking call)45 visible tokens after ~6 s — it reasons before answeringOur test
Cerebras gpt-oss-120b—~3,000 tok/sCerebras' own figure
Cerebras qwen-3.8-27b—~1,850 tok/sCerebras' own figure

Why Cerebras has no measured number: getting a working Cerebras key now requires a payment method, and our benchmark only covers what a reader can use without one. The figures above are what Cerebras publishes on its model list and pricing page; independent testers have reported the hardware is very fast, but we haven't verified these numbers ourselves.

Two things stand out. Groq's first-token time varies a lot by model (0.35 s to 2.7 s) because the gpt-oss models reason before they answer. And gemini-3.5-flash is hard to use interactively on the free tier: in our other tests the same day it returned 503 "high demand" on several attempts, and in this run gemini-3.1-flash-lite returned 503. gemini-3.5-flash-lite was the Gemini model that answered every time.

Same model, two providers: Groq vs Cerebras

Since September 2026, Cerebras' public endpoint serves only gpt-oss-120b and qwen-3.8-27b — the same two models that do most of the work on Groq's free plan (Cerebras removed Gemma 4 31B from public endpoints on September 3). That makes the comparison unusually clean:

For gpt-oss-120bGroq free planCerebras trialCerebras pay-as-you-go
Cost$0$5 credit, expires in 30 days$0.35 / 1M input, $0.75 / 1M output
CardNot neededRequiredRequired
Requests per minute3051,000
Tokens per minute8K30K1M
Tokens per day200K1MNo daily cap
Context131K65K131K

Read it this way: Groq allows more requests, Cerebras allows more tokens. Groq's 8K tokens/minute counts your prompt plus the max_tokens you ask for, so a single long-context request can hit it; Cerebras' trial takes much bigger requests but only five a minute. For a chat bot or an agent making many small calls, Groq's free plan fits better and never expires. For a one-off batch job over long documents with the same model, a Cerebras trial gets more tokens through — for 30 days.

Which to use

If you need…UseWhy
A free API that stays freeGroqNo card, no expiry, fixed published limits
Fast replies in a chat UIGroq openai/gpt-oss-20b0.35 s first token, ~700 tok/s in our test
A stronger open model, still freeGroq openai/gpt-oss-120bSame model Cerebras sells, at $0
Long documents (100K+ tokens)Gemini gemini-3.5-flash-lite1M-token window; Groq's 8K tokens/minute blocks long prompts
Images, PDFs, audio or videoGeminiThe only one of the three with full multimodal input
A big batch job for a few weeks, card on fileCerebras trial1M tokens/day and 30K tokens/minute on gpt-oss-120b

Get your keys

One client for all three

All three accept the OpenAI SDK, including Gemini through its /v1beta/openai/ endpoint — no Google SDK needed. (Older versions of this page used the google-generativeai package, which Google has deprecated.)

import os
from openai import OpenAI

PROVIDERS = {
    "groq":     ("https://api.groq.com/openai/v1", "GROQ_API_KEY", "openai/gpt-oss-120b"),
    "gemini":   ("https://generativelanguage.googleapis.com/v1beta/openai/", "GEMINI_API_KEY", "gemini-3.5-flash-lite"),
    "cerebras": ("https://api.cerebras.ai/v1", "CEREBRAS_API_KEY", "gpt-oss-120b"),
}

def ask(provider, prompt, model=None):
    base_url, key_env, default_model = PROVIDERS[provider]
    client = OpenAI(api_key=os.environ[key_env], base_url=base_url)
    resp = client.chat.completions.create(
        model=model or default_model,
        messages=[{"role": "user", "content": prompt}],
    )
    return resp.choices[0].message.content

print(ask("groq", "Explain rate limiting in two sentences."))

Route each request to the provider that fits

def smart_complete(prompt, has_media=False):
    est_tokens = len(prompt) / 4          # rough: ~4 characters per token
    if has_media or est_tokens > 6000:
        # Gemini: multimodal and a 1M window. Groq's 8K tokens/minute
        # counts prompt + max_tokens, so long prompts don't fit there.
        return ask("gemini", prompt)
    try:
        return ask("groq", prompt)        # free, no expiry
    except Exception:
        return ask("gemini", prompt)      # fall back on 429 / 5xx

Gemini's free Flash models return 503 "high demand" often enough that anything calling them needs a retry with back-off, and gemini-3.5-flash-lite is the safer default.

OpenClaw: Groq and Gemini in one config

OpenClaw takes several providers in one file, so you can default to Groq and switch to Gemini for long context. Save as ~/.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)",
            "reasoning": true, "contextWindow": 131072, "maxTokens": 8192 },
          { "id": "openai/gpt-oss-20b", "name": "GPT-OSS 20B (Groq)",
            "reasoning": true, "contextWindow": 131072, "maxTokens": 8192 }
        ]
      },
      "gemini": {
        "baseUrl": "https://generativelanguage.googleapis.com/v1beta/openai/",
        "apiKey": "YOUR_GEMINI_API_KEY",
        "api": "openai-completions",
        "models": [
          { "id": "gemini-3.5-flash-lite", "name": "Gemini 3.5 Flash-Lite",
            "reasoning": true, "input": ["text", "image"],
            "contextWindow": 1048576, "maxTokens": 65536 }
        ]
      }
    }
  },
  "agents": {
    "defaults": { "model": { "primary": "groq/openai/gpt-oss-120b" } }
  }
}

Keep maxTokens modest on Groq: its 8K tokens/minute limit counts the max_tokens you request, not just what the model writes. If you have a Cerebras trial, add it as a third provider with the same gpt-oss-120b ID and base URL https://api.cerebras.ai/v1.

Caveats

  • These change often. Between August and September 2026 Groq dropped two Qwen/compound models, Cerebras dropped Gemma 4 from its public endpoint (its no-card tier had already ended in July), and Google closed Gemini 2.5 to new users. Check /models and send one small request before you build on a model.
  • Gemini's limits aren't published. Google's rate-limits page says they "can be viewed in Google AI Studio", per project. Any RPM/RPD table for Gemini you find elsewhere is either old or someone else's project.
  • One run per model. Our speed figures are single streamed requests from one US location on one day; Groq and Gemini both vary with load. The raw results are in the benchmark repo.
  • Cerebras speeds are the vendor's. We'll measure them if Cerebras brings back a no-card tier.

FAQ

Is Cerebras still free?

Not without a card. New accounts get $5 of credit after adding a verified payment method, and it expires after 30 days. You aren't charged unless you buy more credit, but there is no ongoing free tier.

Is Groq faster than Cerebras?

By Cerebras' own figures, no: it publishes ~3,000 tok/s for gpt-oss-120b, against the 470 tok/s we measured on Groq's free plan. But Groq's speed is available at $0 with no card and no expiry, and for most chat or agent use 470 tok/s is already faster than a person reads.

Which Gemini model should I use for free?

gemini-3.5-flash-lite. It answered every call in our tests and streamed at 278 tok/s. gemini-3.5-flash works but returns 503 "high demand" often, and every gemini-2.5-* ID returns 404 on new keys.

Can I use one SDK for all three?

Yes — the OpenAI SDK. Change base_url, the key and the model ID, as in the code above.

Verdict

Start with Groq: it is the only one of the three that is free with no card and no end date, and it serves the same gpt-oss-120b that Cerebras charges for. Add Gemini (gemini-3.5-flash-lite) when you need long documents or images — it's free too, just less predictable. Consider Cerebras only if you're willing to put a card on file and want its speed for a 30-day batch job.

More detail on each: Groq free API tested · Cerebras API: the free tier now needs a card · Google Gemini free API tested · Free AI APIs compared