Comment utiliser l'API GLM-5.1 : Guide complet avec exemples de code

En bref

GLM-5.1 est disponible via l'API BigModel à l'adresse https://open.bigmodel.cn/api/paas/v4/. L'API est compatible avec OpenAI : même structure de point de terminaison, même format de requête, même modèle de streaming. Vous avez besoin d'un compte BigModel, d'une clé API et du nom de modèle glm-5.1. Ce guide couvre l'authentification, votre première requête, le streaming, l'appel d'outils et le test de votre intégration avec Apidog.

Introduction

GLM-5.1 est le modèle agentique phare de Z.AI, lancé en avril 2026. Il se classe n°1 sur SWE-Bench Pro et surpasse GLM-5 sur tous les principaux benchmarks de codage. Si vous développez un assistant de codage IA, un agent autonome ou toute application bénéficiant de l'exécution de tâches à long terme, GLM-5.1 mérite d'être intégré.

La bonne nouvelle pour les développeurs : l'API est compatible avec OpenAI. Si vous avez déjà développé avec GPT-4 ou Claude, vous pouvez passer à GLM-5.1 en changeant l'URL de base et le nom du modèle. Pas de nouveau SDK à apprendre. Pas de format de réponse différent à gérer.

Prérequis

Avant d'effectuer votre premier appel, vous avez besoin de :

1. Un compte BigModel sur bigmodel.cn. L'inscription est gratuite.
2. Une clé API depuis la console BigModel, sous Clés API.
3. Python 3.8+ ou Node.js 18+ (les exemples couvrent les deux).
4. Le SDK OpenAI ou les requêtes/fetch standards (l'API de GLM-5.1 est compatible avec OpenAI).

Définissez votre clé API comme variable d'environnement :

export BIGMODEL_API_KEY="votre_clé_api_ici"

Ne jamais coder en dur les clés API dans votre code source.

Authentification

Chaque requête nécessite un jeton Bearer dans l'en-tête Authorization :

Authorization: Bearer VOTRE_CLÉ_API

Le format de la clé API BigModel ressemble à xxxxxxxx.xxxxxxxxxxxxxxxx, une chaîne en deux parties séparées par un point. C'est différent du format sk- d'OpenAI mais fonctionne de la même manière dans l'en-tête.

URL de base

https://open.bigmodel.cn/api/paas/v4/

Le point de terminaison pour les complétions de chat est :

POST https://open.bigmodel.cn/api/paas/v4/chat/completions

Votre première requête

Utilisation de curl

curl https://open.bigmodel.cn/api/paas/v4/chat/completions \
  -H "Authorization: Bearer $BIGMODEL_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "glm-5.1",
    "messages": [
      {
        "role": "user",
        "content": "Write a Python function that finds all prime numbers up to n using the Sieve of Eratosthenes."
      }
    ],
    "max_tokens": 1024,
    "temperature": 0.7
  }'

Utilisation de Python (requests)

import os
import requests

api_key = os.environ["BIGMODEL_API_KEY"]

response = requests.post(
    "https://open.bigmodel.cn/api/paas/v4/chat/completions",
    headers={
        "Authorization": f"Bearer {api_key}",
        "Content-Type": "application/json"
    },
    json={
        "model": "glm-5.1",
        "messages": [
            {
                "role": "user",
                "content": "Write a Python function that finds all prime numbers up to n using the Sieve of Eratosthenes."
            }
        ],
        "max_tokens": 1024,
        "temperature": 0.7
    }
)

result = response.json()
print(result["choices"][0]["message"]["content"])

Utilisation du SDK OpenAI (recommandé)

L'API étant compatible avec OpenAI, vous pouvez utiliser le SDK Python officiel d'OpenAI avec une URL de base personnalisée :

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["BIGMODEL_API_KEY"],
    base_url="https://open.bigmodel.cn/api/paas/v4/"
)

response = client.chat.completions.create(
    model="glm-5.1",
    messages=[
        {
            "role": "user",
            "content": "Write a Python function that finds all prime numbers up to n using the Sieve of Eratosthenes."
        }
    ],
    max_tokens=1024,
    temperature": 0.7
)

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

