Cerebras Pricing: Actual Rate Limits, Per-Token Cost & Enterprise Tiers (2026)

Actual Cerebras Rate Limits by Tier (June 2026)

This is the table the pricing page does not show. Numbers below come from the official Cerebras rate-limit docs. Limits are per model and vary by account, so the docs tell you to confirm in the Limits section of your dashboard. RPM is requests per minute, TPM is tokens per minute, TPD is tokens per day.

The Developer tier removes the hourly and daily caps entirely: you pay per token and the only ceiling is the per-minute rate. That is the tier you need to evaluate Cerebras for real agent traffic. Enterprise rate limits are not published; they are set in the contract (see What Enterprise Unlocks).

Cerebras Per-Token Pricing

All prices per million tokens (MTok). Cerebras runs open-weight models only, no proprietary or self-serve fine-tuned variants (Enterprise customers can bring custom weights). The actively benchmarked catalog has narrowed: as of June 2026, Artificial Analysis tracks only gpt-oss-120b and GLM-4.7 on Cerebras, and Cerebras Code migrated from Qwen3 Coder to GLM-4.7. Verify any specific model in the Cerebras models docs before building on it.

For comparison, Anthropic's Claude Sonnet sits around $3.00 input / $15.00 output per MTok. GLM-4.7 on Cerebras is roughly an order of magnitude cheaper on output while, by Cerebras's own benchmark claims, landing comparable code-generation quality. Cerebras frames this as ~10x price-performance versus Sonnet 4.5 once you account for speed.

Speed Benchmarks: Measured vs Advertised

Cerebras competes on throughput, and the throughput is genuinely faster than GPU clusters. But there is a gap between the marketing number and what people measure. The figures below are from Artificial Analysis independent benchmarks, June 2026.

For context, a typical GPU provider delivers 50-200 tok/s on a model this size. At ~1,800 tok/s, gpt-oss-120b is roughly 10-30x faster. That advantage is real and it is the reason to use Cerebras. The honesty caveat: the 2,000-2,500 tok/s headlines Cerebras advertised on earlier models do not match what most testers see today on the current lineup.

Why Wafer-Scale Is Fast

The speed comes from hardware architecture, not software tricks. GPU inference is bottlenecked by memory bandwidth: model weights live in HBM, and the GPU spends most of its time waiting for data to arrive. NVIDIA's H100 has about 3.35 TB/s of memory bandwidth. Fast, but still the limiting factor for inference.

Cerebras' WSE-3 (Wafer-Scale Engine, third generation) takes a different approach. Instead of a small chip that shuttles data from external memory, it is a single silicon wafer the size of a dinner plate: 46,255 mm², 4 trillion transistors, 900,000 AI cores. The key number: 44 GB of SRAM sits directly on the chip, co-located with compute. No off-chip memory fetch. No bandwidth wall.

The 44 GB of on-chip SRAM is roughly 1,000x more than an H100's on-chip memory. During inference, model parameters are already positioned next to the cores that need them. The result is 21 petabytes per second of aggregate memory bandwidth across the wafer, compared to 3.35 TB/s on an H100. That 6,000x bandwidth advantage is why a single Cerebras system outperforms racks of GPUs on inference throughput.

The tradeoff: 44 GB of SRAM constrains which models fit on a single chip. Dense models larger than roughly 70B parameters require model parallelism or mixture-of-experts architectures where active parameters stay within SRAM capacity. This is why Cerebras'fastest current result is gpt-oss-120b, an MoE model whose active parameters per forward pass are far smaller than its total parameter count.

Cerebras Code: $50 and $200 Subscription Plans

Separate from the API, Cerebras sells flat-rate coding subscriptions that work with IDE agents like Cline, RooCode, OpenCode, and Crush. Both plans now run on GLM-4.7 (they previously used Qwen3 Coder) with a 131K context window, at up to ~1,000 tok/s. Numbers below are from the Cerebras Code FAQ.

The value math is simple at the daily-token level. At GLM-4.7 API pricing, $50 of pay-per-token buys roughly 18-20M tokens once. Code Pro gives you 24M tokens per day. For anyone coding full-time on Cerebras models, the subscription is far cheaper than metered API usage. The catch is that the daily ceiling and the per-minute throttle, not the price, are what you actually run into.

Two more realities: the plans have repeatedly sold out, and you are locked to Cerebras's model selection. No Claude, no GPT-5.x, no Gemini. The subscription supplements your other providers, it does not replace them.

The Limits That Bite (From People Who Hit Them)

The published caps look generous until you map them to how an agent actually behaves. These are the failure modes developers report most, with the numbers that cause them.

None of these are dealbreakers. They are the difference between reading the pricing page and knowing what you signed up for. The two that surprise people most: the per-minute throttle bites long before the daily budget does, and the dashboard's local-time display against UTC resets makes quota math confusing.

What Enterprise Actually Unlocks

Enterprise is contact-sales only, and Cerebras does not publish the numbers. What the tier includes, per the pricing page:

The negotiation levers people actually use: committed-volume pricing below the public per-token rates, a guaranteed-throughput SLA instead of best-effort shared capacity, and dedicated wafer-scale capacity so you are not competing for the per-minute pool during US working hours. If your workload is production and throughput-sensitive, the dedicated queue is the real reason to move off self-serve, not the price.

Cerebras vs Groq: Speed and Price

Groq is the other name in fast inference, built on custom LPU (Language Processing Unit) silicon. Both companies position themselves as alternatives to GPU-based inference. But the performance profiles differ.

