Research-backed calculator guide

Cerebras API Cost and Capacity: Price PayGo Usage Under Uncached and Total Token Limits

Plan Cerebras API spend and throughput together by separating input/output token cost, uncached TPM, total TPM, RPM, PayGo caps, and prompt-cache hit rate.

What to price before you size capacity

Start with four measured inputs for each workload slice:

1. Input tokens per request. Include the system prompt, tools, conversation history, retrieved context, and the new user message.
2. Output tokens per request. Use an observed average for cost planning and a conservative maximum for admission planning. Cerebras estimates token consumption before processing and can use max_completion_tokens as an upper bound, so an unnecessarily large setting can trigger a limit earlier than the final response would have. ^[3]
3. Request volume and burst shape. Monthly calls determine spend. Calls per minute during the busiest interval determine whether RPM or TPM becomes the operational ceiling.
4. Cache-hit share. Estimate the proportion of input tokens served from an identical cached prefix. Do not assume every repeated request hits: Cerebras caches 128-token blocks, requires an exactly matching prefix, and gives a guaranteed five-minute TTL, with possible persistence for up to one hour depending on load. ^[4]

The token-only cost formula is:

monthly cost = (monthly input tokens ÷ 1,000,000 × input rate) + (monthly output tokens ÷ 1,000,000 × output rate)

At the rates checked, 10,000 gpt-oss-120b requests with 12,000 input tokens and 2,000 output tokens per request would be:

• Input: 120,000,000 ÷ 1,000,000 × $0.35 = $42.00
• Output: 20,000,000 ÷ 1,000,000 × $0.75 = $15.00
• Modeled token cost: $57.00

The 70% cache-hit scenario in the worked example below changes the capacity calculation, not this billed-token total. That distinction is central to Cerebras cache-hit capacity planning.

For a reusable price sheet, compare models in the model pricing comparison. If your main uncertainty is token volume, use the AI token cost calculator before applying the provider’s rate limits.

Cerebras limits: uncached TPM, total TPM, and RPM

Cerebras’s current rate-limit documentation describes separate limits for each organization and model. For gpt-oss-120b on Developer PayGo, the documented values are 1,000 RPM, 1 million uncached tokens per minute, and 3 million total tokens per minute. For qwen-3.8-27b, the documented Developer values are 300 RPM, 150,000 uncached TPM, and 750,000 total TPM; the page notes that 750,000 is temporarily above the standard three-times relationship. ^[3]

Treat those numbers as a planning snapshot. Cerebras says the exact limits can vary by organization and project and directs operators to the Cloud Console Limits view for the values that apply to their account. The console also checks project-level limits alongside the organization ceiling. ^[5]

The simplest capacity equations are:

• uncached tokens/request = uncached input tokens + tokens that still require fresh processing
• capacity from uncached TPM = uncached TPM limit ÷ uncached tokens/request
• capacity from total TPM = total TPM limit ÷ total tokens/request
• capacity from RPM = RPM limit
• usable requests/minute = the smallest of those three results

These equations are estimates, not a guarantee of accepted traffic. Cerebras may estimate a request before execution, the actual usage can differ, project limits can be lower, and concurrency or application queueing can add latency. Use your own request logs to validate the estimate.

A high cache-hit rate is valuable only when the workload retains a stable prefix. Cerebras says system instructions, tool definitions, few-shot examples, and large fixed context should appear before dynamic fields. Put timestamps, unique IDs, and changing user content at the end. Check usage.prompt_tokens_details.cached_tokens and the console’s Cached-Usage tab rather than inferring cache behavior from latency alone. ^{[4] [5]}

Worked cost example: 10,000 gpt-oss-120b requests

This is an illustrative planning case, not a vendor benchmark or quote. Assume a PayGo application sends 10,000 requests in a month. Each request has 12,000 input tokens and produces 2,000 output tokens. Assume 70% of input tokens are cache hits, the model is gpt-oss-120b, and the current public rates are $0.35 per million input tokens and $0.75 per million output tokens. ^[1]

Without cache hits, the same planning assumption would treat 14,000 tokens per request as fresh, giving about 71 requests per minute from the 1 million uncached TPM limit. With the assumed 70% input cache hit rate, the estimate rises to about 178 requests per minute. That is roughly 2.5 times the no-cache estimate in this particular input/output mix. It is not the full three-times headline because the 2,000 output tokens remain in the fresh-token assumption.

The monthly bill remains $57 under the stated assumption because Cerebras says cached tokens are priced at the standard input rate. If you instead route these requests through a partner, do not copy the direct API arithmetic without checking that partner’s meter. OpenRouter lists Cerebras-served openai/gpt-oss-120b and qwen/qwen3.8-27b as provider models, but the partner API is a separate billing and routing surface. ^[6]

The practical conclusion is not “set concurrency to 178.” Keep headroom for estimation, uneven request sizes, cache misses, retries, project limits, and traffic bursts. A safer application policy might reserve 20% of the calculated uncached ceiling, then shape the queue around roughly 140 requests per minute until production measurements justify a higher value. That 20% is an internal planning assumption, not a Cerebras recommendation.

PayGo removes daily caps, not budget risk

