GLM-5.3-Flash API Is Here: Pricing, Benchmarks & How to Use It

Mengbi editorial cover. The artwork is original and does not reproduce an official benchmark chart.

The GLM-5.3-Flash API is now live, and this release is more interesting than its name suggests. Z.ai has paired low token prices with a 1M-token context window, native image input, tool calling, structured output and open weights under the MIT license. The model id is glm-5.3-flash.

The launch claim is simple: GLM-5.3-Flash exceeds GLM-5.2 on Z.ai's reported evaluations while costing one tenth as much at list price. During the launch promotion, the gap is even wider. That makes the model worth testing for coding agents, visual front-end work, document analysis and long-running workflows where output cost used to limit how often an agent could inspect and revise its own work.

There are two important caveats. First, the 50% API discount expires on September 9, 2026. Second, most performance figures available on launch day come from Z.ai or evaluation setups selected by Z.ai. This guide keeps the price facts, benchmark claims and early hands-on observations separate so you can judge each on the right evidence.

GLM-5.3-Flash API at a glance

If you only need a first recommendation, use GLM-5.3-Flash for a bounded evaluation where cost, long context or image-aware coding matters. Keep GLM-5.3 in the comparison when the task is difficult enough that a higher per-call price is acceptable. For a nearby low-cost multimodal release, our DeepSeek V4 Flash Vision-Exp API guide covers a different balance of image support and API limits.

GLM-5.3-Flash API pricing

Z.ai prices the model by input, cached input and output tokens. The official pricing page lists both the temporary 50% discount and the normal rate.

The promotion ends at 24:00 on September 9, 2026, UTC+8 Singapore time. This date matters. A budget built only from the discounted column will double when list pricing resumes unless Z.ai changes the offer.

The price is still low after the promotion. GLM-5.3 currently costs $1.40 per million input tokens and $4.40 per million output tokens on the same official page. At list price, GLM-5.3-Flash is roughly one tenth of those token rates. Z.ai also markets the discounted model as one twentieth the price of GLM-5.3 and one fortieth the price of Claude Opus 4.8. The first comparison can be verified directly from Z.ai's own table. The Opus comparison depends on the Anthropic price and workload assumptions used by Z.ai, so treat it as launch positioning rather than a universal bill ratio.

What does one GLM-5.3-Flash request cost?

Consider a repository task that sends 1 million uncached input tokens and receives 200,000 output tokens. During the promotion, the token cost is about $0.125: $0.075 for input and $0.05 for output. At list price, the same token mix is about $0.25.

A larger batch with 10 million input tokens and 2 million output tokens costs about $1.25 during the promotion and $2.50 at list price. These examples exclude optional tools. Z.ai currently lists web search at $0.01 per use, so an agent that searches repeatedly can spend more on tool calls than on model tokens.

Do not confuse API billing with the GLM Coding Plan. The Coding Plan uses a points-based quota and currently gives GLM-5.3-Flash three times the available quota of GLM-5.3. Off-peak calls, including weekends, consume half the standard points. That subscription is useful for supported coding clients, but its quota is not a token price you can insert into a server-side API cost model.

What the GLM-5.3-Flash benchmarks show

Z.ai's launch chart places GLM-5.3-Flash ahead of GLM-5.2 on six coding, agent and work benchmarks. The largest gaps in the chart are DeepSWE v1.1, where the scores are 63.4 and 46.2, and AutomationBench, where they are 48.8 and 26.2. GLM-5.3-Flash also scores 84.3 on Terminal Bench 2.1 and 55.3 on HLE with tools.

Z.ai's official launch chart. Results use different evaluation runners and settings, so compare each benchmark within its stated setup. Source: Z.ai GLM-5.3-Flash model page.

The chart does not say the model wins every test. Claude Opus 4.8 scores 85.0 on Terminal Bench 2.1 against 84.3 for GLM-5.3-Flash. On Agents' Last Exam, GLM-5.3-Flash reaches 26.3 while Claude Opus 4.8 reaches 27.0 and GPT-5.6 reaches 28.0. The launch result is better read as a cost and capability argument than as proof of one universal winner.

