Qwen 3 235B API pricing across inference providers

Qwen 3 235B API pricing providers differ sharply in how they meter tokens, expose context windows, and handle throughput. If you’re routing production traffic to a 235B-parameter model, the per-token cost is only one axis; cold-start behavior, cache hints, and fallback policies decide whether your bill survives a traffic spike. This post compares the six hosts engineers actually weigh when deploying Qwen 3 235B, across concrete dimensions you can benchmark yourself.

The field: who serves Qwen 3 235B

Six providers routinely show up when teams evaluate hosted Qwen 3 235B endpoints:

• Aliyun DashScope – Alibaba’s first-party platform. Native weights, earliest access to new revisions, and regional optimizations inside Asia.
• Together AI – Serverless GPU cloud with OpenAI-compatible routes for open weights and a batch queue for offline jobs.
• Fireworks AI – Optimized inference engine, per-token billing, function-calling tuned for low latency.
• DeepInfra – Bare-metal open-model hosting, aggressively priced, minimal abstraction over the HuggingFace config.
• OpenRouter – Aggregator that resells capacity from multiple upstreams behind one API key and a blended price.
• Groq – Specialized LPU hardware; availability for 235B-class models depends on memory footprint and may be intermittent.

A gateway such as n4n.ai collapses these inconsistent APIs into one OpenAI-compatible endpoint with automatic fallback when a provider is rate-limited, and forwards cache-control hints to cut repeated prompt costs.

Capabilities and model access

Context and tooling

Qwen 3 235B ships with a 128K token context in its reference implementation. DashScope typically serves the untruncated window and supports Alibaba’s proprietary extensions (document parsing, native RAG). Together and Fireworks cap practical context at 128K but may truncate system prompts silently if you exceed internal chunk limits. DeepInfra mirrors the HuggingFace config exactly, so you get what the checkpoint declares.

Tool use is another divergence. DashScope ships Qwen’s native function-calling schema. Fireworks and Together translate to OpenAI’s tools format. If your client code assumes OpenAI tool calls, you’ll write less adaptation on the non-Alibaba hosts.

Quantization and fidelity

A 235B model is expensive to run at full precision. Some providers deploy FP8 or INT4 variants to fit throughput targets. That changes output distribution subtly. DashScope and DeepInfra publish the quantization level; aggregator tiers often do not, which makes reproducibility harder when you switch routing.

Fine-tune and snapshot access

DashScope lets you fork Qwen 3 235B into a private checkpoint inside its tenant. Together offers LoRA fine-tunes on the base model. Fireworks exposes a similar adapter path. DeepInfra is read-only base weights. For most app teams this is irrelevant, but if you plan to specialize the model, first-party or Together is the only practical route.

Price and cost model

Qwen 3 235B API pricing providers universally use per-token metering, but the structure varies in ways that dominate your actual spend:

• Input vs. output split – DashScope, Together, Fireworks, and DeepInfra charge distinct rates for prompted vs. generated tokens. Output is consistently 2–4× input on these platforms because decode is compute-heavy.
• Cached prompt tokens – Fireworks and Together honor cache_control breakpoints, billing cached input at a steep discount (often 10% of full input). DashScope has its own session-reuse discount that triggers when you repeat system prompts within a window.
• Blended pricing – OpenRouter exposes a single MTok price that averages input/output. This simplifies budgeting but hides the fact that long outputs cost more upstream, so a chatty agent can blow the implied ratio.
• Batch discounts – Together and DeepInfra offer asynchronous batch endpoints at roughly half price but with hour-scale latency.

None require a minimum commit for pay-as-you-go tiers. Enterprise contracts through DashScope or Together can lock lower rates. Avoid judging purely on headline numbers: a provider quoting $0.40/MTok blended may be more expensive than one quoting $0.30 input / $0.90 output if your traffic is 80% generation. Model your own prompt/output ratio before signing.

Latency and throughput

Cold vs. warm TTFT

A 235B model is memory-bound. Time-to-first-token (TTFT) on a cold request ranges from ~300ms on Fireworks’ warmed pools to 2–3s on DeepInfra’s spin-up-on-demand. DashScope keeps warm reserves for paid tiers, holding TTFT near 400ms in-region (Hangzhou, Singapore). Groq’s LPU, where the model is loaded, pushes TTFT under 100ms but the model is not always resident.

Decode speed under load

