GLM-5.1 API nutzen: Komplette Anleitung mit Code-Beispielen

Kurz gesagt

GLM-5.1 ist über die BigModel API unter https://open.bigmodel.cn/api/paas/v4/ verfügbar. Die API ist OpenAI-kompatibel: gleiche Endpunktstruktur, gleiches Anfrageformat, gleiches Streaming-Muster. Sie benötigen ein BigModel-Konto, einen API-Schlüssel und den Modellnamen glm-5.1. Dieser Leitfaden behandelt die Authentifizierung, Ihre erste Anfrage, Streaming, Tool-Aufrufe und das Testen Ihrer Integration mit Apidog.

Einleitung

GLM-5.1 ist Z.AIs führendes agentenbasiertes Modell, veröffentlicht im April 2026. Es belegt Platz 1 bei SWE-Bench Pro und übertrifft GLM-5 in allen wichtigen Coding-Benchmarks. Wenn Sie einen KI-Codierungsassistenten, einen autonomen Agenten oder eine Anwendung entwickeln, die von der Ausführung langfristiger Aufgaben profitiert, lohnt sich die Integration von GLM-5.1.

Die gute Nachricht für Entwickler: Die API ist OpenAI-kompatibel. Wenn Sie bereits auf GPT-4 oder Claude aufgebaut haben, können Sie zu GLM-5.1 wechseln, indem Sie die Basis-URL und den Modellnamen ändern. Keine neuen SDKs zu lernen. Kein anderes Antwortformat zu handhaben.

Voraussetzungen

Bevor Sie Ihren ersten Aufruf tätigen, benötigen Sie:

1. Ein BigModel-Konto unter bigmodel.cn. Die Registrierung ist kostenlos.
2. Einen API-Schlüssel aus der BigModel-Konsole unter API-Schlüssel.
3. Python 3.8+ oder Node.js 18+ (Beispiele decken beides ab).
4. Das OpenAI SDK oder Standard-requests/fetch (die API von GLM-5.1 ist OpenAI-kompatibel).

Setzen Sie Ihren API-Schlüssel als Umgebungsvariable:

export BIGMODEL_API_KEY="your_api_key_here"

Hardcodieren Sie niemals API-Schlüssel in Ihrem Quellcode.

Authentifizierung

Jede Anfrage benötigt einen Bearer-Token im Authorization-Header:

Authorization: Bearer YOUR_API_KEY

Das Format des BigModel API-Schlüssels sieht aus wie xxxxxxxx.xxxxxxxxxxxxxxxx, eine zweiteilige Zeichenfolge, getrennt durch einen Punkt. Dies unterscheidet sich vom sk-Format von OpenAI, funktioniert aber im Header auf die gleiche Weise.

Basis-URL

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

Der Endpunkt für Chat-Vervollständigungen ist:

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

Ihre erste Anfrage

Verwendung von 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
  }'

Verwendung von 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"])

Verwendung des OpenAI SDK (empfohlen)

Da die API OpenAI-kompatibel ist, können Sie das offizielle OpenAI Python SDK mit einer benutzerdefinierten Basis-URL verwenden:

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)

Dies ist der sauberste Ansatz. Das OpenAI SDK übernimmt Wiederholungsversuche, Timeout-Management und das Parsen von Antworten. Sie erhalten all das kostenlos, indem Sie es einfach auf die BigModel-Basis-URL verweisen.

Antwortformat

Die Antwortstruktur ist identisch mit der von 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
  }
}

Greifen Sie auf den Antworttext über result["choices"][0]["message"]["content"] zu.

Das Feld usage zeigt die Token-Anzahl für die Anfrage. Verfolgen Sie dies, um Ihren Kontingentverbrauch zu überwachen, da GLM-5.1 während der Spitzenzeiten (14:00-18:00 UTC+8) das 3-fache des Kontingents berechnet.

Streaming-Antworten

Bei langen Codegenerierungsaufgaben liefert Streaming die Tokens, sobald sie eintreffen, anstatt auf die vollständige Antwort zu warten. Dies ist unerlässlich für jede benutzerorientierte Anwendung.

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()  # newline after streaming completes

Jeder Chunk im Stream ist ein Delta, das nur die neuen Tokens seit dem letzten Chunk enthält. Der letzte Chunk hat finish_reason auf "stop" gesetzt (oder "length", wenn Sie das Token-Limit erreicht haben).

Streaming mit Roh-Anfragen

Wenn Sie das OpenAI SDK nicht verwenden möchten:

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)

Tool-Aufrufe

GLM-5.1 unterstützt Tool-Aufrufe: die Möglichkeit, die Ausführung von Funktionen mitten im Gespräch anzufordern. Dies ist der zentrale Mechanismus für agentenbasierte Workflows, bei denen das Modell Code ausführen, Datenbanken durchsuchen, externe APIs aufrufen oder Aktionen in der realen Welt ausführen muss.

Tools definieren

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"Finish reason: {response.choices[0].finish_reason}")

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

Behandeln von Tool-Aufruf-Antworten

