Bonus: Top up now and we'll double your first deposit — get x2 credits instantly.
Get Started
Sign Up
Sign Up

Qwen3 VL 235B A22B Thinking: Self-Hosting & Deployment Guide

Qwen3 VL 235B A22B Thinking is a large Qwen multimodal model that can process both images and text with enhanced chain-of-thought style reasoning.

Start Using API

What is Qwen3 VL 235B A22B Thinking?

Qwen3 VL 235B A22B Thinking is a multimodal large language model from Qwen that supports visual and textual understanding with an emphasis on extended reasoning. It is mainly used for complex analysis of images and documents, such as detailed visual question answering, multi-step interpretation, and grounded explanations. It is also applied to advanced text-only reasoning tasks where deliberate, step-by-step thinking is valuable, for example in technical problem-solving or multi-hop research-style queries. It belongs to the Qwen3 family of large-scale language and vision-language models that follow earlier Qwen and Qwen-VL generations.

How to run Qwen3 VL 235B A22B Thinking yourself

Open weights (apache-2.0), 235.7B parameters. Below: how much memory the weights need at each quantization, which hardware fits them, and the commands to serve it.

Qwen3 VL 235B A22B Thinking VRAM requirements

Precision / quantizationWeightsFigureSource
BF16 (full precision)471.3 GBEstimate235.7B params × 2 bytes
FP8237.6 GBFile sizeQwen/Qwen3-VL-235B-A22B-Thinking-FP8
AWQ 4-bit125.2 GBFile sizeQuantTrio/Qwen3-VL-235B-A22B-Thinking-AWQ
GGUF Q8_0250.7 GBFile sizeQwen/Qwen3-VL-235B-A22B-Thinking-GGUF

File size = actual download size on Hugging Face. Estimate = parameter count × bytes per weight. Weights only — the KV cache for long contexts needs extra memory; the fit tables below add 15% headroom as a rule of thumb.

GPU requirements: deploy Qwen3 VL 235B A22B Thinking on your hardware

HardwareBF16 (full precision)FP8AWQ 4-bitGGUF Q8_0
NVIDIA H200141 GB4×2×2×3×
NVIDIA H10080 GB7×4×2×4×
NVIDIA A100 80GB80 GB7×4×2×4×
NVIDIA L40S48 GB—6×3×7×

GPUs needed per variant.

HardwareGGUF Q8_0
RTX 509032 GB—
RTX 409024 GB—
RTX 309024 GB—

GGUF via llama.cpp; more cards or CPU offload for larger files.

HardwareGGUF Q8_0
Mac, 512 GBM3 UltraFits
Mac, 192 GBM2 Ultra—
Mac, 128 GBM4 Max / M3 Max—
Mac, 64 GBM4 Pro / Max—

Assumes ~75% of unified memory is usable by the GPU.

HardwareBF16 (full precision)FP8AWQ 4-bitGGUF Q8_0
AWS p5.48xlarge8× H100 · 640 GBFitsFitsFitsFits
AWS p4de.24xlarge8× A100 80GB · 640 GBFitsFitsFitsFits
AWS g6e.12xlarge4× L40S · 192 GB——Fits—
Google Cloud a3-highgpu-8g8× H100 · 640 GBFitsFitsFitsFits
Azure ND H100 v58× H100 · 640 GBFitsFitsFitsFits

Whole-instance GPU memory; public instance specs.

Serve it yourself

pip install -U vllm
vllm serve Qwen/Qwen3-VL-235B-A22B-Thinking
pip install 'sglang[all]'
python -m sglang.launch_server --model-path Qwen/Qwen3-VL-235B-A22B-Thinking
llama-server -hf Qwen/Qwen3-VL-235B-A22B-Thinking-GGUF:Q8_0 \
  --ctx-size 32768 --n-gpu-layers 99

Commands use the official repositories above; vLLM and SGLang expose an OpenAI-compatible endpoint.

Skip the deploy — use LLM.API as your endpoint

No GPUs, no quantization trade-offs. Same model, OpenAI-compatible, with custom volume discounts on request.

Get API keySee API code ↓

Providers

Different companies host the same model. OpenRouter routes your request to one of them based on the routing mode you pick — Balanced (price + speed), Nitro (fastest), or Exacto (highest tool-calling accuracy).

List price by provider

InputOutput
alibaba$0.5 in
$2 out
novita$0.98 in
$3.95 out

