In 2026, the gap between a slow free API and a fast one is the difference between an AI tool that feels broken and one that feels like magic. Groq and Gemini still offer free access with no credit card; Cerebras closed its permanent free tier and now runs a 30-day, $5-credit trial that requires a verified payment method. All three still make GPT-4o feel sluggish — but they're fast in different ways for different reasons. Here's what the numbers mean and when to pick each.

What "Speed" Actually Means

• Time to First Token (TTFT): how long before the first word — critical for chat and streaming UX.
• Throughput (tokens/second): how fast the full response arrives — critical for agent loops and long outputs.
• Daily throughput capacity: tokens/day × speed — how much work you get done for free in 24 hours.

Groq's LPU is built for raw throughput. Cerebras' Wafer-Scale Engine eliminates the memory-bandwidth bottleneck. Gemini optimizes for scale with very generous daily limits. Which metric you care about decides the winner.

The Three Providers

Groq (LPU) — custom Language Processing Units built for sequential token generation. Free tier delivers 300–800 tokens/s: Llama 3.3 70B around 300–500 tokens/s, the 8B model 1,500–2,000 tokens/s. 16+ models including reasoning models like DeepSeek R1.

Cerebras (WSE-3) — a chip the size of a dinner plate, with enough on-chip SRAM to hold Llama 3.1 70B weights, so no external memory fetches. Roughly ~2,100 tokens/s on 8B, ~450–500 on 70B. The catch is no longer the daily cap — it's access. Cerebras' docs answer “is there a permanently free tier?” with a flat no: the Free Trial is $5 in credits, granted only after you add a verified payment method, expiring 30 days later. Within it, gpt-oss-120b allows 5 RPM / 30K TPM / 1M TPD. For short, latency-sensitive completions nothing public is faster — but you can't run on it for free indefinitely.

Google Gemini — not chasing raw throughput. Gemini 2.5 Flash runs ~100–200 tokens/s but ships a 1M-token context window, multimodal input (image, audio, video, docs), 1,500 requests/day, and 1M tokens/minute. Gemini 2.5 Pro is available on the free tier (limited). It wins on capability per dollar, not speed.

Speed Benchmarks

Real-world observed numbers from hands-on testing, not marketing claims. Speeds vary by load, model, and prompt length.

Speeds are approximate; Cerebras and Groq both slow down during peak hours. The throughput figures above were measured on the earlier Llama lineup — Cerebras now serves gpt-oss-120b and gemma-4-31b instead, so treat them as an indication of what the hardware does, not a current benchmark. Raw speed ranking: Cerebras > Groq > Gemini — but speed isn't the only metric.

Free Tier Rate Limits

Raw speed means nothing if you hit a limit every few minutes.

Practically: Groq's Free Plan is the only one of the three you can plan a daily workload against, and even that is 1,000 requests/day per chat model — the 14,400 RPD figure that circulates for Groq now applies only to the tiny llama-prompt-guard classifiers, not to gpt-oss or qwen. Gemini publishes no free RPD at all; its rate-limits page just tells you to check AI Studio, so treat 429 as a normal path rather than a number you can budget. And Cerebras is a 30-day evaluation, not a free tier — fast enough to be worth the trial, wrong to build on.

Which Wins for Your Use Case

Two notes: for agent loops, Cerebras is fastest per call but is now a 30-day trial rather than a free tier, so a long-running agent has to move off it — Groq's Free Plan is the only one of the three you can point an agent at indefinitely, within 30 RPM and 1,000 requests/day. And for anything with long documents, images, or hard reasoning, Gemini's 1M context and multimodal support are in a different category entirely.

Get Your API Keys (5 minutes, no card)

• Groq — console.groq.com → API Keys → Create API Key
• Cerebras — cloud.cerebras.ai → API Keys → Create new API key
• Gemini — Google AI Studio → Create API key

Benchmark It Yourself

