---

GLM-5.3-Flash Is Free (200 Requests/Day): A Hands-On Guide

The model that anonymously topped OpenRouter for a week — then turned out to be Zhipu AI's open-source GLM-5.3-Flash — also has a free tier: 200 requests per day, with no GPU, no overseas card, and no proxy required. If you've been looking for a frontier-class model to wire into a side project or an agent experiment, this is one of the lowest-friction ways to get one.

Here's how to actually use it.

Who this model is

Quick context in case you missed the story: in late August 2026, a model called Ox Alpha landed on OpenRouter and OpenCode with no branding, went to #1 on day one, set a single-day usage record at 4x the previous platform peak, and burned roughly 62 trillion tokens in six days before Zhipu AI revealed its identity on August 26.

That identity is GLM-5.3-Flash — an MIT-licensed model with 320B total / 18B active parameters, a 1.04M-token context window, native multimodal input (text, image, video, file), and an AA Intelligence Index of 57 — tied with Claude Opus 4.8 and above DeepSeek V4 Pro's 53.

The important thing for this article: it's a flagship-class model, not a stripped-down "lite" tier. The free version is the same model, just rate-limited.

What the free tier gives you

• Model ID: glm-5.3-flash-free
• Quota: 200 free requests per day (RPD), reset daily
• Capability: the full model — AA-57 intelligence, multimodal input, 1.04M context
• Interface: OpenAI-compatible — POST /v1/chat/completions
• Requirements: none beyond an API key — no GPU, no overseas card, no proxy

The same key also routes other models (Claude, GPT, DeepSeek, Kimi, Gemini, Grok) through one gateway with unified billing, so it doubles as a general-purpose key if you need it.

Getting a key

Register on the gateway (TeamoRouter), create an API key from the console — keys start with sk-teamo- — and confirm the model is available by pulling the live model list:

curl https://api.teamorouter.cn/v1/models \
  -H "Authorization: Bearer <your-key>"

You should see glm-5.3-flash, glm-5.3-flash-free (the free tier), glm-5.3, and glm-5.2. The free model is the one ending in -free — keep the spelling all lowercase.

Calling it: OpenAI-compatible endpoint

• Base URL: https://api.teamorouter.cn/v1
• Endpoint: POST /v1/chat/completions

One gotcha from the docs: /v1/responses only supports GPT-series models. GLM models use the OpenAI-compatible chat completions endpoint instead.

cURL:

curl https://api.teamorouter.cn/v1/chat/completions \
  -H "Authorization: Bearer <your-key>" \
  -H "content-type: application/json" \
  -d '{
    "model": "glm-5.3-flash-free",
    "max_tokens": 1024,
    "messages": [{"role": "user", "content": "Write a Python function that returns the nth Fibonacci number"}]
  }'

Python (openai SDK):

from openai import OpenAI

client = OpenAI(
    api_key="<your-key>",
    base_url="https://api.teamorouter.cn/v1",
)

resp = client.chat.completions.create(
    model="glm-5.3-flash-free",
    messages=[{"role": "user", "content": "Write a Python function that returns the nth Fibonacci number"}],
)
print(resp.choices[0].message.content)

Node:

import OpenAI from "openai";

const client = new OpenAI({
  apiKey: "<your-key>",
  baseURL: "https://api.teamorouter.cn/v1",
});

const resp = await client.chat.completions.create({
  model: "glm-5.3-flash-free",
  messages: [{ role: "user", content: "Write a Python function that returns the nth Fibonacci number" }],
});
console.log(resp.choices[0].message.content);

Replace <your-key> with your actual key and each of these runs as-is. That's the whole setup — no separate Zhipu account, no GPU, no proxy.

A worked example, end to end

To make the accounting concrete, here's a realistic single request: you want a code review of a small function before you commit it. Put the full function in the prompt, ask for a review in a specific format, and the model returns it in one call:

POST /v1/chat/completions
{
  "model": "glm-5.3-flash-free",
  "max_tokens": 1024,
  "messages": [
    {"role": "system", "content": "You are a senior Python reviewer. Be concise, flag bugs first, then style."},
    {"role": "user", "content": "<paste your function here>"}
  ]
}

