Cerebras added Qwen 3.8 27B to its public inference catalog running at roughly 1,500 output tokens per second, several times faster than the same model on a typical GPU-based API. It's a straight API swap if you're already calling another Qwen endpoint — same chat-completions shape, different base URL and model name.
Short answer: Qwen 3.8 27B runs on Cerebras Inference at about 1,500 tokens per second, priced at $0.99 per million input tokens and $1.49 per million output tokens. Free tier gives 64K context and 32K max output; paid tiers extend to 128K context and 40K output. It's a 27.78B-parameter dense multimodal model, Apache 2.0 licensed, with a 262K-token native context window from Alibaba's Qwen team.
In my testing, the jump from a standard GPU-hosted Qwen endpoint to Cerebras's wafer-scale hardware is the kind of thing you notice immediately in a terminal — a multi-paragraph answer that normally streams in over three or four seconds lands in under one. Alibaba's Qwen team shipped Qwen3.8-27B’s open weights on Hugging Face on August 14, 2026 under Apache 2.0, and Cerebras is one of several providers now serving it, but it's the fastest one I've checked.
What you'll need
An account at cloud.cerebras.ai is the only hard requirement — sign up, generate an API key from the console, and set it as an environment variable so you're not pasting it into every request. Cerebras's free tier gets you in the door with $5 of trial credit and no card required, though free accounts sit behind lower per-minute rate limits than paid ones. You'll also want an OpenAI-compatible client library (the openai Python package works fine by just pointing the base URL at Cerebras) since the API shape mirrors the standard chat-completions format. Budget a few minutes to test a request before wiring it into anything real — free-tier context is capped at 64K tokens versus 128K on paid, which matters if you're feeding it long documents.
Step-by-step: getting Qwen 3.8 27B running on Cerebras
1. Create a Cerebras Cloud account and API key
Log into cloud.cerebras.ai, head to the API Keys section, and generate a key. There's a no-code playground in the console too, if you want to try a prompt before writing any code.
2. Point your client at Cerebras instead of your usual endpoint
If you're already calling Qwen through another provider's OpenAI-compatible API, the swap is usually just the base URL and the model string — set the model to qwen-3.8-27b and export your Cerebras key as the API key. Nothing else in a standard chat-completions call needs to change.
3. Send a test request and time it yourself
Run one real prompt and note the wall-clock time, not just what the docs claim. In my testing, a 400-token response that would take 5-6 seconds on a typical GPU-hosted endpoint finished in under a second on Cerebras — consistent with the roughly 1,500 tokens/second Cerebras lists for this model.
4. Check your context and output limits against your workload
Free tier caps you at 64K context and 32K max output tokens per response; paid tiers move that to 128K context and 40K output. If you're summarizing long documents or running an agent loop with a growing conversation history, confirm you're under those ceilings before you build around it.
5. Watch image limits if you're using the vision side
Qwen 3.8 27B accepts images as well as text. The free tier caps you at 2 images per request; the paid developer tier allows up to 10. If your use case is document OCR or multi-image comparison, that free-tier limit will bite fast.
Example prompts you can copy
These are close to what I ran while timing Cerebras's throughput against a standard endpoint:
Summarize this changelog in three bullet points: [paste text]— a good baseline for timing short, structured output.Walk through this Python traceback and list the three most likely causes in order of probability.— tests reasoning speed on a task that normally involves some visible "thinking."Extract every date and dollar amount from this text as a JSON array: [paste text]— useful for checking structured-output speed on a repetitive extraction task.Describe what's happening in this image in two sentences.— tests the vision path specifically, since Qwen 3.8 27B is multimodal.Rewrite this paragraph in a more direct, less formal tone, under 60 words.— a short generation task where the speed difference is easy to feel in a chat UI.
Common mistakes to avoid
The first mistake is assuming the free tier's 64K context and 32K output limits match the paid tier — they don't, and a document that fits comfortably on a paid key can get truncated on a free one. Second, don't skip timing the request yourself; a vendor-listed "~1,500 tokens/second" is a peak figure, and your actual throughput depends on prompt length, request queueing, and whether you're on the free or paid tier. Third, if you're doing image work, don't build past the 2-images-per-request free-tier cap before checking it — I hit that limit testing a multi-image comparison prompt and had to switch to a paid key mid-test. Fourth, speed doesn't change token pricing: Cerebras charges $0.99 per million input tokens and $1.49 per million output tokens regardless of how fast the response streams back, so a chatty prompt still costs what a chatty prompt costs. Fifth, don't assume every Qwen provider runs the same weights at the same speed — Cerebras states its public endpoints serve the original, unpruned model, but throughput and pricing both vary a lot provider to provider, which is worth checking before you commit to one.
Cerebras vs. other Qwen 3.8 27B providers
| Provider | Input / 1M tokens | Output / 1M tokens | Throughput |
|---|---|---|---|
| Cerebras | $0.99 | $1.49 | ~1,500 tokens/sec |
| Venice | $0.45 | $3.20 | ~77 tokens/sec |
| io.net | $0.432 | $3.06 | ~70 tokens/sec |
| Ionstream | $0.35 | $2.55 | ~73 tokens/sec |
| AkashML | $0.25 | $2.20 | ~64 tokens/sec |
Cerebras charges more per input token than most of these but less per output token, and it's roughly 20x faster than the next-quickest option on this list. If your workload is latency-sensitive — a voice agent, a live coding assistant, anything with a human waiting on the response — that speed gap is worth the higher input price. If you're running large batch jobs overnight where nobody's watching a spinner, a cheaper, slower provider probably saves more money than the speed is worth to you.
Tools that make this easier
If you're deciding whether Qwen is the right model family at all before you pick a speed tier, my Qwen vs. DeepSeek comparison covers where each one actually wins, and how to use DeepSeek is worth a look if cost matters more to you than raw throughput. For the flagship end of the Qwen lineup rather than this 27B model, see Qwen3.8 Max’s Agentic Index ranking. Cerebras isn't only fast for Qwen — my guide to GPT-5.6 Sol’s Ultrafast tier covers the same wafer-scale hardware serving OpenAI's model. And if you'd rather skip the API entirely and run a small Qwen model on your own hardware, I built a local car AI with a Raspberry Pi and Qwen walks through that path. Before you commit to a high-throughput setup in production, managing AI coding costs at scale is a useful gut-check on tracking token spend once request volume goes up.
My take
The speed is real and easy to confirm yourself in a single timed request — Cerebras's wafer-scale hardware is consistently the fastest place I've run a Qwen model. What's worth knowing going in: the free tier's context and image limits are tight enough to hit quickly if you're doing anything beyond short chat, and the $0.99/$1.49 pricing sits in an odd spot — pricier on input than most other Qwen 3.8 27B providers, cheaper on output. If your app is latency-sensitive, that trade is worth making. If you're running high-volume batch work with no one waiting on the response, a slower, cheaper provider is the better buy.
Frequently Asked Questions
Is Qwen 3.8 27B on Cerebras free?
Cerebras gives new accounts $5 of free trial credit and a free tier with lower rate limits, 64K context, and a 32K max output cap — no card required to start. Beyond the trial credit, it bills at $0.99 per million input tokens and $1.49 per million output tokens.
How fast is Qwen 3.8 27B on Cerebras compared to other providers?
Cerebras lists roughly 1,500 tokens per second, which is about 20x faster than mid-tier providers like Venice or io.net that run the same open-weight model at 60-80 tokens per second.
What is the easiest way to try it?
Use the no-code playground in the Cerebras Cloud Console — you don't need an API key or any setup to send a test prompt and see the speed for yourself before writing code.
Does Cerebras run the same model as other providers?
Yes. Cerebras states that models on its public endpoints are the original, unpruned versions of the open weights Alibaba published on Hugging Face, not a modified or distilled build.
What's the context window limit?
64K tokens on the free tier, 128K tokens on paid tiers. The model's native context from Alibaba is larger — 262,144 tokens, extensible to 1 million — but Cerebras's own serving limits are lower than that ceiling.