Wenn GLM-5.1 einen Tool-Aufruf anfordert, führen Sie die Funktion aus und geben das Ergebnis in der nächsten Nachricht zurück:

import subprocess

def execute_tool(tool_call):
    """Execute the tool and return the result."""
    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"Error: file {args['path']} not found"

    return f"Unknown tool: {name}"


def run_agent_loop(user_message, tools, max_iterations=20):
    """Run a full agent loop with tool calling."""
    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":
            # Model is done
            return message.content

        if response.choices[0].finish_reason == "tool_calls":
            # Execute each tool call and add results
            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 "Max iterations reached"


result = run_agent_loop(
    "Write a quicksort implementation, test it with a random list of 1000 integers, and report the time.",
    tools
)
print(result)

Dieses Muster skaliert direkt mit der Stärke von GLM-5.1 als agentenbasiertem Modell. Sie lassen das Modell entscheiden, wann Tools aufgerufen werden sollen, verarbeiten die Ergebnisse und fahren fort, bis es eine Lösung erreicht oder entscheidet, dass es fertig ist.

Wichtige Parameter

Empfohlene Einstellungen für Codierungsaufgaben:

{
    "model": "glm-5.1",
    "temperature": 1.0,
    "top_p": 0.95,
    "max_tokens": 163840  # full context for long agentic runs
}

Z.AI verwendet diese Einstellungen in ihren eigenen Benchmark-Bewertungen. Für die deterministische Codegenerierung senken Sie die Temperatur auf 0,2-0,4.

GLM-5.1 mit Codierungsassistenten verwenden

Der Z.AI Coding Plan ermöglicht es Ihnen, Claude Code, Cline, Kilo Code und andere KI-Codierungsassistenten über GLM-5.1 via BigModel API zu leiten. Dies ist nützlich, wenn Sie ein starkes Codierungsmodell zu geringeren Kosten als bei der direkten Ausführung von Claude Opus oder GPT-5.4 wünschen.

Claude Code Einrichtung

In Ihrer Claude Code Konfigurationsdatei (~/.claude/settings.json oder Ähnlichem):

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

Cline / Roo Code Einrichtung

In Ihren VS Code-Einstellungen oder der Cline-Erweiterungskonfiguration:

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

Kontingentverbrauch

GLM-5.1 verwendet das Z.AI-Kontingentsystem anstelle der Token-basierten Abrechnung: - Spitzenzeiten (14:00-18:00 UTC+8): 3x Kontingent pro Anfrage - Nebenzeiten: 2x Kontingent pro Anfrage - Aktionspreis bis April 2026: 1x während der Nebenzeiten

Für hohe agentenbasierte Arbeitslasten planen Sie langlaufende Aufgaben für die Nebenzeiten. Ein Optimierungslauf mit 600 Iterationen, wie von Z.AI demonstriert, kostet in Spitzenzeiten deutlich mehr Kontingent.

Testen der GLM-5.1 API mit Apidog

Das Testen einer agentenbasierten API-Integration erfordert die korrekte Handhabung mehrerer Antworttypen: normale Vervollständigungen, Streaming-Chunks, Tool-Aufrufanfragen, Tool-Ergebnismeldungen und Fehlerzustände. Das Testen all dieser gegen die echte API verbraucht Kontingent und erfordert eine Live-Verbindung.

Apidogs Smart Mock ermöglicht es Ihnen, all diese Antwortzustände zu definieren und zu testen, ohne die echte API aufzurufen.

Einrichten des Mock-Endpunkts

1. Erstellen Sie in Apidog einen neuen Endpunkt: POST https://open.bigmodel.cn/api/paas/v4/chat/completions
2. Fügen Sie eine Mock-Erwartung für eine Standard-Erfolgsantwort hinzu:

