NL ▾
API-sleutel aanvragen

GLM API-voorbeelden: Python, JSON-modus en streaming

Deze GLM API-voorbeelden draaien allemaal tegen één OpenAI-compatible endpoint, met de base URL https://api.glmapikey.com/v1 en het model uncensored. Elke snippet is kort en compleet, zodat je hem kunt plakken, je sleutel toevoegen en uitvoeren.

Bijgewerkt

Terminalvenster met streaming gloeiende datatokens naar een cloudserver, ter illustratie van API-codevoorbeelden

Belangrijkste punten

  • Elk voorbeeld gebruikt de base URL https://api.glmapikey.com/v1, bearer-authenticatie en de model ID uncensored.
  • Streaming, JSON-modus en tool calling worden allemaal ondersteund op hetzelfde chat completions endpoint.
  • Lees X-Balance-USD en de gebruikscijfers om je uitgaven per verzoek bij te houden.
  • Handel 429 af op basis van de code: rate_limited, concurrency of een Retry-After: 5 bij overbelasting.

Voordat je iets uitvoert

Je hebt een sleutel nodig en verder niets. Maak er een aan op de API key-pagina; nieuwe accounts kunnen met één klik $0,50 aan trial credit claimen, zonder kaart. Exporteer deze zodat de voorbeelden deze kunnen lezen:

export API_KEY="YOUR_KEY"
pip install openai
npm install openai

De API volgt het OpenAI chat completions-formaat. Het exposeert POST /v1/chat/completions en GET /v1/models, accepteert Authorization: Bearer, en serveert één model met de ID uncensored. Dit model is een open-weight model dat wordt uitgevoerd door een onafhankelijke provider en is afgestemd op het geven van antwoorden zonder content refusals voor legaal gebruik door volwassenen. Het is niet de officiële API van een modelvendor. Het verwerkt alleen tekst: geen afbeeldingen, audio, embeddings of fine-tuning.

De voorbeelden hieronder gaan van het eenvoudigste verzoek tot function calling. Als je alleen de kortst mogelijke test nodig hebt om te controleren of je sleutel werkt, is het eerste curl-commando genoeg.

Een eerste verzoek met curl, en de parameters die ertoe doen

curl https://api.glmapikey.com/v1/chat/completions \
  -H "Authorization: Bearer $API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "uncensored",
    "messages": [
      {"role": "system", "content": "You are a concise assistant."},
      {"role": "user", "content": "What is a mutex, in one sentence?"}
    ],
    "temperature": 0.3,
    "max_tokens": 80
  }'

Het antwoord is een JSON-object met choices[0].message.content dat het antwoord bevat en een usage-object met prompt_tokens en completion_tokens. De antwoordheaders bevatten X-Request-Id, X-Balance-USD en de twee X-RateLimit-Limit-headers. Voeg -i toe aan curl om ze te zien.

De velden temperature, top_p, stop, seed en de presence en frequency penalties worden doorgegeven aan het model. max_tokens is optioneel. Zonder dit veld kan de completion wat er overblijft van het 100.000-token contextvenster na je prompt gebruiken.

De chat completions body heeft veel optionele velden, maar vijf doen het meeste werk. Allemaal worden ze doorgegeven aan het model.

VeldWat het doetTypisch gebruik
temperatureHogere waarden geven meer gevarieerde wording0,2 voor extractie, 0,8 voor fictie
top_pBeperkt sampling tot de meest waarschijnlijke tokensLaat op standaard staan tenzij je het afstelt
stopBeëindigt het antwoord wanneer een string verschijntAfsnijden bij een delimiter zoals een lege regel
seedMaakt sampling repeatable op een best-effort basisVergelijken van twee promptversies
presence_penalty, frequency_penaltyOntmoedigen van het herhalen van tokensKleine waarden zoals 0,3 wanneer tekst loopt

Verander één waarde tegelijk en houd de prompt hetzelfde, anders kun je niet zeggen welke verandering hielp. Voor alles wat code verwerkt, zoals classificatie of extractie, gebruik je een lage temperature en een vaste seed zodat je een test kunt herhalen en hetzelfde resultaat ziet. Voor creatief schrijven verhoog je de temperature en laat je de penalties repetition afhandelen.

Het veld max_tokens is hier optioneel. Als je het weglaat, kan het antwoord alle ruimte in het 100.000-token contextvenster gebruiken, wat zelden is wat je wilt voor een één-regel antwoord. Stel het in wanneer je weet hoe lang het antwoord moet zijn.

Python: een gesprek met geheugen

De API is stateless, dus je houdt het gesprek zelf bij en stuurt het elke keer. Deze lus houdt een lijst van berichten bij en voegt beide kanten toe:

from openai import OpenAI

