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

Actual Cerebras Rate Limits by Tier (October 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.

Cerebras now meters two token buckets per organization. Uncached TPM counts cache misses and is the binding limit; total TPM counts cached plus uncached tokens and defaults to 3x the uncached number (Qwen 3.8 27B is temporarily at 5x on the Developer tier). Cached prompt tokens only draw from the total bucket, so an agent that resends the same long system prompt gets far more throughput from the same plan, and a 429 response names the bucket you exceeded.

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 shared catalog has narrowed to two models: as of October 2026 the Cerebras docs list gpt-oss-120b and Qwen 3.8 27B. GLM-4.7 left the per-token API but still runs Cerebras Code, and other model families are sold through Dedicated Inference. Verify any specific model in the Cerebras models docs before building on it.

For comparison, Anthropic's Claude Sonnet 5.5 lists at $2 input / $10 output per MTok. Qwen 3.8 27B on Cerebras costs less than a sixth of that on output, and gpt-oss-120b about a thirteenth, with both running several times faster than GPU-hosted APIs.

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, when GLM-4.7 was still on the shared API. Cerebras' own catalog now lists ~3,000 tok/s for gpt-oss-120b and ~1,850 tok/s for Qwen 3.8 27B.

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 caveat: the ~3,000 tok/s figure Cerebras now lists for gpt-oss-120b sits well above the ~1,800 tok/s Artificial Analysis measured, and most testers see the lower number.

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 run on GLM-4.7 (they previously used Qwen3 Coder), at up to ~1,000 tok/s. On October 2, 2026 the Cerebras Code page showed Pro and Max as sold out. Numbers below are from the Cerebras Code FAQ.

The value math is simple at the daily-token level. At the last published GLM-4.7 API price ($2.25/$2.75), $50 bought 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 (October 2026): 5 requests per minute, 30K uncached tokens per minute, 1M tokens per day, on gpt-oss-120b and qwen-3.8-27b. The trial runs on a one-time $5 credit that needs a payment method and expires after 30 days; Cerebras has no permanently free tier. At 5 RPM the trial suits one-at-a-time evaluation rather than agent loops.

How much does Cerebras inference cost?

gpt-oss-120b costs $0.35 input / $0.75 output per MTok and Qwen 3.8 27B costs $0.99 input / $1.49 output. The first credit purchase moves you to the Developer (pay-as-you-go) tier. Output on gpt-oss-120b is about a thirteenth of Claude Sonnet 5.5's $10/MTok.

How fast is Cerebras inference, really?

Artificial Analysis (June 2026) measured gpt-oss-120b at ~1,812 tok/s and GLM-4.7 at ~1,008 tok/s. Cerebras lists ~3,000 tok/s for gpt-oss-120b, 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 October 2026, shared inference lists gpt-oss-120b (65K context on the trial, 131K paid) and Qwen 3.8 27B (64K / 128K). GLM-4.7 left the per-token API but still powers Cerebras Code. Other open-weight families run on Dedicated Inference, and Enterprise customers can bring custom weights. Claude, GPT, and Gemini are not available. 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 the last published GLM-4.7 API price, $50 of pay-per-token bought roughly 18-20M tokens once; Code Pro gives you 24M every day. Code Max ($200/month) provides 120M tokens/day and 5,000 messages/day. Both work with Cline, OpenCode, Crush, and similar IDE agents, and both showed as sold out on October 2, 2026.

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.