Cara Menggunakan GLM-5.1 API: Panduan Lengkap dengan Contoh Kode

TL;DR

GLM-5.1 tersedia melalui API BigModel di https://open.bigmodel.cn/api/paas/v4/. API ini kompatibel dengan OpenAI: struktur endpoint yang sama, format permintaan yang sama, pola streaming yang sama. Anda memerlukan akun BigModel, kunci API, dan nama model glm-5.1. Panduan ini mencakup autentikasi, permintaan pertama Anda, streaming, pemanggilan alat (tool calling), dan pengujian integrasi Anda dengan Apidog.

Pendahuluan

GLM-5.1 adalah model agen unggulan Z.AI, dirilis April 2026. Ini menempati peringkat #1 di SWE-Bench Pro dan mengungguli GLM-5 di setiap tolok ukur pengkodean utama. Jika Anda sedang membangun asisten pengkodean AI, agen otonom, atau aplikasi apa pun yang mendapat manfaat dari eksekusi tugas berjangka panjang, GLM-5.1 layak untuk diintegrasikan.

Kabar baik bagi para pengembang: API ini kompatibel dengan OpenAI. Jika Anda sudah membangun di atas GPT-4 atau Claude, Anda dapat beralih ke GLM-5.1 dengan mengubah URL dasar dan nama model. Tidak ada SDK baru untuk dipelajari. Tidak ada format respons berbeda untuk ditangani.

Prasyarat

Sebelum melakukan panggilan pertama Anda, Anda memerlukan:

1. Akun BigModel di bigmodel.cn. Pendaftaran gratis.
2. Kunci API dari konsol BigModel di bawah API Keys.
3. Python 3.8+ atau Node.js 18+ (contoh mencakup keduanya).
4. OpenAI SDK atau requests/fetch standar (API GLM-5.1 kompatibel dengan OpenAI).

Atur kunci API Anda sebagai variabel lingkungan:

export BIGMODEL_API_KEY="your_api_key_here"

Jangan pernah menulis kunci API secara langsung (hardcode) dalam kode sumber Anda.

Autentikasi

Setiap permintaan memerlukan token Bearer di header Otorisasi:

Authorization: Bearer YOUR_API_KEY

Format kunci API BigModel terlihat seperti xxxxxxxx.xxxxxxxxxxxxxxxx, sebuah string dua bagian yang dipisahkan oleh titik. Ini berbeda dari format sk- OpenAI tetapi berfungsi dengan cara yang sama di header.

URL Dasar

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

Endpoint penyelesaian obrolan adalah:

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

Permintaan pertama Anda

Menggunakan 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
  }'

Menggunakan 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"])

Menggunakan OpenAI SDK (direkomendasikan)

Karena API ini kompatibel dengan OpenAI, Anda dapat menggunakan OpenAI Python SDK resmi dengan URL dasar khusus:

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)

Ini adalah pendekatan paling bersih. OpenAI SDK menangani percobaan ulang (retries), manajemen batas waktu (timeout management), dan penguraian respons (response parsing). Anda mendapatkan semua itu secara gratis hanya dengan mengarahkannya ke URL dasar BigModel.

Format respons

Struktur respons identik dengan 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
  }
}

Akses teks respons melalui result["choices"][0]["message"]["content"].

Kolom usage menunjukkan jumlah token untuk permintaan. Lacak ini untuk memantau konsumsi kuota Anda, karena GLM-5.1 menagih 3x kuota selama jam sibuk (14:00-18:00 UTC+8).

Respons streaming

Untuk tugas pembuatan kode yang panjang, streaming memberi Anda token saat tiba daripada menunggu respons penuh. Ini penting untuk aplikasi apa pun yang berinteraksi dengan pengguna.

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

Setiap "chunk" dalam aliran adalah delta yang hanya berisi token baru sejak "chunk" terakhir. "Chunk" terakhir memiliki finish_reason yang diatur ke "stop" (atau "length" jika Anda mencapai batas token).

Streaming dengan permintaan mentah (raw requests)

Jika Anda lebih suka tidak menggunakan OpenAI SDK:

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)

Pemanggilan alat (Tool calling)

