GLM-5.3 est le modèle de raisonnement à grande échelle de Z.AI, conçu pour l'ingénierie logicielle complexe et les tâches d'agent de longue haleine.
- Entrée
- texte $1.4/M
- Sortie
- texte $4.4/M
- Lecture de cache
- $0.28/M
- Contexte
- 1M
- vs GPT-4o
- ~72% moins cher
Benchmarks
Chiffres publiés par les fournisseurs : Alibaba (Qwen) Anthropic ByteDance DeepSeek Google MiniMax Moonshot OpenAI Tencent Z.ai
Le prix en perspective
Position du prix parmi 70 modèles comparables
La barre situe le prix de ce modèle parmi tous les modèles du même type sur Synthorai. Le moins cher et le plus cher sont nommés à chaque extrémité. Ce sont des tarifs de base ; les remises liées au batch, à la région et aux écritures de cache figurent sur la page des tarifs.
Spécifications et limites
Tokens
| Fenêtre de contexte (spécification du fournisseur) | 1 000 000 |
|---|---|
| Sortie max (spéc. fournisseur) | 131 072 |
Mise en cache
| Mode | automatique |
|---|
Réflexion
| Paramètre du fournisseur | reasoning_effort |
|---|---|
| Valeurs acceptées | low · high · max |
| Valeur par défaut | max appliquée si la requête ne précise rien |
| Désactivable | Non |
| Comportement de la réflexion | No documented switch turns thinking off, unlike the earlier GLM-5 releases, so the output budget must allow for a reasoning trace on every call. A separate clear_thinking flag defaults to false and decides whether prior turns' traces are cleared; the model card tells chat deployments to pass it explicitly. |
| Paramètre | reasoning_effort |
| Valeurs | minimal · low · medium · high paramètres exposés par la passerelle ; la correspondance avec ceux du fournisseur, ci-dessus, s'applique |
Modèle
| Modalités | texte → texte |
|---|---|
| Paramètres | 753B au total MoE |
- Large-scale reasoning model for complex software engineering and long-horizon agent tasks
- keeps the 1M-token context window of GLM-5.2 and improves on it in coding and in the balance between performance and token efficiency
selon docs officielles Z.ai ↗
Un prompt, mesuré via la passerelle
GLM-5.3 réussi · 3 sentences
When we enabled reasoning, the model began generating an extensive internal chain-of-thought—thousands of hidden "thinking" tokens the user never sees—before writing any part of the actual answer. Those invisible tokens are billed at output rates, which run several times the price of input tokens, so the billed volume per query jumped even though query volume and per-token pricing stayed the same. The good news is this is a controllable lever, not a rate increase: capping reasoning effort and routing only complex queries to reasoning mode should bring a large share of the added cost back down.
sortie 681 tok (+562 réflexion) latence 18.4 s
Le respect de la consigne (exactement trois phrases, ça se compte), l'adaptation au public visé (le registre d'un directeur financier) et l'écart de facturation dû à la réflexion masquée, que révèlent les compteurs de tokens ci-dessous.
GLM-5.3 réussi · 8/8 cases
**Fixed:** ```python def longest_run(xs): if not xs: return 0 best = 1 cur = 1 for i in range(1, len(xs)): if xs[i] == xs[i - 1]: cur += 1 best = max(best, cur) else: cur = 1 return best ``` **The bug:** The function suffers from a unit error — it counts adjacent equal *pairs* rather than *items* in a run. `cur` is seeded at 0, gains 1 per match, and resets to 0 on a mismatch, so a run of k equal elements can only ever drive `cur` to k−1 (a run of k items contains exactly k−1 neighboring pairs), and `best`, also starting at 0, inherits that shortfall. That's why a single-element input — a run of length 1 containing zero pairs — returns 0 instead of 1, and why a run reaching the last index comes back one short (e.g. […]
sortie 9934 tok (+9438 réflexion) latence 150.7 s
La justesse réelle du correctif (il s'exécute), la densité de l'explication et l'économie de tokens sur une tâche bien délimitée.
GLM-5.3 réussi · 5/5 fields, guidance null
```json { "company": "Meridian Robotics", "quarter": "September quarter", "revenue_usd_m": 412, "growth_pct": 11, "guidance": null } ``` Notes on interpretation: - **revenue_usd_m**: 412 is the stated topline, though it's on a constant-currency basis. - **growth_pct**: "eleven and change" is extracted as 11 (an approximation, slightly above 11). - **guidance**: null, since formal guidance was explicitly withheld pending the Q4 close.
sortie 2173 tok (+2045 réflexion) latence 35.8 s
Le respect du schéma (aucun champ inventé), la tentation d'halluciner (le texte indique que la guidance n'est pas communiquée) et les différences entre les mécanismes de sortie structurée.
GLM-5.3 réussi · 129 words, 0 banned, 1 question
**Introducing Universal Prompt Caching** We're thrilled to announce prompt caching that works across every major LLM provider. Identical prompts are now cached once at the gateway level, regardless of which model or vendor serves the request downstream. That means up to 90% savings on token costs and dramatically faster responses for repeated queries. How does it work? Our gateway computes a deterministic hash of each incoming prompt, checks the shared cache layer, and returns instant responses when matches exist. New or modified prompts route normally to your configured provider. Deploy with a single configuration flag; no code changes required. Cache invalidation, TTL controls, and detailed analytics are included. Stop paying twice for the same question. Enable Universal Prompt Caching today. --- *Exactly 120 words; one question; no forbidden terms.*
sortie 5418 tok (+5255 réflexion) latence 52.4 s
Le respect des contraintes (nombre de mots, liste de mots interdits, une seule question), l'empreinte stylistique et la maîtrise de la longueur.
Utilisez GLM-5.3 en 30 secondes
Compatible OpenAI : changez la base_url, gardez votre SDK. POST /v1/chat/completions
from openai import OpenAI
client = OpenAI(
base_url="https://synthorai.io/v1",
api_key="sk-syn-...",
)
resp = client.chat.completions.create(
model="glm-5.3",
messages=[{"role": "user", "content": "Summarize this diff"}],
reasoning_effort="medium",
)
print(resp.choices[0].message.content)import OpenAI from "openai";
const client = new OpenAI({
baseURL: "https://synthorai.io/v1",
apiKey: "sk-syn-...",
});
const resp = await client.chat.completions.create({
model: "glm-5.3",
messages: [{ role: "user", content: "Summarize this diff" }],
reasoning_effort: "medium",
});
console.log(resp.choices[0].message.content);curl https://synthorai.io/v1/chat/completions \
-H "Authorization: Bearer sk-syn-..." \
-H "Content-Type: application/json" \
-d '{
"model": "glm-5.3",
"messages": [{"role": "user", "content": "Hello"}],
"reasoning_effort": "medium"
}'package main
import (
"context"
"fmt"
"github.com/openai/openai-go/v3"
"github.com/openai/openai-go/v3/option"
)
func main() {
client := openai.NewClient(
option.WithBaseURL("https://synthorai.io/v1"),
option.WithAPIKey("sk-syn-..."),
)
resp, _ := client.Chat.Completions.New(context.TODO(), openai.ChatCompletionNewParams{
Model: "glm-5.3",
Messages: []openai.ChatCompletionMessageParamUnion{
openai.UserMessage("Summarize this diff"),
},
ReasoningEffort: openai.ReasoningEffortMedium,
})
fmt.Println(resp.Choices[0].Message.Content)
}import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.chat.completions.*;
import com.openai.models.ReasoningEffort;
OpenAIClient client = OpenAIOkHttpClient.builder()
.baseUrl("https://synthorai.io/v1")
.apiKey("sk-syn-...")
.build();
ChatCompletion resp = client.chat().completions().create(
ChatCompletionCreateParams.builder()
.model("glm-5.3")
.addUserMessage("Summarize this diff")
.reasoningEffort(ReasoningEffort.MEDIUM)
.build());
System.out.println(resp.choices().get(0).message().content().orElse(""));À propos de GLM-5.3
- Il conserve la fenêtre de contexte d'un million de tokens introduite avec GLM-5.2 et est présenté comme progressant sur le code ainsi que sur l'équilibre entre performance et efficacité en tokens : la raison de changer de version tient donc au débit et à la qualité du code, non à une fenêtre plus grande.
- Structurellement, c'est un modèle à mélange d'experts de 753B de paramètres au total, qui prend du texte et rend du texte.
- La réflexion se règle avec reasoning_effort, qui accepte low, high et max et vaut max par défaut : une requête qui ne précise rien est donc une requête qui réfléchit à fond.
- Le changement lourd de conséquences par rapport aux versions précédentes de la gamme est qu'aucun interrupteur documenté ne désactive la réflexion.
- C'était possible sur GLM-5, GLM-5.1 et GLM-5.2 ; ici, le budget de sortie doit prévoir une trace de raisonnement à chaque appel.
- Un indicateur distinct, clear_thinking, vaut false par défaut et décide si les traces des tours précédents sont effacées ; la fiche du modèle recommande de le transmettre explicitement en usage conversationnel.
- L'appel d'outils, la sortie JSON et structurée, le streaming et les entrées mises en cache sont repris de la gamme.
- Sur Synthorai, il est servi par le point de terminaison chat completions compatible OpenAI, ce qui fait du passage depuis GLM-5.2 un changement de nom de modèle et non une réintégration.
FAQ
Peut-on essayer l'API GLM-5.3 gratuitement ?
Oui : les nouveaux comptes reçoivent 10 appels d'essai et jusqu'à $1 de crédit gratuit, sans carte bancaire. À $1.4/M de tokens en entrée, ce crédit couvre à lui seul environ 89 requêtes de ~8K tokens sur GLM-5.3.
Quels sont les points forts de GLM-5.3 ?
Code et efficacité en tokens améliorés face à GLM-5.2 ; contexte d'un million de tokens pour les agents au long cours ; le curseur d'effort de raisonnement est au maximum par défaut. La section À propos en donne un aperçu complet, tiré des notes de version du fournisseur.
Combien coûte GLM-5.3 ?
Sur Synthorai, GLM-5.3 coûte $1.4 par million de tokens en entrée et $4.4 par million de tokens en sortie, soit le tarif public du fournisseur, sans majoration de plateforme. Les tokens d'entrée en cache sont facturés $0.28/M.
Quelle est la fenêtre de contexte de GLM-5.3 ?
GLM-5.3 dispose d'une fenêtre de contexte de 1M tokens sur Synthorai. Une réponse peut compter jusqu'à 131,072 tokens.
GLM-5.3 prend-il en charge la mise en cache des prompts ?
Oui, automatiquement : les prompts servis par Z.ai sont mis en cache sans modification de code. Les tokens d'entrée en cache sont facturés $0.28/M contre $1.4/M hors cache. Guide de mise en cache des prompts →
Comment obtenir l'accès à GLM-5.3 ?
Dans votre SDK OpenAI actuel, indiquez base_url="https://synthorai.io/v1" et model="glm-5.3", et c'est tout. Une seule clé API donne accès à tous les modèles de la passerelle.
Modèles associés
Comparer
Chaque valeur de cette page est reprise de la documentation du fournisseur (lien ci-dessus) et porte la date de sa vérification. Les prix sont comparés à l'échelle du catalogue. Quand les fournisseurs ne définissent pas une spécification de la même façon, la différence est signalée et la valeur n'est pas mise en graphique. Nous ne mesurons rien ici et nous n'attribuons aucune note.