Decode speed (tokens/sec) scales with tensor parallelism degree. Together runs 8×H100 shards, delivering 30–45 tok/s for single streams. Fireworks is similar but with more aggressive continuous batching. DeepInfra’s default plan throttles concurrent streams, so a single user may see 20 tok/s while the next request queues. OpenRouter inherits the latency of whichever upstream it routes to; you trade predictability for availability.

Concurrency limits

Concurrent request limits are the silent killer. DashScope ties limits to account tier (e.g., 10–100 RPM). DeepInfra defaults to 1 concurrent stream on the cheapest plan. If you need bursty fan-out—say, 50 parallel summarizations—Fireworks’ autoscaling or a gateway fallback strategy is mandatory.

Ergonomics and API compatibility

Every non-Alibaba provider here speaks OpenAI’s /v1/chat/completions shape. DashScope uses its own REST schema but provides an OpenAI shim. Concrete client differences:

# Fireworks / Together / DeepInfra / OpenRouter – identical OpenAI client
from openai import OpenAI
client = OpenAI(base_url="https://api.fireworks.ai/inference/v1", api_key="fk-...")
resp = client.chat.completions.create(
    model="qwen3-235b",
    messages=[{"role": "user", "content": "Summarize RFC 9000"}],
    temperature=0.2,
    stream=True
)

# DashScope native (simplified)
import dashscope
dashscope.api_key = "sk-..."
resp = dashscope.Generation.call(
    model="qwen3-235b",
    prompt="Summarize RFC 9000",
    temperature=0.2
)

Streaming works everywhere. Only Fireworks and Together support bidirectional streaming with intermediate tool-call deltas conforming to OpenAI’s stream_options. DeepInfra streams raw tokens only, which means you must buffer and parse yourself for function calls.

SDK maturity: DashScope’s Python SDK lags OpenAI’s in typing coverage and error models. The aggregators win on drop-in compatibility—if you already use the OpenAI SDK, you change base_url and model string and ship.

Error semantics also vary. Fireworks returns structured error.code fields; DeepInfra sometimes returns bare 502 on backend OOM. A retry wrapper with backoff is non-negotiable regardless of provider.

Ecosystem and limits

Regional availability

DashScope is Asia-centric; EU/US latency suffers without a proxy. Together, Fireworks, and DeepInfra have US/EU endpoints with reasonable in-region TTFT. OpenRouter routes to whatever is closest but does not guarantee region pinning unless you pass routing hints.

Compliance and data handling

DashScope inherits Alibaba Cloud’s certifications (ICP, ISO). US providers satisfy SOC2; data residency needs explicit configuration. If you process EU user data, confirm that the chosen endpoint is in-region and that the subprocessors are disclosed.

Deprecation and longevity

OpenRouter can yank a model if upstream pulls it, leaving your code with 404. First-party DashScope guarantees longevity for the Qwen family. Together and Fireworks have maintained their open-model catalogs for years but reserve the right to swap quantization.

Head-to-head comparison

Which to choose

Early-stage startup, cost-sensitive, US-based: DeepInfra or Together. Use batch for offline jobs, live endpoint for low-QPS interactive features. Write a thin wrapper so you can swap base_url if limits bite. Expect to implement your own warm-up pings on DeepInfra.

Latency-critical consumer app (chat, coding): Fireworks. The cache-control discount and warmed pools keep p95 TTFT under 500ms. Pay the premium per token to avoid timeout-driven churn. Use cache_control on static system prompts to claw back margin.

Enterprise with China footprint or regulatory need: DashScope. You get first-party weights, longest support guarantee, and Alibaba’s compliance envelope. Budget for a proxy if serving EU users, and negotiate tier limits upfront.

Multi-region, never-bleed availability: OpenRouter or a gateway layer. The blended price is predictable and you inherit fallback. If you need provider cache hints passed through, use a gateway that honors client routing directives—n4n.ai does this while presenting one endpoint across 240+ models, which removes the per-provider SDK tax.

High-throughput agentic loops with tool calls: Together or Fireworks. Their OpenAI tool-streaming reduces client complexity. Set cache_control on stable system prompts to cut repeated input billing, and load-test concurrency before launch.

Qwen 3 235B API pricing providers will keep shifting as hardware gets cheaper and quantization improves. Benchmark your own prompt mix—input length, output length, cache hit rate—before committing. The right choice is the one where your observed token ratio meets the provider’s discount structure, not the one with the lowest headline number.