GLM-5.2 API nutzen: Anleitung

Die GLM-5.2 API ermöglicht Ihnen programmatischen Zugriff auf Z.ais neuestes Open-Weights-Flaggschiff, ein MoE-Modell mit ~753 Milliarden Parametern, das bei langfristigen Codierungs-Benchmarks die höchsten Werte unter den Open-Source-Modellen erzielt. Dieser Leitfaden ist praxisnah. Sie erhalten einen API-Schlüssel, senden Ihre erste Anfrage und arbeiten sich dann durch Python, curl, Denkmodi, Streaming, Tool-Aufrufe und Kostenverfolgung, alles mit realen Werten, die Sie in ein Terminal einfügen können.

Wenn Sie von der vorherigen Version kommen, beginnen Sie hier.

Was sich seit GLM-5.1 geändert hat

GLM-5.2 löst die 5.1-Generation ab. Wenn Sie bereits Integrationscode für die GLM-5.1 API geschrieben haben, ist das Wire-Format dasselbe, sodass Sie meistens nur die Modell-ID austauschen müssen. Die wissenswerten Unterschiede:

• Ein neues spärliches Aufmerksamkeits-Schema. GLM-5.2 führt „IndexShare“ ein, das einen einzelnen Indexer über jeweils vier Sparse-Attention-Schichten wiederverwendet, um die Aufmerksamkeitskosten bei langem Kontext zu senken. Als API-Benutzer berühren Sie dies nicht; es macht das 1M-Token-Fenster einfach kostengünstiger.
• Ein echter Sprung beim agentischen Codieren. Die veröffentlichten Ergebnisse von Z.ai setzen Terminal-Bench 2.1 auf 81.0, gegenüber 62.0 von GLM-5.1. Das ist die Schlagzeile für jeden, der Codierungs-Agenten entwickelt.
• Zwei Denk-Anstrengungsstufen. GLM-5.2 bietet hohe (High) und maximale (Max) Argumentationsanstrengung, und Z.ai empfiehlt Max speziell für Codierungsaufgaben. Mehr dazu weiter unten.

Da der 5.1-Anfragecode bereits funktioniert, wird dieser Leitfaden ihn nicht wiederholen. Alles hier zielt direkt auf glm-5.2 ab.

Schritt 1: Einen GLM-5.2 API-Schlüssel erhalten

Melden Sie sich unter z.ai an und öffnen Sie den Bereich API-Schlüssel in Ihrem Kontodashboard. Erstellen Sie einen Schlüssel, kopieren Sie ihn einmal (Sie können ihn normalerweise nicht erneut ansehen) und speichern Sie ihn in einer Umgebungsvariablen, anstatt ihn in den Quellcode einzufügen:

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

Bewahren Sie Ihren glm-5.2 API-Schlüssel außerhalb von Git auf. Ein geleakter Schlüssel wird Ihrem Konto belastet, und die GLM-5.2-Ausgabe wird pro Million Tokens abgerechnet, sodass ein außer Kontrolle geratenes Skript echtes Geld kostet.

Schritt 2: Endpunkt und Basis-URL kennen

GLM-5.2 ist mit OpenAI-kompatibel, was bedeutet, dass jeder Client, der das OpenAI Chat Completions-Format spricht, funktioniert, sobald Sie die Basis-URL neu zuweisen. Die Werte, die Sie benötigen:

Der OpenRouter-Alias ist z-ai/glm-5.2, wenn Sie es vorziehen, über OpenRouter zu routen, anstatt Z.ai direkt aufzurufen. Für lokale Ausführungen veröffentlicht Ollama die Gewichte als glm-5.2 (siehe die Ollama-Bibliothek), und die offenen Gewichte befinden sich auf Hugging Face unter einer MIT-Lizenz.

Ein Hinweis zu Limits, bevor Sie entwickeln: Das Kontextfenster beträgt 1M Tokens (1.048.576). Für die maximale Ausgabe listen die z.ai-Dokumente bis zu 128K auf, aber OpenRouter veröffentlicht keine Zahl, daher behandeln Sie es als bis zu 128K gemäß den z.ai-Dokumenten (live überprüfen) und nicht als feste Garantie.

Schritt 3: Ihre erste Anfrage mit curl