The response is standard OpenAI chat-completion JSON: choices[0].message.content holds the review text, and the usage field tells you exactly how many tokens that call consumed toward your daily quota. Because the free model is the full GLM-5.3-Flash, a review like this — which would be a "heavy" request on a lite tier — is ordinary work here. One request in, one review out; that's the whole accounting.

Wiring it into agent tools

Because the gateway speaks both Anthropic and OpenAI protocols, you can point agent tools at it with a few environment variables.

Claude Code:

export ANTHROPIC_BASE_URL="https://api.teamorouter.cn"
export ANTHROPIC_AUTH_TOKEN="<your-key>"
export ANTHROPIC_MODEL="glm-5.3-flash-free"
export ANTHROPIC_SMALL_FAST_MODEL="glm-5.3-flash-free"

Codex or other OpenAI-protocol tools:

export OPENAI_BASE_URL="https://api.teamorouter.cn/v1"
export OPENAI_API_KEY="<your-key>"

Beyond that, GLM-5.3-Flash is MIT-licensed and OpenAI-compatible, so it works in any OpenAI-compatible client. It's the same model that first made its name on OpenRouter and OpenCode, so it's easy to find there as well.

What you can realistically do with 200 requests/day

200/day isn't a demo quota — it's a real working budget for a solo developer. Because the model is flagship-class, each request can carry heavier work:

Task	What a single request can complete
Code generation	A full function or component, with comments and edge-case handling
Code understanding	Explaining an unfamiliar codebase, reviewing logic
Test writing	A batch of unit tests covering core paths
Documentation / translation	Translating a whole README between languages
Long-context analysis	The 1.04M-token context can hold an entire mid-size repository

For everyday coding assistance, 200/day is plenty. The thing that actually drains the quota is agent loops: a single feature — read code, modify, verify — can burn 20-30 requests. So before pointing an agent at the free tier, prepare your prompts and context instead of iterating on vague requirements.

A realistic daily split looks like this:

Task type	Est. requests	Examples
Code generation	50-70	New functions, components, API routes, SQL queries
Code understanding / review	40-60	Reading unfamiliar code, explaining logic, reviewing PRs
Test writing	30-40	Unit tests, edge cases
Documentation / translation	20-30	README, comments, translations
Bug fixing	20-30	Locating errors, fixes, regression checks
Long-doc analysis	10-20	Whole documents inside the 1.04M context

The key insight isn't "is 200 enough" — it's "is each request efficient." A clear prompt with enough context gets a usable result on the first call; a vague prompt can bounce back and forth several times and eat the budget fast.

Limits and caveats

• Hard cap. The 200/day quota resets daily. It's not a rate for high-volume production.
• Agent loops. Continuous agentic work will hit the cap quickly (one feature ≈ 20-30 calls).
• Endpoint gotcha. /v1/responses is GPT-only; GLM must use /v1/chat/completions.
• When the quota runs out. Change only the model field to paid glm-5.3-flash — same key, same code, no daily cap, and still cheap (¥0.8 in / ¥2.8 out per 1M tokens domestically). Or fall back to the DeepSeek free tiers on the same key (deepseek-v4-flash-free at 200/day, deepseek-v4-pro-free at 50/day). GLM and DeepSeek quotas are separate, so one key effectively gives you two free buckets.
• Third-party gateway. This free tier is offered by a routing service, not by Zhipu directly. The model itself is MIT open source, so if you outgrow the tier, self-hosting is possible — at the cost of running your own GPU cluster.

Conclusion

A frontier-class model — the one that anonymously topped OpenRouter — available free at 200 requests per day is a low-risk way to evaluate whether it fits your actual workload before you spend anything. The quota is generous enough for real coding assistance and genuine evaluation, the integration is a standard OpenAI-compatible call, and the paid path is a one-line change when you need more. For a side project or an agent experiment, that's about as cheap as an on-ramp gets.