Groq vs Cerebras: Fast Inference Compared

Both sell very fast inference for open models through an API. On the same model, gpt-oss-120b, Groq lists $0.15 input and $0.60 output per million tokens at about 500 tokens a second. Cerebras lists $0.35 and $0.75 at about 3,000 tokens a second. Pick Groq for the wider model list and lower token prices, Cerebras when raw speed is the point. Checked 31 October 2026. Affiliate links on this site go through /go/ and are marked sponsored.

The short version

What each one is

Groq

GroqCloud serves open models on its own inference hardware. Its docs split models into Production (meant for production use) and Preview (evaluation only, may be discontinued at short notice). The production list includes Llama 3.1 8B and Llama 3.3 70B (enterprise, contact sales), OpenAI GPT OSS 120B and 20B, and two Whisper speech models. The preview list includes Qwen3.8-27B, MiniMax M2.7, safety models and text-to-speech models. Hosted models are available through a models API at api.groq.com/openai/v1/models, which tells you the API is OpenAI-style. Our related entry is hosting.

Cerebras

Cerebras sells inference on its own wafer-scale hardware. Its docs describe Cerebras Shared Inference, available on Free Trial and Pay as You Go tiers, and Dedicated Inference for more models and capacity. The shared catalogue we read lists two models: OpenAI gpt-oss-120b and Qwen 3.8 27B. Its pricing page also lists Cerebras through partners: AWS Marketplace, OpenRouter, Hugging Face and Vercel.

The difference in one line: Groq offers more models and speech; Cerebras offers fewer models and higher listed speed.

Models, prices and speed

From each vendor's docs on 31 October 2026. Prices are per million tokens.

Context windows: Groq lists 131,072 tokens for Qwen3.8-27B with 16,384 max output. Cerebras lists 65k on the free tier and 131k on paid for gpt-oss-120b (max output 32k free, 40k paid), and 64K free and 128K paid for Qwen 3.8 27B.

Three notes. First, speeds are vendor figures, not independent tests. Second, Cerebras is about six times faster on gpt-oss-120b by these numbers, but costs more per token. Third, whether speed matters depends on the job: an agent that makes many sequential calls feels it; a batch job does not.

What speed buys you

Tokens per second matter most when a person or an agent waits for the answer. A coding agent that calls a model forty times to finish a task spends most of its wall-clock time waiting. At 500 tokens a second, a 1,000-token reply takes about two seconds; at 3,000, about a third of a second. Over forty calls that is roughly 80 seconds against 13 seconds of generation. These are arithmetic from the listed speeds and ignore network, queueing and the time to read the prompt.

For batch work, such as summarising ten thousand documents overnight, speed matters little and price per token matters most. That is where Groq's lower list price on the same model has the edge. Both vendors also describe slower or cheaper processing options: Groq mentions Batch and Flex processing for higher tiers, and Cerebras describes prompt-caching behaviour in its rate limit rules.

Rate limits and plans

Groq. The model table lists limits for the Developer plan, such as 250K tokens per minute and 1K requests per minute for gpt-oss-120b and Qwen3.8-27B. The docs say to upgrade to the Developer plan for higher limits, Batch and Flex processing. Free-tier limits are listed per model in the rate limits page.

Cerebras. Its docs describe limits as requests per minute, hour and day and tokens per minute, hour and day, where whichever hits first triggers limiting. Its token limits split into uncached tokens per minute, the primary limit, and total tokens per minute at three times that, so cache hits let you push more total tokens through. The pricing page says a valid payment method earns a one-time $5 promotional credit that expires after 30 days, and API access pauses when it is used up unless you buy credits.

Compression and quality

Hosts sometimes shrink models to run faster. Cerebras states it plainly: shared inference serves original, unpruned versions, with selective weight-only quantisation in storage, and it says it will not change a model's architecture under an existing ID without notice.

If you compare answers from the two for the same model, check that they use the same precision and settings. Small differences in output are normal, and a large drop in quality is a signal to ask the vendor.

A worked monthly cost

Take a job that reads 100 million input tokens and writes 10 million output tokens a month on gpt-oss-120b, at the list prices above.

Groq is about half the price on this mix. If faster responses let an agent finish tasks in fewer minutes, the cost per task may favour the faster vendor, but only a test on your own workload shows that. Input-heavy jobs, such as reading large codebases, lean on the input price, which is where the two differ most: $0.15 against $0.35.

Cached input matters too. Cerebras documents that cached tokens do not count toward the uncached limit and that its total limit is three times the uncached one, so an agent that resends the same long prompt gets more throughput from caching.

Test both in an hour

You only need an API key from each and one script.

1. Write ten prompts from your real work, from short questions to long code reviews.
2. Use an OpenAI-style client for both, changing only the base URL, key and model ID. Groq's base is https://api.groq.com/openai/v1.
3. Send the prompts one at a time and record time to first token and total time.
4. Send them in parallel groups of five and ten to see how each handles load and whether rate limits bite.
5. Read the outputs side by side. If you chose the same model on both, they should be close; large differences deserve a question to the vendor.
6. Multiply the token counts by each vendor's prices to get the cost per run.
7. Write down the limits you hit, including context size and requests per minute.