Provider list prices; the LLM.API discount applies on top.

Provider Input Output Cache read /M Latency Throughput Uptime
alibabain $0.5; out $2 per 1M tokens131K tokensvision, tools, streaming, reasoning, JSON, structured
novitain $0.98; out $3.95 per 1M tokens131K tokensvision, tools, streaming, reasoning

Prices and availability from the LLMAPI catalogue, updated nightly. Last updated 11 Oct 2026.

Try this model

Test Qwen3 VL 235B A22B Thinking right here — free to start.

Qwen3 VL 235B A22B Thinking
Hi! Want to test the model?

Suggestions for your first prompt

Code snippet

Call the model through the OpenAI-compatible API.

Switching from OpenAI? Change 2 lines.

- base_url="https://api.openai.com/v1"
- api_key="YOUR_OPENAI_KEY"
+ base_url="https://api.llmapi.ai/v1"
+ api_key="YOUR_LLMAPI_KEY"

Everything else stays the same — SDK, message format, tools, streaming. Set model to qwen3-vl-235b-a22b-thinking and the call runs unchanged.

bash
curl https://api.llmapi.ai/v1/chat/completions \
  -H "Authorization: Bearer $LLMAPI_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "qwen3-vl-235b-a22b-thinking",
    "messages": [
      {"role": "user", "content": "Give me three crisp launch checklist items."}
    ]
  }'
from openai import OpenAI

client = OpenAI(
    api_key="YOUR_LLMAPI_KEY",
    base_url="https://api.llmapi.ai/v1",
)

resp = client.chat.completions.create(
    model="qwen3-vl-235b-a22b-thinking",
    messages=[
        {"role": "system", "content": "You are a precise product assistant."},
        {"role": "user", "content": "Give me three crisp launch checklist items."},
    ],
)
print(resp.choices[0].message.content)
import OpenAI from "openai";

const client = new OpenAI({
  apiKey: process.env.LLMAPI_KEY,
  baseURL: "https://api.llmapi.ai/v1",
});

const resp = await client.chat.completions.create({
  model: "qwen3-vl-235b-a22b-thinking",
  messages: [
    { role: "user", content: "Give me three crisp launch checklist items." },
  ],
});

console.log(resp.choices[0].message.content);
stream = client.chat.completions.create(
    model="qwen3-vl-235b-a22b-thinking",
    messages=[{"role": "user", "content": "Write a haiku about latency."}],
    stream=True,
)

for chunk in stream:
    delta = chunk.choices[0].delta.content
    if delta:
        print(delta, end="", flush=True)
{
  "model": "qwen3-vl-235b-a22b-thinking",
  "messages": [
    {"role": "system", "content": "You are a precise product assistant."},
    {"role": "user", "content": "Give me three crisp launch checklist items."}
  ]
}

ENDPOINTS

Supported endpoints & features

Base URL https://api.llmapi.ai/v1 · model ID qwen3-vl-235b-a22b-thinking · OpenAI-compatible.

  • POST /v1/chat/completionsChat Completions — supported
FeatureStatusHow to set it
Function calling (tools)Supportedtools, tool_choice
Parallel tool callsNot supportedparallel_tool_calls
JSON modeSupportedresponse_format: {"type": "json_object"}
Structured outputsSupportedresponse_format: {"type": "json_schema", …}
StreamingSupportedstream: true
Vision (image input)Supportedimage_url content parts
Web searchNot supportedweb_search

ERRORS

Errors & fallback routing

CodeWhat it meansWhat to do
401Missing or invalid API key.Send Authorization: Bearer YOUR_LLMAPI_KEY and check the key is active.
429Rate limited, or the upstream provider is throttling the request.Back off and retry with jitter; the gateway also retries the request on another provider where one is available.
5xxUpstream provider error or timeout.Retry; fallback routing sends the retry to the next healthy provider for this model.

When a provider fails or throttles, the request is routed to the next provider serving this model — the ones listed in the providers table above.

Qwen3 VL 235B A22B Thinking: Self-Hosting & Deployment Guide in production