The footnotes matter too. Z.ai ran DeepSWE with mini-swe-agent, a six-hour timeout and a 400K context. Terminal Bench 2.1 used Claude Code 2.1.207, a six-hour timeout and up to 65,536 generated tokens. HLE with tools used a maximum 300K context with context management and GPT-5.6 Luna as the judge. Toolathlon results came from the official evaluation service and report pass@1 averaged across three runs.

Those choices are not necessarily wrong. They define the result. A coding model can look different when the evaluation runner, timeout, tools, sampling parameters or repository set changes. Treat the numbers as a strong reason to test, then run the same task against the same acceptance checks in your own environment.

Cost and intelligence on Artificial Analysis

Z.ai also plots GLM-5.3-Flash on the Artificial Analysis Intelligence Index v4.1.1. The chart shows an index score of 57 at a discounted estimated cost of $0.045 per task. Z.ai describes that point as a new Pareto frontier, meaning no cheaper model in the plotted set has a higher score under the same index and cost method.

The source and update date are printed in the chart. The $0.045 figure is an Artificial Analysis task-cost estimate, not the price of every API request. Source: Z.ai GLM-5.3-Flash model page.

This is useful comparison evidence because the chart applies one external methodology across many models. It is not a substitute for your invoice or workload test. The score compresses several evaluations into one index, and the cost per task depends on the benchmark's token use and current promotional price.

Why GLM-5.3-Flash can be cheaper at long context

GLM-5.3-Flash is a mixture-of-experts model with 320 billion total parameters and 18 billion active parameters. Z.ai says it starts from a newly trained base model and a 30 trillion-token multimodal pre-training corpus. It also cuts the GLM-4.5 series layer count from 92 to 45 while reducing active parameters from 32 billion to 18 billion.

The more unusual change is its attention design. Linear attention handles local dependencies through a compact state, while sparse attention retrieves selected global context through an indexer. Z.ai's IndexPool combines four indexer key vectors into one before sparse retrieval. Manifold-Constrained Hyper-Connections, shortened to mHC, connect the attention and expert layers.

Z.ai reports 4.44 times less per-layer KV cache and 3.01 times less per-layer attention compute than GLM-5.3 at a 1M-token sequence. Source: Z.ai GLM-5.3-Flash model page.

According to the official diagram, GLM-5.3-Flash uses 4.44 times less KV cache per layer and 3.01 times less attention compute per layer than GLM-5.3 at one million tokens. Those are architecture calculations reported by Z.ai, not a promise that every request will be three or four times faster. End-to-end latency also depends on hardware, batching, quantization, output length and the serving stack.

The weights are available on the official Hugging Face model card under the MIT license. Z.ai lists SGLang, vLLM, TokenSpeed and KTransformers as deployment paths. Open weights do not make this a laptop model. A 320B model still demands a serious memory and serving plan even when only 18B parameters are active for each token.

How to use the GLM-5.3-Flash API

The general Z.ai endpoint is https://api.z.ai/api/paas/v4. Create an API key in the Z.ai console, store it as a server-side environment variable and send Chat Completions requests with the model id glm-5.3-flash. The official API introduction documents Bearer authentication and the quick start confirms OpenAI SDK compatibility.

Call GLM-5.3-Flash with curl

curl 'https://api.z.ai/api/paas/v4/chat/completions' \  -H 'Authorization: Bearer YOUR_ZAI_API_KEY' \  -H 'Content-Type: application/json' \  -d '{    "model": "glm-5.3-flash",    "messages": [      {        "role": "user",        "content": "Review this implementation plan. Return the three highest-risk assumptions as JSON."      }    ],    "temperature": 1,    "top_p": 0.95,    "reasoning_effort": "max",    "thinking": {      "type": "enabled",      "clear_thinking": false    },    "stream": false  }'

