Escolha o padrão de integração primeiro
A maioria das integrações com a API GLM se enquadra em um de quatro formatos, e a escolha afeta tudo o mais: onde as chaves ficam, como lidar com picos e como uma falha aparece para o usuário.
| Padrão | Bom para | Risco principal |
|---|---|---|
| Proxy de backend | Apps web e mobile com seus próprios usuários | Endpoint aberto que qualquer pessoa pode esvaziar |
| Worker de fila | Bots, jobs em lote, processamento em massa de texto | Acúmulo quando as requisições superam os limites |
| Bot de chat | Personagens e companheiros no Discord, Telegram ou Matrix | Históricos longos inflando o custo |
| Ferramenta de automação | Fluxos de trabalho em ferramentas que oferecem um nó HTTP ou OpenAI | Falhas silenciosas quando um passo falha |
As quatro usam a mesma chamada por baixo: POST /v1/chat/completions em https://api.glmapikey.com/v1 com uma chave Bearer e o modelo uncensored. A API é compatível com OpenAI, então você pode usar qualquer SDK OpenAI, ou HTTP puro se sua stack não tiver SDK. É um único modelo de pesos abertos rodado por um provedor independente, não a API oficial de nenhum fornecedor e não um roteador, então construa para o comportamento de um modelo. Apenas texto: se seu produto também precisar de imagens ou embeddings, planeje um segundo provedor para essas partes.
A página de documentação lista endpoints e cabeçalhos, e o artigo sobre a chave GLM explica como obter uma chave.
Proxy de backend: mantenha a chave fora do cliente
Qualquer coisa que rode no navegador ou em um bundle de app pode ser inspecionada. Se a chave estiver lá, qualquer um pode copiá-la e gastar seu crédito. A solução é uma rota de servidor fina que segura a chave, aplica suas regras e encaminha a requisição.
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")
A rota truncará o prompt e limitará a resposta, que é o mínimo. Adicione controles reais antes do lançamento: autenticação de usuário, orçamento diário de tokens por usuário e um limite de taxa de requisições por IP ou conta. A API retorna uso em cada chamada, então você pode contar tokens por usuário no seu banco de dados e recusar requisições que excedam sua cota.
Streaming através de um proxy precisa de uma verificação: confirme que seu proxy reverso não faz buffer nas respostas, ou o texto chegará em um bloco só no final em vez de palavra por palavra.
Worker de fila: respeite o limite de concorrência
Os limites são por chave. Uma chave completa permite 8 requisições simultâneas e 300 requisições por minuto. Uma chave de teste permite 2 e 60. Para um fluxo contínuo de tarefas, a concorrência geralmente é o limite que aparece primeiro, porque cada requisição ocupa uma vaga até ser concluída, e uma em streaming até o fim do fluxo.
Um pool de workers dimensionado para o limite é a solução mais limpa. As tarefas aguardam na sua fila em vez de falhar com 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
O código de erro no corpo 429 diz por que você foi interrompido: rate_limited para requisições por minuto, concurrency para muitos ao mesmo tempo, e um 429 simples com Retry-After: 5 para uma sobrecarga curta. Honrar o cabeçalho é mais simples que adivinhar um atraso. Requisições falhas e recusadas não são cobradas, então as retentativas não custam nada.
Bots e personagens
Um chat bot é o lugar usual onde surpresas de custo aparecem, porque um bot que mantém o histórico reenvia ele em cada mensagem. Decida cedo quantas mensagens de histórico manter e armazene o histórico você mesmo, já que a API não guarda estado entre chamadas.
Um exemplo de orçamento ilustra o ponto. Suponha um bot com 500 usuários ativos que enviam 20 mensagens por dia. Cada mensagem carrega 1.500 tokens de entrada (persona, um histórico curto e a nova linha) e retorna 250 tokens:
- Por mensagem: 1.500 / 1.000.000 x $0,15 = $0,000225 de entrada, mais 250 / 1.000.000 x $0,50 = $0,000125 de saída, totalizando $0,00035
- Por dia: 500 x 20 = 10.000 mensagens, então $3,50
- Por 30 dias: $105
Se você deixar o histórico crescer até preencher uma janela de contexto de 12.000 tokens, a entrada por mensagem aumenta oito vezes para 12.000 tokens, ou $0,0018 apenas para a entrada, e o valor mensal sobe conforme o uso. Uma janela móvel com um resumo curto dos eventos mais antigos mantém a persona consistente a um custo menor.
Para bots de companheiro e roleplay, mantenha as regras do produto na sua própria camada. O modelo é ajustado para responder sem recusas de conteúdo para uso adulto legal, e o limite rígido é conteúdo sexual envolvendo menores de idade, que o serviço recusa. Se seu bot vive em um servidor público, adicione verificação de idade e regras de canal que correspondam à plataforma onde você o executa.
Ferramentas de automação e fluxos de trabalho no-code
Ferramentas de fluxo de trabalho que oferecem um nó estilo OpenAI com URL base configurável podem usar esta API alterando três campos: a URL para https://api.glmapikey.com/v1, a chave e o nome do modelo para uncensored. Ferramentas que só têm um nó de requisição HTTP genérica podem enviar a requisição bruta:
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"}}'
Para etapas de fluxo que alimentam outra etapa, o modo JSON vale a pena, assim o próximo nó recebe texto analisável. Adicione um ramo de erro para qualquer etapa que chama a API, porque respostas 429 e 5xx vão ocorrer ocasionalmente e uma falha silenciosa no meio de um fluxo é difícil de encontrar depois. Configure uma retentativa com uma espera curta nesse nó, e certifique-se de que os ramos paralelos não excedam o número de requisições simultâneas que sua chave permite.
O que seus usuários veem quando algo falha
Toda integração precisa de um plano para o caminho de erro, e a parte visível ao usuário é tão importante quanto o código de retentativa. Três situações aparecem na prática.
A primeira é uma sobrecarga curta: um 429 com Retry-After: 5. Retente silenciosamente e mostre um indicador de digitação enquanto isso, para que o usuário veja uma resposta um pouco mais lenta em vez de um erro. A segunda é atingir o limite do seu próprio pool. Se todas as oito vagas estiverem ocupadas, coloque a mensagem na fila e informe ao usuário que está aguardando, o que é melhor do que uma tela em branco. A terceira é ficar sem crédito, o que nenhuma retentativa resolve. Observe o cabeçalho do saldo, configure alertas para um limite e mantenha uma mensagem de fallback pronta para o dia em que acabar sem você perceber.
Não mostre erros brutos da API para usuários finais. Registre-os com o ID da requisição e mostre uma frase simples que diga o que aconteceu e o que fazer a seguir. Nunca inclua a chave, a URL base ou rastros de execução no que um usuário pode ler.
Dinheiro, monitoramento e verificações de lançamento
O faturamento é pré-pago. Você recarrega qualquer valor inteiro de $20 a $500, com +5% de $50, +10% de $100 e +15% de $200. O crédito não expira e não há assinatura. Pague com cripto (USDT no TRC20, USDC na Base). Novos usuários podem reivindicar $0,50 de crédito de teste com um clique na página de chave de API, válido por 7 dias, para que você possa testar uma integração antes de financiá-la. Veja a página de preços para as taxas.
O que monitorar em produção:
- Saldo. Leia
X-Balance-USDnas respostas e configure um alerta quando ele cair abaixo de um limite que você escolher. - IDs de requisição. Armazene
X-Request-Idjunto a cada tarefa para que uma falha possa ser rastreada. - Uso de tokens. Some
usagepor usuário e por recurso para ver para onde o dinheiro vai. - Taxa 429. Uma contagem crescente significa que seu pool é maior que os limites da chave.
Uma lista curta de lançamento: execute uma requisição real do host de produção, teste um 429 forçado no ambiente de staging, confirme que um usuário não consegue acessar a API sem sua autenticação e anote o que seu serviço mostra quando a API fica indisponível. Os prompts não são usados para treinamento, o que você pode comunicar aos seus usuários, mas inclua em sua própria política de privacidade que o texto deles é enviado a um provedor de terceiros para gerar as respostas.
