Qwen3.7 Plus is the multimodal workhorse of the Qwen3.7 generation, which the Qwen team calls "The Agent Frontier."
- Input
- text image video $0.4/M
- Output
- text $1.6/M
- Cache read
- $0.08/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 + preserve_thinking |
|---|---|
| Accepted values | enable_thinking true · false; thinking_budget in tokens; preserve_thinking true · false |
| Default | on; the Qwen3.7 Plus series is hybrid thinking with thinking enabled by default, 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. |
| Parameter | reasoning_effort |
| Values | minimal · low · medium · high the gateway's parameter surface - the vendor mapping above applies |
Model
| Modalities | text + image + video → text |
|---|
- Multimodal agent model unifying vision and language
- official unified GUI & CLI operation and coding-agent capability
- 1M-token context
- hybrid thinking on by default
One prompt, measured through the gateway
Qwen3.7 Plus passed · 3 sentences
Enabling reasoning requires the model to generate extensive internal "thinking" tokens to process complex logic before delivering a final answer. Because our vendor charges us per token consumed, this hidden computational overhead effectively doubles our output volume for the exact same number of user requests. Consequently, our costs have doubled because we are now paying for the model's increased processing time to achieve higher-quality, more accurate results.
out 1428 tok (+1345 thinking) latency 25.2 s
Instruction following (exactly three sentences - countable), audience shaping (CFO register), and the hidden-thinking billing gap the token meters below expose.
Qwen3.7 Plus passed · 8/8 cases
## Fixed Code ```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 ``` ## Bug Explanation The function has two related bugs rooted in how it counts run lengths. First, `cur` is initialized to `0` and only incremented on matches, so it counts the number of *transitions* between equal elements rather than the total elements in the run—a run of N identical items only reaches `cur = N − 1`, undercounting by one. This also causes the single-element case to return `0`, since the loop never executes and `cur` never increments. […]
out 2317 tok (+2005 thinking) latency 40.5 s
Whether the fix is actually correct (runnable), explanation density, and token efficiency on a bounded task.
Qwen3.7 Plus passed · 5/5 fields, guidance null
{ "company": "Meridian Robotics", "quarter": "September", "revenue_usd_m": 412, "growth_pct": 11, "guidance": null }
out 1807 tok (+1750 thinking) latency 31.6 s
Schema obedience (no invented fields), hallucination pressure (guidance is explicitly withheld), and structured-output path differences.
Qwen3.7 Plus passed · 120 words, 0 banned, 1 question
Introducing PromptCache, our new API gateway feature designed to store and reuse prompts across multiple artificial intelligence providers. Have you ever noticed how repeatedly sending identical queries drains your budget and increases latency? PromptCache solves this by intelligently storing responses at the gateway level. When your application requests the same prompt from a different provider, the system instantly returns the cached result. This drastically reduces API costs and accelerates response times for your users. You can configure custom expiration times and set specific fallback rules for each vendor. You must stop paying twice for the exact same computation. Please upgrade your entire infrastructure today and experience much faster and cheaper integrations without changing a single line of your application code.
out 4453 tok (+4312 thinking) latency 76.8 s
Constraint obedience (word budget, banned-word list, the single question), style fingerprint, and length control.
Use Qwen3.7 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.7-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.7-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.7-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.7-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.7-plus")
.addUserMessage("Summarize this diff")
.reasoningEffort(ReasoningEffort.MEDIUM)
.build());
System.out.println(resp.choices().get(0).message().content().orElse(""));About Qwen3.7 Plus
- It extends the generation's agentic backbone with image and video understanding while keeping deep reasoning, coding strength, and tool invocation, and carries a 1M-token context window for long-horizon sessions.
- Positioned as the balanced, lower-cost sibling to Qwen3.7 Max, it accepts text and visual input and returns text, making it suited to screen-aware agents and document workflows.
- Alibaba describes it perceiving real-world scenes, reading a screen and operating the GUI, generating code from a visual reference, and navigating a mobile app end to end.
- It is also the tier Alibaba recommends by default across its lineup, for balanced performance and cost with full tool calling and enough context for a large codebase.
- Documented input limits are unusually concrete: up to 2,048 images or 64 videos in a request, with video up to two hours and 2 GB, and output to 65,536 tokens.
- Thinking is hybrid and on by default, disabled per request with enable_thinking, capped with thinking_budget, and returned separately in reasoning_content where it bills as output; like the flagship it is one of the models Alibaba documents as supporting preserve_thinking, carrying reasoning across turns so multi-step agent runs stay consistent without re-deriving earlier decisions.
- Structured output, function calling, built-in tools, batch inference and both caching modes are listed for it.
- Synthorai serves it via the OpenAI-compatible endpoint.
FAQ
Is the Qwen3.7 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.7 Plus.
What is Qwen3.7 Plus best at?
Adds image and video understanding; balanced, lower-cost sibling to the flagship; suited to screen-aware agents and documents. See the About section for the full picture from the vendor's own release notes.
How much does Qwen3.7 Plus cost?
Qwen3.7 Plus costs $0.4 per million input tokens and $1.6 per million output tokens on Synthorai. That is the provider's list price, with no platform markup. Cached input tokens bill at $0.08/M.
Does Qwen3.7 Plus support prompt caching?
Yes: automatic caching is on by default, with an explicit mode for guaranteed savings. Cached input tokens bill at $0.08/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.7 Plus?
Point your existing OpenAI SDK at base_url="https://synthorai.io/v1", set model="qwen3.7-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.