GLM-5.3 API Reference

GLM-5.3 accepts text and returns text or tool calls. It always reasons, supports low, high and max effort, and allows up to 131,072 output tokens. Use glm-5.3 for the Default tier. Its default group is glm; glm-5.3:glm remains an explicit selection of that same group. Additional groups use their own model suffix.

Base URL: https://api.seedrouter.ai. Authenticate with Authorization: Bearer $SEEDROUTER_API_KEY. Keep credentials on your server. Messages also accepts the compatible x-api-key header.

This reference follows the Z.ai Chat contract, the manufacturer's Responses schema, and its Messages compatibility guide. Model-specific limits come from the GLM-5.3 guide. Documentation alignment does not establish every live behavior. Checks on October 29, 2026 completed text and streaming requests in all three formats, Chat function calling, JSON object output, and saved-response continuation. Cache hits, explicit cache lifetimes and every compatibility control were not established. Messages reference fields below are distinguished from manufacturer-documented GLM fields.

OpenAPI specification · Markdown reference · Model and Playground · Pricing guide

Quickstart

Each example sends one Chat Completions request. max_tokens: 2048 is an example budget, not the default. Reasoning and the visible answer share that budget; inspect finish_reason before treating the answer as complete.

curl https://api.seedrouter.ai/v1/chat/completions \
  -H "Authorization: Bearer $SEEDROUTER_API_KEY" \
  -H 'Content-Type: application/json' \
  -d '{"model":"glm-5.3","messages":[{"role":"user","content":"Explain an idempotency key with one concrete example."}],"reasoning_effort":"low","max_tokens":2048}'

import os
from openai import OpenAI

client = OpenAI(api_key=os.environ["SEEDROUTER_API_KEY"], base_url="https://api.seedrouter.ai/v1")
response = client.chat.completions.create(
    model="glm-5.3",
    messages=[{"role": "user", "content": "Explain an idempotency key with one concrete example."}],
    max_tokens=2048,
    extra_body={"reasoning_effort": "low"},
)
print(response.choices[0].message.content)
print(response.usage)

import OpenAI from 'openai';
const client = new OpenAI({apiKey: process.env.SEEDROUTER_API_KEY, baseURL: 'https://api.seedrouter.ai/v1'});
const response = await client.chat.completions.create({
  model: 'glm-5.3',
  messages: [{role: 'user', content: 'Explain an idempotency key with one concrete example.'}],
  reasoning_effort: 'low',
  max_tokens: 2048,
});
console.log(response.choices[0].message.content);
console.log(response.usage);

package main

import (
    "bytes"
    "fmt"
    "io"
    "net/http"
    "os"
    "time"
)

func main() {
    body := []byte(`{"model":"glm-5.3","messages":[{"role":"user","content":"Explain an idempotency key with one concrete example."}],"reasoning_effort":"low","max_tokens":2048}`)
    req, err := http.NewRequest("POST", "https://api.seedrouter.ai/v1/chat/completions", bytes.NewReader(body))
    if err != nil { panic(err) }
    req.Header.Set("Authorization", "Bearer " + os.Getenv("SEEDROUTER_API_KEY"))
    req.Header.Set("Content-Type", "application/json")
    client := &http.Client{Timeout: 3 * time.Minute}
    res, err := client.Do(req)
    if err != nil { panic(err) }
    defer res.Body.Close()
    data, err := io.ReadAll(res.Body)
    if err != nil { panic(err) }
    if res.StatusCode != http.StatusOK { panic(fmt.Sprintf("HTTP %d: %s", res.StatusCode, data)) }
    fmt.Println(string(data))
}

Chat Completions

POST /v1/chat/completions accepts 16 top-level fields. Fields are not nullable unless explicitly stated. Optional fields can be omitted; do not send null in place of omission.

system and user messages require string content. An assistant message can carry string content, reasoning_content and tool_calls. A tool message requires content and tool_call_id. Preserve exact historical reasoning when using thinking.clear_thinking: false, including the order of assistant calls and tool results. Thinking cannot be disabled.

A function tool uses {type:"function", function:{name, description, parameters}}. The name contains 1–64 ASCII letters, digits, underscores or hyphens. The machine schema requires description and parameters; prose mentions omission for parameterless functions. Use the full shape until this conflict is resolved. parameters is your function's JSON Schema; it is not interpreted as message content.

A retrieval tool uses {type:"retrieval", retrieval:{knowledge_id, prompt_template?}}. A knowledge ID belongs to the account serving the request; declaring this tool does not create a knowledge base.

A web search tool uses {type:"web_search", web_search:{search_engine:"search_pro_jina"}}. Optional fields include enable, search_query, count (1–50), search_domain_filter, search_recency_filter (oneDay, oneWeek, oneMonth, oneYear, noLimit), content_size (medium, high), result_sequence (before, after), search_result, require_search and search_prompt. See OpenAPI for exact types. Account-specific search and retrieval availability need live verification.

JSON object mode produces JSON, not enforcement of a supplied JSON Schema. Include the desired fields in the prompt and validate the result in your application.

Responses