Hier ist ein minimaler glm-5.2 curl-Aufruf. Er sendet eine Benutzernachricht und gibt die JSON-Antwort aus:

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": "Sie sind ein prägnanter Backend-Entwickler."},
      {"role": "user", "content": "Schreiben Sie eine SQL-Abfrage, die die 5 neuesten Bestellungen pro Kunde zurückgibt."}
    ]
  }'

Die Antwortstruktur entspricht dem OpenAI-Standard: eine id, ein choices-Array mit der Assistenten-Nachricht und ein usage-Objekt. Dieses letzte Feld dient der Kostenverfolgung, die am Ende behandelt wird.

Schritt 4: Aufruf aus Python mit dem OpenAI SDK

Da die API OpenAI-kompatibel ist, benötigen Sie keinen speziellen Client. Installieren Sie das Standard-SDK und richten Sie die base_url auf Z.ai aus. Dies ist die kanonische glm-5.2 Python-Einrichtung:

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": "Sie sind ein prägnanter Backend-Entwickler."},
        {"role": "user", "content": "Erklären Sie Idempotenzschlüssel in 3 Sätzen."},
    ],
)

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

Das ist die gesamte Integration. Das client-Objekt verhält sich genau wie bei OpenAI, sodass vorhandener Hilfscode, Wiederholungsversuche und Logging übernommen werden. Wenn Sie eine tiefere Einführung in die Plattform selbst wünschen, behandelt die GLM-5 API-Übersicht die familienweiten Konventionen.

Schritt 5: Argumentation mit Thinking und Reasoning_Effort steuern

GLM-5.2 ist ein Argumentationsmodell. Sie können sein internes Denken ein- oder ausschalten, und wenn es eingeschaltet ist, können Sie einstellen, wie intensiv es arbeitet.

Deaktivieren Sie das Denken für schnelle, kostengünstige Antworten mit geringer Latenz (Klassifizierung, kurze Umschreibungen, Routing):

resp = client.chat.completions.create(
    model="glm-5.2",
    messages=[{"role": "user", "content": "Klassifizieren: 'Meine Karte wurde zweimal belastet'"}],
    extra_body={"thinking": {"type": "disabled"}},
)

Aktivieren Sie das Denken und stellen Sie den Aufwand auf "Max" für anspruchsvolles Codieren und Mathematik. Z.ai empfiehlt "Max" speziell für das Codieren:

resp = client.chat.completions.create(
    model="glm-5.2",
    messages=[
        {"role": "user", "content": "Refaktorieren Sie diese Funktion, um die N+1-Abfrage zu entfernen, und erklären Sie die Korrektur."},
    ],
    extra_body={
        "thinking": {"type": "enabled"},
        "reasoning_effort": "max",
    },
)

Der extra_body-Wrapper ist die Art und Weise, wie das OpenAI Python SDK nicht-standardmäßige Felder an Z.ai weiterleitet. In einem Roh-Curl-Body würden Sie thinking und reasoning_effort auf der obersten Ebene neben model platzieren. Maximaler Aufwand verbraucht mehr Ausgabe-Tokens (Argumentation zählt), also reservieren Sie ihn für Aufgaben, bei denen der Qualitätssprung sich auszahlt.

Schritt 6: Die Antwort streamen

Für Chat-UIs und lange Generierungen streamen Sie Tokens, sobald sie eintreffen, anstatt auf die vollständige Vervollständigung zu warten. Setzen Sie stream: true und iterieren Sie über die Chunks:

stream = client.chat.completions.create(
    model="glm-5.2",
    messages=[{"role": "user", "content": "Schreiben Sie einen 200-Wörter langen Changelog-Eintrag für eine Ratenlimit-Korrektur."}],
    stream=True,
)

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

In curl fügen Sie "stream": true zum Body hinzu, und der Server gibt Server-Sent Events zurück, eine data:-Zeile pro Chunk, endend mit data: [DONE]. Streaming ändert nichts an der Preisgestaltung; Sie zahlen weiterhin pro Token, Sie sehen sie nur früher.

Schritt 7: Funktions- und Tool-Aufrufe

