Cerebras Systems builds the Wafer-Scale Engine — a chip the size of a dinner plate with 4 trillion+ transistors. Less known is that it also runs a free cloud inference API that outpaces Groq on smaller models and rivals it on 70B-class ones. No credit card, OpenAI-compatible endpoint, benchmarks that speak for themselves.

Why Cerebras is so fast

On a GPU cluster, model weights live in external HBM, and every generated token pulls weights from that memory — the bandwidth bottleneck that caps GPU inference around 100-150 tokens/second. The Cerebras WSE-3 (46,225 mm², 57× larger than the biggest GPU die) fits an entire Llama 3.1 70B in on-chip SRAM. No external fetch, no bottleneck. The result: Llama 3.1 8B at ~2,100 tokens/s, 70B at ~450-500 tokens/s — versus Groq's ~300-500 on 70B and GPT-4o's ~50-100.

Why we have no measured number for Cerebras

We benchmark every free AI API we write about, from the same machine with the same method, and publish the raw results in an open repo. Cerebras is the one platform in our comparison set we could not measure, for a simple reason: getting a working key now requires a payment method, and our test rig deliberately only uses tiers that need no card.

So the widely-quoted "~2,100 tokens/second" figure in this article — and in every other article about Cerebras — comes from Cerebras, not from us. It is plausible; their hardware is unusual and independent testers have reported similar. But we haven't verified it ourselves, and we'd rather say so than present a vendor number as a measurement.

What we did measure, on free-and-no-card tiers, in August 2026:

If speed matters and you want to avoid a card, Groq is the measured answer. If you're willing to add payment details, Cerebras is worth benchmarking yourself for your own workload — and our harness is open if you'd like to run the same test.

Models and rate limits

Model availability changes — check the Cerebras Cloud Console for the current list. The free tier: 30 RPM, 60,000 TPM, ~900 RPD, no credit card. The 60,000 tokens/minute is unusually generous; interactive workloads rarely hit it.

Get a key and make your first call

Sign up at cloud.cerebras.ai (email, Google, or GitHub), open API Keys → Create new API key, and copy it (shown once). No billing form. The official SDK:

pip install cerebras-cloud-sdk

from cerebras.cloud.sdk import Cerebras

client = Cerebras(api_key="YOUR_CEREBRAS_API_KEY")
response = client.chat.completions.create(
    model="llama-3.3-70b",
    messages=[{"role": "user", "content": "Write a Python function that checks if a number is prime"}],
)
print(response.choices[0].message.content)

Because Cerebras is fully OpenAI-compatible, existing projects just change the base URL and model name — no rewrite:

from openai import OpenAI

client = OpenAI(api_key="YOUR_CEREBRAS_API_KEY", base_url="https://api.cerebras.ai/v1")
response = client.chat.completions.create(
    model="llama-3.3-70b",
    messages=[{"role": "user", "content": "PostgreSQL vs SQLite — main differences?"}],
)
print(response.choices[0].message.content)

Streaming (stream=True), async (AsyncCerebras), and JSON mode (response_format={"type": "json_object"}) all work with the standard parameters. The endpoint config for any language: base URL https://api.cerebras.ai/v1, header Authorization: Bearer YOUR_KEY, chat at POST /v1/chat/completions. That makes it a drop-in for LangChain, LlamaIndex, LiteLLM, OpenWebUI, and more. Via LiteLLM it's one line — model="cerebras/llama-3.3-70b" — which also makes switching between Cerebras, Groq, and OpenAI effortless.

Cerebras vs Groq: which free API is faster?

The honest verdict: Cerebras wins (or ties) on raw throughput and TPM for prompts that fit in 8K; Groq wins decisively on context (128K vs 8K), daily volume (14,400 vs ~900 RPD), and model variety. The practical move is to keep both keys — Cerebras for short, frequent, speed-critical completions; Groq when you need long context or higher daily limits. See our Groq free API guide for the other half of that pairing.

A practical multi-provider fallback

Route short, latency-sensitive calls to Cerebras and fall back to Groq for long context or when limits are exhausted:

from openai import OpenAI
import os

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

def smart_complete(prompt, max_context_tokens=4000):
    if len(prompt.split()) * 1.3 < max_context_tokens:
        try:
            r = cerebras.chat.completions.create(
                model="llama-3.3-70b", messages=[{"role": "user", "content": prompt}])
            return r.choices[0].message.content
        except Exception:
            pass  # fall through to Groq on rate limit or error
    r = groq.chat.completions.create(
        model="openai/gpt-oss-120b", messages=[{"role": "user", "content": prompt}])
    return r.choices[0].message.content

You can also connect Cerebras to a custom-endpoint agent like OpenClaw (select "Custom OpenAI-compatible", base URL https://api.cerebras.ai/v1, default model llama-3.3-70b) for an agent whose replies feel near-instant.

Where Cerebras shines

• Real-time chat — 2,100 tok/s makes even the 8B model feel alive versus a laggy GPU-backed chat.
• Agentic tool-calls — dozens of short completions (intent, extraction, branching); at ~100ms each the agent loop runs several times faster.
• Voice pipelines — LLM latency is the bottleneck in STT→LLM→TTS; streaming the first tokens to TTS gets near-human response times.
• Batch annotation — 60,000 TPM plus raw throughput processes far more records per hour than GPU providers.

Limitations to know

• 8K context — the biggest practical limit; you can't feed a large codebase or long document. Use Gemini (1M) or Groq (128K) for that.
• Text only — no vision or multimodal as of 2026.
• Fewer models (4-6 vs Groq's 16+) and lower ~900 RPD — high-volume production hits this quickly.
• Inference-only (no fine-tuning) and US-centric infrastructure, so Asia/Europe users see network round-trip latency on top of the fast inference.

FAQ

Is the Cerebras API really free?

Yes — no credit card, with 30 RPM / 60,000 TPM / ~900 RPD on the free tier, across Llama 3.1/3.3 and Qwen models. It's inference-only.

Is Cerebras faster than Groq?

On short prompts, yes or tied — ~2,100 tok/s on 8B and higher TPM. Groq wins on context (128K vs 8K), daily volume (14,400 vs ~900 RPD), and model count. Keep both.

Does it work with the OpenAI SDK?

Yes. Point the OpenAI SDK at https://api.cerebras.ai/v1 with your Cerebras key and a Cerebras model name. Streaming, async, and JSON mode all work with standard parameters, so it drops into LangChain, LiteLLM, OpenWebUI, and similar tools.

What's the catch?

The 8K context window. Cerebras is built for short, latency-critical completions, not long documents or extended histories.

Final thoughts

Cerebras is the best-kept secret in free AI APIs: while everyone talks about Groq, it quietly delivers the fastest raw inference on the market, powered by genuinely unusual hardware. The 8K context is a real limit, so it isn't the tool for every job — but for real-time chat, agent tool-calls, voice pipelines, and developer tools, 2,100 tokens/second at zero dollars is hard to beat. Get a key at cloud.cerebras.ai. To compare all the best free AI APIs side by side, see Free AI APIs in 2026: We Tested 10, Four Now Want a Card.