PayGo is easy to misunderstand because “no hourly or daily restrictions” can sound like unlimited service. The documented Developer tier still has per-model RPM, uncached TPM, and total TPM limits. PayGo means that the daily or hourly token ceiling is no longer the first documented cap for that tier; it does not waive the minute-level buckets. ^[3]

That change affects how you forecast. A free-trial batch may stop at a daily limit even when its average rate is modest. A PayGo batch can run for longer, but the monthly dollar total can grow for as long as your queue continues to submit successful requests. Set a monthly application budget, a per-workflow token allowance, and an alert threshold. Keep a positive credit balance and test what happens when the balance reaches zero.

The direct Cerebras API is not the same as an AWS Marketplace purchase. The AWS Marketplace listing describes a SaaS product sold by Cerebras, usage-based billing through a Cerebras Consumption Units dimension, and possible additional AWS infrastructure costs. That is useful context for procurement, but it is not a replacement for the direct API’s input/output price table. ^[8]

Similarly, the verified Cerebras organization page on Hugging Face shows model and research activity, while the OpenRouter provider page shows which Cerebras models are exposed through OpenRouter. Neither page should be treated as the source of direct Cerebras PayGo limits. ^{[6] [7]}

A practical monitoring and reconciliation loop

Record the following by request or small time bucket: model ID, organization and project, request count, input tokens, output tokens, cached tokens, HTTP status, retry count, and the configured max_completion_tokens. Then compare three views:

• Usage: total requests and tokens over a date range.
• Cached-Usage: cache-hit and fresh-processing shares.
• Cost: monthly spend by model and token type.

Cerebras documents all three in the console and notes that cost data can be delayed by up to 10 minutes. Use UTC when joining console exports to application events. ^[5] For invoice comparison, the AI API invoice reconciliation calculator can help separate modeled token cost from provider-reported spend.

A 429 is a capacity signal, not automatically a billing error. Read which bucket the error identifies. If uncached TPM is binding, reduce fresh prompt size, improve prefix stability, lower the admission rate, or choose a model with a different limit. If total TPM is binding, the cache may be helping uncached capacity but the aggregate prompt-plus-output load is still too large. If RPM is binding, token reduction alone may not fix the request-count ceiling.

Do not use a larger max_completion_tokens value as a vague safety margin. Cerebras says the estimate can use that upper bound before processing; set it near a tested maximum for the request class, then retain a separate application timeout and retry policy. ^[3]

Limitations and assumptions

This guide uses public Shared Inference documentation checked on 2026-11-02. Prices and limits can change, and the console values for a specific organization or project can differ from documentation examples. Dedicated Inference and enterprise arrangements may use negotiated capacity and pricing, so the public PayGo arithmetic should not be presented as an enterprise quote.

The worked example assumes stable request sizes, a 70% input cache-hit rate, no failed or duplicate requests, no fallback provider, and output tokens that require fresh processing. Real workloads have skewed prompts, cache expiry, retries, model reasoning behavior, queue delay, and application overhead. Measure p50 and p95 input/output tokens and cache-hit rate before setting a hard concurrency limit.

The calculation also excludes taxes, marketplace fees or infrastructure charges, discounts, credits, refunds, and the business cost of delayed or failed requests. It estimates token spend and provider admission capacity; it does not promise latency, availability, throughput, or a particular monthly invoice.

FAQ

Does Cerebras charge less for cached tokens?

Not in the public prompt-caching documentation checked here. Cached input tokens are billed at the standard input-token rate. The economic benefit is lower fresh-processing demand and often lower prompt-processing latency, which can increase usable capacity under a dual-bucket limit. ^[4]

What is the Cerebras uncached token limit?

It is the per-minute allowance for tokens that require full compute, separate from the total-token allowance. On the documented Developer tier, the checked examples are 1 million uncached TPM for gpt-oss-120b and 150,000 uncached TPM for qwen-3.8-27b. Confirm the value in the Cloud Console because limits can vary by model, organization, and project. ^{[3] [5]}

Does Cerebras PayGo have a daily token limit?

The current rate-limit documentation says hourly and daily restrictions do not apply to Developer PayGo users. That does not remove RPM, uncached TPM, or total TPM limits, and it does not create an unlimited spend budget. ^[3]

How should I calculate Cerebras API cost?

Multiply input tokens by the input price per million, multiply output tokens by the output price per million, divide each token total by 1 million, and add the two amounts. Keep cache hits in the billed input total unless the applicable vendor or partner documentation states otherwise. Then model rate-limit capacity separately using uncached TPM, total TPM, and RPM.

Why can a request hit a limit even when monthly spend is low?

Monthly spend and minute-level capacity measure different things. A short burst can exceed RPM or TPM even when the month’s token total is small. A large max_completion_tokens estimate, a cache miss, or a project-level limit can also reduce the request’s available quota before the response finishes. ^{[3] [5]}

Is 70% cache hit rate a safe planning assumption?

Only if your own logs support it. Cerebras requires an exactly matching prefix for cache reuse and describes a five-minute guaranteed TTL. Dynamic content near the beginning of a prompt can make the observed hit rate much lower. Measure cached_tokens over representative traffic instead of borrowing the worked example’s 70%. ^[4]