If you've been following the AI market lately, you already know the headline numbers: DeepSeek V4 costs about 3% of what GPT-4o charges per token. GLM-4 runs benchmarks competitive with GPT-4 at roughly one-twentieth the price. Qwen delivers multilingual performance that rivals Claude for a rounding error in your cloud bill.
The spreadsheets look incredible. The problem is actually using these models.
Signing up for each provider means navigating Chinese-language dashboards, topping up separate wallets, managing six different API key formats, and dealing with SDKs that don't follow any consistent convention. Most developers give up after the second integration. That friction is why, despite the economics being objectively absurd in 2026, most teams still default to a single Western provider and eat the cost.
AIWave exists to kill that friction. One API key. One endpoint. Fifty-plus models across eight Chinese labs, all speaking standard OpenAI-compatible format. Zero code changes to switch between DeepSeek, GLM, Qwen, MiniMax, and everything else.
This post covers how the platform works under the hood, what the request lifecycle looks like, and how to integrate it in any language that can speak HTTP.
Before getting into the solution, here's what the Chinese LLM landscape actually looks like as of June 2026:
| Provider | Flagship Model | API Format | Auth Method | SDK Language |
|---|---|---|---|---|
| DeepSeek | V4-Pro | Custom (DS format) | Bearer token + signature | Python, JS |
| Zhipu | GLM-4.5 | OpenAI-compatible-ish | JWT with expiry | Python, Java |
| Alibaba | Qwen-3-Max | DashScope (Alibaba) | AK/SK + HMAC | Python, Java, Go |
| MiniMax | MiniMax-Text-01 | Custom REST | API Key + Group ID | Python |
| Moonshot | Kimi-K2 | OpenAI-compatible | API Key | Python, JS |
| Baidu | ERNIE 4.5 | Qianfan (Baidu) | OAuth 2.0 Client Cred | Python |
| ByteDance | Doubao-Pro | Ark (Volcengine) | IAM AK/SK + SigV4 | Python, Go |
| 01.AI | Yi-Lightning | OpenAI-compatible | API Key | Python |
Eight providers, seven different authentication schemes, four distinct API formats. Want to compare GLM-4 against Qwen-3? That's two separate accounts, two top-up workflows, two SDKs, and two different error-handling strategies. Want to fall back from DeepSeek to Kimi when rate limits hit? Write a load balancer.
Now multiply that by every developer on your team.
AIWave sits between your application and every Chinese model provider as a protocol-normalizing proxy. Your code speaks OpenAI format. AIWave translates it into whatever dialect the target provider expects.
Your App (OpenAI SDK)
│
▼
POST /v1/chat/completions
Authorization: Bearer sk-aiwave-xxx
{"model": "deepseek/deepseek-v4-pro", "messages": [...]}
│
▼
┌──────────────────────┐
│ AIWave Gateway │
│ │
│ - Auth validation │
│ - Model routing │
│ - Format translation│
│ - Load balancing │
│ - Fallback chains │
└──────────────────────┘
│
▼
DeepSeek API (native format)
Authorization: Bearer ds-sk-xxx
{"model": "deepseek-v4-pro", ...}
The key insight: every model, regardless of its native API format, exposes roughly the same primitives. Chat completions, streaming, function calling, token counting. The differences are syntactic, not semantic. A messages
array is a messages
array whether its JSON keys are content
(OpenAI), text
(some Alibaba endpoints), or wrapped in extra nesting (MiniMax's chat format).
The practical consequence of this normalization: if your codebase already uses the OpenAI SDK, switching to Chinese models requires changing two strings.
Before:
from openai import OpenAI
client = OpenAI(api_key="sk-openai-xxxxxxxx")
response = client.chat.completions.create(
model="gpt-4o",
messages=[{"role": "user", "content": "Explain MoE architecture"}]
)
After:
from openai import OpenAI
client = OpenAI(
api_key="sk-aiwave-xxxxxxxx",
base_url="https://api.aiwave.live/v1"
)
response = client.chat.completions.create(
model="deepseek/deepseek-v4-pro",
messages=[{"role": "user", "content": "Explain MoE architecture"}]
)
That's it. base_url
points to AIWave. model
uses the provider/model-name
convention. Everything else — streaming, function calling, response_format
, temperature
, max_tokens
— passes through exactly as you'd expect.
Same pattern works in JavaScript:
import OpenAI from 'openai';
const client = new OpenAI({
apiKey: 'sk-aiwave-xxxxxxxx',
baseURL: 'https://api.aiwave.live/v1'
});
const stream = await client.chat.completions.create({
model: 'zhipu/glm-4.5',
messages: [{ role: 'user', content: 'Write a haiku about API routing' }],
stream: true
});
for await (const chunk of stream) {
process.stdout.write(chunk.choices[0]?.delta?.content || '');
}
And in curl, because sometimes you just want to sanity-check without an SDK:
curl https://api.aiwave.live/v1/chat/completions -H "Content-Type: application/json" -H "Authorization: Bearer sk-aiwave-xxxxxxxx" -d '{
"model": "deepseek/deepseek-v4-pro",
"messages": [{"role": "user", "content": "Benchmark SQL vs NoSQL in three sentences"}]
}'
Here's the current catalog, organized by strength:
| Model ID | Provider | Context | Best For |
|---|---|---|---|
deepseek/deepseek-v4-pro |
|||
| DeepSeek | 128K | Complex reasoning, code, math | |
deepseek/deepseek-v4 |
|||
| DeepSeek | 128K | General, cost-efficient | |
zhipu/glm-4.5 |
|||
| Zhipu | 128K | Balanced, strong bilingual | |
qwen/qwen-3-max |
|||
| Alibaba | 256K | Long context, multilingual |
| Model ID | Provider | Context | Best For |
|---|---|---|---|
deepseek/deepseek-v4-lite |
|||
| DeepSeek | 32K | Latency-sensitive, high QPS | |
minimax/minimax-text-01 |
|||
| MiniMax | 256K | Bulk processing, summarization | |
moonshot/kimi-k2 |
|||
| Moonshot | 128K | Fast, long-document QA |
| Model ID | Provider | Context | Best For |
|---|---|---|---|
qwen/qwen-3-turbo |
|||
| Alibaba | 32K | Prototyping, testing | |
yi/yi-lightning |
|||
| 01.AI | 32K | Simple tasks, classification | |
doubao/doubao-pro |
|||
| ByteDance | 128K | Chinese-heavy workloads |
The naming convention is always {provider}/{model}
. This keeps it discoverable — you know which lab you're routing to just from the model string.
One of the nastier patterns in production ML is hard-coding model names across a codebase and then needing a full deploy cycle when you want to A/B test a new model. AIWave decouples the model string from your code via API-side routing.
Set up an alias in the dashboard (my-prod-model
→ deepseek/deepseek-v4-pro
), and your application code never changes:
response = client.chat.completions.create(
model="my-prod-model", # Resolved server-side
messages=[...]
)
When you want to test GLM-4.5 against DeepSeek V4 in production, you change the alias mapping in the AIWave dashboard — no CI/CD involved. Rollback is changing it back. This is the kind of operational flexibility that teams running A/B tests on model quality come to depend on quickly.
Let's talk numbers, because the cost delta between Western and Chinese models in mid-2026 is so large that not discussing it would be journalistic malpractice.
| Model | Input (per 1M tokens) | Output (per 1M tokens) |
|---|---|---|
| GPT-4o | $2.50 | $10.00 |
| Claude Opus 4 | $15.00 | $75.00 |
| DeepSeek V4-Pro | $0.14 | $0.55 |
| GLM-4.5 | $0.10 | $0.40 |
| Qwen-3-Max | $0.08 | $0.32 |
| Kimi-K2 | $0.06 | $0.24 |
A workload processing 10 million tokens per day (input-heavy, say a document analysis pipeline):
The annual difference pays for a junior engineer. Or two. And these Chinese models are not "discount" quality — DeepSeek V4-Pro sits within striking distance of GPT-4o on MMLU-Pro, MATH, and HumanEval. You're not trading quality for cost. You're trading brand familiarity for cost.
The unglamorous reality of multi-provider routing is that providers go down. Rate limits trigger. Models get deprecated with three days' notice. AIWave handles this with configurable fallback chains:
fallback_chain = [
"deepseek/deepseek-v4-pro", # Primary
"zhipu/glm-4.5", # First fallback
"qwen/qwen-3-max" # Last resort
]
When the primary model returns a 429, 503, or times out, the gateway retries on the next model in the chain. Your application doesn't need to know this happened. It just gets a successful response, possibly with a slightly different model annotation in the response metadata.
Transparent retry with exponential backoff is built in. Connection pooling to each upstream provider is managed per-endpoint. The gateway emits structured logs so you can trace exactly which model handled which request, how long it took, and whether a fallback was triggered.
Streaming works identically to OpenAI's SSE protocol:
stream = client.chat.completions.create(
model="deepseek/deepseek-v4-pro",
messages=[{"role": "user", "content": "Explain transformers in detail"}],
stream=True,
stream_options={"include_usage": True}
)
for chunk in stream:
if chunk.choices:
delta = chunk.choices[0].delta
if delta.content:
print(delta.content, end="", flush=True)
if hasattr(chunk, 'usage') and chunk.usage:
print(f"
Tokens used: {chunk.usage}")
The gateway proxies the SSE stream with minimal buffering, so time-to-first-token is determined by the upstream provider, not by any intermediate hop. For real-time chat applications, this is non-negotiable — nobody wants to stare at a spinner while a proxy buffers the entire response before forwarding it.
A quick trace of a single /v1/chat/completions
call through the gateway:
deepseek/deepseek-v4-pro
parsed into provider (deepseek
) and model (deepseek-v4-pro
). Alias lookup performed if applicable.id
, object
, created
, model
, choices
, usage
— before being returned to your client.Typical overhead from the translation layer is under 50ms p99, meaning the gateway adds negligible latency beyond network transit.
If you're currently using OpenAI, Claude, or Gemini and spending more than $100/month on API calls, running a two-week comparison against Chinese models through AIWave is one of the highest-ROI experiments you can run this quarter.
base_url
and model
)No Chinese phone number required. No WeChat account. No Alipay top-up. The entire platform is designed so that Western developers never need to touch a Chinese-language interface. You use the same Stripe checkout and the same OpenAI SDK you already have.
The economics of Chinese AI in 2026 are too compelling to ignore on the basis of integration friction. AIWave removes that friction. One endpoint, fifty models, your existing code.
If you found this useful, check out our DeepSeek V4 Pro vs GPT-4o benchmark comparison for a deep dive on real-world performance. Try the API free at aiwave.live.