
Qwen is Alibaba Cloud's large language model family, and the Qwen API opens the entire lineup to developers. Reach flagship Qwen3.7 Max for advanced reasoning and coding, efficient mixture-of-experts models across many scales, and Qwen3.5 Flash for instant, high-volume responses. On Atlas Cloud every model runs through one endpoint with transparent pay-as-you-go pricing and Day-0 access to new releases. Start building today.
Atlas Cloud provides you with the latest industry-leading creative models.
See how each Qwen API endpoint turns text prompts into generated text, from fast lightweight assistants to flagship reasoning models, so you can match the right model to your workload.
| Modality | Description |
|---|---|
| Qwen3.6 35B A3B (Text to Text) | The newest reasoning model in the lineup, this 35B mixture-of-experts endpoint activates about 3B parameters per token so deep reasoning stays affordable. Send it multi-step math, logic, and analysis tasks where chain-of-thought quality matters more than raw speed. |
| Qwen3.6 Plus (Text to Text) | Versatile across chat and productivity workflows, Qwen3.6 Plus pairs strong conversational quality with prompt caching and tiered pricing that extends past 256K tokens. Reach for it when assistants must stay coherent over long documents or lengthy multi-turn sessions. |
| Qwen3.5 122B A10B (Text to Text) | Running roughly 10B active parameters per token, this 122B mixture-of-experts model trades a little scale for faster, cheaper inference. It suits general text generation, summarization, and reasoning where you want large-model quality at mid-tier cost. |
| Qwen3.5 35B A3B (Text to Text) | When throughput and budget both matter, this 35B MoE endpoint keeps only about 3B parameters active per token. Use it for high-volume chat, drafting, and classification that would be wasteful to run on a flagship model. |
| Qwen3.5 27B (Text to Text) | A dense 27B model, Qwen3.5 27B delivers predictable latency and consistent quality without mixture-of-experts routing. It fits straightforward generation and instruction-following tasks that benefit from a compact, reliable backbone. |
| Qwen3.5 397B A17B (Text to Text) | The largest model in the 3.5 tier, this 397B mixture-of-experts endpoint activates around 17B parameters per token and adds prompt caching to cut repeat-context cost. Bring it demanding reasoning and generation jobs that call for the family's deepest capacity. |
| Qwen3.7 Max (Text to Text) | As the flagship, Qwen3.7 Max targets advanced reasoning, coding, and complex multi-step tasks, with prompt caching to reduce cost on repeated context. Choose it for agentic pipelines, hard coding problems, and workloads where accuracy outweighs price. |
| Qwen3.5 Plus (Text to Text) | Efficient by design, Qwen3.5 Plus powers everyday tasks and AI assistants while supporting prompt caching and inputs that run past 256K tokens. It is a dependable default for production assistants that need steady quality at manageable cost. |
| Qwen3.7 Plus (Text to Text) | Need capability, speed, and efficiency in one model? Qwen3.7 Plus balances all three, adds prompt caching, and applies tiered pricing for prompts beyond 256K tokens. Deploy it for scaled assistants and document-heavy workflows that still demand quick responses. |
| Qwen3.5 Flash (Text to Text) | Optimized for instant responses and large-scale usage, Qwen3.5 Flash is the fastest and most economical option in the family. Ship it into high-traffic chat, autocomplete, and real-time features where low latency is the priority. |
| Qwen3 VL 235B A22B Thinking (Text to Text) | This reasoning-tuned endpoint runs a 235B mixture-of-experts architecture with about 22B active parameters and a dedicated thinking mode. Turn to it for structured problem solving and analysis that reward explicit, step-by-step reasoning. |
| Qwen3-235B-A22B-Instruct-2507 (Text to Text) | With 235B total parameters and roughly 22B active per token, this instruction-tuned MoE model in the Qwen3 series handles broad text generation and reasoning. The 2507 release makes it a solid pick for general-purpose assistants and content pipelines on the Qwen API. |
The Qwen API brings dual-mode thinking, native function calling, context past 256K tokens, coverage of 119 languages, and prompt caching together behind one OpenAI-compatible key, spanning Qwen3.5 Flash to Qwen3.7 Max.