{
  "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. Fügen Sie eine zweite Erwartung für eine Tool-Aufruf-Antwort hinzu:

{
  "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. Fügen Sie eine Ratenbegrenzungsantwort (HTTP 429) hinzu:

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

Testen des vollständigen Agenten-Loops

Verwenden Sie die Test-Szenarien von Apidog, um mehrere Anfragen miteinander zu verketten. Für einen Agenten-Loop-Test:

1. Schritt 1: POST an /chat/completions mit Ihrer ursprünglichen Nachricht, bestätigen Sie 200 und finish_reason == "tool_calls"
2. Schritt 2: Erneut POSTen mit dem Tool-Ergebnis im Nachrichten-Array, bestätigen Sie 200 und finish_reason == "stop"
3. Schritt 3: Extrahieren Sie den endgültigen Inhalt und bestätigen Sie, dass er den erwarteten Code enthält

Dies testet den vollständigen Agenten-Loop, ohne Kontingent zu verbrauchen. Sie können auch die Fehlerbehandlung testen, indem Sie den Mock auf die Rückgabe von 429 umschalten und dann überprüfen, ob Ihre Wiederholungslogik korrekt greift.

Für mehrstufige agentenbasierte Workflows ermöglichen Apidogs Test-Szenarien, Daten zwischen den Schritten mithilfe von Variablen zu übergeben, sodass request_id- oder tool_call_id-Werte aus Schritt 1 automatisch in Schritt 2 fließen. Dies spiegelt wider, wie ein echter Agenten-Loop funktioniert und fängt Integrationsfehler vor der Produktion ab.

Fehlerbehandlung

Die API gibt Standard-HTTP-Statuscodes zurück:

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"Rate limited. Waiting {retry_after}s...")
                time.sleep(retry_after)
                continue

            response.raise_for_status()
            return response.json()

        except requests.exceptions.Timeout:
            wait = 2 ** attempt
            print(f"Timeout on attempt {attempt + 1}. Retrying in {wait}s...")
            time.sleep(wait)

    raise Exception("Max retries exceeded")

Bei langen agentenbasierten Läufen, bei denen einzelne Schritte 30-60 Sekunden dauern können, stellen Sie immer ein großzügiges Timeout (120-300 Sekunden) ein. Das Modell benötigt möglicherweise Zeit, um eine vollständige Codedatei zu generieren oder ein komplexes Benchmark-Ergebnis zu analysieren.

Fazit

Die OpenAI-kompatible API von GLM-5.1 bedeutet, dass Sie sie in wenigen Minuten integrieren können, wenn Sie bereits mit GPT oder Claude gearbeitet haben. Der Hauptunterschied ist der Endpunkt (open.bigmodel.cn) und das Kontingentsystem anstelle der Pro-Token-Abrechnung.

Für agentenbasierte Anwendungen, bei denen das Modell Hunderte von Tool-Aufrufen über eine lange Sitzung ausführt, ist die Langzeitoptimierungsfähigkeit von GLM-5.1 ein echter Vorteil. Kombinieren Sie dies mit ordnungsgemäßem Testen über Apidogs Smart Mock und Test-Szenarien, um sicherzustellen, dass Ihre Integration alle Grenzfälle handhabt, bevor sie unbeaufsichtigt läuft.

Für Hintergrundinformationen darüber, was GLM-5.1 ist und wie seine Benchmarks im Vergleich abschneiden, siehe die GLM-5.1 Modellübersicht. Weitere Informationen zum Erstellen und Testen von KI-Agenten-Workflows mit Apidog finden Sie unter wie das Gedächtnis von KI-Agenten funktioniert.

FAQ

Ist die GLM-5.1 API OpenAI-kompatibel?Ja. Das Anfrageformat, die Antwortstruktur, das Streaming-Protokoll und das Tool-Aufruf-Format sind alle identisch mit der OpenAI Chat Completions API. Sie können das offizielle OpenAI Python SDK oder jeden OpenAI-kompatiblen Client verwenden, indem Sie die Basis-URL auf https://open.bigmodel.cn/api/paas/v4/ setzen.

Welchen Modellnamen soll ich in API-Anfragen verwenden?Verwenden Sie "glm-5.1" als Modellnamen. Verwenden Sie keinen vollständigen Versionsnamen; glm-5.1 funktioniert.

Wie funktioniert die Preisgestaltung der GLM-5.1 API?Die BigModel API verwendet ein Kontingentsystem. GLM-5.1 verbraucht das 3-fache Kontingent während der Spitzenzeiten (14:00-18:00 UTC+8) und das 2-fache in Nebenzeiten. Bis Ende April 2026 wird die Nutzung in Nebenzeiten mit dem 1-fachen Kontingent als Aktionspreis abgerechnet.

Was ist die maximale Kontextlänge?200.000 Tokens Eingabekontext. Die maximale Ausgabe beträgt 163.840 Tokens. Für lange agentenbasierte Läufe setzen Sie max_tokens auf einen großen Wert (32.768 oder höher), um zu vermeiden, dass die Ausgabe des Modells mitten in der Aufgabe abgeschnitten wird.

Kann ich GLM-5.1 für Funktionsaufrufe / Tool-Nutzung verwenden?Ja. GLM-5.1 unterstützt das gleiche Tool-Aufruf-Format wie die OpenAI API. Definieren Sie Tools mit einem type: "function" Schema, übergeben Sie sie im tools Array und behandeln Sie finish_reason: "tool_calls" Antworten in Ihrem Agenten-Loop.

Wie teste ich GLM-5.1 API-Aufrufe, ohne Kontingent zu verbrauchen?Verwenden Sie Apidogs Smart Mock, um Mock-Antworten für jeden API-Zustand zu definieren: Erfolg, Tool-Aufrufe, Ratenbegrenzungen, Fehler. Führen Sie Ihre Testsuite während der Entwicklung gegen den Mock aus und verwenden Sie die echte API nur zur endgültigen Validierung.

Wo finde ich die Modellgewichte von GLM-5.1?Die Open-Source-Gewichte finden Sie auf HuggingFace unter zai-org/GLM-5.1. Sie werden unter der MIT-Lizenz veröffentlicht und unterstützen vLLM und SGLang für die lokale Inferenz.