Qwen3.8 Flash is the fast, low-cost tier of Alibaba's Qwen3.8 generation, released on 27 August 2026.
- Input
- text image video $0.15/M
- Output
- text $0.47/M
- Cache read
- $0.016/M
- Context
- 984K
- vs GPT-4o
- ~97% cheaper
Benchmarks
Vendor-published: Alibaba (Qwen) Anthropic ByteDance DeepSeek Google MiniMax Moonshot OpenAI Tencent Z.ai
Price in context
Where the price sits among 66 comparable models
The bar shows how this model’s price compares with every other model of the same kind on Synthorai. The cheapest and the most expensive are named at each end. These are base rates; batch, region and cache-write discounts are on the pricing page.
Specs & limits
Tokens
| Context window (vendor spec) | 1,000,000 |
|---|---|
| Max output (vendor spec) | 131,072 |
Prompt caching
| How it caches | automatic + explicit |
|---|---|
| Min prefix | 1,024 |
| Lifetime | explicit: 5m, reset on hit |
| Write cost | 1.25x |
Thinking
| Vendor control | enable_thinking + thinking_budget + preserve_thinking |
|---|---|
| Accepted values | enable_thinking true · false; thinking_budget in tokens; preserve_thinking true · false |
| Default | on; qwen3.8-flash is hybrid thinking with thinking enabled by default, thinking_budget defaults to the 262,144-token chain maximum, and preserve_thinking is off applied when the request sets nothing |
| Can be turned off | Yes |
| Thinking behaviour | Trace returns in reasoning_content and is dropped from later turns unless preserve_thinking is true, which appends it to the input and bills it as input tokens; qwen3.8-flash is on Alibaba's preserve_thinking list. |
| Parameter | reasoning_effort |
| Values | minimal · low · medium · high the gateway's parameter surface - the vendor mapping above applies |
Model
| Modalities | text + image + video → text |
|---|---|
| Parameters | 125B total · 6B active MoE |
- Multimodal Flash model on the Qwen3.8-Flash-Next architecture (Gated DeltaNet with Qwen Sparse Attention, n-gram embeddings; 51B n-gram embedding parameters on top of the 125B MoE)
- text, image and video in, text out
- max input 991,808 tokens, 983,616 in thinking mode
- reasoning chain up to 262,144 tokens
- one price for thinking and non-thinking calls with no length tiers
- batch inference not offered
One prompt, measured through the gateway
Qwen3.8 Flash passed · 3 sentences
Enabling reasoning makes the model spend additional output tokens to plan and validate answers before responding, and those tokens are billed. It also increases compute and latency per request, so each task consumes more capacity than a non-reasoning call. As a result, billable tokens and compute roughly doubled, directly driving the higher invoice.
out 330 tok (+262 thinking) latency 8.9 s
Instruction following (exactly three sentences - countable), audience shaping (CFO register), and the hidden-thinking billing gap the token meters below expose.
Qwen3.8 Flash passed · 8/8 cases
```python def longest_run(xs): if not xs: return 0 best = 1 cur = 1 for i in range(1, len(xs)): if xs[i] == xs[i - 1]: cur += 1 else: cur = 1 best = max(best, cur) return best ``` The bug is that the original version counts adjacent equal pairs rather than items in a run, starting both `cur` and `best` at `0`, and it resets `cur` to `0` after a mismatch, thereby discarding the first element of the new run. That makes single-element inputs return `0`, and because every run is effectively measured in “steps” between equal elements, the last element is not counted—particularly noticeable when the longest run ends at the final index.
out 2123 tok (+1933 thinking) latency 43.8 s
Whether the fix is actually correct (runnable), explanation density, and token efficiency on a bounded task.
Qwen3.8 Flash passed · 5/5 fields, guidance null
{ "company": "Meridian Robotics", "quarter": "September quarter", "revenue_usd_m": 412, "growth_pct": 11, "guidance": null }
out 519 tok (+463 thinking) latency 10.5 s
Schema obedience (no invented fields), hallucination pressure (guidance is explicitly withheld), and structured-output path differences.
Qwen3.8 Flash passed · 120 words, 0 banned, 1 question
We are announcing prompt caching across providers in our API gateway. Store approved prompt outputs once and reuse them across supported model providers, cutting latency, cost, and duplicate token spend. The feature matches identical requests, checks validity, and returns cached results while preserving routing controls. Developers keep existing endpoints; the gateway manages storage, invalidation, and provider differences. This reduces noisy repeat calls, improves steady responses, and frees teams to focus on better agent workflows. OpenAI, Anthropic, Google, Mistral, and custom routes are supported. Cache hits appear in analytics with latency, token, and cost reductions visible. Check retention and privacy rules before enabling it. Ready to add cache controls to your gateway? Enable it in settings and watch spend drop now.
out 5958 tok (+5805 thinking) latency 88.8 s
Constraint obedience (word budget, banned-word list, the single question), style fingerprint, and length control.
Use Qwen3.8 Flash in 30 seconds
OpenAI-compatible: swap the base_url, keep your SDK. POST /v1/chat/completions
from openai import OpenAI
client = OpenAI(
base_url="https://synthorai.io/v1",
api_key="sk-syn-...",
)
resp = client.chat.completions.create(
model="qwen3.8-flash",
messages=[{"role": "user", "content": "Summarize this diff"}],
reasoning_effort="medium",
)
print(resp.choices[0].message.content)import OpenAI from "openai";
const client = new OpenAI({
baseURL: "https://synthorai.io/v1",
apiKey: "sk-syn-...",
});
const resp = await client.chat.completions.create({
model: "qwen3.8-flash",
messages: [{ role: "user", content: "Summarize this diff" }],
reasoning_effort: "medium",
});
console.log(resp.choices[0].message.content);curl https://synthorai.io/v1/chat/completions \
-H "Authorization: Bearer sk-syn-..." \
-H "Content-Type: application/json" \
-d '{
"model": "qwen3.8-flash",
"messages": [{"role": "user", "content": "Hello"}],
"reasoning_effort": "medium"
}'package main
import (
"context"
"fmt"
"github.com/openai/openai-go/v3"
"github.com/openai/openai-go/v3/option"
)
func main() {
client := openai.NewClient(
option.WithBaseURL("https://synthorai.io/v1"),
option.WithAPIKey("sk-syn-..."),
)
resp, _ := client.Chat.Completions.New(context.TODO(), openai.ChatCompletionNewParams{
Model: "qwen3.8-flash",
Messages: []openai.ChatCompletionMessageParamUnion{
openai.UserMessage("Summarize this diff"),
},
ReasoningEffort: openai.ReasoningEffortMedium,
})
fmt.Println(resp.Choices[0].Message.Content)
}import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.chat.completions.*;
import com.openai.models.ReasoningEffort;
OpenAIClient client = OpenAIOkHttpClient.builder()
.baseUrl("https://synthorai.io/v1")
.apiKey("sk-syn-...")
.build();
ChatCompletion resp = client.chat().completions().create(
ChatCompletionCreateParams.builder()
.model("qwen3.8-flash")
.addUserMessage("Summarize this diff")
.reasoningEffort(ReasoningEffort.MEDIUM)
.build());
System.out.println(resp.choices().get(0).message().content().orElse(""));About Qwen3.8 Flash
- It is built on a new architecture that the Qwen team calls an experimental preview of what will underpin Qwen4: a Mixture-of-Experts model with 125 billion parameters and 6 billion active per token, plus 51 billion parameters of n-gram embeddings, pairing Gated DeltaNet layers with a new Qwen Sparse Attention that Alibaba says cuts latency on long inputs.
- The open-weight release of that architecture is Qwen3.8-Flash-Next; the hosted model is described as the production build of it, with a 1M-token context enabled by default and Alibaba's built-in tools.
- It takes text, images and video and returns text, with up to 131,072 output tokens.
- Thinking is hybrid and on by default: enable_thinking turns it off per request, thinking_budget caps it, and the trace comes back in reasoning_content and bills as output.
- It is also on Alibaba's preserve_thinking list, so an agent can carry earlier reasoning into later turns instead of re-deriving it.
- Function calling, structured output, prefix completion, web search and context caching are listed; batch inference is not.
- Alibaba's own selection guidance names it as the way to cut cost from Qwen3.7 Plus while keeping similar capability.
- The pricing is simpler than the Qwen3.7 Flash it follows, which billed in three context-length steps: Qwen3.8 Flash has one flat rate across the whole window, the same for thinking and non-thinking calls, and cache hits cost roughly a tenth of standard input whether the cache was created automatically or explicitly.
- Synthorai serves it through the OpenAI-compatible chat completions endpoint.
FAQ
Is the Qwen3.8 Flash API free to try?
Yes: new accounts get 10 trial calls and up to $1 in free credit, no card required. At $0.15/M input tokens, that credit alone covers roughly 833 requests of ~8K tokens against Qwen3.8 Flash.
What is Qwen3.8 Flash best at?
125B-parameter MoE with 6B active per token; text, image and video in, 131K max output; one flat price across the 1M context. See the About section for the full picture from the vendor's own release notes.
How much does Qwen3.8 Flash cost?
Qwen3.8 Flash costs $0.15 per million input tokens and $0.47 per million output tokens on Synthorai. That is the provider's list price, with no platform markup. Cached input tokens bill at $0.016/M.
Does Qwen3.8 Flash support prompt caching?
Yes: automatic caching is on by default, with an explicit mode for guaranteed savings. Cached input tokens bill at $0.016/M vs $0.15/M uncached; prompts need a 1,024-token stable prefix to cache (TTL explicit: 5m, reset on hit). Prompt caching guide →
How do I get access to Qwen3.8 Flash?
Point your existing OpenAI SDK at base_url="https://synthorai.io/v1", set model="qwen3.8-flash", and you're done. One API key covers every model on the gateway.
Related models
Compare
Every value on this page is transcribed from the vendor's own documentation, linked above, and carries the date it was checked. Prices are compared across the catalogue; specification values that vendors define differently are shown with the difference stated rather than charted. Nothing here is measured by us, and nothing is scored.