FR ▾
Obtenir une clé API

Guide d’intégration de l’API GLM pour bots et backends

Une intégration de l’API GLM se résume à l’endroit où réside la clé, au nombre de requêtes que vous autorisez à s’exécuter simultanément et à ce qui se passe lorsque l’API demande d’attendre. Ce guide couvre ces décisions pour les backends, les bots et les outils de workflow, avec du code adaptable.

Mis à jour le

Cube passerelle recevant des éléments depuis l’application, le chat et les blocs d’automatisation, représentant l’intégration API

Points clés

  • Conservez la clé sur un serveur que vous contrôlez et laissez les applications appeler votre backend, jamais l’API directement depuis un navigateur.
  • Limitez les requêtes en vol à la limite de la clé : 8 pour une clé complète, 2 pour une clé d’essai.
  • Planifiez le budget en tokens : à $0,15 et $0,50 par 1M, un message de bot typique coûte une fraction de centime.
  • Tout outil avec une option compatible OpenAI et un champ URL de base personnalisée peut utiliser https://api.glmapikey.com/v1.

Choisissez d’abord le schéma d’intégration

La plupart des intégrations de l’API GLM rentrent dans l’une des quatre formes, et ce choix affecte tout le reste : où résident les secrets, comment vous gérez les pics et à quoi ressemble une erreur pour l’utilisateur.

SchémaConvient pourRisque principal
Proxy backendApplications web et mobiles avec leurs propres utilisateursEndpoint ouvert que n’importe qui peut vider
Worker de file d’attenteBots, tâches par lots, traitement de texte en vracFile d’attente lorsque les requêtes dépassent les limites
Bot de chatPersonnages et compagnons Discord, Telegram ou MatrixHistoriques longs gonflant le coût
Outil d’automatisationWorkflows dans des outils offrant un nœud HTTP ou OpenAIÉchecs silencieux lorsqu’une étape génère une erreur

Les quatre utilisent le même appel en sous-jacent : POST /v1/chat/completions sur https://api.glmapikey.com/v1 avec une clé Bearer et le modèle uncensored. L'API est compatible OpenAI, vous pouvez donc utiliser n'importe quel SDK OpenAI, ou du HTTP brut si votre pile n'a pas de SDK. Il s'agit d'un modèle à poids ouverts géré par un fournisseur indépendant, et non de l'API officielle d'un fournisseur ni d'un routeur, donc concevez pour le comportement d'un seul modèle. Texte uniquement : si votre produit a aussi besoin d'images ou d'embeddings, prévoyez un deuxième fournisseur pour ces parties.

La page de documentation liste les endpoints et les en-têtes, et l’article sur la clé GLM explique comment obtenir une clé.

Proxy backend : gardez la clé hors du client

Tout ce qui s’exécute dans un navigateur ou un bundle d’application peut être inspecté. Si la clé y est livrée, n’importe qui peut la copier et dépenser votre crédit. La solution est une route serveur mince qui détient la clé, applique vos propres règles et transmet la requête.

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

La route tronque le prompt et limite la réponse, ce qui est le minimum. Ajoutez de vrais contrôles avant le lancement : authentification des utilisateurs, un quota quotidien de tokens par utilisateur et une limite de débit de requêtes par IP ou par compte. L'API renvoie l'utilisation à chaque appel, vous pouvez donc compter les tokens par utilisateur dans votre base de données et refuser les requêtes qui dépassent leur part.

Le streaming via un proxy nécessite une vérification : confirmez que votre proxy inverse ne met pas en buffer les réponses, sinon le texte arrivera en un seul bloc à la fin au lieu de mot par mot.

Worker de file d’attente : respectez la limite de concurrence

Les limites sont par clé. Une clé complète permet 8 requêtes simultanées et 300 requêtes par minute. Une clé d'essai permet 2 et 60. Pour un flux régulier de tâches, la concurrence est généralement le facteur limitant, car chaque requête occupe un créneau jusqu'à son achèvement, et une requête en streaming jusqu'à la fin du streaming.

Un pool de workers dimensionné à la limite est la réponse propre. Les tâches attendent dans votre file d’attente au lieu d’échouer avec 429 :

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

Le code d'erreur dans le corps 429 vous indique pourquoi vous avez été bloqué : rate_limited pour les requêtes par minute, concurrency pour trop de requêtes à la fois, et un 429 simple avec Retry-After: 5 pour une surcharge brève. Respecter l'en-tête est plus simple que d'estimer un délai. Les requêtes échouées et refusées ne sont pas facturées, donc les réessais ne coûtent rien.

Bots et personnages

Un bot de chat est l’endroit habituel où les surprises de coût apparaissent, car un bot qui conserve l’historique le renvoie à chaque message. Décidez tôt combien de messages d’historique conserver, et stockez l’historique vous-même, car l’API ne conserve aucun état entre les appels.

Un exemple de budget illustre le propos. Supposons un bot avec 500 utilisateurs actifs qui envoient chacun 20 messages par jour. Chaque message transporte 1 500 tokens d’entrée (persona, un court historique et la nouvelle ligne) et renvoie 250 tokens :

  • Par message : 1 500 / 1 000 000 x $0,15 = $0,000225 entrée, plus 250 / 1 000 000 x $0,50 = $0,000125 sortie, soit $0,00035
  • Par jour : 500 x 20 = 10 000 messages, soit $3,50
  • Par 30 jours : $105

Si vous laissez l’historique grandir jusqu’à remplir une fenêtre de contexte de 12 000 tokens, l’entrée par message augmente huit fois à 12 000 tokens, soit $0,0018 pour l’entrée seule, et le montant mensuel augmente en conséquence. Une fenêtre glissante plus un résumé court des événements anciens garde la persona cohérente à un prix inférieur.