Function calling lets Qwen models emit structured tool invocations that plug straight into your own APIs, databases, and MCP servers. The model decides when to call a function, formats the arguments, then folds the result back into its answer. Combined with the OpenAI-compatible endpoint, this turns existing SDK code into autonomous agents, retrieval pipelines, and workflow automations.

Switch a single model between a deliberate thinking mode for math, logic, and coding and a fast non-thinking mode for everyday dialogue. Reasoning models such as Qwen3.6 35B A3B and the flagship Qwen3.7 Max expose this depth through one endpoint. When a task needs step-by-step deduction you enable thinking; when latency matters you turn it off, with no model or key swap.

Trained across 119 languages and dialects, Qwen handles multilingual instruction following and translation with equal fluency in Chinese and English. A single prompt can move between languages without a separate translation service. Teams shipping to global audiences rely on it for localized chat, cross-lingual search, and copy that reads naturally in each target market.

From the low-latency Qwen3.5 Flash to the flagship Qwen3.7 Max, the entire family answers to one OpenAI-compatible key. Efficient mixture-of-experts designs such as the 397B A17B and 235B A22B activate only a fraction of their parameters per token, and every tier shares the same request format. Route simple calls to Flash and hard reasoning to Max without rewriting a line of integration code.

Repeated context is billed at a cached rate well below the standard input price, so system prompts and shared documents cost less on every follow-up call. Pricing stays pay-as-you-go and transparent, with published per-token rates and no subscription. High-volume assistants, RAG stacks, and long conversations gain the most, since the same prefix is sent again and again.
Hand one identical brief to the Qwen API and to rival engines, then watch each model turn the very same instruction into a working single file web page you can open and click right away.
Build a complete, single-file, self-contained HTML page (all CSS and JavaScript inlined in one .html file) that renders an interactive "Late-Night French Patisserie Window" — a boutique dessert display case, still glowing with warm light after closing hours. Absolute constraint: NO external resources of any kind — no CDNs, no linked stylesheets or scripts, no web fonts, no `<img>` tags, no SVG files, no base64 photos, no emoji as art. Every visual must be constructed purely from HTML elements styled with CSS: layered linear/radial/conic gradients, stacked and inset box-shadows, border-radius, blur/backdrop-filter, transforms, and canvas or DOM-drawn shapes only. This is a test of rendering faux-realistic material and light with vector CSS alone. The scene: a front-on, eye-level view into a glass patisserie window, shelves arranged in a calm rule-of-thirds composition. On the shelf sits a row of at least four distinct, meticulously crafted desserts, each built entirely from gradients and shadows: (1) a glossy chocolate-cocoa mousse dome with a mirror-glaze finish that shows a soft specular highlight and reflected light; (2) a mille-feuille with many crisp, visibly separated puff-pastry layers; (3) a tiered macaron tower with sugar-frosted, slightly matte shells; (4) a lemon tart on a slowly rotating turntable plate. Model believable depth: warm golden spotlight from above (the window's display lamp) contrasted against a cool blue ambient night, with cast shadows, rim light on edges, and gentle glossy reflections. A subtle glass layer floats in front of everything — faint reflections, streaks, and a scatter of condensation droplets — and there is a soft reflection of each dessert on the shelf surface below it. Interactions (all smooth, spring-like CSS/JS transitions): - HOVER a dessert: it lifts gently, its spotlight and shadow intensify, and a cross-section "cutaway" animation reveals its internal structure — the layered cream, ganache, curd, and biscuit/pastry base drawn as stacked gradient bands with a label. - CLICK a dessert to enter a "Customize" mode: an elegant panel appears with sliders and toggles that let the user add and adjust decorative elements in real time — sprinkled sugar pearls (density slider), drizzled pulled caramel (amount + strand thickness), and a mirror-glaze/glossy pectin coat (glossiness slider), plus an accent-berry-red drizzle. The dessert must repaint live as values change, with the highlight/gloss responding to the glossiness value. Provide a "Reset" and an "Exit" control. Persist each dessert's customization while switching between them. - Optional ambient touches: a faint animated flicker on the warm lamp, drifting condensation, and the lemon tart's turntable rotating on a loop. Visual style: refined, cozy, seductive late-night mood; palette of caramel brown, cream white, and berry red, accented with mint green, over a deep cool-blue night background. Typography should feel like a chic patisserie — set headings and dessert names in an elegant CSS-only serif stack with generous letter-spacing; keep the layout tidy, ordered, and responsive so it looks good from mobile to widescreen. Prioritize tasteful micro-animations, layered depth, and material realism over clutter. Include everything needed to open the file directly in a browser and immediately interact with it. Output only the full HTML document, nothing else.
Generated with Qwen3.7 Max on Atlas Cloud
Generated with Grok 4.5 on Atlas Cloud
Generated with Qwen3.5 397BA17B on Atlas Cloud
Create a single self-contained HTML file (all CSS and JavaScript inline, absolutely no external libraries, CDNs, images, fonts, or network requests) that renders a real-time, playable whitewater kayaking game called "Rapid Run" entirely on a single HTML5 Canvas element that fills the browser window and stays responsive on resize. The view is a third-person top-down camera with slight forward perspective, looking down a procedurally generated alpine mountain stream that scrolls continuously from top to bottom and never repeats: seed the level with a noise/pseudo-random generator so each run carves a different braided channel with narrowing chutes, midstream boulders, swirling whirlpools, small waterfall drops, and churning white-foam wave trains. The player pilots a single crimson-and-amber kayak that holds near the lower third of the screen while the river rushes past; steer with Left/Right arrow keys (or A/D) to edge and carve, and let the mouse act as a paddle — the kayak leans and pulls toward the horizontal mouse position, with a click or held button to plant a hard paddle stroke that snaps the boat onto a tighter line. Simulate the water as a live flow field driven by layered scrolling noise: the current pushes the kayak downstream and sideways, faster in the tongues and slower in eddies, so the player must read the water and fight for the racing line. Emit a rich GPU-friendly particle system — a fan of spray bursting off the bow when it slaps a wave, a trailing turbulence wake churning off the stern, foam sheets exploding on impacts, and rings rippling out of whirlpools. Hitting a rock spins the boat out with a jarring wobble, momentary loss of control, and a shudder of the camera. Render in a crisp flat-illustration style fused with light fluid realism: the water surface shows animated ripples and refractive highlight glints from the flow field, noon high-plateau top light, cool white speculars on the spray, and deep pools graded from turquoise green into inky teal. Color palette is glacier cyan-blue dominant, with the kayak's vermilion-orange-yellow as the punchy accent, banks dressed in grey stone and pine green. Include an on-screen HUD: distance traveled, current speed, a stability/health meter that drains on rock hits, and a live score; show a start screen with brief controls, a game-over screen when stability is depleted with a Restart option, and gradually ramp difficulty (faster current, denser hazards) the farther you descend. Target a smooth 60fps game loop using requestAnimationFrame with delta-time physics, all tuned for a genuinely tense, satisfying feel where nailing a clean line through a foaming chute feels earned.
Generated with Qwen3.7 Max on Atlas Cloud
Generated with Grok 4.5 on Atlas Cloud
Generated with Qwen3.7 Max on Atlas Cloud
See how the Qwen API measures up against other flagship text models on Atlas Cloud across context length, output ceilings, supported input types, and transparent per-call pricing.
| Model | Context Window | Max Output Tokens | Input Types | Input Price ($/1M) | Output Price ($/1M) |
|---|---|---|---|---|---|
| Qwen3.7 Max | 1M | 67,072 | Text | $2.50 | $7.50 |
| Qwen3.7 Plus | 1M | 67,072 | Text | $0.40 (≤256K) / $1.20 (>256K) | $1.60 / $4.80 |
| Qwen3.6 35B A3B | 256K | 65,536 | Text, Image, Video | $0.248 | $1.485 |
| Qwen3.5 Flash | 1M | 67,072 | Text | $0.10 | $0.40 |
| DeepSeek V4 Pro | 1M | 393,216 | Text | $1.74 | $3.45 |
| Grok 4.5 | 500K | 500,000 | Text | $2.00 | $6.00 |
| GLM 5.2 | 1M | 131,072 | Text | $1.40 | $4.40 |
Get started in minutes — follow these simple steps to integrate and deploy models through Atlas Cloud's platform.
Sign up at atlascloud.ai and complete verification. New users receive free credits to explore the platform and test models.
Combining the advanced Qwen models with Atlas Cloud's GPU-accelerated platform provides unmatched performance, scalability, and developer experience.
Low Latency:
GPU-optimized inference for real-time reasoning.
Unified API:
Run Qwen, GPT, Gemini, and DeepSeek with one integration.
Transparent Pricing:
Predictable per-token billing with serverless options.
Developer Experience:
SDKs, analytics, fine-tuning tools, and templates.
Reliability:
99.99% uptime, RBAC, and compliance-ready logging.
Security & Compliance:
SOC 2 Type II, HIPAA alignment, data sovereignty in US.
The Qwen API gives developers programmatic access to Alibaba Cloud's Qwen family of large language models for text generation, reasoning, coding, and multilingual tasks. On Atlas Cloud you reach the full lineup through one OpenAI-compatible endpoint, so a single key covers every Qwen model.
Atlas Cloud hosts a broad lineup, from the fast and economical Qwen3.5 Flash to versatile Plus tiers and the flagship Qwen3.7 Max built for advanced reasoning and coding. Reasoning-focused models such as Qwen3.6 35B A3B and large mixture-of-experts variants like Qwen3.5 397B A17B are also on hand for heavier workloads.
Getting started takes only a few steps: create an Atlas Cloud account, generate an API key, and point your existing OpenAI-compatible client at the Atlas endpoint. Pricing is pay-as-you-go with transparent per-call rates, and Day-0 access means new Qwen releases are ready the moment they launch. Start building today.
Yes. The Qwen API on Atlas Cloud follows the OpenAI chat completions format, so most SDKs work by simply swapping the base URL and key. You keep your current tooling and can call any Qwen model without rewriting your integration.
Qwen models on Atlas Cloud use transparent pay-as-you-go pricing billed per token, with no subscription required. Rates start at $0.1 per million input tokens and $0.4 per million output tokens for Qwen3.5 Flash, rising to $2.5 and $7.5 per million tokens for the flagship Qwen3.7 Max, so you can match spend to each workload.
Flagship models such as Qwen3.7 Max offer context windows up to one million tokens, which suits long documents, large codebases, and extended conversation history. The family also spans text and vision-language variants like Qwen3-VL, giving you options when a task involves more than plain prompts.
Beyond plain chat, Qwen models support streaming responses, function calling, and structured tool use through the standard API parameters. Dedicated reasoning models such as Qwen3.7 Max and Qwen3.6 35B A3B add step-by-step problem solving for math, coding, and complex agentic tasks.
Choosing comes down to the balance you need between speed, cost, and capability. Reach for Qwen3.5 Flash when latency and high volume matter, the Plus tiers for everyday assistants and productivity workflows, and Qwen3.7 Max when a task demands the strongest reasoning and coding. Because every model shares one endpoint, switching between them is a single parameter change.
Join the Discord community for the latest model updates, prompts, and support.