Comment utiliser l'API GLM-5.2 ?

L'API GLM-5.2 vous donne un accès programmatique au nouveau modèle phare à poids ouverts de Z.ai, un modèle MoE d'environ 753 milliards de paramètres qui obtient les meilleurs scores parmi les modèles open-source sur les benchmarks de codage à long terme. Ce guide est pratique. Vous obtiendrez une clé API, effectuerez votre première requête, puis explorerez Python, curl, les modes de pensée, le streaming, l'appel d'outils et le suivi des coûts, le tout avec des valeurs réelles que vous pouvez coller dans un terminal.

Si vous venez de la version précédente, commencez ici.

Ce qui a changé depuis GLM-5.1

GLM-5.2 remplace la génération 5.1. Si vous avez déjà écrit du code d'intégration pour l'API GLM-5.1, le format de transmission est le même, vous n'avez donc qu'à changer l'ID du modèle. Les différences à connaître sont les suivantes :

• Un nouveau mécanisme d'attention éparse. GLM-5.2 introduit « IndexShare », qui réutilise un indexeur unique sur toutes les quatre couches d'attention éparse pour réduire le coût d'attention dans les contextes longs. En tant qu'utilisateur de l'API, vous n'y touchez pas ; cela rend simplement la fenêtre de 1M de tokens moins chère à servir.
• Un véritable bond en avant dans le codage agentique. Les résultats publiés par Z.ai placent Terminal-Bench 2.1 à 81.0, contre 62.0 pour GLM-5.1. C'est la statistique principale pour quiconque développe des agents de codage.
• Deux niveaux d'effort de réflexion. GLM-5.2 expose les niveaux d'effort de raisonnement Élevé et Max, et Z.ai recommande Max pour les tâches de codage. Plus de détails ci-dessous.

Comme le code de requête 5.1 fonctionne déjà, ce guide ne le réexplique pas. Tout ce qui est présenté ici cible directement glm-5.2.

Étape 1 : Obtenir une clé API GLM-5.2

Connectez-vous sur z.ai et ouvrez la section des clés API de votre tableau de bord. Créez une clé, copiez-la une seule fois (vous ne pourrez généralement plus la voir) et stockez-la dans une variable d'environnement au lieu de la coller dans votre code source :

export ZAI_API_KEY="your-glm-5.2-api-key"

Gardez votre clé API glm-5.2 hors de git. Une clé divulguée sera facturée sur votre compte, et la sortie de GLM-5.2 est tarifée par million de tokens, donc un script incontrôlé peut coûter de l'argent réel.

Étape 2 : Connaître le point d'accès et l'URL de base

GLM-5.2 est compatible OpenAI, ce qui signifie que tout client qui utilise le format OpenAI Chat Completions fonctionne une fois que vous avez redirigé l'URL de base. Les valeurs dont vous avez besoin :

L'alias OpenRouter est z-ai/glm-5.2 si vous préférez passer par OpenRouter plutôt que d'appeler Z.ai directement. Pour les exécutions locales, Ollama publie les poids sous le nom glm-5.2 (voir la bibliothèque Ollama), et les poids ouverts se trouvent sur Hugging Face sous licence MIT.

Une note sur les limites avant de construire : la fenêtre de contexte est de 1M de tokens (1 048 576). Pour une sortie maximale, les docs de z.ai indiquent jusqu'à 128K, mais OpenRouter ne publie pas de chiffre, alors considérez-le comme jusqu'à 128K selon les docs de z.ai (à vérifier en direct) plutôt que comme une garantie fixe.

Étape 3 : Votre première requête avec curl

Voici un appel curl minimal à glm-5.2. Il envoie un message utilisateur et affiche la réponse JSON :

curl https://api.z.ai/api/paas/v4/chat/completions \
  -H "Authorization: Bearer $ZAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "glm-5.2",
    "messages": [
      {"role": "system", "content": "Vous êtes un ingénieur backend concis."},
      {"role": "user", "content": "Écrivez une requête SQL qui renvoie les 5 dernières commandes par client."}
    ]
  }'