Pour les bots de compagnon et de jeu de rôle, gardez les règles du produit dans votre propre couche. Le modèle est ajusté pour répondre sans refus de contenu pour un usage adulte légal, et la limite stricte est le contenu sexuel impliquant des mineurs, que le service refuse. Si votre bot vit sur un serveur public, ajoutez un filtrage d’âge et des règles de canal correspondant à la plateforme sur laquelle vous le faites tourner.

Outils d’automatisation et workflows no-code

Les outils de workflow offrant un nœud de style OpenAI avec une URL de base configurable peuvent utiliser cette API en changeant trois champs : l’URL vers https://api.glmapikey.com/v1, la clé et le nom du modèle vers uncensored. Les outils qui n’ont qu’un nœud de requête HTTP générique peuvent envoyer la requête brute à la place :

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

Pour les étapes de workflow qui alimentent une autre étape, le mode JSON vaut la peine d’être utilisé, afin que le nœud suivant reçoive du texte analysable. Ajoutez une branche d’erreur pour toute étape qui appelle l’API, car les réponses 429 et 5xx se produiront occasionnellement et un échec silencieux au milieu d’un workflow est difficile à trouver plus tard. Définissez une tentative avec un court délai d’attente sur ce nœud, et assurez-vous que les branches parallèles ne dépassent pas le nombre de requêtes simultanées que votre clé permet.

Ce que vos utilisateurs voient lorsqu’une erreur survient

Toute intégration a besoin d’un plan pour le chemin du malheur, et la partie visible par l’utilisateur est aussi importante que le code de tentative. Trois situations se présentent en pratique.

La première est une surcharge courte : un 429 avec Retry-After: 5. Réessayez discrètement, et affichez un indicateur de frappe en attendant, afin que l’utilisateur voie une réponse légèrement plus lente au lieu d’une erreur. La deuxième est le dépassement de votre limite de pool. Si tous les huit slots sont occupés, mettez le message en file d’attente et dites à l’utilisateur qu’il attend, ce qui est mieux qu’un écran vide. La troisième est la fin du crédit, ce qu’aucune tentative ne répare. Surveillez l’en-tête de solde, alertez-vous à un seuil, et gardez un message de secours prêt pour le jour où il s’épuise sans être remarqué.

Ne montrez pas les erreurs API brutes aux utilisateurs finaux. Enregistrez-les avec l’ID de requête, et affichez une phrase simple qui dit ce qui s’est passé et quoi faire ensuite. N’incluez jamais la clé, l’URL de base ou les traces de pile dans quoi que ce soit qu’un utilisateur peut lire.

Argent, surveillance et vérifications de lancement

La facturation est prépayée. Vous rechargez n’importe quel montant entier de $20 à $500, avec +5% à partir de $50, +10% à partir de $100 et +15% à partir de $200. Le crédit n’expire jamais, et il n’y a pas d’abonnement. Payez par crypto (USDT sur TRC20, USDC sur Base). Les nouveaux utilisateurs peuvent réclamer $0,50 de crédit d’essai en un clic sur la page de clé API, valable 7 jours, afin que vous puissiez tester une intégration avant de la financer. Voir la page de tarification pour les tarifs.

Ce qu’il faut surveiller en production :

  • Solde. Lisez l’en-tête X-Balance-USD dans les réponses et alertez quand il passe sous un seuil que vous choisissez.
  • IDs de requête. Stockez l’ID de requête X-Request-Id à côté de chaque tâche pour pouvoir tracer une défaillance.
  • Consommation de tokens. Additionnez l’usage de usage par utilisateur et par fonctionnalité pour voir où va l’argent.
  • Taux 429. Une augmentation du nombre d’erreurs signifie que votre pool est plus grand que les limites de la clé.

Une courte liste de lancement : envoyez une vraie requête depuis l’hôte de production, testez une erreur 429 forcée en environnement de staging, confirmez qu’un utilisateur ne peut pas atteindre l’API sans votre authentification, et notez ce que votre service affiche quand l’API est injoignable. Les prompts ne sont pas utilisés pour l’entraînement, ce que vous pouvez indiquer à vos propres utilisateurs, mais précisez dans votre politique de confidentialité que leur texte est envoyé à un fournisseur tiers pour générer des réponses.

Questions et réponses

Dois-je appeler l’API depuis le navigateur ?

Non. Gardez la clé sur votre serveur et faites en sorte que le navigateur appelle votre backend, car une clé dans le code client peut être copiée et son crédit dépensé par n’importe qui.

Combien de requêtes peuvent s’exécuter simultanément ?

Une clé complète permet 8 requêtes simultanées et 300 par minute. Une clé d’essai permet 2 requêtes simultanées et 60 par minute.

Que doit faire mon code en cas d’erreur 429 ?

Lisez le code d'erreur, puis attendez. Utilisez la valeur Retry-After lorsqu'elle est présente, qui est de 5 secondes en cas de surcharge temporaire, puis réessayez. Les requêtes échouées ne sont pas facturées.

L’état est-il conservé entre les appels ?

Non. Vous envoyez toute la conversation à chaque fois, jusqu’à 100 000 tokens pour le prompt et la réponse combinés, et vous payez pour les tokens d’entrée à chaque appel.

Puis-je l’utiliser avec des outils no-code ?

Oui, si l’outil vous permet de définir une URL de base sur son nœud OpenAI ou d’envoyer une requête HTTP personnalisée à https://api.glmapikey.com/v1/chat/completions avec une clé bearer.

Votre clé n'est qu'à un formulaire d'ici

Créez un compte, copiez la clé, modifiez l'URL de base. C'est toute la configuration.

Obtenir une clé API