Cerebras API: Fast, But the Free Tier Now Needs a Card

On this page
  1. Why Cerebras is so fast
  2. Why we have no measured number for Cerebras
  3. Models and rate limits
  4. Get a key and make your first call
  5. Cerebras vs Groq: which free API is faster?
  6. A practical multi-provider fallback
  7. Where Cerebras shines
  8. Limitations to know
  9. FAQ
  10. Final thoughts
Quick answer: Cerebras runs inference on wafer-scale hardware and is genuinely among the fastest anywhere — but the no-credit-card free tier is gone. New accounts now get $5 in trial credits that expire after 30 days, and a payment method is required to activate them (Cerebras' own rate-limit docs state that API access stays inactive until you add one). It's still OpenAI-compatible and still very fast; it just isn't free to start any more. For free-with-no-card speed, Groq measured 527 tok/s in our tests.

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 cloud inference API that Cerebras says outpaces Groq on smaller models and rivals it on 70B-class ones. The endpoint is OpenAI-compatible, but since 2026 it stays inactive until you add a payment method (see the quick answer above).

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 the free chat APIs in our comparison set 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:

ProviderGeneration speedCard required?
Groq (gpt-oss-120b)527 tok/sNo
Mistral167 tok/sNo
Google Gemini141 tok/sNo
Cerebrasnot testedYes

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 IDParamsContextSpeed (approx)Best for
llama3.1-8b8B8K~2,100 tok/sMaximum speed, chat, code
llama3.1-70b70B8K~500 tok/sHigher quality, reasoning
llama-3.3-70b70B8K~450 tok/sBest quality on Cerebras
qwen-3-32b32B32K~700 tok/sMultilingual, coding

Model availability changes — check the Cerebras Cloud Console for the current list. The table above is the older lineup: on 2026-10-09 the official rate-limit page listed only gpt-oss-120b and qwen-3.8-27b for the trial tier. The trial tier itself: $5 of credit for 30 days, 5 requests/min, 1M tokens/day, payment method required.

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?

FeatureCerebrasGroq
8B model speed~2,100 tok/s~1,500-2,000 tok/s
70B model speed~450-500 tok/s~300-500 tok/s
Context window8K128K
Free allowance$5 trial credit (30 days), 1M tokens/day1,000 requests/day, 200K tokens/day per model
Rate limit5 requests/min (trial)30 requests/min, 8K tokens/min per model
Models available2 listed for the trial (2026-10-09)4 chat models answered on a free key (2026-10-09)
Vision supportNoLimited (preview)
Credit card requiredYes (payment method)No

The honest verdict: Cerebras claims the edge on raw throughput for prompts that fit in 8K, but it now needs a payment method and its trial is time-limited; Groq wins on context (128K vs 8K), an ongoing no-card free tier, and model choice. The practical move: start on Groq, and add Cerebras only if you are willing to put a card on file for short, speed-critical completions. 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 (2 listed for the trial) and a 5 requests/min trial limit — 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?

Not any more. New accounts get $5 of trial credit that expires after 30 days (5 requests/min, 1M tokens/day), and the API stays inactive until you add a payment method. If you need a free API with no card, see Groq.

Is Cerebras faster than Groq?

Cerebras claims ~2,100 tok/s on 8B models; we have not measured it, because a working key now requires a card. Groq, which we did measure (527 tok/s on gpt-oss-120b), wins on context (128K vs 8K) and its no-card free tier.

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 runs some of the fastest inference hardware on the market. The 8K context is a real limit, so it isn't the tool for every job — and since 2026 it is no longer free: after the $5, 30-day trial you pay, and a card is required from the start. For a no-card free tier, Groq is the measured alternative. 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.