How to Use Cerebras Free Credits for Fast Inference

How to Use Cerebras Free Credits for Fast Inference

If you have ever watched an API bill climb while a chat app sits in development, you know why fast free inference is so attractive. Cerebras runs one of the quickest LLM inference platforms available, powered by its wafer-scale chips, and it hands new developers $5 in free credits to try it. This guide walks you through claiming those credits, making your first API call, and getting real work done before the 30-day trial expires.

What the Cerebras free trial actually includes

Honesty first: Cerebras does not offer a permanently free tier. The free offer is a one-time $5 credit grant for new accounts. Here are the terms as stated in Cerebras's own rate-limits documentation:

• $5 in free credits, granted once per new account
• Expires 30 days after the grant — unused credits do not roll over
• A verified payment method is required at sign-up (no charge until you buy more credits)
• Without a payment method, Playground and API access stay inactive
• Trial limits run around 5 requests per minute and 1 million tokens per day on models like GPT OSS 120B and Qwen3.8-27B

That is a genuinely generous trial for prototyping. At Cerebras's published rate for GPT OSS 120B ($0.35 per million input tokens, $0.75 per million output tokens), $5 buys roughly 4–5 million output tokens — enough to build, test, and demo a complete side project.

Step 1: Create your Cerebras Cloud account

1. Go to cloud.cerebras.ai and sign up with your email.

2. Verify your email address through the confirmation link.

3. Add a payment method in the billing section. You are not charged at this point — the card only activates your trial and sets you up for future top-ups.

4. Confirm the $5 free credit appears in your billing dashboard with its expiry date.

Tip: note the expiry date immediately and set a calendar reminder for day 25. The most common way developers waste this trial is discovering on day 29 that half the credit is about to vanish.

Step 2: Generate your API key

In the Cerebras Cloud dashboard, open the API Keys section and create a new key. Cerebras keys start with csk-. Copy it once and store it somewhere safe — the dashboard will not show it again.

From this point on, treat the key like a password. Never commit it to a public repo, never paste it into a client-side app, and never share screenshots of the dashboard with the key visible. The trial credits burn fast if a leaked key gets abused.

Step 3: Make your first call with the OpenAI-compatible API

Cerebras exposes an OpenAI-compatible endpoint, so any OpenAI SDK works with a one-line change. Install the Python client and point it at Cerebras:

pip install openai

Then run your first request:

import os
from openai import OpenAI

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

response = client.chat.completions.create(
    model="gpt-oss-120b",
    messages=[
        {"role": "user", "content": "Explain rate limiting in one sentence."},
    ],
)
print(response.choices[0].message.content)

Set the key in your shell with export CEREBRAS_API_KEY=csk-... before running. If you see a response stream back almost instantly, that is the Cerebras hardware doing its thing — throughput routinely reaches thousands of tokens per second on supported models.

Step 4: Pick the right model for your credit budget

Cerebras serves curated open-weights models rather than letting you upload arbitrary weights. For a $5 trial, model choice matters because output tokens cost roughly double input tokens. Practical rules:

• Prototyping and chat features: GPT OSS 120B is the workhorse — strong enough for real features, priced low enough to stretch the credit.
• Long documents: Qwen3.8-27B handles larger contexts well and is well-suited to summarization and retrieval-augmented pipelines.
• Structured output: keep responses short by asking for JSON or bullet lists in the system prompt. Every unnecessary token is credit burned.

A useful habit during the trial: log every request's usage field (prompt tokens, completion tokens). At day 3 you will know your burn rate and can plan the remaining 27 days with precision instead of guessing.

Step 5: Stretch the trial across 30 days

The trial is not large, so treat it like a resource you are budgeting:

1. Mock the API in unit tests. Write a fake client that returns canned responses for your test suite, and hit Cerebras only in integration tests.

2. Cache aggressively. LLM responses to identical inputs are deterministic enough to cache — store them in Redis or even a JSON file during development.

3. Develop prompts locally. Draft and debug system prompts on free local models (Ollama runs small models on your own machine), then validate the final versions on Cerebras.

4. Batch low-priority jobs. The 1M-token daily ceiling is per day, not per trial — spread long jobs across days instead of bursting them in one afternoon.

5. Respect the 5-requests-per-minute trial cap. Add simple backoff in your client (the OpenAI SDK accepts max_retries) rather than hammering and getting 429s.

What happens when the trial ends

Three paths, depending on how the trial went:

• Developer tier: self-serve pay-as-you-go starting with a $10 deposit, with 10x higher rate limits than the trial and priority processing.
• Cerebras Code plans: flat monthly subscriptions ($50 and $200 tiers) with large daily token allowances, better value if your usage is steady and high.
• Other free tiers: if you are not ready to pay, providers like Groq and OpenRouter's free models offer ongoing free inference with lower limits — good for hobby projects, though usually slower than Cerebras on heavy workloads.

One caution from the small print: free and trial inference tiers are typically funded by your usage data. Keep production data and customer prompts off any free tier, including this one — the paid tier is partly a privacy purchase.

Key takeaways

• Cerebras grants new accounts a one-time $5 credit for inference — no charge until you top up, but a payment method is required to activate it.
• Credits expire 30 days after the grant and do not renew; plan your prototyping around that deadline from day one.
• The API is OpenAI-compatible: point any OpenAI SDK at https://api.cerebras.ai/v1 with a csk- key and you are running.
• Trial limits sit around 5 requests per minute and 1 million tokens per day on models like GPT OSS 120B and Qwen3.8-27B.
• Stretch the trial with mocked tests, response caching, local prompt drafting, and token-budget logging.
• When credits run out, choose the $10-start Developer tier for pay-as-you-go, Cerebras Code plans for steady heavy use, or another provider's free tier for hobby projects.