Cerebras Inference Pricing in 2026: Every Model Priced, Verified

Cerebras Inference prices two open-weight models on its self-serve rate card as of 2026-10-20 — gpt-oss-120b at $0.35/$0.75 per million tokens and Qwen 3.8 27B at $0.99/$1.49 — and third-party medians measure its gpt-oss-120b endpoint as the fastest of 16 tracked providers. The premium is real (roughly 6x the cheapest blended price for the same checkpoint), and the cache discount most GPU hosts offer doesn't exist here.

Key facts

• The whole self-serve rate card is two rows: gpt-oss-120b at $0.35 input / $0.75 output per million tokens (listed at ~3,000 tokens/s) and Qwen 3.8 27B at $0.99 / $1.49 (listed ~1,850 tokens/s) (Cerebras pricing, accessed 2026-10-20).
• Speed (independent): Artificial Analysis's 72-hour medians on gpt-oss-120b (high) measured Cerebras at 1,734.5 output tokens/s — #1 of 16 providers, ahead of SambaNova (709.4) and Groq (473.6) — with a 0.34s first chunk and a 1.78s end-to-end 500-token response (Artificial Analysis, accessed 2026-10-20).
• Rate limits: the Developer tier runs 1,000 RPM and 1M uncached TPM (3M total TPM) on gpt-oss-120b with no hourly or daily token caps (Cerebras rate limits).
• No cache discount: Cerebras's docs state cached input tokens are "billed at the standard input token rate" — the caching payoff is latency and rate-limit headroom, not bill relief (Prompt caching docs).
• Blended price: $0.23 per million on Artificial Analysis's 7:2:1 measure as of 2026-10-20 — versus a $0.04 floor across the tracked field (CoreWeave), an accuracy index of 87% versus reference (Artificial Analysis).
• Company footing: Q1 2026 GAAP revenue of $193.4 million (core revenue $191.3M, up 92% year over year) and a $6.4 billion Q2 IPO — the largest semiconductor offering on record (Cerebras Q1 2026 results).

What Cerebras Inference is

Cerebras Inference is the public API of Cerebras Systems, the Sunnyvale company whose Wafer-Scale Engine (WSE-3) puts an entire wafer of silicon to work as one chip. Instead of sharding a model across hundreds of GPUs, a CS-3 system holds inference in wafer-scale on-chip memory — which is why the endpoints specialize in speed rather than breadth. The shared API speaks the OpenAI chat-completions schema, and Cerebras also routes through partner platforms: OpenRouter, AWS Marketplace, Hugging Face, and Vercel.

The company behind the rate card is no longer a startup bet: its first quarter of fiscal 2026 (ended March 31) booked $193.4 million in GAAP revenue, a $20 billion-plus multi-year deal to deploy 750 megawatts of inference capacity for OpenAI, a decode-focused partnership with AWS (Trainium 3 handles prefill, the CS-3 handles decode), and a $6.4 billion Q2 IPO. For builders, the relevant takeaway is supply-side stability: the capacity behind the endpoint is contracted years out.

The full rate card, priced (2026-10-20)

Every self-serve model is open-weight. Prices are Cerebras's first-party list rates, accessed 2026-10-20:

Two rows, and that is the story. The Qwen 3.8 27B checkpoint is Alibaba's dense multimodal small model released August 13–14, 2026 under Apache 2.0 (The Decoder; Hugging Face) — it takes text and image input (up to 10 images per request on the Developer tier) and is the only model on the card with a published free-tier context split (64k free / 128k paid, per Cerebras's model page).

Everything else lives behind Dedicated Inference, which is enterprise-quoted with no published price: the dedicated catalog spans Qwen3-Coder 480B-A35B, MiniMax-M2.5, GLM-5.1, Kimi K2.6 and K2.7-Code, DeepSeek V3.x, Mistral Large 3, Llama 4 Maverick and Scout, and the gpt-oss safeguard variant, with custom weights and fine-tuning by agreement. That means the checkpoints dominating October 2026's open-weight coverage — Kimi K3, DeepSeek V4, GLM 5.3 — are simply not available self-serve here. If your model isn't one of the two rows above, Cerebras is not currently a bidder for your traffic.

Cache economics: speed and headroom, not discounts

Cerebras's prompt caching is the opposite of the GPU-host playbook. Caching is automatic — no cache breakpoints, no headers — with 128-token block prefix matching, an organization-scoped cache (caches are never shared between organizations), and a guaranteed 5-minute TTL that can stretch to an hour under low load. Hits cut time to first token on long, repeated prefixes like system prompts and tool definitions.

But the money angle inverts. Groq bills cached input at a 50% discount and SambaNova's MiniMax rows cache at 90% off; Cerebras's documentation states plainly that cached tokens are "billed at the standard input token rate for the respective model" — no published discount. What caching buys instead is throughput: Cerebras rate-limits on a dual-bucket model in which cached tokens don't count against your uncached TPM, the primary constraint. At a 70% cache-hit rate, a 1M uncached TPM account can process up to 3M total tokens per minute. For agent fleets whose bottleneck is the rate limiter rather than the bill, that's worth more than a discount; for cache-heavy RAG on a budget, it isn't.