C'est l'approche la plus propre. Le SDK OpenAI gère les tentatives, la gestion des délais d'attente et l'analyse des réponses. Vous obtenez tout cela gratuitement en le pointant simplement vers l'URL de base de BigModel.

Format de réponse

La structure de la réponse est identique à celle d'OpenAI :

{
  "id": "chatcmpl-abc123",
  "object": "chat.completion",
  "created": 1744000000,
  "model": "glm-5.1",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "def sieve_of_eratosthenes(n):\n    ..."
      },
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 32,
    "completion_tokens": 215,
    "total_tokens": 247
  }
}

Accédez au texte de la réponse via result["choices"][0]["message"]["content"].

Le champ usage affiche le nombre de jetons pour la requête. Suivez ceci pour surveiller votre consommation de quota, car GLM-5.1 est facturé à 3x le quota pendant les heures de pointe (14h00-18h00 UTC+8).

Streaming des réponses

Pour les tâches de génération de code longues, le streaming vous donne les jetons au fur et à mesure qu'ils arrivent, plutôt que d'attendre la réponse complète. C'est essentiel pour toute application destinée aux utilisateurs.

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["BIGMODEL_API_KEY"],
    base_url="https://open.bigmodel.cn/api/paas/v4/"
)

stream = client.chat.completions.create(
    model="glm-5.1",
    messages=[
        {
            "role": "user",
            "content": "Explain how a B-tree index works in a database, with a code example."
        }
    ],
    stream=True,
    max_tokens=2048
)

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

print()  # saut de ligne après la fin du streaming

Chaque bloc dans le flux est un delta contenant uniquement les nouveaux jetons depuis le dernier bloc. Le bloc final a finish_reason défini sur "stop" (ou "length" si vous avez atteint la limite de jetons).

Streaming avec des requêtes brutes

Si vous préférez ne pas utiliser le SDK OpenAI :

import os
import json
import requests

api_key = os.environ["BIGMODEL_API_KEY"]

response = requests.post(
    "https://open.bigmodel.cn/api/paas/v4/chat/completions",
    headers={
        "Authorization": f"Bearer {api_key}",
        "Content-Type": "application/json"
    },
    json={
        "model": "glm-5.1",
        "messages": [{"role": "user", "content": "Write a merge sort in Python."}],
        "stream": True,
        "max_tokens": 1024
    },
    stream=True
)

for line in response.iter_lines():
    if line:
        line = line.decode("utf-8")
        if line.startswith("data: "):
            data = line[6:]
            if data == "[DONE]":
                break
            chunk = json.loads(data)
            delta = chunk["choices"][0]["delta"]
            if "content" in delta:
                print(delta["content"], end="", flush=True)

Appel d'outils

GLM-5.1 prend en charge l'appel d'outils : la capacité de demander l'exécution d'une fonction en cours de conversation. C'est le mécanisme central pour les workflows agentiques où le modèle doit exécuter du code, rechercher dans des bases de données, appeler des API externes ou entreprendre des actions dans le monde réel.

Définition d'outils

import os
import json
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["BIGMODEL_API_KEY"],
    base_url="https://open.bigmodel.cn/api/paas/v4/"
)

