October 2026 DashScope Model Sunset: Migration Guide for 100+ Retiring Models

On October 10, 2026 at 00:00 CST, Alibaba Cloud will shut down the largest single wave of model retirements in DashScope (Bailian) history. Across four official notices — #118344, #118177, #118345, and #118331/#118332 — more than 100 model IDs will stop returning responses. No grace period, no degraded mode, just a hard stop (Model deprecation page, retrieved 2026-07-07).

This guide covers every text and reasoning model in the October 10 wave. We skip voice/TTS models (notices #118331/#118332) — they are not routable through OpenAI-compatible endpoints.

We route OpenAI-compatible requests through configured providers and support provider/model routing and fallback where the live product path supports it. We do not claim universal model support, zero downtime, or guaranteed cheapest pricing.

1. Swap three values, not three SDKs. Change api_key, base_url, and model in the existing OpenAI client. Keep your request/response code unchanged.
2. Map model IDs explicitly. The target provider's model id is almost never identical to the OpenAI id. Keep a single dict of { openai_id: target_id } outside business logic.
3. Verify streaming format. SSE chunks must follow the OpenAI data: {...} + data: [DONE] contract. Test one streaming call before moving production traffic.
4. Check rate-limit headers. Some providers omit x-ratelimit-* headers. Add a wrapper that defaults safely when headers are absent.
5. Keep a rollback path. Ship the swap behind a feature flag, run both endpoints in shadow for 24 hours, then cut over.

30-Second Answer

Four waves retire on October 10, 2026. Here is the scope:

If you use any third-party model (DeepSeek, GLM, MiniMax, Kimi) through DashScope, you must switch to a vendor-direct API endpoint. DashScope recommends qwen3.7-plus as a generic replacement, but that ignores why you chose those models in the first place. We cover vendor-direct migration below.

Wave 1 — Qwen3 Mainline Models (Notice #118344)

These five Qwen3-generation mainline models retire on October 10:

We previously covered these same models in our September 2026 Qwen Model Sunset Migration Guide. The September 8 deadline from the original notice appears to have been extended to October 10. If you already migrated based on our September guide, no further action is needed.

Pricing Impact: qwen3-max → qwen3.7-max

For short requests (≤32K input), qwen3.7-max costs ~4.8× more on input. For long-context workloads (128K+), the flat ¥12 is actually cheaper than qwen3-max's ¥7 tier 3. Evaluate based on your typical prompt length (Model pricing, retrieved 2026-07-07).

Wave 2 — Legacy Mainline Models (Notice #118177)

Notice #118177 (published 2026-04-13) retires 10 legacy mainline model IDs that many teams still rely on:

Key gotcha with qwq-plus and qvq-max/plus: These are reasoning models with chain-of-thought output. Their replacements in the Qwen3.7 series use a different thinking mode API — you need to explicitly enable enable_thinking: true and handle the reasoning_content field in the response. The thinking tokens are billed at the output rate. See our Qwen3.7 series guide for the thinking-mode API surface.

Key gotcha with qwen-turbo-realtime: There is no exact drop-in for realtime streaming variants. If your pipeline depends on realtime-mode WebSocket connections, test the replacement thoroughly.

We covered some of these legacy models in our July 2026 Qwen Turbo/VL/Coder Sunset Migration Guide. That guide targets a July 13 deadline — notice #118177 lists October 10. It appears the same model set may have dual deadlines or the July 13 date was superseded. Check both notices against your actual API responses for deprecation headers.

Wave 3 — Snapshots and Third-Party Models (Notice #118345)

This is the wave with the highest migration complexity. Notice #118345 retires:

Qwen Snapshots (switch to latest mainline)

All of these map to a newer Qwen3.7 mainline — straightforward model ID swaps:

• Qwen Max snapshots → qwen3.7-max
• Qwen VL snapshots → qwen3.6-flash or qwen3.7-plus
• Qwen Coder snapshots → qwen3.7-plus
• Qwen3 open-source snapshots (qwen3-8b, qwen3-14b, qwen3-32b, qwen3-235b-a22b, etc.) → qwen3.6-flash or qwen3.7-plus

Third-Party Models — The Big One

DashScope is removing all third-party hosted models. These are models from other vendors that Alibaba was hosting through Bailian:

DashScope's official recommendation is qwen3.7-plus as a generic replacement. But if you specifically chose DeepSeek R1 for reasoning, or GLM-4.7 for Chinese long-context, or Kimi K2 for agentic coding — qwen3.7-plus is not a like-for-like swap. Switch to the vendor's own API endpoint.

We covered the July 2026 third-party model removal in our Migrating Off Bailian-Hosted DeepSeek, GLM, MiniMax guide. The October wave adds deepseek-v3.2, deepseek-v3.2-exp, deepseek-r1-0528, kimi-k2-thinking, and an expanded deepseek-r1-distill-qwen-* set. The migration pattern is identical — switch base_url to the vendor's endpoint and get a new API key.

Before/After Code Diff (OpenAI SDK)

Qwen Model Swap (Wave 1 and 2)

The migration is a model ID swap. If you are using the OpenAI Python SDK against DashScope's OpenAI-compatible endpoint:

# Before — retiring October 10
from openai import OpenAI

client = OpenAI(
    api_key="sk-xxx",
    base_url="https://dashscope.aliyuncs.com/compatible-mode/v1"
)

response = client.chat.completions.create(
    model="qwen3-max",        # ← retiring
    messages=[{"role": "user", "content": "Hello"}]
)

# After — replacement
response = client.chat.completions.create(
    model="qwen3.7-max",      # ← replacement, same endpoint
    messages=[{"role": "user", "content": "Hello"}]
)

Third-Party Model Migration (Wave 3)

For third-party models, you must change both the base_url and model ID:

# Before — DeepSeek through DashScope (retiring October 10)
client = OpenAI(
    api_key="sk-dashscope-xxx",
    base_url="https://dashscope.aliyuncs.com/compatible-mode/v1"
)

response = client.chat.completions.create(
    model="deepseek-v3",
    messages=[{"role": "user", "content": "Hello"}]
)

# After — DeepSeek vendor-direct
client = OpenAI(
    api_key="sk-deepseek-xxx",              # new API key from DeepSeek
    base_url="https://api.deepseek.com"      # vendor-direct endpoint
)

response = client.chat.completions.create(
    model="deepseek-chat",                   # DeepSeek's own model ID
    messages=[{"role": "user", "content": "Hello"}]
)

Routing via TheRouter

If you route through TheRouter, you can configure fallback from retiring model IDs to replacements. TheRouter routes OpenAI-compatible requests through configured providers and supports model routing and fallback where the live product path supports it. See our fallback routing guide for configuration details.

Complete Replacement Mapping Table

Migration Checklist and Rollback Path

Before October 10

1. Audit your model usage. Check your DashScope model telemetry page for any calls to retiring model IDs.
2. Get vendor-direct API keys. If you use third-party models (DeepSeek, GLM, MiniMax, Kimi), register at each vendor's platform and generate API keys now.
3. Test replacements. Run your evaluation suite against the replacement model. Pay attention to:
   • Output format differences (especially reasoning model thinking-mode changes for qwq/qvq → qwen3.7)
   • Context window changes (256K tiered → 1M flat for Max models)
   • Pricing delta (see tables above)
4. Update model IDs in code. For Qwen models, swap the model ID string. For third-party models, swap both base_url and model.
5. Configure fallback routing. If you use TheRouter, set up model fallback from retiring IDs to replacements.
6. Monitor rate limit changes. DashScope may gradually reduce QPM/TPM for retiring models between now and October 10 (Deprecation mechanism, retrieved 2026-07-07).

Rollback Path

If a replacement model produces unacceptable results:

• For Qwen models: Switch to a different Qwen3.7/3.6 variant. For example, if qwen3.7-max is too expensive for your workload, try qwen3.7-plus at ¥2/¥8 per million tokens.
• For third-party models: You are switching to the vendor's own endpoint — the model itself is identical. If vendor-direct has different rate limits or pricing, try SiliconFlow as an alternative host for open-source models like DeepSeek.
• Emergency: If you need more time, there is no extension mechanism. DashScope retirements are hard cutoffs at the announced date.

Cost Delta — Old vs New

Qwen Model Replacements (Mainland China, ¥/1M tokens)

Key takeaway: If you are on qwen3-max with short prompts, expect a significant cost increase. Consider qwen3.7-plus (¥2/¥8) if you do not need Max-tier capability. Legacy qwen-turbo users migrating to qwen3.6-flash will actually see a cost decrease.

Third-Party Model Pricing After Migration

Third-party model pricing on vendor-direct endpoints varies. See our provider guides for current rates:

• DeepSeek API guide — DeepSeek-V3 at $0.27/$1.10 per 1M tokens
• Zhipu GLM API guide — GLM-4.7 pricing
• Kimi K2 API guide — Kimi K2 pricing

FAQ

Q: Is the October 10 deadline firm, or could it be extended? A: DashScope deprecation deadlines have historically been extended (the September 8 Qwen3 mainline deadline appears to have moved to October 10). However, plan for the announced date. There is no official extension mechanism.

Q: Will DashScope reduce my rate limits before October 10? A: Yes. Starting from the notice publication date, DashScope gradually reduces QPM and TPM for retiring models. If you previously requested expanded limits, those reset to defaults first (Deprecation mechanism).

Q: I use deepseek-v3 through DashScope. Can I just change the model ID to qwen3.7-plus? A: Technically yes — DashScope recommends qwen3.7-plus as a replacement. But DeepSeek V3 and Qwen3.7-Plus are different models with different strengths. If you chose DeepSeek for its specific capabilities, switch to vendor-direct at api.deepseek.com instead.

Q: What about the deepseek-r1-distill-qwen- models?* A: These small distilled models (7B, 14B, 32B) are also retiring from DashScope. You can run them through vendor-direct DeepSeek API, or through SiliconFlow which hosts open-source models including DeepSeek R1 distill variants.

Q: How does this affect my TheRouter configuration? A: If you route DashScope-hosted third-party models through TheRouter, update your provider configuration to point to vendor-direct endpoints. TheRouter supports provider/model routing and fallback — configure the vendor-direct endpoint as a new provider, then set up routing rules to redirect traffic from the retiring DashScope-hosted model IDs.

---

Sources: Aliyun Model Deprecation Page (retrieved 2026-07-07), Notice #118344, Notice #118177, Notice #118345, Model Pricing (retrieved 2026-07-07).