One caution: Artificial Analysis's blended (7:2:1) price for Cerebras on gpt-oss-120b reads $0.23 per million as of 2026-10-20, down from the $0.39 our SambaNova Cloud pricing comparison recorded on 2026-10-06 — even though Cerebras's list prices haven't moved. Third-party blended figures are point-in-time measurements, not rate-card rows; re-check them alongside the Price Index before budgeting.

Speed and accuracy: what the third-party medians show

Artificial Analysis tracks 16 providers serving gpt-oss-120b (high). Cerebras's 72-hour medians as of 2026-10-20, against the rivals we've priced on their own pages:

(The full table, including Azure, Novita, Crusoe, Baseten, Parasail, Nebius, Amazon Bedrock, Google Vertex, and Together AI, is on Artificial Analysis.)

The gap is roughly 2.4x to the closest custom-silicon rival and 18x to the cheapest GPU host — and it shows up end to end, where Cerebras finishes a 500-token response in 1.78s against CoreWeave's 27.12s. Against that: Cerebras's Endpoint Accuracy Index score is 87% versus reference, the second-lowest in the top-tier speed band, while slower rivals score 93–101%. Fast endpoints can lose accuracy to quantization or sampling defaults, and on this measure Cerebras gives up more of the reference endpoint's accuracy than SambaNova (98%) or Amazon Bedrock (101%). If your workload is accuracy-sensitive at the margin, that row belongs in the evaluation next to the speed row.

Also note what the row prices don't show: the published per-token rates are for the shared Developer tier, and production-grade reserved capacity is quote-only. There is no public crossover point where dedicated becomes cheaper, so serverless-to-dedicated economics can't be modeled from the outside.

Rate limits and the free tier, exactly

• Developer (pay as you go): gpt-oss-120b at 1,000 RPM / 1M uncached TPM / 3M total TPM; Qwen 3.8 27B at 300 RPM / 150K uncached TPM / 750K total TPM (temporarily elevated from 450K). No hourly or daily caps — the budget is the cap.
• Free trial: a one-time $5 credit granted after adding a verified payment method, expiring after 30 days, with hard ceilings of 5 RPM / 30K uncached TPM / 90K total TPM / 1M tokens per hour and per day. There is no permanently free tier; API and Playground access stop when the credit is gone.
• Enterprise: provisioned per organization, unpublished.

Against peers: Groq's self-serve developer plan runs 1,000 RPM / 250K TPM on gpt-oss-120b, and SambaNova caps developer accounts at 20M tokens per day across all models. Cerebras's self-serve limits are the most generous of the three custom-silicon hosts — and its token-bucket replenishment (continuous refill rather than fixed-window resets) smooths burst traffic.

Privacy: a no-retention policy, not an attestation

Cerebras's privacy policy (effective August 27, 2024, Section 6) states: "We do not retain inputs and outputs associated with our training, inference and chatbot Services," and that related logs are deleted "when they are no longer necessary to provide services to you." DeAI's standing rule is that privacy absence-claims are policy statements, not verified facts, and the same standard applies here: this is a self-published commitment, not an independent attestation, and the policy document carries no per-request retention window we can cite. Two mitigating mechanisms are documented: prompt caches are organization-scoped (never shared across organizations) and expire within 5 minutes to 1 hour. If your prompts are sensitive and you need verifiability rather than policy language, the TEE-attestation providers tracked in the Provider Trust Tracker are the category to compare — Cerebras does not currently offer TEE attestation on its public cloud. For the policy-vs-policy field comparison, see our zero data retention explainer.

Should you use it?

Cerebras Inference fits when decode speed is the product: interactive voice or coding agents where a 5-second completion feels broken, high-volume single-checkpoint pipelines pinned to gpt-oss-120b, and evaluation rigs that need the fastest first token in the field (0.34s). Its Developer-tier rate limits are the most generous among the custom-silicon hosts, and the two-row catalog is at least two open-weight, Apache 2.0 checkpoints with no license traps.

It fits poorly when you need a current-frontier checkpoint (DeepSeek V4, Kimi K3, GLM 5.3), when cache-heavy RAG economics matter more than latency (the GPU hosts' cache discounts compound), or when endpoint accuracy at the reference level is a hard requirement — the 87% index score is the worst in the top speed band. For breadth at the floor price, the cheapest-LLM-API roundup is the better starting point; for the full non-GPU head-to-head, see Cerebras vs Groq and SambaNova Cloud pricing.

Prices and speed medians here are dated 2026-10-20 and will move; this page gets refreshed alongside the weekly Price Index re-shoot.

Switching cost: a base-URL swap

The endpoint is OpenAI-compatible, so testing Cerebras from any OpenAI-shaped client is a two-line change:

from openai import OpenAI

client = OpenAI(
    base_url="https://api.cerebras.ai/v1",
    api_key=os.environ["CEREBRAS_API_KEY"],
)

resp = client.chat.completions.create(
    model="gpt-oss-120b",
    messages=[{"role": "user", "content": "ping"}],
)

curl https://api.cerebras.ai/v1/chat/completions \
  -H "Authorization: Bearer $CEREBRAS_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model": "gpt-oss-120b", "messages": [{"role": "user", "content": "ping"}]}'

Model slugs are not portable across providers (gpt-oss-120b here versus openai/gpt-oss-120b on Groq), reasoning effort is set per request on the gpt-oss checkpoints, and a canary pattern — 5% of traffic for two hours — is the zero-commitment way to compare the measured latency on your own traffic before moving anything.