Qwen3.6 Flash is the fast, economical tier of the Qwen3.6 generation, which the Qwen team framed as a move "Towards Real World Agents."
- Input
- text image video $0.25/M
- Output
- text $1.5/M
- Cache read
- $0.05/M
- Context
- 256K
- vs GPT-4o
- ~95% cheaper
Price in context
Where the price sits among 60 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) | 65,536 |
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 |
|---|---|
| Accepted values | enable_thinking true · false; thinking_budget in tokens |
| Default | on; the Qwen3.6 Flash series is hybrid thinking with thinking enabled by default applied when the request sets nothing |
| Can be turned off | Yes |
| Thinking behaviour | Trace returns in reasoning_content and is ignored on later turns; qwen3.6-flash is not among the models Alibaba lists as accepting preserve_thinking, unlike qwen3.6-plus. |
| Parameter | reasoning_effort |
| Values | minimal · low · medium · high the gateway's parameter surface - the vendor mapping above applies |
Model
| Modalities | text + image + video → text |
|---|
- Native vision-language Flash model, officially a significant upgrade over Qwen3.5-Flash
- the Qwen3.6 generation adds preserve_thinking to carry reasoning across turns, but Alibaba lists it for qwen3.6-plus and qwen3.6-max-preview, not for this Flash tier
One prompt, measured through the gateway
Qwen3.6 Flash passed · 3 sentences
Enabling reasoning mode forces the model to generate multiple internal analysis steps before producing a final answer, effectively doubling the computational effort per request. Because our vendor bills for every token processed—including these hidden reasoning tokens—the increased processing directly multiplied our usage charges by approximately two. This spike reflects a deliberate shift from low-cost, basic outputs to higher-intelligence results that reduce error rates and downstream correction costs, optimizing spend for long-term efficiency.
out 1231 tok (+1141 thinking) latency 11.7 s
Instruction following (exactly three sentences - countable), audience shaping (CFO register), and the hidden-thinking billing gap the token meters below expose.
Qwen3.6 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 best = max(best, cur) else: cur = 1 return best ``` The original implementation counts matching transitions rather than actual element counts, initializing both accumulators to zero. This causes single-element inputs to bypass the loop entirely and return zero instead of one, while any run of length `k` only increments the counter `k-1` times, consistently undercounting by one. Additionally, resetting `cur` to zero on a mismatch discards the newly started element, losing a potential candidate for the longest run. […]
out 2724 tok (+2473 thinking) latency 19.0 s
Whether the fix is actually correct (runnable), explanation density, and token efficiency on a bounded task.
Qwen3.6 Flash passed · 5/5 fields, guidance null
```json { "company": "Meridian Robotics", "quarter": "September quarter", "revenue_usd_m": 412, "growth_pct": 11.0, "guidance": null } ```
out 1629 tok (+1564 thinking) latency 12.0 s
Schema obedience (no invented fields), hallucination pressure (guidance is explicitly withheld), and structured-output path differences.
Qwen3.6 Flash passed · 120 words, 0 banned, 1 question
We are pleased to announce PromptCache, a new capability built directly into our enterprise API gateway. This innovation stores frequently used text prompts across all integrated model providers, eliminating redundant transmission costs while accelerating response times. Developers can now configure retention policies, set TTL limits, and monitor cache hit rates through our unified dashboard. System performance improves dramatically when identical queries bypass repeated network hops. Your infrastructure will maintain consistent throughput during peak traffic windows without additional provisioning overhead. Teams deploying multimodal applications benefit from reduced latency across diverse inference endpoints. […]
out 5005 tok (+4866 thinking) latency 26.3 s
Constraint obedience (word budget, banned-word list, the single question), style fingerprint, and length control.
Use Qwen3.6 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.6-flash",
messages=[{"role": "user", "content": "Summarize this diff"}],
)
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.6-flash",
messages: [{ role: "user", content: "Summarize this diff" }],
});
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.6-flash",
"messages": [{"role": "user", "content": "Hello"}]
}'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.6-flash",
Messages: []openai.ChatCompletionMessageParamUnion{
openai.UserMessage("Summarize this diff"),
},
})
fmt.Println(resp.Choices[0].Message.Content)
}import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.chat.completions.*;
OpenAIClient client = OpenAIOkHttpClient.builder()
.baseUrl("https://synthorai.io/v1")
.apiKey("sk-syn-...")
.build();
ChatCompletion resp = client.chat().completions().create(
ChatCompletionCreateParams.builder()
.model("qwen3.6-flash")
.addUserMessage("Summarize this diff")
.build());
System.out.println(resp.choices().get(0).message().content().orElse(""));About Qwen3.6 Flash
- Versus Qwen3.5, the generation's official announcement highlights drastically enhanced agentic coding from frontend work to repository-level tasks, improved multimodal perception and reasoning accuracy, and a new preserve_thinking option that carries reasoning content across turns to keep agent decisions consistent while reducing token use.
- Flash trades some depth for lower latency and cost.
- Alibaba's own guidance is to start on the newer Plus tier and switch here to reduce spend while keeping similar capability, and it names this model for long documents and large codebases on the strength of its 1M-token context.
- It is natively vision-language, accepting image and video input alongside text, returns up to 65,536 output tokens, and raises the generation's reasoning allowance well above Qwen3.5's.
- Model Studio lists function calling, built-in tools, structured output, batch inference and explicit prompt caching.
- Like the rest of its generation it is a hybrid thinking model with reasoning enabled by default, the opposite of the Qwen3 series, so a plain request deliberates unless enable_thinking is set to false; thinking_budget caps the spend, and the trace is returned in reasoning_content and billed as output.
- Worth checking before you design around it: Alibaba's thinking documentation lists preserve_thinking support model by model, and the Flash tier is not among the entries named, so treat cross-turn reasoning as a generation-level feature rather than something guaranteed here.
- Synthorai serves it over the OpenAI-compatible endpoint.
FAQ
Is the Qwen3.6 Flash API free to try?
Yes: new accounts get 10 trial calls and up to $1 in free credit, no card required. At $0.25/M input tokens, that credit alone covers roughly 500 requests of ~8K tokens against Qwen3.6 Flash.
What is Qwen3.6 Flash best at?
Enhanced agentic coding to repository level; 1M context for long documents and codebases; trades some depth for lower latency. See the About section for the full picture from the vendor's own release notes.
How much does Qwen3.6 Flash cost?
Qwen3.6 Flash costs $0.25 per million input tokens and $1.5 per million output tokens on Synthorai. That is the provider's list price, with no platform markup. Cached input tokens bill at $0.05/M.
Does Qwen3.6 Flash support prompt caching?
Yes: automatic caching is on by default, with an explicit mode for guaranteed savings. Cached input tokens bill at $0.05/M vs $0.25/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.6 Flash?
Point your existing OpenAI SDK at base_url="https://synthorai.io/v1", set model="qwen3.6-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.