Qwen3.5 Flash is the speed- and cost-optimized hosted tier of the Qwen3.5 generation, which the Qwen team introduced under the banner "Towards Native Multimodal Agents."
- Input
- text image video $0.1/M
- Output
- text $0.4/M
- Cache read
- $0.029/M
- Context
- 1M
- vs GPT-4o
- ~98% 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.5 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; prior turns' reasoning_content is ignored, and no Qwen3.5 model is on the 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 | 35B total · 3B active MoE |
- Native vision-language flash model (text/image/video input)
- hybrid thinking on by default
- overall quality officially positioned close to qwen3.5-plus
One prompt, measured through the gateway
Qwen3.5 Flash passed · 3 sentences
Enabling reasoning requires the model to execute multi-step verification internally, which consumes significantly more tokens than a standard query. Since vendor fees are calculated per token processed, this added workload has directly resulted in a doubling of our total monthly expenditure. We view this cost increase as a strategic investment in higher model reliability, which prevents far more expensive errors from occurring downstream.
out 2010 tok (+1934 thinking) latency 18.7 s
Instruction following (exactly three sentences - countable), audience shaping (CFO register), and the hidden-thinking billing gap the token meters below expose.
Qwen3.5 Flash passed · 8/8 cases
The bug stems from two related issues: the function incorrectly initializes its counters and fails to account for runs starting at the beginning or ending at the last element. Specifically, `cur` counts how many consecutive pairs match (transitions) rather than the actual number of items in a run—for example, two equal items yield a `cur` value of 1 instead of 2. Additionally, if the input has fewer than two elements, the loop never executes, causing single-element lists to return 0 instead of 1, and runs that end at the final index may not be fully captured since updates rely on detecting a mismatch or completing the loop. To fix it, initialize `cur` and `best` to 1 (assuming a non-empty input), handle empty inputs explicitly, and ensure every comparison contributes accurately to the actual item count in the current run. […]
out 1020 tok (+747 thinking) latency 9.8 s
Whether the fix is actually correct (runnable), explanation density, and token efficiency on a bounded task.
Qwen3.5 Flash passed · 5/5 fields, guidance null
{ "company": "Meridian Robotics", "quarter": "September quarter", "revenue_usd_m": 412, "growth_pct": 11, "guidance": null }
out 3545 tok (+3487 thinking) latency 33.1 s
Schema obedience (no invented fields), hallucination pressure (guidance is explicitly withheld), and structured-output path differences.
Qwen3.5 Flash passed · 120 words, 0 banned, 1 question
We announce our cross platform prompt caching feature in the API Gateway. Storing frequent inputs allows developers to significantly reduce latency and minimize token costs for every request sent through our system. Utilizing OpenAI or Anthropic ensures consistency without repetitive processing fees. Organizations gain better control over spending while maintaining rapid response times for end users globally. Our engineering team ensured compatibility with your existing infrastructure without friction. Can your current setup handle such efficiency improvements effectively? All clients receive immediate access starting today. Update your configuration files now to enable this capability. Join thousands of others optimizing deployment pipelines efficiently. This tool delivers tangible results for scalable applications needing lower overhead costs. […]
out 10675 tok (+10535 thinking) latency 80.1 s
Constraint obedience (word budget, banned-word list, the single question), style fingerprint, and length control.
Use Qwen3.5 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.5-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.5-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.5-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.5-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.5-flash")
.addUserMessage("Summarize this diff")
.reasoningEffort(ReasoningEffort.MEDIUM)
.build());
System.out.println(resp.choices().get(0).message().content().orElse(""));About Qwen3.5 Flash
- The generation is built on the Qwen3-Next architecture combining gated linear attention with sparse Mixture-of-Experts for high-throughput inference, and is trained natively for agentic work: planning, tool calling, and multi-step execution.
- The hosted Flash tier offers a 1M-token context by default with official built-in tools, and up to 65,536 output tokens.
- Alibaba positions it as coming close to Qwen3.5 Plus in capability while answering faster, and the size gap behind that is public: the Qwen team's card for Qwen3.5-35B-A3B names it as the open counterpart of this hosted tier, a 35B-parameter Mixture-of-Experts activating about 3B per token, released under Apache 2.0, against Plus's 397B.
- So the choice between them is capacity, not just latency, and Flash is one you can also run yourself.
- It is natively vision-language, taking image and video input alongside text and returning text.
- Thinking flips the Qwen3 default: across the 3.5 generation hybrid thinking arrives enabled, so requests reason unless you pass enable_thinking as false, with thinking_budget available to cap the spend and the trace returned in reasoning_content.
- Tool calling, structured output, batch inference and explicit prompt caching are supported; parallel tool calls are opt-in rather than the default.
- Synthorai puts it behind the standard OpenAI-compatible endpoint for drop-in use.
FAQ
Is the Qwen3.5 Flash API free to try?
Yes: new accounts get 10 trial calls and up to $1 in free credit, no card required. At $0.1/M input tokens, that credit alone covers roughly 1,250 requests of ~8K tokens against Qwen3.5 Flash.
What is Qwen3.5 Flash best at?
Gated linear attention with sparse MoE; 1M-token context by default; trained natively for agentic work. See the About section for the full picture from the vendor's own release notes.
How much does Qwen3.5 Flash cost?
Qwen3.5 Flash costs $0.1 per million input tokens and $0.4 per million output tokens on Synthorai. That is the provider's list price, with no platform markup. Cached input tokens bill at $0.029/M.
Does Qwen3.5 Flash support prompt caching?
Yes: automatic caching is on by default, with an explicit mode for guaranteed savings. Cached input tokens bill at $0.029/M vs $0.1/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.5 Flash?
Point your existing OpenAI SDK at base_url="https://synthorai.io/v1", set model="qwen3.5-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.