client = OpenAI(
    base_url="https://api.glmapikey.com/v1",
    api_key="YOUR_KEY",
)

messages = [{"role": "system", "content": "You are a helpful assistant."}]

while True:
    user = input("you> ")
    if not user:
        break
    messages.append({"role": "user", "content": user})
    resp = client.chat.completions.create(model="uncensored", messages=messages)
    reply = resp.choices[0].message.content
    messages.append({"role": "assistant", "content": reply})
    print("bot>", reply)

Omdat elke call de volledige lijst opnieuw stuurt, groeien input tokens met de lengte van het gesprek. Bij $0,15 per 1M input tokens is dat goedkoop, maar het loopt op in lange sessies, dus verwijder oude berichten zodra de thread de grootte passeert waar je voor wilt betalen. De prijzenpagina heeft werkvoorbeelden.

Streaming in Python en Node

Stel stream: true in en de server stuurt tokens zodra ze geproduceerd zijn, via server-sent events. In Python:

stream = client.chat.completions.create(
    model="uncensored",
    messages=[{"role": "user", "content": "Write four lines about the sea."}],
    stream=True,
)

text = ""
for chunk in stream:
    if chunk.choices and chunk.choices[0].delta.content:
        piece = chunk.choices[0].delta.content
        text += piece
        print(piece, end="", flush=True)
    if getattr(chunk, "usage", None):
        print("\ntokens:", chunk.usage.prompt_tokens, chunk.usage.completion_tokens)

De stream eindigt met usage informatie, daarom controleert de lus hierop. Hetzelfde in Node:

import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.glmapikey.com/v1",
  apiKey: process.env.API_KEY,
});

const stream = await client.chat.completions.create({
  model: "uncensored",
  messages: [{ role: "user", content: "Write four lines about the sea." }],
  stream: true,
});

for await (const chunk of stream) {
  process.stdout.write(chunk.choices[0]?.delta?.content ?? "");
}

Eén detail over limits: een gestreamd verzoek houdt zijn concurrency slot vast tot de stream eindigt. Als je een stream start en nooit leest tot het einde, blijft dat slot bezet. Gebruik de stream altijd op of sluit hem.

JSON-modus voor gestructureerde output

Wanneer je code het antwoord moet parseren, vraag dan een JSON-object aan met response_format. Zeg ook in de prompt welke structuur je wilt, omdat het format-flag geldige JSON-syntax garandeert, niet jouw specifieke schema.

import json

resp = client.chat.completions.create(
    model="uncensored",
    response_format={"type": "json_object"},
    messages=[
        {"role": "system", "content": "Reply only with JSON: {\"title\": string, \"tags\": [string]}."},
        {"role": "user", "content": "Suggest a title and three tags for a post about home espresso."},
    ],
    temperature=0.2,
)

data = json.loads(resp.choices[0].message.content)
print(data["title"], data["tags"])

Controleer of de keys die je nodig hebt bestaan voordat je ze gebruikt, en houd de temperature laag voor extractiewerk. Als een parse faalt, werkt een keer opnieuw proberen met dezelfde input meestal wel, en gefaalde requests worden niet in rekening gebracht.

Tool calling: een volledige round trip

Tool calling laat het model je code een functie laten uitvoeren. Je beschrijft de functie in tools, het model antwoordt met een tool_calls entry, je voert het uit en stuurt het resultaat terug als een role: "tool" bericht.

import json

def get_weather(city: str) -> dict:
    return {"city": city, "temp_c": 18, "sky": "cloudy"}

tools = [{
    "type": "function",
    "function": {
        "name": "get_weather",
        "description": "Get current weather for a city",
        "parameters": {
            "type": "object",
            "properties": {"city": {"type": "string"}},
            "required": ["city"],
        },
    },
}]

messages = [{"role": "user", "content": "Is it warm in Lisbon right now?"}]
first = client.chat.completions.create(
    model="uncensored", messages=messages, tools=tools, tool_choice="auto"
)
msg = first.choices[0].message

if msg.tool_calls:
    messages.append(msg)
    for call in msg.tool_calls:
        args = json.loads(call.function.arguments)
        messages.append({
            "role": "tool",
            "tool_call_id": call.id,
            "content": json.dumps(get_weather(**args)),
        })
    final = client.chat.completions.create(
        model="uncensored", messages=messages, tools=tools
    )
    print(final.choices[0].message.content)
else:
    print(msg.content)

De functie hier retourneert vaste data, dus vervang dit door een echte lookup. Tool arguments komen aan als een JSON-string, dus parse ze altijd en valideer de waarden voordat je actie onderneemt. Met stream: true komen de tool_calls in stukken aan die je assembleert voordat je parseert. Gebruik tool_choice om een specifieke tool af te dwingen als je dat nodig hebt.

Wat de voorbeelden kosten, en fouten die een uur kosten