POST /v1/responses accepts 15 top-level create fields. This follows the manufacturer's Responses schema, specialized to GLM-5.3; exact behavior across services remains subject to verification.

curl https://api.seedrouter.ai/v1/responses \
  -H "Authorization: Bearer $SEEDROUTER_API_KEY" \
  -H 'Content-Type: application/json' \
  -d '{"model":"glm-5.3","input":[{"type":"message","role":"user","content":"Give a concise example of a safe retry."}],"reasoning":{"effort":"low"},"max_output_tokens":2048,"store":false}'

Message input items require type: "message", a role (user, system, assistant, developer) and content. Content can be a string, one text block or an array of text blocks. Use input_text or assistant output_text with a string text. Generic image/file schemas do not grant vision capability to this text-only model.

Function-call input items require type: "function_call", name, call_id and a JSON-string arguments; namespace is optional. Results require type: "function_call_output", call_id and string output. Reasoning items use type: "reasoning" and a single content: {type:"reasoning_text", text:"..."} object. Preserve it without converting to an array.

Function tools require type: "function" and name, with optional description and parameters. Namespace tools require type: "namespace" and name, and can contain function tools. Custom tools require type: "custom" and name. Web search tools require type: "web_search". Do not copy Chat's function-required fields into this format.

The referenced previous response must have been stored. Saving the current response is a separate choice; previous_response_id does not force current store: true. The manufacturer's retention period is seven days. A live check successfully saved a response and continued from its ID with current store: false; this does not establish every saved-response operation.

Saved response operations

When store: true succeeds, keep the returned response ID unchanged. These authenticated operations use the same account that created it:

• GET /v1/responses/{response_id} retrieves the saved response.
• GET /v1/responses/{response_id}/input_items lists input items. Optional query fields: order (asc or desc, default desc), limit (integer 1–100, default 20) and after (the prior page's last_id).
• DELETE /v1/responses/{response_id} deletes the saved response.

A subsequent create request can use the saved ID as previous_response_id. Access requires the original user's current model access. Retention is at most seven days; expired or deleted responses cannot be continued. Retrieval, deletion and continuation keep the original account binding. No cancel endpoint is documented. These operations are covered by local contract tests. The October 29 live check confirmed save and continuation; retrieval and input-item listing returned 404, and deletion was not tested. Do not rely on retrieval, listing or deletion until their availability is confirmed.

Messages compatibility

POST /v1/messages uses an Anthropic-compatible envelope. Include anthropic-version: 2023-06-01. The manufacturer directly demonstrates model, messages, max_tokens and stream. It does not publish a complete GLM Messages schema and warns about differences from Claude. The remaining controls are compatibility-reference fields, not individually verified GLM capabilities.

curl https://api.seedrouter.ai/v1/messages \
  -H "Authorization: Bearer $SEEDROUTER_API_KEY" \
  -H 'Content-Type: application/json' \
  -H 'anthropic-version: 2023-06-01' \
  -d '{"model":"glm-5.3","messages":[{"role":"user","content":"Explain a safe retry in two sentences."}],"max_tokens":2048}'

Enabled thinking's compatible budget is at least 1024 and less than max_tokens. Text blocks require text; thinking history requires thinking and signature; redacted thinking requires data. Tool-use blocks require id, name and input; tool-result blocks require tool_use_id. No image, audio or video block is accepted. Explicit cache markers do not establish a cache hit, a lifetime or a separate rate. The model's documented context cache is automatic.

Output, streaming and usage

Chat returns id, created, model, choices and usage, with optional request_id and web_search. Read choices[].message.content, reasoning_content and tool_calls. A tool-call response may have no answer text. SSE sends reasoning, text and tool argument deltas, then [DONE]. Join argument fragments by call index. No stream_options field is part of the official GLM Chat request.

Responses returns the native output union: messages, reasoning and tool calls. SSE includes response.created, response.in_progress, output-item and content-part events, text/reasoning/function-argument deltas, search progress, and terminal response.completed, response.incomplete or response.failed. It does not require a [DONE] marker. Preserve indices and sequence numbers.

Messages returns a native message envelope with content blocks, stop_reason and usage. Its event names include message_start, content_block_start/delta/stop, message_delta and message_stop. Preserve thinking signatures and tool IDs as opaque history.

Reasoning is a subset of output, not an additional charge. Chat/Responses cached input is a subset of total input. Subtract separately reported cached portions before applying the ordinary input rate. Public responses expose token usage, not monetary charges. Current prices come from live billing settings; failed requests are not charged.

Validation and errors

Invalid types, disabled thinking, unsupported effort, excessive output budgets and media input fail validation. Chat's tool_stream requires stream. Unsupported top-level fields are omitted rather than forwarded. Credentials are required; insufficient balance prevents a paid request. Errors use the public error envelope (Messages uses its native error shape). Never treat an interrupted stream as a completed answer or automatically resubmit a request with an uncertain result.

The Playground exposes the same admitted fields for the selected format. Blank optional values are omitted; explicit false and zero are preserved. Changing formats starts a new conversation. Its usage estimate needs both reported usage and current rates.