tools = [
    {
        "type": "function",
        "function": {
            "name": "run_python",
            "description": "Execute Python code and return the output. Use this to test, profile, or benchmark code.",
            "parameters": {
                "type": "object",
                "properties": {
                    "code": {
                        "type": "string",
                        "description": "The Python code to execute"
                    }
                },
                "required": ["code"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "read_file",
            "description": "Read the contents of a file",
            "parameters": {
                "type": "object",
                "properties": {
                    "path": {
                        "type": "string",
                        "description": "File path to read"
                    }
                },
                "required": ["path"]
            }
        }
    }
]

response = client.chat.completions.create(
    model="glm-5.1",
    messages=[
        {
            "role": "user",
            "content": "Write a function to compute Fibonacci numbers, test it for n=10, and show me the output."
        }
    ],
    tools=tools,
    tool_choice="auto"
)

message = response.choices[0].message
print(f"Raison de l'achèvement: {response.choices[0].finish_reason}")

if message.tool_calls:
    for tool_call in message.tool_calls:
        print(f"\nOutil appelé: {tool_call.function.name}")
        print(f"Arguments: {tool_call.function.arguments}")

Gestion des réponses d'appel d'outils

Lorsque GLM-5.1 demande un appel d'outil, vous exécutez la fonction, puis renvoyez le résultat dans le message suivant :

import subprocess

def execute_tool(tool_call):
    """Execute l'outil et renvoie le résultat."""
    name = tool_call.function.name
    args = json.loads(tool_call.function.arguments)

    if name == "run_python":
        result = subprocess.run(
            ["python3", "-c", args["code"]],
            capture_output=True,
            text=True,
            timeout=10
        )
        return result.stdout or result.stderr

    elif name == "read_file":
        try:
            with open(args["path"]) as f:
                return f.read()
        except FileNotFoundError:
            return f"Erreur : fichier {args['path']} introuvable"

    return f"Outil inconnu : {name}"


def run_agent_loop(user_message, tools, max_iterations=20):
    """Exécute une boucle d'agent complète avec appel d'outils."""
    messages = [{"role": "user", "content": user_message}]

    for i in range(max_iterations):
        response = client.chat.completions.create(
            model="glm-5.1",
            messages=messages,
            tools=tools,
            tool_choice="auto",
            max_tokens=4096
        )

        message = response.choices[0].message
        messages.append(message.model_dump())

        if response.choices[0].finish_reason == "stop":
            # Le modèle a terminé
            return message.content

        if response.choices[0].finish_reason == "tool_calls":
            # Exécute chaque appel d'outil et ajoute les résultats
            for tool_call in message.tool_calls:
                tool_result = execute_tool(tool_call)
                messages.append({
                    "role": "tool",
                    "tool_call_id": tool_call.id,
                    "content": tool_result
                })

    return "Nombre maximal d'itérations atteint"


result = run_agent_loop(
    "Écrivez une implémentation de quicksort, testez-la avec une liste aléatoire de 1000 entiers, et rapportez le temps.",
    tools
)
print(result)

Ce modèle s'adapte directement à la force de GLM-5.1 en tant que modèle agentique. Vous laissez le modèle décider quand appeler des outils, traiter les résultats, et continuer jusqu'à ce qu'il atteigne une solution ou qu'il décide qu'il a terminé.

Paramètres clés

Paramètres recommandés pour les tâches de codage :

{
    "model": "glm-5.1",
    "temperature": 1.0,
    "top_p": 0.95,
    "max_tokens": 163840  # contexte complet pour les exécutions agentiques longues
}

Z.AI utilise ces paramètres dans ses propres évaluations de performance. Pour une génération de code déterministe, baissez la température à 0,2-0,4.

Utilisation de GLM-5.1 avec les assistants de codage

Le Plan de Codage Z.AI vous permet de router Claude Code, Cline, Kilo Code et d'autres assistants de codage IA via GLM-5.1 via l'API BigModel. C'est utile si vous souhaitez un modèle de codage puissant à un coût inférieur à celui de l'exécution directe de Claude Opus ou GPT-5.4.

Configuration de Claude Code

Dans votre fichier de configuration Claude Code (~/.claude/settings.json ou équivalent) :

{
  "model": "glm-5.1",
  "baseURL": "https://open.bigmodel.cn/api/paas/v4/",
  "apiKey": "votre_clé_api_bigmodel"
}

Configuration de Cline / Roo Code

Dans vos paramètres VS Code ou la configuration de l'extension Cline :

{
  "cline.apiProvider": "openai",
  "cline.openAIBaseURL": "https://open.bigmodel.cn/api/paas/v4/",
  "cline.openAIApiKey": "votre_clé_api_bigmodel",
  "cline.openAIModelId": "glm-5.1"
}

Consommation de quota

GLM-5.1 utilise le système de quota Z.AI plutôt que la facturation par jeton : - Heures de pointe (14h00-18h00 UTC+8) : 3x le quota par requête - Hors heures de pointe : 2x le quota par requête - Tarif promotionnel jusqu'à fin avril 2026 : 1x pendant les heures creuses

Pour les charges de travail agentiques importantes, planifiez les tâches de longue durée pendant les heures creuses. Une exécution d'optimisation de 600 itérations, comme celle démontrée par Z.AI, coûte beaucoup plus de quota en période de pointe.

Tester l'API GLM-5.1 avec Apidog

Tester une intégration d'API agentique nécessite de gérer correctement plusieurs types de réponses : complétions normales, blocs de streaming, requêtes d'appel d'outils, messages de résultat d'outils et états d'erreur. Tester tout cela avec l'API réelle consomme du quota et nécessite une connexion en direct.

Le Smart Mock d'Apidog vous permet de définir tous ces états de réponse et de les tester sans interroger l'API réelle.

Configuration du point de terminaison de simulation

1. Dans Apidog, créez un nouveau point de terminaison : POST https://open.bigmodel.cn/api/paas/v4/chat/completions
2. Ajoutez une attente de simulation pour une réponse de succès standard :

{
  "id": "chatcmpl-test123",
  "object": "chat.completion",
  "created": 1744000000,
  "model": "glm-5.1",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "def sieve(n): ..."
      },
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 32,
    "completion_tokens": 120,
    "total_tokens": 152
  }
}