La forme de la réponse correspond au standard OpenAI : un id, un tableau choices avec le message de l'assistant, et un objet usage. Ce dernier champ est la manière dont vous suivez les coûts, ce qui sera abordé à la fin.

Étape 4 : L'appeler depuis Python avec le SDK OpenAI

L'API étant compatible OpenAI, vous n'avez pas besoin d'un client spécial. Installez le SDK standard et pointez base_url vers Z.ai. Voici la configuration Python canonique pour glm-5.2 :

pip install openai

from openai import OpenAI
import os

client = OpenAI(
    api_key=os.environ["ZAI_API_KEY"],
    base_url="https://api.z.ai/api/paas/v4/",
)

resp = client.chat.completions.create(
    model="glm-5.2",
    messages=[
        {"role": "system", "content": "Vous êtes un ingénieur backend concis."},
        {"role": "user", "content": "Expliquez les clés d'idempotence en 3 phrases."},
    ],
)

print(resp.choices[0].message.content)

C'est toute l'intégration. L'objet client se comporte exactement comme il le ferait avec OpenAI, de sorte que le code d'assistance existant, les tentatives et la journalisation sont tous transférables. Si vous souhaitez une présentation plus approfondie de la plateforme elle-même, l'aperçu de l'API GLM-5 couvre les conventions générales de la famille.

Étape 5 : Contrôler le raisonnement avec thinking et reasoning_effort

GLM-5.2 est un modèle de raisonnement. Vous pouvez activer ou désactiver sa réflexion interne, et lorsqu'elle est activée, vous pouvez définir son niveau d'effort.

Désactivez la réflexion pour des réponses rapides, économiques et à faible latence (classification, courtes réécritures, routage) :

resp = client.chat.completions.create(
    model="glm-5.2",
    messages=[{"role": "user", "content": "Classifier : 'ma carte a été débitée deux fois'"}],
    extra_body={"thinking": {"type": "disabled"}},
)

Activez la réflexion et poussez l'effort à Max pour le codage difficile et les mathématiques. Z.ai recommande Max spécifiquement pour le codage :

resp = client.chat.completions.create(
    model="glm-5.2",
    messages=[
        {"role": "user", "content": "Refactorisez cette fonction pour supprimer la requête N+1 et expliquez la correction."},
    ],
    extra_body={
        "thinking": {"type": "enabled"},
        "reasoning_effort": "max",
    },
)

Le wrapper extra_body est la manière dont le SDK Python d'OpenAI transmet des champs non standard à Z.ai. Dans un corps curl brut, vous placeriez thinking et reasoning_effort au niveau supérieur à côté de model. L'effort maximal consomme plus de tokens de sortie (le raisonnement compte), alors réservez-le pour les tâches où l'amélioration de la qualité en vaut la peine.

Étape 6 : Diffuser la réponse en continu

Pour les interfaces utilisateur de chat et les longues générations, diffusez les tokens au fur et à mesure de leur arrivée au lieu d'attendre la complétion complète. Définissez stream: true et itérez sur les fragments :

stream = client.chat.completions.create(
    model="glm-5.2",
    messages=[{"role": "user", "content": "Rédigez une entrée de journal des modifications de 200 mots pour une correction de limite de débit."}],
    stream=True,
)

for chunk in stream:
    delta = chunk.choices[0].delta.content
    if delta:
        print(delta, end="", flush=True)

En curl, ajoutez "stream": true au corps et le serveur renvoie des événements envoyés par le serveur (Server-Sent Events), une ligne data: par fragment, se terminant par data: [DONE]. Le streaming ne change rien au prix ; vous payez toujours par token, vous les voyez juste plus tôt.

Étape 7 : Appel de fonctions et d'outils

L'appel d'outils est le domaine où la force agentique de GLM-5.2 se manifeste, et il obtient un score de 77.0 sur MCP-Atlas dans les résultats publiés par Z.ai, proche de Claude Opus 4.8. Le modèle est le processus standard en deux étapes d'OpenAI : vous décrivez un outil, le modèle renvoie une requête tool_calls, vous exécutez la fonction, puis vous renvoyez le résultat.

