DE ▾
API-Schlüssel erhalten

GLM-API-Integrationshandbuch für Bots und Backends

Eine GLM-API-Integration dreht sich darum, wo der Schlüssel liegt, wie viele Anfragen du gleichzeitig laufen lässt und was passiert, wenn die API dich warten lässt. Dieser Leitfaden behandelt diese Entscheidungen für Backends, Bots und Workflow-Tools mit anpassbarem Code.

Aktualisiert

Gateway-Würfel, der Elemente von App-, Chat- und Automatisierungsblöcken empfängt, repräsentiert die API-Integration

Wichtige Punkte

  • Halte den Schlüssel auf einem Server, den du kontrollierst, und lass Apps dein Backend aufrufen, niemals die API direkt aus einem Browser.
  • Begrenze die laufenden Anfragen auf das Limit des Schlüssels: 8 für einen vollen Schlüssel, 2 für einen Test-Schlüssel.
  • Plane dein Budget basierend auf Token: bei $0,15 und $0,50 pro 1M Token kostet eine typische Bot-Nachricht nur einen Bruchteil eines Cents.
  • Jedes Tool mit einer OpenAI-kompatiblen Option und einem Feld für die Basis-URL kann https://api.glmapikey.com/v1 nutzen.

Wähle zuerst das Integrationsmuster

Die meisten GLM-API-Integrationen fallen in eine von vier Formen, und die Wahl beeinflusst alles Weitere: wo Geheimnisse liegen, wie du Lastspitzen behandelst und wie ein Fehler für den Benutzer aussieht.

MusterGut fürHauptrisiko
Backend-ProxyWeb-Apps und Mobile-Apps mit eigenen BenutzernOffener Endpunkt, den jeder leeren kann
Queue-WorkerBots, Stapeljobs, MassentextverarbeitungStau, wenn Anfragen die Limits übertreffen
Chat-BotDiscord-, Telegram- oder Matrix-Charaktere und BegleiterLange Verläufe, die die Kosten in die Höhe treiben
AutomatisierungstoolWorkflows in Tools, die einen HTTP- oder OpenAI-Knoten anbietenStille Fehler, wenn ein Schritt fehlschlägt

Alle vier nutzen denselben Aufruf darunter: POST /v1/chat/completions auf https://api.glmapikey.com/v1 mit einem Bearer-Schlüssel und dem Modell uncensored. Die API ist OpenAI-kompatibel, sodass du jedes OpenAI-SDK oder rohes HTTP verwenden kannst, falls dein Stack kein SDK hat. Es ist ein Open-Weight-Modell, das von einem unabhängigen Anbieter betrieben wird, nicht die offizielle API eines Herstellers und kein Router, also baue für das Verhalten eines Modells. Nur Text: Wenn dein Produkt auch Bilder oder Embeddings benötigt, plane einen zweiten Anbieter für diese Teile.

Die Dokumentationsseite listet Endpunkte und Header auf, und der GLM-Schlüssel-Artikel erklärt, wie du einen Schlüssel erhältst.

Backend-Proxy: Halte den Schlüssel vom Client fern

Alles, was in einem Browser oder App-Bundle läuft, kann inspiziert werden. Wenn der Schlüssel dort ausgeliefert wird, kann ihn jeder kopieren und dein Guthaben ausgeben. Die Lösung ist eine dünne Serverroute, die den Schlüssel hält, deine eigenen Regeln anwendet und die Anfrage weiterleitet.

from fastapi import FastAPI
from fastapi.responses import StreamingResponse
from openai import AsyncOpenAI
from pydantic import BaseModel

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

class Ask(BaseModel):
    prompt: str

@app.post("/ask")
async def ask(body: Ask):
    async def gen():
        stream = await client.chat.completions.create(
            model="uncensored",
            messages=[{"role": "user", "content": body.prompt[:4000]}],
            max_tokens=600,
            stream=True,
        )
        async for chunk in stream:
            if chunk.choices and chunk.choices[0].delta.content:
                yield chunk.choices[0].delta.content
    return StreamingResponse(gen(), media_type="text/plain")

Die Route kürzt den Prompt und begrenzt die Antwort, was das Minimum ist. Füge vor dem Launch echte Kontrollen hinzu: Benutzerauthentifizierung, ein tägliches Token-Budget pro Benutzer und ein Limit der Anfragerate pro IP oder Konto. Die API gibt die Nutzung bei jedem Aufruf zurück, sodass du Tokens pro Benutzer in deiner Datenbank zählen und Anfragen ablehnen kannst, die ihren Anteil überschreiten.

Streaming durch einen Proxy erfordert eine Prüfung: Stelle sicher, dass dein Reverse-Proxy keine Antworten puffert, sonst kommt der Text am Ende als Block anstatt Wort für Wort an.

Queue-Worker: Respektiere das Parallelitätslimit

Die Limits gelten pro Schlüssel. Ein voller Schlüssel erlaubt 8 parallele Anfragen und 300 Anfragen pro Minute. Ein Test-Schlüssel erlaubt 2 und 60. Für einen gleichmäßigen Job-Strom ist die Parallelität meist der Engpass, da jede Anfrage einen Slot belegt, bis sie abgeschlossen ist, und eine gestreamte, bis der Stream endet.

