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éma | Convient pour | Risque principal |
|---|---|---|
| Proxy backend | Applications web et mobiles avec leurs propres utilisateurs | Endpoint ouvert que n’importe qui peut vider |
| Worker de file d’attente | Bots, tâches par lots, traitement de texte en vrac | File d’attente lorsque les requêtes dépassent les limites |
| Bot de chat | Personnages et compagnons Discord, Telegram ou Matrix | Historiques longs gonflant le coût |
| Outil d’automatisation | Workflows 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-USDdans 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
usagepar 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.