1. Ajoutez une deuxième attente pour une réponse d'appel d'outil :

{
  "id": "chatcmpl-tool456",
  "object": "chat.completion",
  "created": 1744000001,
  "model": "glm-5.1",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": null,
        "tool_calls": [
          {
            "id": "call_abc",
            "type": "function",
            "function": {
              "name": "run_python",
              "arguments": "{\"code\": \"print(2+2)\"}"
            }
          }
        ]
      },
      "finish_reason": "tool_calls"
    }
  ],
  "usage": {
    "prompt_tokens": 48,
    "completion_tokens": 35,
    "total_tokens": 83
  }
}

1. Ajoutez une réponse de limite de débit (HTTP 429) :

{
  "error": {
    "message": "Rate limit exceeded. Please retry after 60 seconds.",
    "type": "rate_limit_error",
    "code": "rate_limit_exceeded"
  }
}

Test de la boucle d'agent complète

Utilisez les Scénarios de Test d'Apidog pour enchaîner plusieurs requêtes. Pour un test de boucle d'agent :

1. Étape 1 : Effectuez une requête POST vers /chat/completions avec votre message initial, vérifiez le code 200 et finish_reason == "tool_calls"
2. Étape 2 : Effectuez une nouvelle requête POST avec le résultat de l'outil dans le tableau des messages, vérifiez le code 200 et finish_reason == "stop"
3. Étape 3 : Extrayez le contenu final et assurez-vous qu'il contient le code attendu

Cela teste la boucle d'agent complète sans dépenser de quota. Vous pouvez également tester la gestion des erreurs en configurant la simulation pour renvoyer 429, puis en vérifiant que votre logique de réessai fonctionne correctement.

Pour les workflows agentiques en plusieurs étapes, les Scénarios de Test d'Apidog vous permettent de transmettre des données entre les étapes à l'aide de variables, de sorte que les valeurs request_id ou tool_call_id de l'étape 1 sont automatiquement transférées à l'étape 2. Cela reflète le fonctionnement d'une vraie boucle d'agent et permet de détecter les bugs d'intégration avant la production.

Gestion des erreurs

L'API renvoie des codes d'état HTTP standards :

import time
import requests

