GLM 5.3 API: Pricing, Endpoints, and reasoning_effort

Account restriction (September 9, 2026): the official model guide states that accounts that previously subscribed to a GLM Coding Plan, including expired subscriptions, currently access the model API only through the OpenAI Chat Completion-compatible protocol. The three documented endpoint families are not all available to every account.

The GLM 5.3 API opened five days after the model did, at $1.40 per million input tokens and $4.40 per million output, the same rate as GLM 5.2. The price is not what will surprise you. reasoning_effort defaults to max, and on a short classification call we measured max spending a median of 105 output tokens where low spent 3.

That is a 35x difference on the metered half of your bill, set by a parameter most people will not send.

Price:        $1.40 in / $0.26 cached in / $4.40 out per 1M tokens
Context:      1M tokens, 128K max output
Base URLs:    api.z.ai/api/coding/paas/v4  (OpenAI Chat Completions)
              api.z.ai/api/v1              (OpenAI Responses)
              api.z.ai/api/anthropic       (Anthropic Messages)
Gateways:     z-ai/glm-5.3 on OpenRouter and ofox
Effort:       low | high | max, default max, cannot be disabled
Removed:      thinking.type "disabled" now returns HTTP 400
Measured:     classify task 3 / 8 / 105 output tokens at low / high / max
Snapshot:     2026-08-19, effort validation re-probed 2026-08-20

How Much Does the GLM 5.3 API Cost?

$1.40 per million input tokens, $0.26 cached input, $4.40 output. Z.ai’s pricing table now carries a GLM-5.3 row, and it matches GLM 5.2 and GLM 5.1 line for line.

Two things are worth pulling out of that table. Cached input at $0.26 is 19% of a cold read, and storage was free in the recorded promotion, so a repeated system prompt is close to a free win. And output costs 3.1x input, which is the ratio that makes the effort setting below the most expensive line in your config.

OpenRouter lists the same $1.4 / $4.4 pair at a 1,048,576-token context, so the third-party routes are passing the first-party rate through rather than marking it up.

What Is the Base URL for the GLM 5.3 API?

Three protocols, and the docs page contradicts itself about one of them. The model page lists these:

Then the Quick Start section further down the same page posts to https://api.z.ai/api/paas/v4/chat/completions, without the /coding segment. One page, two answers. Choose the documented endpoint for your account before resubmitting; a 404 alone is not a reason to try a second billable route.

Neither of them is the https://open.bigmodel.cn/api/paas/v4 that Zhipu previewed on launch day. Anything written in the first 24 hours after the announcement is quoting a base URL that did not ship.

One restriction is easy to miss and it catches exactly the people most likely to be reading this: accounts that have ever subscribed to a GLM Coding Plan, including expired subscriptions, can currently reach the model API only through the OpenAI Chat Completions protocol. If your Responses or Anthropic-protocol calls fail on an account that used to run a plan, that is why.

What Does reasoning_effort Do to Your Bill?

More than the model choice does. GLM 5.3 always reasons, reasoning_effort takes low, high or max, and the default is max.

We ran two workloads through z-ai/glm-5.3 on an OpenAI-compatible gateway on 2026-08-19. A short classification prompt at n=10 per level, and a small code-generation prompt at n=5 per level. Same prompt, same model, only the effort string changing.

The classification row is the one to look at twice. Three output tokens at low, 105 at max, for an answer that is a single word either way. We then re-ran the classification 18 more times, six per effort level, capturing the text: every single run returned billing, the correct label, at all three settings. On this task max bought 102 extra output tokens and changed nothing.

Priced out, the same million classification calls cost $84.60 at low and $533.40 at max. The model, the prompt and the answer are identical. The difference is one string.

Here is the same arithmetic on the code task, where the reasoning is doing real work rather than restating the obvious:

Both rows are all-in: input at $1.40 per million plus output at $4.40, priced at the uncached rate. Output alone on the classification row would be $13.20, $35.20 and $462.00, so the fixed $71.40 of input is what compresses the ratio from 35x on tokens to 6.3x on the bill.

high is the setting that gets skipped and probably should not be. It cost 26% more than low on the classification job and 26% more on the code job, and on the code job it was faster than low at the median, 8.6 seconds against 11.6. Latency does not climb monotonically with effort. Only max is dramatically slower, and on the code task it was 5.5x the wall clock of low for output that a reviewer still has to read.

A caveat on the numbers: these are two prompts, not a benchmark suite, and the max ranges are wide, 47 to 160 tokens on a one-word answer and 2,807 to 10,596 on the code task. Run your own prompt before you size a budget on it. The ordering held across every run; the magnitude will depend on your workload.