Z.ai recommends temperature: 1, top_p: 0.95 and reasoning_effort: max for this model. Thinking is always enabled. The model page says thinking.type only accepts enabled, and it recommends keeping clear_thinking false so previous reasoning state can continue across a multi-turn task.

For a production service, do not put the key in browser code or a committed .env file. Add timeouts, retry only errors that are safe to retry, record usage from the API response and place a budget around long agent loops. Low per-token pricing makes repeated inspection affordable, but it does not make an unbounded loop safe.

Call GLM-5.3-Flash with the OpenAI Python SDK

import os
from openai import OpenAI
client = OpenAI(    api_key=os.environ["ZAI_API_KEY"],    base_url="https://api.z.ai/api/paas/v4/",)
response = client.chat.completions.create(    model="glm-5.3-flash",    messages=[        {            "role": "user",            "content": "Design a migration checklist for this API change. Keep every item testable.",        }    ],    temperature=1,    top_p=0.95,    reasoning_effort="high",    extra_body={        "thinking": {            "type": "enabled",            "clear_thinking": False,        }    },)
print(response.choices[0].message.content)print(response.usage)

The example uses extra_body for Z.ai's thinking object because it is not a standard Chat Completions field in every OpenAI SDK version. Test the exact SDK version you deploy. These examples follow the documented request shape; Mengbi did not send a live request with a paid API key for this article.

How to send an image to GLM-5.3-Flash

Native multimodal input is the main difference between this release and a cheap text-only model. Put the prompt and one or more image_url blocks in a user message. Z.ai recommends a reachable image URL, but a Base64 data URL is also supported.

response = client.chat.completions.create(    model="glm-5.3-flash",    messages=[        {            "role": "user",            "content": [                {                    "type": "text",                    "text": "Inspect this interface. List visible defects and propose a test for each one.",                },                {                    "type": "image_url",                    "image_url": {                        "url": "<YOUR_PUBLIC_IMAGE_URL>"                    },                },            ],        }    ],    reasoning_effort="max",    extra_body={        "thinking": {            "type": "enabled",            "clear_thinking": False,        }    },)

Multiple images require multiple image_url blocks. The model overview also lists video and file understanding, but the Chat Completions example on that page is specific about image URL and Base64 input. Validate the separate upload or media path before assuming a local video file can be inserted into the same payload.

The useful pattern for coding is an observation loop. Let the agent implement a page, run it, capture a screenshot, compare the render with the reference and revise the code. Our AI coding agents comparison explains the surrounding IDE and terminal choices. GLM-5.3-Flash supplies the model capability; your agent still needs a browser, screenshot path, tests and a clear stopping rule.

Early hands-on evidence from Ox Alpha

Before the public reveal, Z.ai served GLM-5.3-Flash as the anonymous model Ox Alpha on OpenCode and OpenRouter. Z.ai says it became the most popular model of the week and that the traffic ran on Chinese AI chips. Those are first-party launch claims, not an independent traffic audit.

The most useful early report comes from Chinese AI writer Guizang's hands-on article. He tested three front-end tasks with real visual complexity and described the prompts, generated implementation choices and visible shortcomings.

In the first task, one screenshot showed two interactive glass cubes above a typographic poster. The model chose an off-screen canvas for the typography, used physical glass materials and added pointer-driven rotation and parallax. In the second, a screen recording showed a ribbon made from 60 glass panels changing pose during scroll. The first result needed a correction to panel orientation, but the model inferred the scroll states, hover response and environment lighting from the video.

The third task was less about copying. Guizang supplied a static voxel poster and asked for an interaction where covering blocks fall away during scroll. The model built the object with instanced geometry, generated a layered reveal and tied the falling sequence to scroll progress. That result suggests the model can turn a visual reference into an implementation plan rather than treating the image as a flat texture.

This report adds something the launch charts cannot show: the kinds of mistakes a human can inspect and correct during visual coding. It is still one author's evaluation with three selected tasks. It does not prove that GLM-5.3-Flash always beats DeepSeek, Claude or another model, and Mengbi did not reproduce the tests. Use the examples to design your own trial, not to skip it.