Don't take the numbers on faith. This script measures tokens/second across all three at once:

import time, os
from openai import OpenAI
import google.generativeai as genai

groq_client = OpenAI(api_key=os.environ["GROQ_API_KEY"],
                     base_url="https://api.groq.com/openai/v1")
cerebras_client = OpenAI(api_key=os.environ["CEREBRAS_API_KEY"],
                         base_url="https://api.cerebras.ai/v1")
genai.configure(api_key=os.environ["GEMINI_API_KEY"])
gemini_model = genai.GenerativeModel("gemini-2.0-flash")

TEST_PROMPT = (
    "Write a detailed explanation of how transformer attention mechanisms work, "
    "including scaled dot-product attention, multi-head attention, and positional "
    "encodings. Include Python code examples where relevant."
)

def benchmark_openai_compatible(client, model_id, name):
    print(f"n[{name}] Starting benchmark...")
    start, first, tokens = time.time(), None, 0
    stream = client.chat.completions.create(
        model=model_id,
        messages=[{"role": "user", "content": TEST_PROMPT}],
        stream=True, max_tokens=800)
    for chunk in stream:
        delta = chunk.choices[0].delta.content
        if delta:
            if first is None:
                first = time.time()
                print(f"  Time to first token: {first - start:.3f}s")
            tokens += len(delta.split())
    elapsed = time.time() - start
    tps = tokens / elapsed if elapsed > 0 else 0
    print(f"  Total time: {elapsed:.2f}s")
    print(f"  ~{tps:.0f} words/s (~{tps * 1.3:.0f} tokens/s)")

def benchmark_gemini():
    print("n[Gemini] Starting benchmark...")
    start, first, tokens = time.time(), None, 0
    for chunk in gemini_model.generate_content(TEST_PROMPT, stream=True):
        if chunk.text:
            if first is None:
                first = time.time()
                print(f"  Time to first token: {first - start:.3f}s")
            tokens += len(chunk.text.split())
    elapsed = time.time() - start
    tps = tokens / elapsed if elapsed > 0 else 0
    print(f"  Total time: {elapsed:.2f}s")
    print(f"  ~{tps:.0f} words/s (~{tps * 1.3:.0f} tokens/s)")

benchmark_openai_compatible(groq_client, "openai/gpt-oss-120b", "Groq")
benchmark_openai_compatible(cerebras_client, "llama-3.3-70b", "Cerebras")
benchmark_gemini()

Run it several times and average — results swing a lot with time of day and server load.

Use All Three: Route by Task

The real power move is stacking all three free tiers and routing each request to the provider that fits it:

import os
from openai import OpenAI
import google.generativeai as genai

cerebras = OpenAI(api_key=os.environ["CEREBRAS_API_KEY"],
                  base_url="https://api.cerebras.ai/v1")
groq = OpenAI(api_key=os.environ["GROQ_API_KEY"],
              base_url="https://api.groq.com/openai/v1")
genai.configure(api_key=os.environ["GEMINI_API_KEY"])
gemini = genai.GenerativeModel("gemini-2.0-flash")

def smart_complete(prompt, has_image=False,
                   expect_long_context=False, need_reasoning=False):
    # Multimodal: only Gemini
    if has_image:
        return gemini.generate_content(prompt).text

    estimated_tokens = len(prompt.split()) * 1.3
    # Long context: Groq (128K) or Gemini (1M)
    if estimated_tokens > 8000 or expect_long_context:
        if estimated_tokens > 100_000:
            return gemini.generate_content(prompt).text
        return groq.chat.completions.create(
            model="openai/gpt-oss-120b",
            messages=[{"role": "user", "content": prompt}]
        ).choices[0].message.content

    # Complex reasoning: Groq's DeepSeek R1
    if need_reasoning:
        return groq.chat.completions.create(
            model="deepseek-r1-distill-llama-70b",
            messages=[{"role": "user", "content": prompt}]
        ).choices[0].message.content

    # Default: Cerebras for maximum speed on short prompts
    try:
        return cerebras.chat.completions.create(
            model="llama-3.3-70b",
            messages=[{"role": "user", "content": prompt}]
        ).choices[0].message.content
    except Exception:
        # Fallback to Groq if Cerebras hits daily limits
        return groq.chat.completions.create(
            model="openai/gpt-oss-120b",
            messages=[{"role": "user", "content": prompt}]
        ).choices[0].message.content