Why Does My GLM 5.3 Request Return 400?

Most likely because reasoning cannot be switched off, and the API says so with a message that is only half accurate. This is the 400 you are most likely to hit:

{
  "error": {
    "message": "This model always engages in thinking and cannot be disabled; please use low, high, or max"
  }
}

That is the response to "thinking": {"type": "disabled"}, which is correct and expected. On 2026-08-19 it was also the response to "reasoning_effort": "medium" and to "reasoning_effort": "none", which was not, because neither of those tried to disable anything. medium is a perfectly reasonable guess if you came from another provider, and the error will send you hunting for a thinking parameter you never set.

That second behaviour did not hold, and the update is worth more than the original finding. Re-probed on 2026-08-20, the same route accepted medium, none, minimal and xhigh with HTTP 200, each spending eight to thirteen times the output tokens of an explicit low on the same prompt, while a different route to the same model name still returned the 400 above on that same day. A genuinely malformed value such as "invalid_value" was rejected on both routes, so validation exists; it just sits on the route you call rather than in the model, and it changed under a fixed model name with no announcement.

Two things follow for anyone writing this into a config. A 400 here does not always mean what the message says. And a 200 is not confirmation that your value selected the tier its name suggests: on the accepting route every undocumented value landed near max rather than anywhere in the middle, so a harness that sends medium believing it picked a middle setting is paying top-tier prices without being told.

The short list of what actually breaks:

How Do I Migrate a GLM 5.2 Workload to GLM 5.3?

Change the effort parameter first, then the model ID. Z.ai is explicit about the order, and the reason is that a request carrying thinking.type: "disabled" fails the moment the model ID flips.

from openai import OpenAI

client = OpenAI(api_key="YOUR_KEY", base_url="https://api.ofox.run/v1")

r = client.chat.completions.create(
    model="z-ai/glm-5.3",
    messages=[{"role": "user", "content": "Classify this ticket: ..."}],
    reasoning_effort="low",   # omit this and you are billed at max
)
print(r.usage.completion_tokens)

The migration is cheaper than the GLM 5.2 numbers implied. When we measured the cost of losing disabled on GLM 5.2 back in the launch write-up, the cheapest thinking-on setting still burned 69 to 122 output tokens on a trivial prompt against 2 for thinking off. On GLM 5.3, low came back at a median of 3. Whatever changed between the two, the floor that made people dread this migration is mostly gone, as long as you set the parameter.

Set it explicitly everywhere, including in the places that inherit defaults: retry wrappers, evaluation harnesses, and any framework that builds the request body for you. A missing reasoning_effort is not a missing feature, it is a bill at max.

If you are wiring up a key from scratch, our GLM 5.2 API access guide applies unchanged, because the endpoint, key and request shape are the same. For the workload math on high-volume short calls, the GLM 5.2 versus GPT-5.5 cost comparison has the model.

Should I Call GLM 5.3 Directly or Through a Gateway?

Direct if you only run GLM. Through a gateway if you run anything else alongside it, or if you got caught by the Coding Plan protocol restriction.

One caveat on gateways that costs people real money: what a proxy reports back is not always what it was billed. On the gateway we tested, usage.completion_tokens_details.reasoning_tokens does come through, so a low call returning 8 completion tokens correctly shows 3 of them as reasoning. What did not come through was any prompt_tokens_details cache field, and the reasoning text itself is absent from the message object. Verify both against your own provider before you build cost accounting or a cache-hit dashboard on them, because billing follows what the upstream did rather than what your response body shows.

ofox covers about 130 models on a single OpenAI-compatible endpoint, with z-ai/glm-5.3 and z-ai/glm-5.2 both live, which makes an A/B between the two the one-line change in the snippet above.

For benchmarks, the weights timeline and the GLM 5.3 versus 5.2 capability picture, our GLM 5.3 launch coverage has the full table. The ofox model page for GLM 5.3 carries the live catalog spec. The smaller sibling has its own trap: GLM-5.3-Flash publishes three parameter counts, and only one of them decides your bill.

Reasoning effort changes the bill through token count rather than through the rate. Six costs the rate card does not show covers that whole family.

References

• Z.ai developer docs: GLM-5.3 model page
• Z.ai developer docs: pricing
• Z.ai developer docs: deep thinking
• Z.ai release note: GLM-5.3
• OpenRouter: z-ai/glm-5.3
• ofox model page: GLM 5.3