curl https://api.groq.com/openai/v1/chat/completions \
  -H "Authorization: Bearer $GROQ_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model":"openai/gpt-oss-120b","messages":[{"role":"user","content":"Explain this stack trace in two sentences."}]}'

That is the standard OpenAI chat format with Groq's base URL and model ID from its model table. For Cerebras, use its quickstart for the base URL and key, and the model ID gpt-oss-120b from its catalogue.

Choosing a model before choosing a vendor

Both vendors serve the same two families in our comparison, OpenAI's gpt-oss and Alibaba's Qwen, so the first question is which model is good enough for your task. Test the model on a slow, cheap route first. If it passes, then choose a fast vendor. If it fails, no amount of speed will fix it, and you may need a larger or closed model. Our Qwen vs Llama page covers one of the open families, and best open-source LLM for coding lists others.

Using them with agents and apps

Both fit any tool that takes an OpenAI-style base URL. Point a coding agent at the vendor's endpoint, set the model ID, and keep your API key in an environment variable. For agents that need strong multi-step tool use, test the model first: gpt-oss and Qwen are capable open models, but they are not the same as the top closed models. See DeepSeek vs Claude and open vs closed models for how to think about that trade, and OpenRouter alternatives for gateways that route to both vendors.

Privacy and data handling

Both are hosted services, so your prompts go to the vendor. . Cerebras links a Trust Center from its site. For sensitive work, read each vendor's terms for your plan, or self-host an open model; see cloud vs self-hosted AI.

Side-by-side facts

Who should pick which

A developer building a chat or voice product

Groq, for the speech models and text models on one API. Test latency from your region.

A team running a coding agent that makes many calls

Test Cerebras first for speed, then compare cost per finished task. The faster model may cost less overall if it shortens sessions.

A batch or analytics job

Groq on gpt-oss-120b for the lower price, or its Batch option on a higher plan.

A startup comparing providers

Try both on the free routes, then add a gateway so you can switch. Compare other hosts at /compare/hosting/.

A company with data rules

Read terms first; if they do not fit, self-host an open model.

Limits and gotchas

• Vendor speeds. The numbers are the vendors' own. Measure on your prompts.
• Preview models. Groq says preview models may be discontinued at short notice. Do not build production on them.
• Short catalogues. Cerebras's shared list is two models. If you need another, ask about Dedicated Inference.
• Context limits differ by tier. Cerebras free-tier context is half the paid window.
• Enterprise-only models. Some Groq Llama models say contact sales instead of a price.
• Prices change. Re-check before you commit.

Cost and time for one agent task

Take a coding-agent task that makes 40 model calls, each sending 10,000 input tokens and getting back 1,000 output tokens. That is 400,000 input tokens and 40,000 output tokens for the task. The task shape is an example; the prices are the vendors' list prices and speeds for gpt-oss-120b.

Both figures leave out time to first token, network time and the time your own tools take, so real runs are slower on both sides than these numbers. They also assume the listed speeds hold under load, which the vendors do not promise. What the table does show is the trade. Cerebras costs about twice as much per task here and finishes generating about six times sooner. If a person waits on every step, the 67 seconds saved may be worth the extra eight cents. If the agent runs overnight, they are not.

Scale it: a thousand such tasks a month is about $84 on Groq and $170 on Cerebras. At that size the money is small next to the engineer's time, and the speed matters more. At a million tasks the money matters more.

What would change the answer

• Your model is not on both. Groq lists more models, including Whisper and text-to-speech previews. Cerebras's shared catalogue we read had two. If you need a model only one hosts, the comparison is over.
• You hit a rate limit. Groq's Developer plan lists limits such as 250K tokens per minute for gpt-oss-120b. Cerebras splits limits into cached and uncached tokens. An agent that resends a long prefix may fare better where cached tokens are counted separately.
• Your region is far away. Network latency adds to both, and a vendor's speed figure does not include your round trip.
• Your data rules change. Neither page settled retention, so a policy that bars either one ends the test early.
• A model you need is Preview. Groq says preview models may be discontinued at short notice.

Questions people ask

Which is cheaper? On gpt-oss-120b, Groq's list price is lower. On other models the catalogues differ, so compare model by model.

Which is faster? By the vendors' own numbers, Cerebras on gpt-oss-120b. These are not independent measurements.

Can I switch between them without rewriting my code? Both accept OpenAI-style requests, so you change the base URL, key and model ID. Tool-calling behaviour can differ, so rerun your tests after you switch.

Our take

For price and breadth, Groq. For raw speed on a model both host, Cerebras. If your workload is interactive or agentic, speed may decide it. If it is batch, price will.

We did not benchmark either, and the speeds above are vendor claims. Prices and limits come from their docs on 31 October 2026. Run your own prompt set on both, measure time to first token and total time, and compute the cost of a finished task. Keep the code behind an OpenAI-style client so you can switch.

Related pages

• Compare hosting providers
• OpenRouter alternatives
• Qwen vs Llama
• AI hosting