One Config, Three Providers in OpenClaw

OpenClaw supports multiple providers in a single config, so you can switch with a model flag and get a free coding agent with the best provider per task:

{
  "models": {
    "mode": "merge",
    "providers": {
      "cerebras": {
        "baseUrl": "https://api.cerebras.ai/v1",
        "apiKey": "YOUR_CEREBRAS_API_KEY",
        "api": "openai-completions",
        "models": [
          { "id": "llama-3.3-70b",
            "name": "Llama 3.3 70B (Cerebras - Ultra Fast)",
            "contextWindow": 8192, "maxTokens": 4096 }
        ]
      },
      "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 - Long Context)",
            "contextWindow": 131072, "maxTokens": 65536 },
          { "id": "openai/gpt-oss-20b",
            "name": "GPT-OSS 20B (Groq - Fastest)",
            "contextWindow": 131072, "maxTokens": 65536 }
        ]
      }
    }
  },
  "agents": {
    "defaults": { "model": { "primary": "cerebras/llama-3.3-70b" } }
  }
}

Save to ~/.openclaw/openclaw.json. Default to Cerebras for fast short tasks; switch to groq/openai/gpt-oss-120b when context exceeds 8K, or groq/openai/gpt-oss-20b for the fastest throughput Groq offers. Groq's Llama models are no longer self-serve — as of August 2026 both llama-3.1-8b-instant and llama-3.3-70b-versatile are listed as Enterprise, with "Contact Sales" in place of a price.

Don't Forget Model Quality

Speed can obscure a truth: Groq and Cerebras both serve Llama 3.3 70B — strong, but not state-of-the-art. Gemini 2.5 Flash and Pro are measurably better on complex coding and reasoning. A 5x faster response doesn't help if the answer is wrong. For high-stakes work, model quality beats throughput; for summarization, classification, extraction, and short code, Llama 70B is plenty and the speed edge dominates.

Honest Caveats

• Cerebras: no permanent free tier — $5 of credits, 30-day expiry, and a verified payment method required before they're granted; the trial allows 5 RPM / 30K TPM / 1M TPD on gpt-oss-120b; text-only; US-centric infra means higher latency from Asia/Europe.
• Groq: per-model rate limits (reusing one model burns its quota faster); marketed speeds are best-case, not sustained during peak hours.
• Gemini: noticeably slower throughput; Gemini 2.5 Pro on free tier has very restricted limits (2 RPM as of early 2026); Google has historically been unpredictable about free API access, and its API differs from OpenAI's in places (system instructions, JSON mode).

The Verdict

If you use only one, pick Groq: 30 RPM and 1,000 requests/day per chat model on the Free Plan, no card, fully OpenAI-compatible — it handles 90% of use cases with no awkward trade-offs. Add Cerebras for maximum raw speed on short prompts (real-time chat, voice AI, agent tool calls). Add Gemini for long documents, images, or hard reasoning. Two of the three (Groq and Gemini) cost nothing and need no card, so routing by task is still the cheapest setup available — just treat Cerebras as an evaluation rather than a permanent leg of it.

Go deeper on each provider:

• Groq Free API Tested: ~525 tok/s + What You Can Build
• Cerebras Inference API: The Fastest Free AI API You've Never Heard Of
• Google Gemini Free API Tested: 34s to First Token
• Free AI APIs in 2026: We Tested 10, Four Now Want a Card