Groq is cheaper per token. Cerebras is roughly 4x faster on sustained throughput. The question is which metric matters for your workload. For throughput-sensitive work (generating large amounts of code, running agent loops), Cerebras's higher per-token price is offset by speed. For short, latency-sensitive requests where time-to-first- token matters more than sustained throughput, Groq is competitive, and its 0.52s vs Groq's lower TTFT is close.

Cerebras vs Fireworks vs Together AI

Fireworks and Together AI run inference on GPU clusters (A100, H100, B200). They compete on price and model breadth rather than raw speed. Both support a wider range of models than Cerebras, including fine-tuned variants and custom deployments.

The pattern is clear. Cerebras and Groq trade price for speed using custom silicon. Fireworks and Together AI offer broader model selection and fine-tuning on GPU infrastructure at competitive per-token rates but 10-20x lower throughput. For production systems that need specific fine-tuned models, Fireworks or Together AI may be the only option. For speed-critical workloads on supported open-source models, Cerebras is in a category of its own.

When Speed Pays for Itself: Coding Agents

A coding agent does not make one LLM call. It makes dozens. Read a file, generate code, run tests, read the error, fix the code, run tests again, read more files, refactor. Each step waits for the previous step's output before it can proceed. This is a serial workload where inference speed directly maps to developer wait time.

Consider a 10-step agent loop where each step generates 2,000 output tokens, using Cerebras's measured ~1,800 tok/s on gpt-oss-120b (not the advertised peak):

11 seconds versus 4 minutes. That is not a marginal improvement. It changes how developers interact with agents. At 11 seconds, you stay in flow. At 4 minutes, you context-switch to something else and lose the thread.

The cost comparison for this loop (20,000 total output tokens on gpt-oss-120b): Cerebras at $0.75/MTok output = $0.015. Groq at $0.60/MTok output = $0.012. A GPU provider lands in the same range. The price difference is a fraction of a cent. The time difference is roughly 10x.

Frequently Asked Questions

What are the actual Cerebras free tier rate limits?

Per the official rate-limit docs (June 2026): 5 requests per minute, 30K tokens per minute, 1M tokens per day, on gpt-oss-120b and GLM-4.7 only. No credit card. Older guides still cite 30 RPM, which appears deprecated. At 5 RPM the free tier is for one-at-a-time evaluation, not agent loops.

How much does Cerebras inference cost?

gpt-oss-120b costs $0.35 input / $0.75 output per MTok (~$0.39 blended). GLM-4.7 costs $2.25 input / $2.75 output (~$2.30 blended). The Developer (pay-as-you-go) tier starts at $10. Output is roughly an order of magnitude cheaper than Claude Sonnet's $15/MTok.

How fast is Cerebras inference, really?

Artificial Analysis (June 2026) measures gpt-oss-120b at ~1,812 tok/s and GLM-4.7 at ~1,008 tok/s. Cerebras advertises up to 2,000+ tok/s, but independent testers and Cerebras Code users report sustained speeds closer to 1,000 tok/s, sometimes under 500 tok/s on long runs once per-minute throttling kicks in.

Is Cerebras faster than Groq?

On sustained throughput, yes, by roughly 4x on gpt-oss-120b. Independent benchmarks from Artificial Analysis confirm this. Groq is cheaper per token and has competitive time-to-first-token, but Cerebras leads on tokens-per-second output.

What models does Cerebras serve?

As of June 2026, the actively benchmarked catalog is gpt-oss-120b and GLM-4.7, both at 131K context. Older Llama 3.x/4.x and Qwen3 variants have appeared, but the public lineup has narrowed and Cerebras Code migrated from Qwen3 Coder to GLM-4.7. No Claude, no GPT-5.x, no Gemini. Enterprise customers can bring custom weights. Current model list.

What does the Cerebras Enterprise tier unlock?

Contact-sales only, with no published numbers. It unlocks the highest rate limits with a dedicated queue (lowest latency), custom model weights, fine-tuning and training services, custom per-token rates, and a dedicated support team with an SLA. The dedicated queue is the real reason to move off self-serve: it is the only way past the per-minute throttle.

How does Cerebras Code Pro compare to the API?

Code Pro ($50/month) includes 24M tokens per day, 1,000 messages/day, running on GLM-4.7. At GLM-4.7 API pricing, $50 of pay-per-token buys roughly 18-20M tokens once; Code Pro gives you 24M every day. Far cheaper for heavy usage. Code Max ($200/month) provides 120M tokens/day and 5,000 messages/day. Both work with Cline, RooCode, OpenCode, and similar IDE agents, and both have repeatedly sold out.

Why is Cerebras inference so fast?

The WSE-3 chip packs 900,000 cores and 44 GB of SRAM on a single wafer. Model weights live in on-chip memory next to compute cores, eliminating the memory bandwidth bottleneck that limits GPU inference. The chip delivers 21 petabytes per second of memory bandwidth, roughly 6,000x more than an H100. More bandwidth, less waiting, faster token generation.

Should I use Cerebras for coding agents?

If your agent workflow runs on open-source models and speed is a priority, yes. Cerebras is the fastest inference provider available. The 10x speed advantage over GPU providers means agent loops complete in seconds instead of minutes. The limitation is model selection: no proprietary models, no fine-tuning on Developer tier. Most production agent systems use Cerebras for speed-critical calls and a proprietary provider for capability-critical calls. Morph helps route between providers based on task requirements.