Qwen3.5 Plus is the flagship hosted tier of the Qwen3.5 generation, the Qwen team's step "Towards Native Multimodal Agents."
- Input
- text image video $0.4/M
- Output
- text $2.4/M
- Cache read
- $0.115/M
- Context
- 1M
- vs GPT-4o
- ~92% cheaper
Benchmarks
Vendor-published: Alibaba (Qwen) Anthropic ByteDance DeepSeek Google MiniMax Moonshot OpenAI Tencent Z.ai
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 | 397B total · 17B active MoE |
- Cloud-hosted counterpart of Qwen3.5-397B-A17B (native VLM, Gated-Delta linear attention + sparse MoE)
- 1M-token context by default, built-in tools, 201 languages
- hybrid thinking on by default
One prompt, measured through the gateway
Qwen3.5 Plus passed · 3 sentences
Enabling reasoning requires the model to generate hidden intermediate steps before answering, which effectively doubles the computational tokens consumed per query. This increase in unit economics is direct, as we are now paying for deeper analytical work rather than simple response generation. The higher spend is justified by improved accuracy, which reduces downstream error correction costs and operational risk.
out 1903 tok (+1832 thinking) latency 33.2 s
Instruction following (exactly three sentences - countable), audience shaping (CFO register), and the hidden-thinking billing gap the token meters below expose.
Qwen3.5 Plus 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: best = max(best, cur) cur = 1 return max(best, cur) ``` The bug arises because `cur` and `best` are initialized to 0, which counts matching transitions rather than the actual number of elements, causing single-item runs to incorrectly return 0; furthermore, `best` is only updated inside the loop, so if the longest run extends to the final index, the final value of `cur` is never compared against `best` before the function returns.
out 5421 tok (+5243 thinking) latency 93.1 s
Whether the fix is actually correct (runnable), explanation density, and token efficiency on a bounded task.
Qwen3.5 Plus passed · 5/5 fields, guidance null
{ "company": "Meridian Robotics", "quarter": "September quarter", "revenue_usd_m": 412, "growth_pct": 11, "guidance": null }
out 1298 tok (+1240 thinking) latency 23.0 s
Schema obedience (no invented fields), hallucination pressure (guidance is explicitly withheld), and structured-output path differences.
Qwen3.5 Plus passed · 120 words, 0 banned, 1 question
Introducing intelligent prompt caching within our API gateway. This new capability stores frequent requests across multiple AI providers, significantly reducing latency and costs for your applications. Why pay for repeated computations when you can serve stored responses instantly? Our system identifies identical inputs and delivers cached outputs without querying external models every time. This ensures faster performance while maintaining secure privacy standards. Developers can optimize their workflows without complex infrastructure changes. The update is available immediately for enterprise plans. Start saving resources by enabling this feature in your dashboard. We believe this tool will transform how you manage API traffic efficiently. Join thousands of users already benefiting from reduced overhead and improved speed. Your infrastructure really deserves this upgrade today.
out 6787 tok (+6649 thinking) latency 116.3 s
Constraint obedience (word budget, banned-word list, the single question), style fingerprint, and length control.
Use Qwen3.5 Plus 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-plus",
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-plus",
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-plus",
"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-plus",
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-plus")
.addUserMessage("Summarize this diff")
.reasoningEffort(ReasoningEffort.MEDIUM)
.build());
System.out.println(resp.choices().get(0).message().content().orElse(""));About Qwen3.5 Plus
- Built on the Qwen3-Next architecture pairing gated linear attention with sparse Mixture-of-Experts, the generation uses early-fusion multimodal training and emphasizes agentic capability across reasoning, coding, and tool use, with adaptive tool-calling modes.
- The hosted Plus tier provides a 1M-token context window by default, suited to large-document and long-horizon agent workloads.
- The Qwen team's own card for Qwen3.5-397B-A17B describes this hosted tier as its managed version: a 397B-parameter Mixture-of-Experts activating about 17B per token, published openly under Apache 2.0.
- That is roughly an order of magnitude more total capacity than the Flash tier, which is the real difference between them rather than latency alone.
- Served limits run to 65,536 output tokens with a large separate reasoning allowance, native image and video input, and multilingual coverage the Qwen team puts at 201 languages and dialects.
- Thinking is hybrid and, unlike the Qwen3 generation, enabled by default: pass enable_thinking as false for a direct answer, use thinking_budget to bound how long it deliberates, and read the trace from the separate reasoning_content field, where it bills as output.
- Built-in tools, function calling, structured output, batch inference and explicit prompt caching round out the surface, with parallel tool calls off unless requested.
- Synthorai routes Qwen3.5 Plus traffic through its OpenAI-compatible API.
FAQ
Is the Qwen3.5 Plus API free to try?
Yes: new accounts get 10 trial calls and up to $1 in free credit, no card required. At $0.4/M input tokens, that credit alone covers roughly 312 requests of ~8K tokens against Qwen3.5 Plus.
What is Qwen3.5 Plus best at?
Early-fusion multimodal training; adaptive tool-calling modes; 1M-token context window by default. See the About section for the full picture from the vendor's own release notes.
How much does Qwen3.5 Plus cost?
Qwen3.5 Plus costs $0.4 per million input tokens and $2.4 per million output tokens on Synthorai. That is the provider's list price, with no platform markup. Cached input tokens bill at $0.115/M.
Does Qwen3.5 Plus support prompt caching?
Yes: automatic caching is on by default, with an explicit mode for guaranteed savings. Cached input tokens bill at $0.115/M vs $0.4/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 Plus?
Point your existing OpenAI SDK at base_url="https://synthorai.io/v1", set model="qwen3.5-plus", 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.