GLM-5.1 mendukung pemanggilan alat (tool calling): kemampuan untuk meminta eksekusi fungsi di tengah percakapan. Ini adalah mekanisme inti untuk alur kerja agen (agentic workflows) di mana model perlu menjalankan kode, mencari basis data, memanggil API eksternal, atau mengambil tindakan di dunia nyata.

Mendefinisikan alat

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}")

Menangani respons pemanggilan alat

Ketika GLM-5.1 meminta pemanggilan alat, Anda mengeksekusi fungsi tersebut, lalu mengembalikan hasilnya dalam pesan berikutnya:

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)

Pola ini berskala langsung ke kekuatan GLM-5.1 sebagai model agen. Anda membiarkan model memutuskan kapan harus memanggil alat, memproses hasilnya, dan melanjutkan hingga mencapai solusi atau memutuskan bahwa tugasnya selesai.

Parameter utama

Pengaturan yang direkomendasikan untuk tugas pengkodean:

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

Z.AI menggunakan pengaturan ini dalam evaluasi tolok ukur mereka sendiri. Untuk pembuatan kode yang deterministik, turunkan suhu ke 0.2-0.4.

Menggunakan GLM-5.1 dengan asisten pengkodean

Rencana Pengkodean Z.AI memungkinkan Anda mengarahkan Claude Code, Cline, Kilo Code, dan asisten pengkodean AI lainnya melalui GLM-5.1 melalui API BigModel. Ini berguna jika Anda menginginkan model pengkodean yang kuat dengan biaya lebih rendah daripada menjalankan Claude Opus atau GPT-5.4 secara langsung.

Pengaturan Claude Code

Di file konfigurasi Claude Code Anda (~/.claude/settings.json atau yang setara):

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

Pengaturan Cline / Roo Code

Di pengaturan VS Code Anda atau konfigurasi ekstensi Cline:

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

Konsumsi kuota

GLM-5.1 menggunakan sistem kuota Z.AI daripada penagihan per-token: - Jam sibuk (14:00-18:00 UTC+8): 3x kuota per permintaan - Di luar jam sibuk: 2x kuota per permintaan - Tarif promosi hingga April 2026: 1x selama di luar jam sibuk

Untuk beban kerja agen yang berat, jadwalkan tugas jangka panjang untuk jam di luar jam sibuk. Jalankan optimasi 600 iterasi seperti yang didemonstrasikan Z.AI akan menghabiskan kuota yang jauh lebih banyak pada jam sibuk.

Menguji API GLM-5.1 dengan Apidog

Menguji integrasi API agen memerlukan penanganan berbagai jenis respons dengan benar: penyelesaian normal, chunk streaming, permintaan pemanggilan alat, pesan hasil alat, dan status kesalahan. Menguji semua ini terhadap API nyata akan menghabiskan kuota dan memerlukan koneksi langsung.

Smart Mock Apidog memungkinkan Anda mendefinisikan semua status respons ini dan mengujinya tanpa harus mengakses API nyata.

Menyiapkan endpoint mock

1. Di Apidog, buat endpoint baru: POST https://open.bigmodel.cn/api/paas/v4/chat/completions
2. Tambahkan Harapan Mock (Mock Expectation) untuk respons sukses standar:

{
  "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. Tambahkan harapan kedua untuk respons pemanggilan alat:

{
  "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. Tambahkan respons batas laju (rate limit) (HTTP 429):

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

Menguji alur agen lengkap (full agent loop)

Gunakan Skenario Uji Apidog (Apidog's Test Scenarios) untuk merangkai beberapa permintaan bersama-sama. Untuk uji alur agen:

1. Langkah 1: Lakukan POST ke /chat/completions dengan pesan awal Anda, pastikan status 200 dan finish_reason == "tool_calls"
2. Langkah 2: Lakukan POST lagi dengan hasil alat (tool result) di array pesan, pastikan status 200 dan finish_reason == "stop"
3. Langkah 3: Ekstrak konten akhir dan pastikan itu berisi kode yang diharapkan

Ini menguji alur agen lengkap tanpa menghabiskan kuota. Anda juga dapat menguji penanganan kesalahan dengan mengalihkan mock untuk mengembalikan 429, lalu memverifikasi bahwa logika percobaan ulang Anda berfungsi dengan benar.

Untuk alur kerja agen multi-langkah, Skenario Uji Apidog (Apidog's Test Scenarios) memungkinkan Anda meneruskan data antar langkah menggunakan variabel, sehingga nilai request_id atau tool_call_id dari langkah 1 secara otomatis mengalir ke langkah 2. Ini mencerminkan cara kerja alur agen nyata dan menangkap bug integrasi sebelum produksi.

Penanganan kesalahan

API mengembalikan kode status HTTP standar:

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")

Untuk eksekusi agen yang panjang di mana langkah-langkah individual dapat memakan waktu 30-60 detik, selalu atur batas waktu yang murah hati (120-300 detik). Model mungkin memerlukan waktu untuk menghasilkan file kode lengkap atau menganalisis hasil tolok ukur yang kompleks.

Kesimpulan

API GLM-5.1 yang kompatibel dengan OpenAI berarti Anda dapat mengintegrasikannya dalam hitungan menit jika Anda sudah pernah bekerja dengan GPT atau Claude. Perbedaan utamanya adalah endpoint (open.bigmodel.cn) dan sistem kuota alih-alih penagihan per-token.

Untuk aplikasi agen di mana model menjalankan ratusan pemanggilan alat (tool calls) selama sesi yang panjang, kemampuan optimasi jangka panjang GLM-5.1 adalah keuntungan nyata. Pasangkan ini dengan pengujian yang tepat melalui Smart Mock dan Skenario Uji Apidog (Apidog's Smart Mock and Test Scenarios) untuk memastikan integrasi Anda menangani semua kasus ekstrem sebelum berjalan tanpa pengawasan.

Untuk latar belakang tentang apa itu GLM-5.1 dan bagaimana perbandingan tolok ukurnya, lihat gambaran umum model GLM-5.1. Untuk informasi lebih lanjut tentang membangun dan menguji alur kerja agen AI dengan Apidog, lihat cara kerja memori agen AI.

FAQ

Apakah API GLM-5.1 kompatibel dengan OpenAI?Ya. Format permintaan, struktur respons, protokol streaming, dan format pemanggilan alat (tool calling) semuanya identik dengan API penyelesaian obrolan OpenAI. Anda dapat menggunakan OpenAI Python SDK resmi atau klien kompatibel OpenAI lainnya dengan mengatur URL dasar ke https://open.bigmodel.cn/api/paas/v4/.

Apa nama model yang harus digunakan dalam permintaan API?Gunakan "glm-5.1" sebagai nama model. Jangan gunakan nama berversi lengkap; cukup glm-5.1 sudah berfungsi.

Bagaimana cara kerja harga API GLM-5.1?API BigModel menggunakan sistem kuota. GLM-5.1 mengonsumsi 3x kuota selama jam sibuk (14:00-18:00 UTC+8) dan 2x selama di luar jam sibuk. Hingga akhir April 2026, penggunaan di luar jam sibuk ditagih dengan tarif promosi 1x kuota.

Berapa panjang konteks maksimum?Konteks masukan 200.000 token. Keluaran maksimum adalah 163.840 token. Untuk eksekusi agen yang panjang, atur max_tokens ke nilai besar (32.768 atau lebih tinggi) untuk menghindari pemotongan keluaran model di tengah tugas.

Dapatkah saya menggunakan GLM-5.1 untuk pemanggilan fungsi / penggunaan alat?Ya. GLM-5.1 mendukung format pemanggilan alat yang sama dengan API OpenAI. Definisikan alat dengan skema type: "function", teruskan di array tools, dan tangani respons finish_reason: "tool_calls" dalam alur agen Anda.

Bagaimana cara menguji panggilan API GLM-5.1 tanpa menghabiskan kuota?Gunakan Smart Mock Apidog untuk mendefinisikan respons tiruan (mock responses) untuk setiap status API: sukses, pemanggilan alat, batas laju, kesalahan. Jalankan suite pengujian Anda terhadap mock selama pengembangan dan hanya gunakan API nyata untuk validasi akhir.

Di mana saya dapat menemukan bobot model GLM-5.1?Bobot sumber terbuka ada di HuggingFace di zai-org/GLM-5.1. Mereka dirilis di bawah Lisensi MIT dan mendukung vLLM serta SGLang untuk inferensi lokal.