Qwen3-VL 235B-A22B Thinking — open-weight vision-language reasoning model, 235B total / 22B active params, 128k context.
Qwen3 VL 235B A22B Thinking is a large-scale multimodal language model from the Qwen family. It employs a mixture-of-experts architecture, where only 22 billion of its 235 billion parameters are…
The model performs a range of vision-language tasks: image captioning, visual question answering, object recognition, and spatial reasoning. It can interpret diagrams, charts, and handwritten text. Because of its MoE structure, it activates relevant expert modules per input, which helps handle diverse image types efficiently. The thinking mode further improves accuracy on complex visual puzzles or multi-step reasoning about scenes. For simple tasks like basic object counting, a smaller model may suffice.
Video input is handled by sampling frames at intervals (configurable). The model can summarize video content, answer questions about actions or objects in the footage, and detect temporal sequences. It treats video as a series of images with a timeline, so reasoning about cause and effect or changes over time is possible. The thinking mode is especially useful here because it can articulate intermediate conclusions before delivering a final analysis. For very long videos, context window limits may apply.
Qwen3 VL 235B A22B Thinking is a large MoE model with specialized reasoning. Use it when you need high accuracy on complex multimodal tasks, especially those requiring logical deduction, detailed document parsing, or video understanding. For straightforward image captioning, basic OCR, or simple retrieval, smaller models (e.g., Qwen2.5 VL 7B) will be faster and cheaper. The thinking mode adds output tokens, so if you don’t need chain-of-thought, disable it to reduce cost and latency.
As an MoE model, it may exhibit slightly higher latency than dense models of similar activated size due to routing overhead. The thinking mode can produce lengthy reasoning chains, increasing output token count and cost. It is primarily optimized for English-language text, and performance on non-English or low-resource languages may be weaker. Video processing is limited by the maximum number of frames that fit within the context window. The model may also hallucinate on ambiguous or adversarial inputs, as common with large language models.
Specific benchmark scores for this model have not been provided in the available data. As a member of the Qwen3 VL family, it inherits the architectural strengths of the series, which generally achieves competitive results on vision-language tasks such as VQAv2, MMLU (multimodal version), and DocVQA. However, performance can vary by task. We recommend testing the model on your own data to evaluate its suitability. The thinking mode typically improves scores on reasoning-heavy benchmarks.
Latency depends on input size, number of active experts (22B), and whether thinking mode is enabled. The MoE architecture allows efficient scaling compared to a dense 235B model. First-token latency is typical for a model of this activated size (approximately 22B parameters). For a short image+text prompt without thinking, time-to-first-token may be a few seconds. With thinking enabled and long output sequences, total inference time can increase significantly. OrcaRouter provides real-time monitoring via the API dashboard.
The MoE design with 22B active parameters offers a favorable trade-off between model capacity and computational cost. It can match or exceed the accuracy of a dense 70B model on many tasks while using fewer FLOPs per token. The expert routing allows specialization: different experts handle different types of visual or reasoning tasks. This makes the model more robust to domain shifts than a smaller dense model. Latency is generally lower than a dense 235B model, though higher than a dense 22B model.
Despite its advantages, the model is not a panacea. It may struggle with tasks requiring precise spatial localization (e.g., exact object bounding boxes) unless fine-tuned. The thinking mode can sometimes produce irrelevant or circular reasoning, increasing cost without benefit. Inference on very high-resolution images may be inefficient because all patches must be processed. If your workload is dominated by simple, low-variance inputs, a smaller model will be more cost-effective and faster.
Pricing is $0.40 per 1 million input tokens and $4.00 per 1 million output tokens. These rates are billed at the provider rate with zero markup applied by OrcaRouter. Input tokens include all text prompts, image tokens, and video frame tokens. Output tokens include both the thinking chain (if enabled) and final answer. For a typical multimodal query of 1,000 input tokens and 500 output tokens, the cost would be $0.00040 + $0.00200 = $0.00240. Total costs scale linearly with token usage.
OrcaRouter does not markup provider prices, but may offer caching options as part of its infrastructure. Specifically, input token caching can reduce costs if you reuse parts of prompts (e.g., system messages or common image snippets). Consult the OrcaRouter documentation for the latest caching policies. There is no commitment or bulk discount structure; you pay only for tokens consumed. The cost advantage of MoE is realized per-token because only 22B parameters are used per step.
Input tokens depend on the number of images or video frames and their resolution. Each image is typically broken into fixed-size patches, each converted into tokens. High-resolution images or longer videos increase input token count substantially. Output tokens include the thinking chain; a typical chain-of-thought for a medium-difficulty question may add 200-500 tokens. The maximum output length is 40,960 tokens, allowing very long reasoning sequences if needed. Plan your budget accordingly.
Use the OpenAI-compatible API endpoint with base URL https://api.orcarouter.ai/v1. Set the model parameter to "qwen/qwen3-vl-235b-a22b-thinking". Authentication is via an API key included in the Authorization header. The request format follows the OpenAI chat completions convention with messages. For multimodal inputs, include a content array with type "text" and type "image_url" (or "video_url" for videos). Example: curl -X POST https://api.orcarouter.ai/v1/chat/completions -H "Authorization: Bearer YOUR_KEY" -H "Content-Type: application/json" -d '{"model":"qwen/qwen3-vl-235b-a22b-thinking","messages":[{"role":"user","content":[{"type":"text","text":"What is in this image?"},{"type":"image_url","image_url":{"url":"https://example.com/photo.jpg"}}]}]}'
In addition to standard OpenAI-compatible parameters (temperature, top_p, max_tokens, stop, etc.), this model supports a "thinking" parameter to enable or disable the chain-of-thought mode. Set "thinking": true (default) to include reasoning, or false to output only the final answer. Other possible model-specific parameters include "max_thinking_tokens" to limit the length of the reasoning chain. See the OrcaRouter API documentation for a full list. The response format is identical to OpenAI’s, with the thinking chain included as part of the content if enabled.
If you currently use OpenAI’s GPT-4V or GPT-4o, migration is straightforward. Change the base URL to https://api.orcarouter.ai/v1, use your OrcaRouter API key, and set the model to "qwen/qwen3-vl-235b-a22b-thinking". The chat completion API is identical in schema. Note that the thinking mode may produce longer outputs; you can disable it with "thinking": false. Image and video inputs use the same content type structure. Test with a small number of requests first to verify compatibility and cost.
Video input is provided as a URL to a video file (e.g., MP4). In the messages content array, use type "video_url" with a url field. OrcaRouter’s backend will sample frames from the video up to a maximum number that fits within the context window. You can optionally specify a frame_sample_rate parameter. The model then processes the sampled frames as a sequence. The thinking mode can reason across frames to understand temporal events. For very long videos, consider pre-filtering or splitting into segments.
Qwen3 VL 235B A22B Thinking uses an MoE architecture with 22B active parameters, whereas GPT-4o is a dense model of undisclosed size. Both support image, text, and video input. The thinking mode provides explicit reasoning, which GPT-4o does not by default (though you can prompt chain-of-thought). Qwen3 VL is generally more cost-effective per token ($0.40/$4.00 vs. GPT-4o’s $5/$15 per 1M input/output tokens). Latency may be higher due to MoE routing. Performance depends on the specific task; we recommend side-by-side evaluation.
Gemini 2.0 Flash is a smaller, faster model optimized for low latency. Qwen3 VL 235B A22B Thinking offers a larger effective capacity through MoE and a built-in thinking mode. Gemini Flash has a context window of ~1M tokens, while Qwen3 VL has 131K. For tasks requiring deep reasoning on complex visuals, Qwen3 VL may produce more accurate results. However, for simple or time-sensitive tasks, Gemini Flash will be faster and cheaper. Both are accessible via OrcaRouter’s API.
Llama 3.2 90B is a dense vision-language model with 90B parameters. Qwen3 VL 235B A22B has more total parameters but activates only 22B, potentially using fewer FLOPs per token. Llama 3.2 supports only image input (not video). The thinking mode in Qwen3 VL provides explicit reasoning, while Llama does not have a built-in mechanism. Pricing for Llama 3.2 via OrcaRouter is typically lower per token, but for tasks where reasoning depth matters, Qwen3 VL may provide better results. Context window is larger in Qwen3 VL (131K vs. 128K).
This model (235B total, 22B active) is the largest in the Qwen3 VL MoE family. Smaller variants (e.g., 72B total / 15B active) are cheaper and faster. Choose this model when you need the highest possible accuracy on challenging multimodal reasoning tasks, video understanding, or when the thinking mode adds value. For tasks that are well-handled by smaller models, such as simple captioning or classification, the cost savings of a smaller MoE (or dense model) will be significant.
OpenAI-compatible — keep the SDK you already use
https://api.orcarouter.ai/v1import os
from openai import OpenAI
client = OpenAI(
base_url="https://api.orcarouter.ai/v1",
api_key=os.environ["ORCAROUTER_API_KEY"],
)
response = client.chat.completions.create(
model="qwen/qwen3-vl-235b-a22b-thinking",
messages=[{"role": "user", "content": "Hello"}],
)
print(response.choices[0].message.content)enable_searchenable_thinkinginclude_reasoninglogprobsmax_tokensnparallel_tool_callspresence_penaltyreasoningrepetition_penaltyresponse_formatseedstopstreamstream_optionstemperaturethinking_budgettool_choicetoolstop_ktop_logprobstop_p| Input / 1M tokens | $0.400 |
|---|---|
| Output / 1M tokens | $4.00 |
| Currency | USD |
Estimate based on list price
Estimate only — actual token counts depend on the provider's tokenizer.
Compare monthly costs across models in the LLM cost calculator
What developers are saying this week
GET /api/public/models/qwen/qwen3-vl-235b-a22b-thinkingOpen @misc{orcarouter_qwen3_vl_235b_a22b_thinking,
title = {Qwen3 VL 235B A22B Thinking API},
author = {Qwen},
year = {2025},
howpublished = {OrcaRouter},
url = {https://www.orcarouter.ai/models/qwen/qwen3-vl-235b-a22b-thinking}
}Qwen. (2025). Qwen3 VL 235B A22B Thinking API. OrcaRouter. https://www.orcarouter.ai/models/qwen/qwen3-vl-235b-a22b-thinking