GLM-5.3-Flash vs GLM-5.3

GLM-5.3-Flash is the economic default; GLM-5.3 remains the higher-priced model to keep in a difficult-task comparison. Both expose long context and modern agent features, but the Flash release adds native multimodal visual coding and a much lower token rate.

A practical router can try GLM-5.3-Flash first, validate the result and escalate only failures that matter. The validation should be external to the model. For code, run tests and inspect the diff. For a visual page, compare screenshots at fixed viewports. For a spreadsheet or report, verify formulas, sources, overflow and exported files.

Do not route by benchmark score alone. Measure task success, latency, token usage, tool failures and the amount of human correction. A cheaper model that needs three full retries may cost more than a stronger model that finishes once. A low token price becomes valuable when the surrounding loop can tell a good result from a plausible one.

Production checklist for the first API trial

Start with one task family, one comparison model and a small evaluation set you can inspect. Record the prompt, model id, input assets, request settings, response usage, tool calls, final artifact and reviewer correction. That evidence will answer the purchase question more reliably than a general leaderboard.

Keep images and other untrusted input away from secrets. A screenshot can contain prompt injection, personal data or credentials. Limit which tools the agent can call, require approval for external writes and set a maximum cost and turn count. For long context, send the files that support the task instead of filling the entire window because it exists.

Finally, pin the expected request shape in a contract test. Check the base URL, model id, image content block, thinking settings, streaming parser and usage fields. Z.ai is explicit that thinking cannot be disabled for GLM-5.3-Flash. An integration that assumes a text-only, non-reasoning response can fail even when the HTTP request succeeds.

FAQ

Is the GLM-5.3-Flash API available now?

Yes. Z.ai documents the model id glm-5.3-flash on its API platform and lists it on the official pricing page. It is also available through the GLM Coding Plan, while the open weights are published on Hugging Face.

How much does the GLM-5.3-Flash API cost?

Until September 9, 2026 at 24:00 UTC+8, the official price is $0.075 per million input tokens, $0.015 for cached input and $0.25 per million output tokens. The listed normal rates are $0.15, $0.03 and $0.50 respectively.

What is the GLM-5.3-Flash context window?

Z.ai documents a 1 million-token context window. A large limit does not guarantee that every part of a million-token prompt receives equal attention, so test retrieval and answer accuracy at the lengths you plan to use.

Does GLM-5.3-Flash support images?

Yes. Add image_url blocks to the user message and pass a public URL or Base64 data URL. Multiple images require multiple blocks. The model returns text; it is not an image-generation API. For image creation products, see our AI image generator comparison.

Can thinking be disabled?

No. The official model page says thinking.type only supports enabled. Z.ai recommends reasoning_effort: max, temperature: 1, top_p: 0.95 and thinking.clear_thinking: false for the model.

Is GLM-5.3-Flash really as capable as Claude Opus 4.8?

Some launch results are close. Z.ai's chart shows 84.3 versus 85.0 on Terminal Bench 2.1, and its own Code Bench reports 29.0 versus 29.5 at max effort. Other tests differ, and one author's visual coding report is not a controlled evaluation. Test both models on your actual acceptance criteria before making a broad claim.

Can I run GLM-5.3-Flash locally?

The weights are published under the MIT license, and Z.ai lists vLLM, SGLang, TokenSpeed and KTransformers. The model has 320B total parameters, so local deployment still needs substantial memory, suitable quantization and a carefully planned serving setup.

Sources and review notes

Core pricing, model and API facts were checked on August 27, 2026 against the official GLM-5.3-Flash model page, Z.ai pricing, API introduction, quick start and official Hugging Face model card. Broader architecture context comes from the GLM-5 technical report.

The visual coding examples are summarized from Guizang's August 26 hands-on article. Independent launch context was checked against TestingCatalog and First Financial. Mengbi did not run the paid API or reproduce the benchmark and visual coding tests. Official performance claims remain attributed to Z.ai, and the promotional price should be rechecked after September 9.

Last reviewed: August 27, 2026.