def call_with_retry(payload, max_retries=3):
    for attempt in range(max_retries):
        try:
            response = requests.post(
                "https://open.bigmodel.cn/api/paas/v4/chat/completions",
                headers={"Authorization": f"Bearer {os.environ['BIGMODEL_API_KEY']}",
                         "Content-Type": "application/json"},
                json=payload,
                timeout=120
            )

            if response.status_code == 429:
                retry_after = int(response.headers.get("Retry-After", 60))
                print(f"Limite de débit atteinte. Attente de {retry_after}s...")
                time.sleep(retry_after)
                continue

            response.raise_for_status()
            return response.json()

        except requests.exceptions.Timeout:
            wait = 2 ** attempt
            print(f"Délai d'attente dépassé à la tentative {attempt + 1}. Nouvelle tentative dans {wait}s...")
            time.sleep(wait)

    raise Exception("Nombre maximal de tentatives dépassé")

Pour les exécutions agentiques longues où les étapes individuelles peuvent prendre 30 à 60 secondes, définissez toujours un délai d'attente généreux (120 à 300 secondes). Le modèle peut avoir besoin de temps pour générer un fichier de code complet ou analyser un résultat de benchmark complexe.

Conclusion

L'API compatible OpenAI de GLM-5.1 signifie que vous pouvez l'intégrer en quelques minutes si vous avez déjà travaillé avec GPT ou Claude. La principale différence est le point de terminaison (open.bigmodel.cn) et le système de quota au lieu de la facturation par jeton.

Pour les applications agentiques où le modèle effectue des centaines d'appels d'outils sur une longue session, la capacité d'optimisation à long terme de GLM-5.1 est un réel avantage. Associez-le à des tests appropriés via le Smart Mock et les Scénarios de Test d'Apidog pour vous assurer que votre intégration gère tous les cas limites avant qu'elle ne fonctionne sans supervision.

Pour des informations générales sur GLM-5.1 et la comparaison de ses performances, consultez l'aperçu du modèle GLM-5.1. Pour en savoir plus sur la création et le test de workflows d'agents IA avec Apidog, consultez le fonctionnement de la mémoire des agents IA.

FAQ

L'API GLM-5.1 est-elle compatible avec OpenAI ?Oui. Le format de requête, la structure de réponse, le protocole de streaming et le format d'appel d'outils sont tous identiques à ceux de l'API de complétions de chat d'OpenAI. Vous pouvez utiliser le SDK Python officiel d'OpenAI ou tout client compatible OpenAI en définissant l'URL de base sur https://open.bigmodel.cn/api/paas/v4/.

Quel est le nom du modèle à utiliser dans les requêtes API ?Utilisez "glm-5.1" comme nom de modèle. N'utilisez pas de nom versionné complet ; glm-5.1 seul fonctionne.

Comment fonctionne la tarification de l'API GLM-5.1 ?L'API BigModel utilise un système de quota. GLM-5.1 consomme 3x le quota pendant les heures de pointe (14h00-18h00 UTC+8) et 2x pendant les heures creuses. Jusqu'à fin avril 2026, l'utilisation hors heures de pointe est facturée à 1x le quota en tant que tarif promotionnel.

Quelle est la longueur maximale du contexte ?Contexte d'entrée de 200 000 jetons. La sortie maximale est de 163 840 jetons. Pour les exécutions agentiques longues, définissez max_tokens sur une valeur élevée (32 768 ou plus) pour éviter de tronquer la sortie du modèle en cours de tâche.

Puis-je utiliser GLM-5.1 pour l'appel de fonctions / l'utilisation d'outils ?Oui. GLM-5.1 prend en charge le même format d'appel d'outils que l'API d'OpenAI. Définissez les outils avec un schéma type: "function", passez-les dans le tableau tools et gérez les réponses finish_reason: "tool_calls" dans votre boucle d'agent.

Comment puis-je tester les appels API de GLM-5.1 sans dépenser de quota ?Utilisez le Smart Mock d'Apidog pour définir des réponses simulées pour chaque état de l'API : succès, appels d'outils, limites de débit, erreurs. Exécutez votre suite de tests par rapport au mock pendant le développement et n'utilisez l'API réelle que pour la validation finale.

Où puis-je trouver les poids du modèle GLM-5.1 ?Les poids open source sont disponibles sur HuggingFace à zai-org/GLM-5.1. Ils sont publiés sous licence MIT et prennent en charge vLLM et SGLang pour l'inférence locale.