Cheap Chinese Coding Models: What to Choose in September 2026
A developer of a web project asked a simple question: which inexpensive model to hook up for programming with pay-per-token billing that also handles the job well. We collected prices and independent benchmarks for Chinese models as of September 14, 2026, and additionally tested DeepSeek, which we use ourselves, on our own tasks.
Short answer. Among the cheap ones, the first to try are DeepSeek V4.1-Flash and GLM-5.3-Flash: both cost about $0.15 per million input tokens and $0.50—0.60 per million output tokens, both sit in the upper part of the independent rankings, and both connect to Claude Code, Cline and OpenCode out of the box. If your tasks are heavy and the budget allows paying several times more, GLM-5.3 is noticeably stronger. And if what matters is the price per solved task rather than speed, take a look at MiMo-V2.5-Pro from Xiaomi.
Our own benchmark of DeepSeek V4.1-Flash added a practical observation to the rankings. Without reasoning mode, the model solved 19 of our 20 tasks, spending about two seconds and three hundredths of a cent per task. Both agentic tasks — fixing a small repository using tools — were solved by the model in every run and in every mode, and a run on Flash cost less than half a cent. Reasoning mode adds almost nothing on such tasks, costs 20—30 times more, and with a 32 thousand token response cap it sometimes cuts off without ever producing code.
What it costs
Prices per million tokens from official pages. For programming, the third column matters most: an agent re-reads the same files dozens of times, and most of the input is repeats that the provider takes from cache.
| Model | Input | Cached input | Output | Open weights |
|---|---|---|---|---|
| DeepSeek V4.1-Flash | $0.15 | $0.003 | $0.60 | yes, MIT |
| GLM-5.3-Flash (Z.ai) | $0.15 | $0.03 | $0.50 | yes, MIT |
| Qwen3.8-Flash (Alibaba) | $0.15 | cache discount available | $0.47 | yes |
| MiMo-V2.5 (Xiaomi) | $0.14 | $0.0028 | $0.28 | yes |
| MiMo-V2.5-Pro (Xiaomi) | $0.435 | $0.0036 | $0.87 | yes, MIT |
| Hy3 (Tencent) | $0.132 | $0.033 | $0.528 | yes, Apache 2.0 |
| MiniMax-M3 | $0.30 | $0.06 | $1.20 | yes |
| GLM-5.3 (Z.ai) | $1.40 | $0.26 | $4.40 | yes |
| Kimi K3 (Moonshot) | $3.00 | $0.30 | $15.00 | yes |
DeepSeek has a quirk: the listed prices apply off-peak, while on weekdays from 01:00 to 04:00 and from 06:00 to 10:00 UTC everything costs twice as much. In Moscow time that is 4:00—7:00 and 9:00—13:00, meaning the peak falls right in the morning of the workday.
What the independent benchmarks show
Manufacturers publish impressive numbers, but those are their own runs. The gap with independent ones can be huge: according to Alibaba, Qwen3.6-27B solves 77.2% of SWE-bench Verified tasks, while on fresh SWE-rebench tasks, which the model could not have seen during training, it solves 31.2%. That is why only third-party measurements appear below.
Artificial Analysis — an overall index across a set of tests, including programming and terminal work (version 4.3):
| Model | Index | Speed, tokens/s |
|---|---|---|
| GLM-5.3 | 45 | 72 |
| Kimi K3 | 44 | 37 |
| GLM-5.3-Flash | 42 | 109 |
| DeepSeek V4.1-Flash | 40 | 212 |
| Qwen3.8-Flash | 40 | 51 |
| MiniMax-M3 | 30 | 107 |
| MiMo-V2.5-Pro | 26 | 43 |
| Hy3 | 26 | 91 |
| for comparison: Claude Sonnet 5 | 38 | 76 |
| for comparison: GPT-5.6 Luna | 38 | 120 |
The three cheap "flash" models rank above Claude Sonnet 5 in the index, and DeepSeek V4.1-Flash responds faster than anything else in the table — twice as fast as GLM-5.3-Flash and four times as fast as Qwen3.8-Flash. For an agent that takes dozens of steps in a row, speed translates directly into minutes of waiting.
SWE-rebench — fixing real bugs in real repositories, 111 tasks that appeared between May 15 and July 1, 2026. It has something other rankings lack: how much money goes into a single task.
| Model | Solved | $ per task | $ per solved |
|---|---|---|---|
| GLM-5.2 | 62.9% | 1.40 | 2.23 |
| MiniMax M3 | 47.2% | 0.95 | 2.01 |
| MiMo-V2.5-Pro | 46.5% | 0.10 | 0.22 |
| DeepSeek V4-Pro | 40.2% | 0.15 | 0.37 |
| Qwen3.6-27B | 31.2% | 0.62 | 1.99 |
| for comparison: Claude Opus 5 | 63.4% | 3.47 | 5.47 |
| for comparison: Claude Sonnet 5 | 56.8% | 1.43 | 2.52 |
The last column is our own calculation: the price per task divided by the share solved. The fresh models (DeepSeek V4.1-Flash, GLM-5.3, Qwen3.8) are not in this window yet; their tasks will land in the next one. But the picture is clear: the senior GLM line nearly catches up with Claude Opus 5 in share solved at a price two and a half times lower, while MiMo-V2.5-Pro solves less, but its solved task costs a little over twenty cents. MiniMax M3 is cheap per token but burns a lot of them — 13.9 million per task versus 4—5.5 million for its neighbors in the table, so it ends up expensive.
Arena WebDev — ratings from people who compare web interfaces built by models blind (data as of September 11). Among Chinese models, the highest are Qwen3.8-Max (4th place) and Kimi K3 (5th), Qwen3.8-Flash is 9th, GLM-5.3 and DeepSeek V4.1-Flash share 15th—16th, GLM-5.3-Flash is 17th. For comparison, Claude Opus 5 is third.
What people actually use. By share of tokens in the "programming" category on OpenRouter in September, the top spots go to MiMo-V2.5 (15.4%), GPT-5.6 Luna (14.4%) and GLM-5.3-Flash (12.8%); DeepSeek V4-Flash and V4.1-Flash together add another 12.1%. Developers vote with their money for exactly the cheap models.
Our benchmark: DeepSeek V4.1-Flash on our own tasks
Other people's rankings answer the question "which model is stronger," but not "which mode to enable and how much it will cost." So we ran DeepSeek, which we use ourselves, on tasks written specifically for this test: the model could not have had them in its training data.
Ten tasks with a single answer, each with hidden tests: parsing a duration string like "1h30m," sorting versions by SemVer rules, an SQL query with window functions for SQLite, fixing a slow business-days counting function with three bugs, JSON Patch per RFC 6902, splitting a sum in cents into shares without losing a cent (up to 1030), asynchronous launching with concurrency limits and cancellation, a token bucket for rate limiting, a PHP function with UTF-8 and array key bugs, and an LRU cache with a time to live in JavaScript. Eight tasks in Python, one each in PHP and JavaScript. Each was solved twice in each mode; if the tests failed, the model saw their output and got one attempt to fix it.
Two agentic tasks — closer to working in Claude Code or Cline. A small repository with failing tests, the model has four tools: list files, read, write and run tests, up to 30 steps. The first repository is an online store cart with rounding, promo code and item addition bugs plus an unfinished receipt; the second is parsing nginx logs with time zones, percentiles and a report that has to be written from scratch. Success meant "all tests pass and the test files are untouched."
| Mode | First try | With test hints | Time per task | Tokens in response | Price per task |
|---|---|---|---|---|---|
| Flash without reasoning | 18 of 20 | 19 of 20 | 1.9 s | 446 | $0.0003 |
| Flash, reasoning high | 17 of 20 | 20 of 20 | 40 s | 11,829 | $0.0075 |
| Flash, reasoning max | 18 of 20 | 20 of 20 | 57 s | 15,572 | $0.010 |
| V4-Pro, reasoning high | 16 of 20 | 19 of 20 | 232 s | 16,881 | $0.043 |
Without reasoning, the model handled almost everything, and that is the main takeaway for everyday work. It only stumbled on version sorting: it checked the string with a regular expression ending in $, and in Python such a pattern lets a string with a newline through, so "1.2.3\n" was accepted as a valid version. In one run the model corrected itself after seeing the failed test, in another it repeated the same mistake. The bug is a classic one, and a human reviewer often misses it too.
Reasoning costs 20—30 times more and is 20—30 times slower. It improved the result only slightly, and four of the five failed first attempts in those modes had nothing to do with code quality at all: the model hit the response cap we set, 32,768 tokens, and cut off mid-reasoning without writing a single line. Similar response length limits are set by default in many agents. If you enable reasoning, raise the cap: DeepSeek allows up to 384 thousand tokens.
We tested that too: three tasks on which reasoning cut off were run again with a 131 thousand token allowance. Mode max solved all six attempts (one on the second try, having misunderstood the leading zeros condition), high solved five of six, but on average a task took 45—55 thousand reasoning tokens, 2—3 minutes and about three cents — a hundred times more than without reasoning. And in one case out of six, mode high spent all 131 thousand tokens thinking about a thirty-line function, five minutes, and again produced no answer.
All modes handled the agentic tasks: both repositories were fixed in each of the four runs, without a single erroneous tool call and without any attempts to tweak the tests instead of the code.
| Mode | Solved | Steps | Run time | Cached input | Run price |
|---|---|---|---|---|---|
| Flash without reasoning | 4 of 4 | 8 | 15 s | 86% | $0.0022 |
| Flash, reasoning high | 4 of 4 | 5 | 16 s | 82% | $0.0027 |
| Flash, reasoning max | 4 of 4 | 5 | 20 s | 82% | $0.0035 |
| V4-Pro, reasoning high | 4 of 4 | 5 | 57 s | 84% | $0.0117 |
Without reasoning, the model behaves differently: it takes eight steps instead of five and makes more tool calls, trying and correcting based on test output — and still fits into the same time and comes out the cheapest of all. And the penny-level prices are explained by caching: the agent re-reads 82—86% of input tokens, and DeepSeek charges $0.003 per million for them.
We managed to test V4-Pro on the last day. DeepSeek announced that as of September 14 requests to it are forwarded to V4.1-Flash, but during the benchmark Pro was still answering with its own model — this is visible from the service fingerprint in the response. It solved slightly less — 19 tasks out of 20 versus 20 for Flash in the same mode — and a task took it an average of 232 seconds versus 40 and cost $0.043 at Pro prices versus $0.0075. All five of its failed attempts were the same cutoff at 32 thousand tokens, and each one took more than seven minutes to wait for: Pro writes its response noticeably slower. It solved the agentic tasks the same way as Flash, but three times longer and four times more expensive. So DeepSeek's move to a single model for programming takes nothing away.
Subscription or pay-per-token
Almost all manufacturers except DeepSeek have "coding plans" with a monthly fee and a request limit per five-hour window: GLM Coding Plan from $18 a month, Token Plan from Xiaomi from $6, from MiniMax from $22, and Alibaba has only Pro left at $50 and without Qwen3.8 in the model list. There is a benefit if you sit in an agent every day. But subscriptions have two limitations: they may only be used from supported tools (Claude Code, Cline, OpenCode and the like), not from your own scripts, and the exact limits are often not published. For irregular work and for your own code, pay-per-token is simpler.
How to connect to Claude Code
All three top candidates have an Anthropic-compatible API endpoint, so Claude Code works with them without any middleware — the environment variables ANTHROPIC_BASE_URL and ANTHROPIC_AUTH_TOKEN are enough:
- DeepSeek:
https://api.deepseek.com/anthropic, modeldeepseek-flash[1m](with a million-token context). DeepSeek's official instructions setCLAUDE_CODE_EFFORT_LEVEL=max. - Z.ai (GLM):
https://api.z.ai/api/anthropic. By default all roles get GLM-5.3-Flash; the senior model must be specified manually. - Xiaomi (MiMo):
https://api.xiaomimimo.com/anthropic.
For Cline, Roo and other tools with an OpenAI-compatible API, the same providers have regular endpoints.
About paying from Russia
According to user reports, Russian cards are accepted by neither DeepSeek, nor Z.ai, nor Alibaba Cloud, and LongCat from Meituan takes only Alipay and WeChat Pay. The usual routes are a foreign card or OpenRouter: it lets you in from Russia, accepts cryptocurrency with a fee of about 5%, and sells access to most of the models in the table. On OpenRouter, check which provider is actually serving the model: the cheap ones sometimes have stripped-down builds and tool calling does not work, while the price of DeepSeek through its own node matches the official one.
And on your own hardware?
All the models in the table are released with open weights, but not all of them can realistically be run at home. DeepSeek V4.1-Flash is 552 billion parameters, GLM-5.3-Flash is 320 billion; they need a server. Of the recent ones, Qwen3.8-27B under the Apache 2.0 license is suitable for a single graphics card: in a four-bit Q4_K_M build it weighs 16.5 GB and fits into a 24 GB card along with context. On Arena WebDev it ranks 18th, right behind GLM-5.3-Flash — very decent for a local model, although it is far from the cloud "flashes" in agentic work.
Bottom line
- DeepSeek V4.1-Flash — a sensible default choice: the fastest of the cheap ones, the cheapest on repeated input ($0.003 per million from cache) and tested by us in practice. Start with the mode without reasoning, enabling it only for tricky algorithms and with a raised response cap. It pays to run heavy sessions off-peak — on weekdays after 13:00 Moscow time.
- GLM-5.3-Flash — worth trying for comparison: slightly higher in the overall index, cheaper output, but cache is ten times more expensive than DeepSeek's, and the model responds twice as slowly. Z.ai has a subscription from $18 a month.
- GLM-5.3 — for hard tasks when the cheap model stalls. The previous version of this line is the best of the Chinese ones on SWE-rebench, but per token it is 7—9 times more expensive than the "flashes."
- MiMo-V2.5-Pro — the cheapest solved task on SWE-rebench, but the model is slow; it suits background work where nobody is waiting for an answer.
- Kimi K3 ($15 per million output tokens) and MiniMax-M3 (many tokens per task) are not cheap to run, even though the second one's price per token is not high.
The limitations of our test are worth keeping in mind: ten tasks and two small repositories are not SWE-bench, and we only tested DeepSeek; the other models are compared by independent rankings. On a real project, the context of each agent step is dozens of times larger than in our repositories, so the difference in cache price between providers is felt more strongly there than in the table.
Sources
Prices are from the official pages of DeepSeek, Z.ai, Alibaba Cloud Model Studio, Xiaomi MiMo, Tencent Cloud, MiniMax and Moonshot as of September 14, 2026. Independent benchmarks: Artificial Analysis, SWE-rebench, Arena WebDev, OpenRouter, "programming" category. Results that manufacturers publish about their own models were deliberately left out of the comparisons — one such number is given only as an example of the discrepancy.