What the model is good at.

  • Visual Reasoning

    Understands and reasons about images and diagrams, identifying objects, spatial relations, and visual patterns for complex tasks.

  • Text Extraction

    Reads and extracts structured and unstructured text from images or documents, enabling downstream analysis and transformation of content.

  • Conversational Assistance

    Engages in multi-turn dialogue, follows complex instructions, and maintains context to provide helpful, coherent, and detailed responses.

  • Code and Tools

    Interprets technical instructions, reasons step-by-step, and can coordinate with tools or systems for complex problem solving.

  • Multilingual Understanding

    Understands and translates between multiple languages, preserving meaning and context across diverse linguistic inputs and outputs.

What you get when you call Qwen3 VL 235B A22B Thinking: Self-Hosting & Deployment Guide through LLM.API.

  • Unified AI Routing

    Define intent once and let LLM.API route to the optimal model across providers based on latency, quality, and constraints—no client changes required.

    One endpoint, every model

  • Cost-Aware Execution

    Enforce per-project budgets, pick cheaper equivalents automatically, and track exact token spend so you can scale usage without surprise invoices.

    Optimize spend by default

  • Automatic Fallback Logic

    Configure multi-provider failover and retry policies so requests keep succeeding even when individual models, regions, or vendors degrade or go offline.

    Resilience built-in

  • End-to-End Observability

    Get structured logs, traces, and metrics for every request—latency, cost, provider, and model—making it easy to debug, tune prompts, and meet SLAs.

    See every token

  • Task-Oriented Abstractions

    Call high-level tasks like chat, tools, embeddings, or rerank via one consistent API while LLM.API selects and orchestrates the best underlying models.

    Tasks, not raw models

  • High-Throughput Batch APIs

    Submit large batches of prompts, tools, or embeddings in a single call to maximize throughput, cut network overhead, and slash per-request compute costs.

    Scale to millions

When to Use — When NOT to Use

Use it if...

  • You need very strong multi-step reasoning where slower but higher-quality chains are acceptable.
  • You need advanced multimodal understanding that jointly reasons over complex images, text, and layouts.
  • Your use case involves difficult coding or algorithmic tasks that benefit from deliberate thinking.
  • You need to analyze lengthy technical documents and derive structured insights or action plans.
  • Your use case involves complex tool-calling or orchestration where accurate reasoning is critical.
  • You need high-end assistant behavior for research, tutoring, or planning with rich explanations.
  • Your use case involves multimodal data extraction from diagrams, charts, or dense scientific figures.

Avoid if...

  • You need ultra-low-latency responses where even moderate deliberate reasoning would be too slow.
  • Your workload requires serving millions of lightweight requests under tight cost constraints daily.
  • You need on-device or edge deployment where model size and memory are strictly limited.
  • Your workload requires strict real-time interaction, like high-frequency trading or fast-twitch gaming.
  • You need simple classification or routing tasks better handled by smaller, cheaper models.
  • Your workload requires guaranteed deterministic outputs with minimal sampling variance across runs.
  • You need basic image tagging or OCR only, without heavy reasoning or contextual understanding.

LLM API rating for Qwen3 VL 235B A22B Thinking

★ 3.8/ 5.0LLM API rating
50% production adoption · 30% category benchmark · 20% tooling & value✓ Verified benchmark · LMArena
4.2Production adoptionStrong open-weight adoption
3.4Benchmark qualityLMArena text rank #145, Elo 1401
3.3Developer ecosystemContext window, tool and JSON support, price against the category median
Reasoning & chat 3.8Coding 3.8Vision & multimodal 3.8Tool & function calling 3.7
How is this rating calculated?

Every model gets a separate 1.0–5.0 score for each category it can be used in, so a model can rate high for coding and lower for vision. The score combines three parts:

  1. Production adoption — 50%. How widely the model is actually used in production: provider traffic, LiteLLM and gateway usage, open-weight downloads and its LMArena rank. Proven, widely used models score highest.
  2. Category benchmark — 30%. The public benchmark that matters for that category — the Artificial Analysis Intelligence Index and LMArena Elo for reasoning, LMArena coding Elo for coding, image and document support plus vision Elo for vision, tool and JSON support for function calling, measured speed for voice.
  3. Tooling & value — 20%. Context window, support for tools, structured outputs and streaming, and price compared with the category median.

Scores of 4.0 and above are shown in green, 3.0–3.9 in yellow, below 3.0 in red. When a model has no public data for a part, it gets a neutral value instead of an invented number.

A “Verified benchmark” mark (✓) means an independent lab — LMArena or Artificial Analysis — has actually tested that model, and the source figure is shown. Models without that mark are labelled “Estimated from published specs”: the score comes from the published context window, tool and schema support, price and adoption only, because no independent lab has tested them yet.