Voorbeelden uitvoeren kost zeer weinig, maar het helpt om de rekenkunde een keer te zien. Bij $0,15 per 1M input tokens en $0,50 per 1M output tokens:

  • De gesprekslus, met een prompt van 1.200 tokens en een antwoord van 300 tokens: $0,00018 voor input plus $0,00015 voor output is $0,00033. Duizend beurten kosten $0,33.
  • De tool round trip maakt twee calls. Als de eerste 400 tokens in en 60 out gebruikt, en de tweede 500 in en 150 out, zijn de totalen 900 in en 210 out: $0,000135 plus $0,000105 is $0,00024.
  • Streaming kost hetzelfde als een normale call met dezelfde token counts. Het verandert wanneer je de tekst ziet, niet wat het kost.

De trial credit van $0,50 zou meer dan 1.500 beurten van de conversation loop kunnen betalen bij die grootte ($0,50 / $0,00033), dus je kunt vrij experimenteren voordat je tegoed oplaadt. Gefaalde en geweigerde requests worden niet in rekening gebracht, wat betekent dat een bug in je parsing die je laat een call opnieuw uitvoert, je niet kost voor de gefaalde pogingen.

  • Een verkeerde base URL. Deze moet eindigen in /v1. Het zelf toevoegen van /chat/completions aan een SDK base URL geeft een 404 omdat de SDK het pad toevoegt.
  • Een andere modelnaam. Namen gekopieerd van andere platforms bestaan hier niet. De ID is uncensored.
  • Geheugen verwachten. De API onthoudt eerdere calls niet. Stuur de history elke keer.
  • De JSON van het model parseren zonder controle. Wrap json.loads in een try-blok en heb een plan voor een slecht antwoord.
  • Streams open laten lopen. Een onafgemaakte stream houdt een concurrency slot bezet, en een trial key heeft er maar twee.
  • De sleutel in front-end code plaatsen. Houd deze op een server.

Als er nog steeds iets vreemd lijkt, stuur dan een verzoek met curl en vergelijk het met wat je code produceert. De curl-vorm haalt de SDK uit de vergelijking en maakt verschillen in de body duidelijk.

Gebruik, saldo en fouten lezen

Om headers van de Python SDK te zien, gebruik je de raw response wrapper:

raw = client.chat.completions.with_raw_response.create(
    model="uncensored",
    messages=[{"role": "user", "content": "Say ok."}],
)
print("request id:", raw.headers.get("x-request-id"))
print("balance usd:", raw.headers.get("x-balance-usd"))
print("rpm limit:", raw.headers.get("x-ratelimit-limit-requests"))
completion = raw.parse()
print(completion.usage.total_tokens)

Log de request ID bij elke call zodat je later naar een specifiek verzoek kunt verwijzen. Gebruik de balance header om een alert te genereren voordat het tegoed op is.

Wanneer je een limiet overschrijdt, retourneert de API HTTP 429 en de error code vertelt je welke het is:

Code of headerWat te doenWat te doen
rate_limitedTe veel verzoeken per minuut (300 op een volledige key, 60 op trial)Back off en spreid je calls uit
concurrencyTe veel in één keer (8 op een volledige key, 2 op trial)Wacht tot een lopend verzoek klaar is
Retry-After: 5Tijdelijke overbelastingProbeer het opnieuw na vijf seconden

Mislukte of geweigerde verzoeken worden niet in rekening gebracht. De request body kan maximaal 8 MB zijn. Voor de complete referentie en hoe je bestaande client code kunt hergebruiken, zie de docs. Voor een walkthrough over het verkrijgen van een key, zie het GLM API key artikel.

Vragen en antwoorden

Welke base URL gebruiken de voorbeelden?

Elk voorbeeld gebruikt https://api.glmapikey.com/v1 met de model ID uncensored en een bearer token. Elke OpenAI SDK werkt zodra je die waarden aanpast.

Ondersteunt de API streaming?

Ja. Stel stream in op true en lees server-sent events. Gebruik wordt gerapporteerd aan het einde van de stream.

Hoe krijg ik geldige JSON terug?

Geef response_format met type json_object en beschrijf de gewenste structuur in de prompt. Parse het resultaat in je code en controleer de velden die je nodig hebt.

Kan ik function calling gebruiken?

Ja. Geef tools en tool_choice door, voer de functie uit die het model vraagt, en retourneer het resultaat als een bericht met role tool.

Waar kan ik mijn resterende tegoed zien?

Elk antwoord bevat een X-Balance-USD-header met je resterende saldo, en het gebruiksblok geeft de tokenaantallen weer.

Je sleutel is nog maar één formulier verwijderd

Maak een account aan, kopieer de sleutel, pas de base URL aan. Dat is de hele setup.

API-sleutel aanvragen