Best Chinese LLM API for Function Calling (2026)

For function calling, all six models we tested emitted the correct tool call, so the real differentiator is speed and cost: Qwen3-235B-A22B was cheapest at $0.0000291 per call and DeepSeek V4-Flash was the fastest Chinese option at 2.68 seconds. Tool-use support is now broad across Chinese LLM APIs, which moves the buying decision to price and latency rather than capability.

Function calling, also called tool calling, is a structured-output capability that lets a model return a machine-readable payload naming a function and its arguments instead of prose, so your own code can execute the call and hand the result back. Because agents fire many of these calls in a loop, small per-call gaps in cost and speed compound fast.

Function calling cost and latency by model (verified 2026-07)

We gave every model the same task: one get_price tool definition and one zero-temperature prompt asking for a model's API price. The pass check was simple and deterministic, namely whether the model emitted a valid get_price tool call rather than answering in prose. All six passed. The table below reports the billed cost and wall-clock latency each returned on that single call.

The spread is real but narrow on latency and wide on cost. The fastest Chinese model here, DeepSeek V4-Flash at 2.68 seconds, edged out Kimi K2, MiniMax-M2.5, and Qwen, while GLM-5 was the slowest of the group at 3.11 seconds. On price, Qwen3-235B-A22B undercut the next-cheapest Chinese option by nearly half and cost roughly one-ninth of GLM-5's call.

What we measured first-hand (OpenRouter-routed, disclosed)

We ran this benchmark on 2026-07-10. Every model was called through OpenRouter this run because api.deepseek.com was unreachable from the run environment, so the DeepSeek figure is a routed rate, not its native price, and carries a native-reverify caveat. This is a single-run, one-prompt, temperature-0 snapshot. A pass means the model followed this instruction on this prompt, not proof it always emits a clean call.

Here is the raw evidence for the two models we recommend. Qwen3-235B-A22B took a 171-token prompt, returned a 25-token completion carrying the tool call, billed $0.0000291, and finished in 2.87 seconds with a tool_calls finish reason. DeepSeek V4-Flash took 163 input and 24 output tokens, billed $0.0000518, and finished in 2.68 seconds. Both returned exactly one get_price call and no stray prose.

For context on DeepSeek's native economics, our prior first-hand testing on the official endpoint measured roughly $0.14 input and $0.28 output per million tokens at about 0.7-second latency. That is the number to reverify against once api.deepseek.com is reachable again, since it should undercut the routed cost shown above.

Why fast and cheap wins in an agent loop

A single tool call costing a fraction of a cent looks trivial in isolation. The economics change once a planning agent chains ten or twenty calls to finish one task, because both the latency and the billed cost multiply by the number of hops. That is exactly where the per-call gap in the table stops being rounding error.

Multiply this task by an agent that fires twenty tool calls to complete a workflow, and Qwen3-235B-A22B runs about $0.000582 while GLM-5 runs about $0.0051, roughly nine times more, and the GPT-4o baseline would cost about $0.00725. Latency compounds too, so a fast, cheap model is the safer default for high-frequency agent loops. Qwen3-235B-A22B is a mixture-of-experts model built by Alibaba Cloud, and it was the fastest-and-cheapest option across our whole six-task run.

According to Alibaba Cloud, the Qwen models on Model Studio expose OpenAI-compatible function calling through the standard tools and tool_choice parameters. That compatibility is why swapping Qwen in behind an existing OpenAI-style agent framework is usually a base-URL and key change rather than a rewrite.

The reasoning-model note on GLM-5

GLM-5 is a reasoning model developed by Zhipu AI, and it emitted the correct get_price call like every other model here. It was simply the slowest at 3.11 seconds and the priciest Chinese option at $0.000255, partly because it spent reasoning tokens even on this short tool-selection prompt. Across our full run the overhead was larger, peaking on a summarization task.

This is a fit question, not a quality knock. Reasoning models earn their overhead on hard multi-step problems where the extra thinking changes the answer, and GLM-5 passed every task we set. For a high-volume loop of simple, well-specified tool calls, that same overhead is cost you do not need, which is why we point volume agent traffic at the leaner models instead.

According to MiniMax Platform, MiniMax models support function calling for agent and tool-use workloads, consistent with the clean get_price call MiniMax-M2.5 returned in 2.84 seconds. Kimi K2, developed by Moonshot AI, likewise emitted a valid call and even prefaced it with a short natural-language acknowledgement, which the API still parses as a proper tool call.

Verdict by workflow

There is no single best Chinese model for function calling, because on the capability itself they are at parity. Pick Qwen3-235B-A22B when a high-frequency agent loop makes per-call cost the binding constraint, since it was cheapest here and fastest across our full run. Pick DeepSeek V4-Flash when you want the lowest single-call latency among Chinese options and expect its native rate to be cheaper still once reverified. Treat GLM-5 as the choice for hard reasoning-heavy tasks rather than simple high-volume calls. According to DeepSeek API Docs, DeepSeek exposes OpenAI-compatible function calling, so the routing swap is straightforward whichever way you go.

FAQ

Do Chinese LLM APIs support parallel tool calls? Several do, though our single-prompt test asked for one call and got one from each model, so we did not exercise parallel calling here. Parallel tool calls depend on the specific model and endpoint, so confirm it in each provider's function-calling documentation before you rely on it in an agent loop.

Are these models OpenAI-compatible for tool use? Largely yes. DeepSeek, Qwen, and MiniMax document OpenAI-style tools and tool_choice parameters, so an existing OpenAI-format agent usually needs only a new base URL and key. Behavior details such as parallel calls and streaming of tool arguments still vary, so test your exact framework against each endpoint.

Which Chinese LLM is cheapest for function calling? On our 2026-07-10 run, Qwen3-235B-A22B was cheapest at $0.0000291 for the tool call, just under half DeepSeek V4-Flash's routed $0.0000518 and about one-ninth of GLM-5's $0.000255. All figures are OpenRouter-routed and pending native reverification.

What does a multi-step agent loop actually cost? Multiply the per-call figure by the number of tool calls your agent makes. A twenty-call workflow runs about $0.000582 on Qwen3-235B-A22B versus about $0.0051 on GLM-5, so the cheap-and-fast model matters far more once calls compound than it does on any single call.

Did any model fail to emit the tool call? No. All six, including the GPT-4o baseline, returned a valid get_price tool call on this prompt. Remember this is one prompt at temperature 0, so it confirms broad tool-use support, not that any model calls tools perfectly on every prompt.

This is part of the best Chinese LLM API by use case hub, which compares DeepSeek, Qwen, GLM, Kimi, and MiniMax across measured tasks. For full rate cards, see the Qwen API pricing hub and the DeepSeek API pricing hub.

Author: Kevin Fan, Customer Success Manager at China LLM Directory, specializing in Chinese LLM ecosystem pricing and model benchmarking. Last verified: 2026-07-10.