Ein Worker-Pool, der auf das Limit skaliert ist, ist die saubere Lösung. Jobs warten in deiner Warteschlange, anstatt mit 429 zu scheitern:

import asyncio
from openai import AsyncOpenAI, RateLimitError

client = AsyncOpenAI(
    base_url="https://api.glmapikey.com/v1",
    api_key="YOUR_KEY",
    max_retries=0,
)
WORKERS = 8  # use 2 on a trial key

async def run_job(prompt: str) -> str:
    for attempt in range(5):
        try:
            r = await client.chat.completions.create(
                model="uncensored",
                messages=[{"role": "user", "content": prompt}],
                max_tokens=500,
            )
            return r.choices[0].message.content
        except RateLimitError as e:
            delay = float(e.response.headers.get("retry-after", 2 * (attempt + 1)))
            await asyncio.sleep(delay)
    raise RuntimeError("gave up after repeated 429 responses")

async def worker(queue: asyncio.Queue, results: list):
    while True:
        prompt = await queue.get()
        try:
            results.append(await run_job(prompt))
        finally:
            queue.task_done()

async def main(prompts):
    queue, results = asyncio.Queue(), []
    for p in prompts:
        queue.put_nowait(p)
    tasks = [asyncio.create_task(worker(queue, results)) for _ in range(WORKERS)]
    await queue.join()
    for t in tasks:
        t.cancel()
    return results

Der Fehlercode im 429-Body sagt dir, warum du gestoppt wurdest: rate_limited für Anfragen pro Minute, concurrency für zu viele gleichzeitig und ein normales 429 mit Retry-After: 5 für eine kurze Überlastung. Die Header zu beachten ist einfacher, als eine Verzögerung zu erraten. Fehlgeschlagene und abgelehnte Anfragen werden nicht berechnet, also kosten Wiederholungen nichts.

Bots und Charaktere

Ein Chat-Bot ist der übliche Ort, an dem Kostenüberraschungen auftreten, weil ein Bot, der die Historie behält, sie bei jeder Nachricht erneut sendet. Entscheide früh, wie viele Nachrichten der Historie du behalten willst, und speichere die Historie selbst, da die API zwischen Aufrufen keinen Zustand speichert.

Ein Budget-Beispiel verdeutlicht den Punkt. Angenommen, ein Bot hat 500 aktive Nutzer, die jeweils 20 Nachrichten pro Tag senden. Jede Nachricht enthält 1.500 Input-Token (Persona, eine kurze Historie und die neue Zeile) und gibt 250 Token zurück:

  • Pro Nachricht: 1.500 / 1.000.000 x $0,15 = $0,000225 rein, plus 250 / 1.000.000 x $0,50 = $0,000125 raus, also $0,00035
  • Pro Tag: 500 x 20 = 10.000 Nachrichten, also $3,50
  • Pro 30 Tage: $105

Wenn du die Historie wachsen lässt, bis sie ein 12.000-Token-Kontextfenster füllt, steigen die Input-Token pro Nachricht achtfach auf 12.000 Token, oder $0,0018 nur für den Input, und der monatliche Betrag steigt entsprechend. Ein Rolling Window plus eine kurze Zusammenfassung älterer Ereignisse hält die Persona konsistent zu einem niedrigeren Preis.

Für Companion- und Roleplay-Bots halte die Produktregeln in deiner eigenen Schicht. Das Modell ist darauf trainiert, ohne Inhaltsablehnungen für legale Erwachsenennutzung zu antworten, und die eine harte Grenze ist sexueller Inhalt mit Minderjährigen, den der Dienst ablehnt. Wenn dein Bot auf einem öffentlichen Server lebt, füge Altersprüfungen und Kanalregeln hinzu, die zur Plattform passen, auf der du ihn betreibst.

Automatisierungstools und No-Code-Workflows

Workflow-Tools, die einen OpenAI-ähnlichen Knoten mit konfigurierbarer Basis-URL anbieten, können diese API nutzen, indem sie drei Felder ändern: die URL zu https://api.glmapikey.com/v1, den Schlüssel und den Modellnamen zu uncensored. Tools, die nur einen generischen HTTP-Anfrage-Knoten haben, können die Rohanfrage stattdessen senden:

curl https://api.glmapikey.com/v1/chat/completions \
  -H "Authorization: Bearer $API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model": "uncensored", "messages": [{"role": "user", "content": "Classify this ticket: printer offline"}], "response_format": {"type": "json_object"}}'

Für Workflow-Schritte, die einen anderen Schritt speisen, ist der JSON-Modus empfehlenswert, damit der nächste Knoten parsebaren Text erhält. Füge einen Fehlerzweig für jeden Schritt hinzu, der die API aufruft, da 429- und 5xx-Antworten gelegentlich auftreten und ein stiller Fehler in der Mitte eines Workflows später schwer zu finden ist. Lege eine Wiederholung mit kurzer Wartezeit für diesen Knoten fest und stelle sicher, dass parallele Zweige die Anzahl der parallelen Anfragen, die dein Schlüssel erlaubt, nicht überschreiten.

