Quick answer: Z.AI lists GLM 5.3 at $1.40 per 1 million input tokens, $0.26 per 1 million cached input tokens, and $4.40 per 1 million output tokens. Cached-input storage is marked as free for a limited time. The separate GLM Coding Plan starts at $18 per month and uses credits rather than the public API's per-token meter.
This guide was rebuilt from Z.AI's current pricing, model, caching, Coding Plan, and subscription pages on August 26, 2026. It separates the two billing systems, shows the arithmetic behind real requests, and removes the earlier launch-period claims that GLM 5.3 API pricing was still unpublished.
GLM 5.3 price at a glance
| Access method | Published price or allowance | Best fit |
|---|---|---|
| Public model API | $1.40 input / $0.26 cached input / $4.40 output per 1M tokens | Products, backends, agents, and metered automation |
| Coding Plan Lite | $18 monthly; $12.60/month effective on annual billing; 2,000 five-hour and 10,000 weekly credits | Lighter coding-tool use |
| Coding Plan Pro | $80 monthly; $56/month effective on annual billing; 12,000 five-hour and 60,000 weekly credits | Longer and more frequent coding sessions |
| Coding Plan Max | $168 monthly; $117.60/month effective on annual billing; 28,000 five-hour and 140,000 weekly credits | The heaviest supported coding-tool workloads |
The most important distinction is simple: API prices are denominated in tokens; Coding Plan usage is denominated in credits. The Coding Plan's 50% off-peak rule does not cut the public API rates in half.
Official GLM 5.3 API token rates
Z.AI's official pricing table gives GLM-5.3 the following rates in US dollars:
| Charge type | Price per 1M tokens | What it means |
|---|---|---|
| Fresh input | $1.40 | Prompt and context tokens that are not served from cache |
| Cached input | $0.26 | Repeated context recognized as a cache hit |
| Cached-input storage | Limited-time free | The storage line is currently marked free, but the offer is time-limited |
| Output | $4.40 | Tokens generated by the model |
GLM 5.3 supports a 1M-token context window and up to 128K output tokens. Reasoning is always enabled, with low, high, and max effort levels. Those effort settings do not change the published rate card; they can change how much work the model performs and therefore how many tokens a request ultimately uses.
The model is available through Z.AI's documented API protocols. The general API and the Coding Plan use different keys and endpoint rules, so use the endpoint associated with the product you actually bought rather than treating the Coding Plan as a general-purpose API balance.
How to calculate a GLM 5.3 API bill
Use three separately metered token buckets:
cost = (fresh input tokens / 1,000,000 × $1.40)
+ (cached input tokens / 1,000,000 × $0.26)
+ (output tokens / 1,000,000 × $4.40)
Built-in tools can add their own charges. For example, Z.AI's pricing page lists Web Search at $0.01 per use, so an agent loop that calls search repeatedly needs a tool-use line in addition to token spend.
Worked GLM 5.3 cost examples
| Request shape | Calculation | Estimated cost |
|---|---|---|
| 10K fresh input + 2K output | 0.01 × $1.40 + 0.002 × $4.40 | $0.0228 |
| 100K fresh input + 10K output | 0.1 × $1.40 + 0.01 × $4.40 | $0.184 |
| 1M fresh input + 100K output | 1 × $1.40 + 0.1 × $4.40 | $1.84 |
| 200K fresh + 800K cached + 20K output | 0.2 × $1.40 + 0.8 × $0.26 + 0.02 × $4.40 | $0.576 |
| Same 1M input with no cache + 20K output | 1 × $1.40 + 0.02 × $4.40 | $1.488 |
| 128K output alone | 0.128 × $4.40 | $0.5632 |
The cache-heavy request costs about 61% less than the equivalent request with all 1M input tokens billed as fresh input. That is not a guaranteed saving for every workload: it depends on how much repeated context Z.AI recognizes as cached. Check usage.prompt_tokens_details.cached_tokens in responses instead of assuming a cache-hit percentage.
Before committing a production budget, run a representative workload and compare the observed input, cached-input, output, and tool-use totals. You can also try GLM 5.3 in the browser before deciding how to structure an integration.
The Pricing Mistake That Causes Bad Budgets
The biggest budgeting error is mixing the API and Coding Plan into one imaginary product.
A statement such as “GLM 5.3 is half price outside peak hours” is incomplete. The official Coding Plan documentation says model usage consumes 50% of normal credits outside Monday-Friday, 14:00-18:00 Singapore time. The public API pricing page does not publish an hourly token discount. A production service should therefore budget the API at $1.40, $0.26, and $4.40 per million tokens regardless of the time of day.
Three other mistakes are common:
- Ignoring output. Output costs more per million tokens than fresh input, so long answers and deep agent runs can dominate the bill.
- Assuming every input token will be cached. The lower cached-input rate applies only to recognized cache hits.
- Treating the 1M context window as a target. A large context limit is capacity, not a reason to send an entire repository on every request.
A useful forecast has at least four rows: fresh input, cached input, output, and paid tool calls. It should also include retry rate, because a cheaper individual call can still become expensive when a workflow repeatedly fails and reruns.
API vs Coding Plan: which billing model fits?
| Decision point | GLM 5.3 public API | GLM Coding Plan |
|---|---|---|
| Billing unit | Fresh input, cached input, and output tokens | Weighted credits |
| Payment pattern | Pay as you go | Monthly, quarterly, or annual subscription |
| Intended use | Applications, services, integrations, and automation | Supported coding tools and coding workflows |
| Usage limits | Account and API rate limits | Both five-hour and weekly credit limits |
| Off-peak benefit | No hourly discount published on the API rate card | Model usage consumes 50% credits off-peak |
| Cost visibility | Exact per-request token usage | Predictable subscription price, but task cost varies with multipliers and cache hits |
Choose the API when software, customers, scheduled jobs, or your own backend call the model. Choose the Coding Plan when you primarily use GLM inside supported coding tools such as Claude Code, Cline, or OpenCode.
The two can coexist. A developer may use the Coding Plan for interactive repository work while the product itself uses the public API. They remain separate meters and should have separate budgets. For the subscription side, see the full GLM 5.3 Coding Plan credit and tier breakdown.
What Other GLM 5.3 Pricing Summaries Blur
Launch-week pricing articles often collapse several different facts. Here is the cleaner version:
- The GLM 5.3 API price is now published. Articles that still say “coming soon” or substitute an estimated GLM 5.2 price are stale.
- GLM 5.3 and GLM 5.2 currently have the same published token rates. That is an official current-price observation, not a promise that the rates will always remain equal.
- Cached-input price and cached-input storage are different fields. Cache hits cost $0.26 per million tokens; storage is separately marked limited-time free.
- Reasoning effort is not a pricing tier.
low,high, andmaxuse the same rate card. They are execution controls that can affect usage. - Coding Plan credits do not convert 1:1 into API tokens. GLM 5.3 applies separate input, cached-input, and output multipliers inside the plan.
- The listed annual figures are effective monthly prices. They require annual billing; they are not month-to-month prices.
This separation is the article's main decision advantage: it tells you which published number belongs in which budget instead of presenting every discount and quota in one table without boundaries.
Practical ways to control GLM 5.3 API cost
Measure cache hits instead of guessing
Keep stable system instructions and repeated context prefixes consistent enough for automatic caching to recognize them. Then log cached_tokens and calculate the actual savings. Constantly rewriting the beginning of the prompt can reduce reuse.
Cap output for each task type
A classification call, code explanation, and repository-wide implementation plan do not need the same output ceiling. Set a realistic maximum rather than inheriting the 128K model limit everywhere.
Match reasoning effort to the task
Use a lower effort for straightforward extraction or formatting and reserve max for work that benefits from deeper reasoning. Validate quality and token use on your own prompts; effort is not a substitute for an evaluation set.
Trim irrelevant context
Send the files, history, and tool results needed for the current step. A 1M context window makes large tasks possible, but irrelevant fresh input is still billed.
Put stop conditions around agents
Limit retries, tool-call loops, and repeated self-correction. Track cost per completed task, not just cost per request.
For implementation examples and the endpoints used by this site, consult the glm5.app API documentation. The prices on the official provider page and the prices charged by glm5.app are separate commercial offers; check the relevant pricing page before buying either service.
Frequently asked questions
What is the official GLM 5.3 API price?
$1.40 per 1M fresh input tokens, $0.26 per 1M cached input tokens, and $4.40 per 1M output tokens. Cached-input storage is currently marked limited-time free.
How much does a typical GLM 5.3 request cost?
It depends on token mix. A request with 100K fresh input and 10K output costs about $0.184 at the published rates. Cache hits can lower the input portion.
Does the 50% off-peak rule apply to the public API?
No hourly discount is published on the API rate card. The 50% rule applies to model-credit consumption inside the GLM Coding Plan.
Is GLM 5.3 more expensive than GLM 5.2?
Not on the current official API table: both list $1.40 input, $0.26 cached input, and $4.40 output per million tokens. Actual task cost can still differ because token usage differs.
Can reasoning be turned off to reduce cost?
No. GLM 5.3 always operates with reasoning enabled. You can choose low, high, or max effort and measure the resulting quality and usage.
What are the GLM 5.3 context and output limits?
The official model guide lists a 1M-token context window and a 128K maximum output length.
Should I buy the Coding Plan or use the API?
Use the Coding Plan for supported coding tools and the public API for applications and general integrations. Compare the plan's credits against your heaviest five-hour coding session rather than trying to convert the subscription price directly into API tokens.
Bottom line
GLM 5.3's public price is no longer an estimate: $1.40 input, $0.26 cached input, and $4.40 output per million tokens. Model fresh input, cache hits, output, tool calls, and retries separately. Keep Coding Plan discounts out of the API forecast, then compare the plan only against your personal coding-tool workload.
Use GLM 5.3 on glm5.app, review the API documentation, or compare this site's own packages on the glm5.app pricing page.
Sources
Facts and prices were checked against these official Z.AI pages on August 26, 2026:
- Z.AI API pricing — Current GLM 5.3 input, cached-input, storage, output, and tool rates.
- Z.AI GLM 5.3 model guide — Context, maximum output, reasoning modes, and API availability.
- Z.AI context caching guide — Automatic cache recognition and cached-token reporting.
- Z.AI Coding Plan overview — Credits, multipliers, reset rules, and off-peak treatment.
- Z.AI Coding Plan subscription page — Current individual-plan prices and tier positioning.