Voici un petit exemple réaliste d'API glm-5.2 avec une recherche météorologique :

import json

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Obtenir la température actuelle pour une ville.",
            "parameters": {
                "type": "object",
                "properties": {
                    "city": {"type": "string", "description": "Nom de la ville, ex. Berlin"},
                    "unit": {"type": "string", "enum": ["c", "f"]},
                },
                "required": ["city"],
            },
        },
    }
]

messages = [{"role": "user", "content": "Quel temps fait-il à Berlin en degrés Celsius ?"}]

first = client.chat.completions.create(
    model="glm-5.2",
    messages=messages,
    tools=tools,
)

call = first.choices[0].message.tool_calls[0]
args = json.loads(call.function.arguments)

# Exécutez la fonction réelle ici. Simulé pour l'exemple :
def get_weather(city, unit="c"):
    return {"city": city, "temp": 12, "unit": unit}

result = get_weather(**args)

# Ajoutez l'appel d'outil de l'assistant, puis le résultat de votre outil.
messages.append(first.choices[0].message)
messages.append({
    "role": "tool",
    "tool_call_id": call.id,
    "content": json.dumps(result),
})

final = client.chat.completions.create(
    model="glm-5.2",
    messages=messages,
    tools=tools,
)

print(final.choices[0].message.content)

Le modèle décide quand appeler l'outil, vous l'exécutez, et la deuxième requête permet à GLM-5.2 de transformer le résultat brut en une réponse naturelle. La même boucle s'adapte à plusieurs outils et à des frameworks d'agents ; rien dans le contrat n'est spécifique à Z.ai.

Tester cette boucle à la main devient vite fastidieux. C'est un bon endroit pour utiliser Apidog : vous pouvez définir le point d'accès GLM-5.2 une seule fois, enregistrer les corps de requête pour chaque mode de pensée et rejouer les tours d'appel d'outils sans réécrire curl à chaque fois. Il gère le schéma de style OpenAI et vous permet d'inspecter les réponses diffusées en continu en un seul endroit.

Étape 8 : Lire l'objet d'utilisation pour le coût

Chaque réponse non diffusée en continu contient un objet usage. C'est votre source de vérité pour la facturation :

resp = client.chat.completions.create(
    model="glm-5.2",
    messages=[{"role": "user", "content": "Résumez REST vs gRPC en 4 points."}],
)

u = resp.usage
print(u.prompt_tokens, u.completion_tokens, u.total_tokens)

La tarification de GLM-5.2 est de 1,40 $ par million de tokens d'entrée et de 4,40 $ par million de tokens de sortie (confirmé par OpenRouter). L'entrée mise en cache coûte environ 0,26 $ par million (selon VentureBeat, qui attribue ce chiffre). Ainsi, un appel avec 8 000 tokens d'entrée et 1 500 tokens de sortie coûte environ :

(8000 / 1_000_000 * 1.40) + (1500 / 1_000_000 * 4.40)
= 0.0112 + 0.0066
= environ $0.0178