Was deine Nutzer sehen, wenn etwas fehlschlägt

Jede Integration braucht einen Plan für den unangenehmen Pfad, und der benutzersichtbare Teil ist genauso wichtig wie der Wiederholungscode. Drei Situationen treten in der Praxis auf.

Die erste ist eine kurze Überlastung: ein 429 mit Retry-After: 5. Wiederhole leise und zeige in der Zwischenzeit einen Tippindikator, damit der Nutzer eine etwas langsamere Antwort statt eines Fehlers sieht. Die zweite ist das Erreichen des eigenen Pool-Limits. Wenn alle acht Slots belegt sind, stelle die Nachricht in die Warteschlange und sage dem Nutzer, dass sie wartet, was besser ist als ein leerer Bildschirm. Die dritte ist das Auslaufen des Guthabens, was keine Wiederholung behebt. Überwache den Balance-Header, warne dich selbst bei einem Schwellenwert und halte eine Ersatznachricht bereit für den Tag, an dem sie unbemerkt ausgeht.

Zeige keine rohen API-Fehler an Endnutzer. Logge sie mit der Request-ID und zeige einen einfachen Satz, der sagt, was passiert ist und was als Nächstes zu tun ist. Nimm niemals den Schlüssel, die Basis-URL oder Stack-Traces in etwas auf, was ein Nutzer lesen kann.

Geld, Überwachung und Launch-Checks

Die Abrechnung ist Prepaid. Du lädst jeden beliebigen Betrag von $20 bis $500 auf, mit +5% ab $50, +10% ab $100 und +15% ab $200. Guthaben verfällt nie, und es gibt kein Abonnement. Bezahle mit Krypto (USDT auf TRC20, USDC auf Base). Neue Nutzer können $0,50 Testguthaben mit einem Klick auf der API-Schlüssel-Seite beanspruchen, gültig für 7 Tage, damit du eine Integration testen kannst, bevor du sie finanzierst. Sieh dir die Preisseite für die Sätze an.

Was du in der Produktion überwachen solltest:

  • Balance. Lies X-Balance-USD aus Antworten aus und warne, wenn sie unter einen von dir gewählten Schwellenwert fällt.
  • Anfrage-IDs. Speichere X-Request-Id neben jedem Job, damit ein einzelner Fehler nachverfolgt werden kann.
  • Token-Nutzung. Summiere usage pro Benutzer und pro Feature, um zu sehen, wohin das Geld fließt.
  • 429-Raten. Eine steigende Anzahl bedeutet, dass dein Pool größer ist als die Limits des Schlüssels.

Eine kurze Checkliste zum Start: Führe eine echte Anfrage vom Produktions-Host aus, teste einen erzwungenen 429-Fehler in der Staging-Umgebung, stelle sicher, dass ein Benutzer die API ohne deine Authentifizierung nicht erreichen kann, und notiere, was deine Anwendung anzeigt, wenn die API nicht erreichbar ist. Prompts werden nicht zum Training verwendet, was du an deine eigenen Benutzer weitergeben kannst, aber erwähne in deiner eigenen Datenschutzerklärung, dass ihr Text an einen Drittanbieter gesendet wird, um Antworten zu generieren.

Fragen und Antworten

Sollte ich die API aus dem Browser heraus aufrufen?

Nein. Halte den Schlüssel auf deinem Server und lass den Browser deine Backend-API aufrufen, da ein Schlüssel im Client-Code kopiert und sein Guthaben von jedem ausgegeben werden kann.

Wie viele Anfragen können gleichzeitig ausgeführt werden?

Ein vollständiger Schlüssel erlaubt 8 gleichzeitige Anfragen und 300 pro Minute. Ein Test-Schlüssel erlaubt 2 gleichzeitige und 60 pro Minute.

Was sollte mein Code bei einem 429-Fehler tun?

Lies den Fehlercode und warte dann. Verwende den Retry-After-Wert, wenn er vorhanden ist, was bei einer temporären Überlastung 5 Sekunden beträgt, und wiederhole die Anfrage. Fehlgeschlagene Anfragen werden nicht berechnet.

Wird der Status zwischen Aufrufen beibehalten?

Nein. Du sendest jedes Mal die gesamte Konversation, bis zu 100.000 Token für Prompt und Antwort zusammen, und du zahlst für die Input-Token bei jedem Aufruf.

Kann ich es von No-Code-Tools aus nutzen?

Ja, wenn das Tool dir erlaubt, eine Base URL auf seinem OpenAI-Knoten zu setzen oder eine benutzerdefinierte HTTP-Anfrage an https://api.glmapikey.com/v1/chat/completions mit einem Bearer-Schlüssel zu senden.

Dein Schlüssel ist nur ein Formular entfernt

Erstelle ein Konto, kopiere den Schlüssel, ändere die Basis-URL. Das ist die gesamte Einrichtung.

API-Schlüssel erhalten