One exception: a brand-new top-tier model that scores very high on the independent benchmarks but has no usage history yet is rated on the benchmark (60%) and tooling & value (40%) alone, so a missing adoption figure can't hold it back. All inputs come from public sources and are refreshed weekly.

Adoption and benchmark inputs come from public sources — LMArena, Artificial Analysis Intelligence Index and published model specs. Updated weekly.

COMMUNITY

What developers say about Qwen3 VL 235B A22B Thinking

LMArena#145 · Elo 1401Arena coding#135 · Elo 1425Speed—Sources: LMArena, Artificial Analysis

Summarised from public developer discussions and write-ups. Opinions are the sources’, not LLM.API’s.

  • Developers on GitHub report that the model is considered a new SOTA (state-of-the-art) vision model and have actively sought its integration into the llama.cpp ecosystem.
  • Developers on Hugging Face indicate the model is capable of running on personal hardware using GGUF quantization, supporting mixed precision for language and vision components across various GPU and CPU backends.
  • Developers on GitHub and Hugging Face describe the 'Thinking' variant as highly effective for complex STEM and math reasoning, despite a noted structured output error rate of approximately 4.25%.

SOURCES

Frequently Asked Questions

  • What is Qwen3 VL 235B A22B Thinking?

    Qwen3 VL 235B A22B Thinking is a large multimodal Qwen model focused on deliberate, step-by-step reasoning over text and images.

  • What is Qwen3 VL 235B A22B Thinking best suited for?

    It is best for complex reasoning tasks, multi-step problem solving, code understanding, and detailed image-plus-text analysis where accuracy matters more than raw speed.

  • What modalities does Qwen3 VL 235B A22B Thinking support via LLM.API?

    Through LLM.API it supports text input and output, plus image inputs for vision-language reasoning and description.

  • How is Qwen3 VL 235B A22B Thinking priced on LLM.API?

    Pricing is usage-based per input and output token on LLM.API; check the Qwen3 VL 235B A22B Thinking entry in the pricing dashboard.

  • What is the context window of Qwen3 VL 235B A22B Thinking?

    Qwen3 VL 235B A22B Thinking supports a long context window suitable for multi-document analysis; refer to the LLM.API model card for the exact limit.

  • How fast is Qwen3 VL 235B A22B Thinking compared to smaller models?

    As a 235B-scale model it has higher latency and lower throughput than smaller models, trading speed for stronger reasoning quality.

  • How do I call Qwen3 VL 235B A22B Thinking through LLM.API?

    Use the standard LLM.API chat or completion endpoint with the model identifier for Qwen3 VL 235B A22B Thinking and your API key.

  • How does Qwen3 VL 235B A22B Thinking compare to similar reasoning models?

    It prioritizes deliberate reasoning quality over speed, making it competitive for complex tasks but less suitable for ultra-low-latency applications.

  • What are the main limitations of Qwen3 VL 235B A22B Thinking?

    It can be slower and more expensive than smaller models and may still hallucinate details, so critical outputs should be validated.

  • Can Qwen3 VL 235B A22B Thinking handle streaming responses on LLM.API?

    Yes, you can enable streaming in your LLM.API request to receive tokens incrementally from Qwen3 VL 235B A22B Thinking.

COMPARE

Competitive Models

Qwen3 Max is Qwen’s flagship trillion-parameter large language model, offered as a high-end proprietary API model. It is designed to deliver state-of-the-art performance across reasoning, coding, and multilingual tasks within the Qwen3 family.

  • Qwen3 Coder Plus

    • Code Generation

    Qwen3 Coder Plus is Qwen’s premium, API-accessible coding model with a 1M‑token context window, optimized for complex, agentic software engineering tasks. It offers higher capability and quality than the base Qwen3-Coder variants for large-scale code generation, refactoring, and debugging.

  • Qwen3 VL 235B A22B Instruct

    • Instruction Following

    Qwen3 VL 235B A22B Instruct is a 235B-parameter Mixture-of-Experts vision-language model from Qwen, offering open-weight, long-context (≈256K) multimodal reasoning over text, images, and video. It is instruction-tuned for chat-style interactions and agentic use, including GUI automation and tool use.

    • Get one key to every model

    Swap your API key. Keep your code.

    Start for free Talk to sales