Les tokens de raisonnement issus de l'effort maximal sont inclus dans le décompte de sortie, de sorte qu'un appel de codage à effort maximal sera plus coûteux qu'un appel sans réflexion. VentureBeat rapporte que GLM-5.2 « surpasse GPT-5.5 en codage à long terme à environ 1/6 du coût », ce qui est l'argument économique derrière ces chiffres (attribuant l'affirmation à VentureBeat).

Si vous préférez utiliser un forfait à prix fixe plutôt que des appels d'API facturés à l'usage, Z.ai propose également des niveaux de Plan de Codage GLM (Lite, Pro, Max, plus Équipe). Les prix exacts peuvent varier, donc en juin 2026, vérifiez les niveaux actuels sur z.ai avant de vous engager. Pour une comparaison directe sur la facturation à l'usage, le détail des prix de GLM-5.2 va plus loin, et comment utiliser GLM-5.2 gratuitement couvre l'option des poids locaux.

Utiliser GLM-5.2 dans Claude Code

GLM-5.2 propose également un chemin compatible Anthropic, vous permettant de l'utiliser depuis Claude Code. Pointez l'URL de base de codage vers https://api.z.ai/api/coding/paas/v4 (certaines sources indiquent open.z.ai/api/paas/v4, à vérifier en direct), puis définissez ces variables d'environnement :

export ANTHROPIC_BASE_URL="https://api.z.ai/api/coding/paas/v4"
export ANTHROPIC_API_KEY="your-glm-coding-plan-key"
export ANTHROPIC_DEFAULT_SONNET_MODEL="glm-5.2[1m]"
export ANTHROPIC_DEFAULT_OPUS_MODEL="glm-5.2[1m]"
export CLAUDE_CODE_AUTO_COMPACT_WINDOW=1000000
export API_TIMEOUT_MS=3000000

Le suffixe [1m] sélectionne la variante de contexte de 1M, et la longue valeur de API_TIMEOUT_MS est importante : sans elle, Claude Code peut interrompre les appels longs à grand contexte avant qu'ils ne retournent un résultat. Le guide complet se trouve dans notre article sur l'exécution de GLM avec Claude Code, et si vous comparez les outils, Claude Code vs Codex vs Cursor vs GLM Plan expose les compromis.

Comparaison de GLM-5.2

Référence rapide des valeurs qui guident les décisions d'intégration :

Pour plus de détails sur les benchmarks, les résultats publiés par Z.ai incluent SWE-bench Pro 62.1 (GPT-5.5 58.6), Humanity’s Last Exam avec outils 54.7, et AIME 2026 99.2. Le récapitulatif des benchmarks de GLM-5.2 les décompose, et GLM-5.2 vs GPT-5.5, Claude Opus, et Gemini les compare côte à côte.

FAQ

L'API GLM-5.2 est-elle vraiment compatible OpenAI ? Oui. Pointez la base_url du SDK OpenAI vers https://api.z.ai/api/paas/v4/ et définissez le modèle sur glm-5.2. Le code standard de chat, de streaming et d'appel d'outils fonctionne sans modification.

Quel est l'ID du modèle GLM-5.2 que je dois envoyer ? Envoyez glm-5.2 à l'API Z.ai. Sur OpenRouter, c'est z-ai/glm-5.2, sur Ollama c'est glm-5.2, et la variante Claude Code est glm-5.2[1m] pour la fenêtre de contexte de 1M.

Comment désactiver le raisonnement pour la vitesse ? Passez thinking: {"type": "disabled"} (via extra_body dans le SDK Python). Pour les tâches de codage complexes, activez la réflexion et définissez reasoning_effort: "max", ce que Z.ai recommande pour le code.

Combien coûte GLM-5.2 par appel ? 1,40 $ par million de tokens d'entrée et 4,40 $ par million de tokens de sortie (confirmé par OpenRouter). Lisez l'objet usage de chaque réponse pour calculer le coût exact ; n'oubliez pas que les tokens de raisonnement à effort maximal sont comptés comme sortie.

GLM-5.2 dispose-t-il d'un modèle de vision ? Il n'y a pas de variante de vision confirmée en juin 2026. L'API est texte en entrée, texte en sortie. Ne comptez pas sur les entrées d'images tant que Z.ai n'a pas documenté un support.

En résumé

L'API GLM-5.2 est un pas rapide depuis n'importe quelle base de code compatible OpenAI : changez l'URL de base, envoyez glm-5.2, et vous disposez d'un modèle de codage sous licence MIT avec un contexte de 1M, un raisonnement tunable et un prix de sortie de 4,40 $ par million de tokens. Commencez par un ping curl, passez au SDK Python, puis ajoutez les modes de pensée et l'appel d'outils selon les besoins de votre cas d'utilisation.

Lorsque vous êtes prêt à tester des points d'accès, à enregistrer des variantes de requêtes et à inspecter les tours d'appel d'outils sans écrire manuellement curl à chaque fois, téléchargez Apidog et configurez le point d'accès GLM-5.2 une seule fois. Pour une vue d'ensemble du modèle lui-même, consultez ce qu'est GLM-5.2 et la comparaison GLM-5.2 vs GLM-5.1.