Tool-Aufrufe zeigen die agentische Stärke von GLM-5.2, und es erzielt in den veröffentlichten Ergebnissen von Z.ai 77.0 auf MCP-Atlas, nahe an Claude Opus 4.8. Das Muster ist der standardmäßige OpenAI-Zweischritt: Sie beschreiben ein Tool, das Modell gibt eine tool_calls-Anfrage zurück, Sie führen die Funktion aus, und dann speisen Sie das Ergebnis zurück.

Hier ist ein kleines, realistisches glm-5.2 API-Beispiel mit einer Wetterabfrage:

import json

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Ermittelt die aktuelle Temperatur für eine Stadt.",
            "parameters": {
                "type": "object",
                "properties": {
                    "city": {"type": "string", "description": "Stadtname, z.B. Berlin"},
                    "unit": {"type": "string", "enum": ["c", "f"]},
                },
                "required": ["city"],
            },
        },
    }
]

messages = [{"role": "user", "content": "Wie ist das Wetter in Berlin in 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)

# Sie führen hier die echte Funktion aus. Für das Beispiel gestubbt:
def get_weather(city, unit="c"):
    return {"city": city, "temp": 12, "unit": unit}

result = get_weather(**args)

# Fügen Sie den Tool-Aufruf des Assistenten und dann das Ergebnis Ihres Tools an.
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)

Das Modell entscheidet, wann das Tool aufgerufen werden soll, Sie führen es aus, und die zweite Anfrage lässt GLM-5.2 das rohe Ergebnis in eine natürliche Antwort umwandeln. Dieselbe Schleife skaliert auf mehrere Tools und auf Agent-Frameworks; nichts an diesem Vertrag ist Z.ai-spezifisch.

Diese Schleife manuell zu testen, wird schnell mühsam. Dies ist ein guter Zeitpunkt, Apidog zu verwenden: Sie können den GLM-5.2-Endpunkt einmal definieren, Anfragetexte für jeden Denkmodus speichern und Tool-Aufrufrunden wiederholen, ohne jedes Mal curl neu schreiben zu müssen. Es verarbeitet das OpenAI-ähnliche Schema und lässt Sie gestreamte Antworten an einem Ort überprüfen.

Schritt 8: Das Usage-Objekt für Kosten lesen

Jede nicht gestreamte Antwort enthält ein usage-Objekt. Das ist Ihre Quelle der Wahrheit für die Abrechnung:

resp = client.chat.completions.create(
    model="glm-5.2",
    messages=[{"role": "user", "content": "Fassen Sie REST vs gRPC in 4 Stichpunkten zusammen."}],
)

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

Die GLM-5.2-Preisgestaltung beträgt 1,40 $ pro 1 Million Eingabe-Tokens und 4,40 $ pro 1 Million Ausgabe-Tokens (von OpenRouter bestätigt). Zwischengespeicherte Eingaben kosten etwa 0,26 $ pro 1 Million (laut VentureBeat, deren Zahlenangabe zitierend). Ein Aufruf mit 8.000 Eingabe- und 1.500 Ausgabe-Tokens kostet also ungefähr:

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

Argumentations-Tokens aus maximalem Aufwand fließen in die Ausgabe-Anzahl ein, daher wird ein Codierungsaufruf mit maximalem Aufwand teurer ausfallen als einer mit deaktiviertem Denken. VentureBeat berichtet, dass GLM-5.2 „GPT-5.5 bei langfristiger Codierung zu etwa 1/6 der Kosten übertrifft“, was die wirtschaftliche Argumentation hinter diesen Zahlen ist (die Behauptung wird VentureBeat zugeschrieben).

Wenn Sie lieber einen Pauschaltarif statt gemessener API-Aufrufe nutzen möchten, verkauft Z.ai auch GLM Coding Plan-Stufen (Lite, Pro, Max, plus Team). Die genaue Preisgestaltung ändert sich, daher überprüfen Sie ab Juni 2026 die aktuellen Stufen unter z.ai, bevor Sie sich festlegen. Für einen direkten Vergleich der gemessenen Seite geht die GLM-5.2 Preisaufschlüsselung tiefer, und wie man GLM-5.2 kostenlos nutzen kann behandelt den Weg über lokale Gewichte.

GLM-5.2 in Claude Code verwenden

GLM-5.2 bietet auch einen Anthropic-kompatiblen Pfad, sodass Sie es von Claude Code aus steuern können. Richten Sie die Basis-URL für das Codieren auf https://api.z.ai/api/coding/paas/v4 (einige Quellen zeigen open.z.ai/api/paas/v4, also live überprüfen) und setzen Sie dann diese Umgebungsvariablen:

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

Das Suffix [1m] wählt die 1M-Kontextvariante aus, und der lange API_TIMEOUT_MS ist wichtig: Ohne ihn kann Claude Code lange Aufrufe mit großem Kontext beenden, bevor sie eine Antwort liefern. Die vollständige Anleitung finden Sie in unserem Leitfaden zum Ausführen von GLM mit Claude Code, und wenn Sie Tools abwägen, stellt Claude Code vs. Codex vs. Cursor vs. GLM Plan die Kompromisse dar.

Wie GLM-5.2 abschneidet

Kurzübersicht über die Werte, die Integrationsentscheidungen beeinflussen:

Für Benchmark-Details umfassen die veröffentlichten Ergebnisse von Z.ai SWE-bench Pro 62.1 (GPT-5.5 58.6), Humanity’s Last Exam mit Tools 54.7 und AIME 2026 99.2. Die GLM-5.2 Benchmarks-Übersicht schlüsselt diese auf, und GLM-5.2 vs. GPT-5.5, Claude Opus und Gemini stellt sie nebeneinander.

Häufig gestellte Fragen (FAQ)

Ist die GLM-5.2 API wirklich OpenAI-kompatibel? Ja. Richten Sie die base_url des OpenAI SDK auf https://api.z.ai/api/paas/v4/ und setzen Sie das Modell auf glm-5.2. Standardmäßiger Chat-, Streaming- und Tool-Aufrufcode funktioniert unverändert.

Welche GLM-5.2 Modell-ID sollte ich senden? Senden Sie glm-5.2 an die Z.ai API. Auf OpenRouter ist es z-ai/glm-5.2, auf Ollama ist es glm-5.2, und die Claude Code-Variante ist glm-5.2[1m] für das 1M-Kontextfenster.

Wie deaktiviere ich die Argumentation für Geschwindigkeit? Übergeben Sie thinking: {"type": "disabled"} (über extra_body im Python SDK). Für anspruchsvolle Codierungsaufgaben aktivieren Sie das Denken und setzen reasoning_effort: "max", was Z.ai für Code empfiehlt.

Wie viel kostet GLM-5.2 pro Aufruf? 1,40 $ pro 1 Million Eingabe-Tokens und 4,40 $ pro 1 Million Ausgabe-Tokens (von OpenRouter bestätigt). Lesen Sie das usage-Objekt in jeder Antwort, um die genauen Kosten zu berechnen; denken Sie daran, dass Argumentations-Tokens mit maximalem Aufwand als Ausgabe zählen.

Hat GLM-5.2 ein Vision-Modell? Es gibt ab Juni 2026 keine bestätigte Vision-Variante. Die API ist Text hinein, Text heraus. Verlassen Sie sich nicht auf Bildeingaben, bis Z.ai deren Unterstützung dokumentiert.

Zusammenfassung

Die GLM-5.2 API ist nur einen Katzensprung von jeder OpenAI-kompatiblen Codebasis entfernt: Tauschen Sie die Basis-URL aus, senden Sie glm-5.2, und Sie haben ein MIT-lizenziertes Codierungsmodell mit 1M Kontext und abstimmbarer Argumentation zu einem Ausgabepreis von 4,40 $ pro 1 Million Tokens. Beginnen Sie mit einem Curl-Ping, wechseln Sie zum Python SDK und fügen Sie dann Denkmodi und Tool-Aufrufe hinzu, je nach Ihren Anwendungsfällen.

Wenn Sie bereit sind, Endpunkte zu testen, Anfragsvarianten zu speichern und Tool-Aufrufrunden zu inspizieren, ohne jedes Mal curl manuell schreiben zu müssen, laden Sie Apidog herunter und richten Sie den GLM-5.2 Endpunkt einmal ein. Für ein umfassenderes Bild des Modells selbst, sehen Sie was GLM-5.2 ist und den GLM-5.2 vs. GLM-5.1 Vergleich.