Integração de API de Chatbot: Conecte um Endpoint de Chat ao Seu App
Uma integração de API de chatbot tem uma regra que você não pode pular: o navegador nunca guarda a chave de API. Coloque um pequeno proxy backend no meio, faça streaming das respostas através dele e o resto é desenvolvimento web comum.
Atualizado

Pontos principais
- O navegador fala com o seu servidor; o seu servidor fala com a API de chat com a chave.
- Faça streaming com eventos enviados pelo servidor para que as respostas apareçam palavra por palavra.
- Limite o histórico, defina limites por usuário e gerencie respostas 429 com uma breve espera.
- O endpoint é compatível com OpenAI, então o SDK oficial funciona após uma alteração na URL base.
O padrão em uma imagem
Toda integração de API de chatbot segura se parece por cima. Uma página no navegador envia a mensagem do usuário para seu próprio endpoint. Seu servidor adiciona o prompt do sistema, corta o histórico, anexa a chave de API e encaminha a chamada. A resposta retorna em streaming da mesma forma.
Browser --POST /api/chat--> Your server --POST /v1/chat/completions--> Chat API
Browser <--SSE stream------ Your server <--SSE stream----------------- Chat API
O proxy existe por quatro motivos: ele oculta a chave, permite verificar quem está chamando, permite limitar o custo por usuário e oferece um único local para alterar as configurações do modelo mais tarde. Uma chave colocada no JavaScript front-end é pública no momento em que a página carrega, e outra pessoa gastaria seu crédito pré-pago.
A API segue o formato da OpenAI. A base URL é https://api.uncensoredchatbotapi.com/v1, o modelo é uncensored e a autenticação é Authorization: Bearer YOUR_KEY. Obtenha uma chave na página de chave.
Passo 1: o proxy do servidor
Este servidor Express aceita uma conversa, adiciona um prompt do sistema, chama a API com streaming e retransmite o texto. Instale as dependências com npm i express openai e defina CHAT_API_KEY no ambiente.
import express from "express";
import OpenAI from "openai";
const app = express();
app.use(express.json({ limit: "200kb" }));
app.use(express.static("public"));
const client = new OpenAI({
baseURL: "https://api.uncensoredchatbotapi.com/v1",
apiKey: process.env.CHAT_API_KEY,
});
const SYSTEM = "You are a helpful companion for adults. Keep replies under 150 words.";
app.post("/api/chat", async (req, res) => {
const incoming = Array.isArray(req.body.messages) ? req.body.messages : [];
const clean = incoming
.filter((m) => ["user", "assistant"].includes(m.role) && typeof m.content === "string")
.slice(-20)
.map((m) => ({ role: m.role, content: m.content.slice(0, 4000) }));
res.writeHead(200, { "Content-Type": "text/event-stream", "Cache-Control": "no-cache" });
try {
const stream = await client.chat.completions.create({
model: "uncensored",
messages: [{ role: "system", content: SYSTEM }, ...clean],
stream: true,
});
for await (const part of stream) {
const t = part.choices[0]?.delta?.content;
if (t) res.write(`data: ${JSON.stringify(t)}\n\n`);
}
res.write("data: [DONE]\n\n");
} catch (e) {
res.write(`event: error\ndata: ${JSON.stringify(e.status === 429 ? "busy" : "failed")}\n\n`);
}
res.end();
});
app.listen(3000);
Observe o filtro. O cliente pode enviar qualquer coisa, então o servidor mantém apenas mensagens de user e assistant, trunca cada uma e ignora qualquer mensagem de system que o navegador tente injetar. O prompt do sistema sempre vem do seu código.
Passo 2: o lado do navegador
O navegador lê o stream com fetch e anexa texto conforme ele chega. Nenhuma biblioteca é necessária.
const messages = [];
async function send(text, out) {
messages.push({ role: "user", content: text });
const res = await fetch("/api/chat", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({ messages }),
});
const reader = res.body.getReader();
const dec = new TextDecoder();
let reply = "", buf = "";
while (true) {
const { done, value } = await reader.read();
if (done) break;
buf += dec.decode(value, { stream: true });
const events = buf.split("\n\n");
buf = events.pop();
for (const ev of events) {
if (ev === "data: [DONE]") break;
if (ev.startsWith("data: ")) {
reply += JSON.parse(ev.slice(6));
out.textContent = reply;
}
}
}
messages.push({ role: "assistant", content: reply });
}
O buffer é importante. Os pedaços da rede não se alinham com os limites de eventos, então você divide na linha em branco e mantém a parte inacabada para a próxima leitura. Para um passo a passo da própria página, consulte o tutorial de chat web, e para o panorama mais amplo de adicionar um bot a um site, como implementar um chatbot em um site.
Limites, erros e retentativas
Uma chave completa permite 8 requisições simultâneas e 300 por minuto. Uma chave de teste permite 2 e 60. Uma requisição em streaming ocupa sua vaga até o fim do streaming, então com 8 vagas você pode servir no máximo 8 respostas ao vivo de uma vez. Se seu site tiver mais usuários simultâneos do que isso, enfileire as requisições no seu servidor e responda "aguarde um momento" em vez de falhar.
- 429 com
concurrency: muitas requisições estão em andamento. Faça fila e tente novamente. - 429 com
rate_limited: muitas requisições por minuto. Diminua o ritmo. - 429 com um cabeçalho
Retry-After: 5: sobrecarga temporária. Aguarde 5 segundos e tente novamente. - 401: chave errada ou ausente.
- Corpo acima de 8 MB: rejeitado, então reduza o que você envia.
Adicione um pequeno contador na memória para que seu próprio servidor nunca abra mais de 8 streams upstream:
let active = 0;
const MAX = 8;
app.use("/api/chat", (req, res, next) => {
if (active >= MAX) return res.status(503).json({ error: "busy" });
active++;
res.on("close", () => { active--; });
next();
});
Registre este middleware antes da rota de chat. O evento close é acionado quando a resposta termina ou o usuário sai, então o contador não vaza.
Controle o custo de cada conversa
O preço é $0,15 por 1M tokens de entrada e $0,50 por 1M tokens de saída. Como cada turno reenvia o histórico, o limite no histórico é sua maior alavanca. Com as últimas 20 mensagens em cerca de 60 tokens cada mais um prompt do sistema de 100 tokens, uma solicitação carrega cerca de 1.300 tokens de entrada. Uma resposta de 150 tokens adiciona saída.
Custo por turno: 1.300 / 1.000.000 x $0,15 = $0,000195, mais 150 / 1.000.000 x $0,50 = $0,000075, totalizando $0,00027. Uma sessão de 30 turnos nesse tamanho custa no máximo $0,0081, já que os turnos iniciais são mais curtos. Limites diários por usuário, por exemplo 100 mensagens, limitam seu pior caso para 100 x $0,00027 = $0,027 por usuário por dia. Para mais informações sobre precificação de um bot de site, leia a página sobre custo de chatbot em site e use a documentação para parâmetros como max_tokens.
Quem está chamando seu proxy
O proxy protege a chave, mas também se torna um endpoint de chat gratuito para qualquer um que encontre a URL. Decida quem pode usá-lo antes de lançar.
Para um site público, um cookie de sessão assinado definido no login é a resposta usual. Verifique-o no início da rota e retorne 401 quando estiver ausente. Para um protótipo rápido, um limite por IP com um pacote como express-rate-limit é melhor do que nada, embora redes compartilhadas tornem os limites de IP grosseiros. Seja qual for sua escolha, conte mensagens por usuário, não por conexão, e armazene a contagem onde uma reinicialização não a redefina.
Mantenha o histórico de conversas no servidor conforme o app cresce. Enviar todo o histórico do navegador em cada turno é fácil de construir, mas os usuários podem editá-lo. Armazene mensagens em um banco de dados sob um id de conversa, carregue as últimas 20 em cada solicitação e anexe a resposta após o stream terminar. Isso também permite que um usuário feche a aba e volte para a mesma conversa.
Antes do lançamento
Uma lista de verificação curta mantém o dia do lançamento silencioso.
- A chave vive apenas em uma variável de ambiente no servidor, e o repositório não a contém.
- O servidor ignora qualquer mensagem de sistema do cliente.
- Cada usuário tem um limite de mensagens por dia e um limite de comprimento de mensagem.
- Erros mostram uma mensagem amigável e nunca imprimem detalhes internos.
- Você registra ids de solicitação do cabeçalho
X-Request-Ide contagens de tokens, não o texto completo. - Você monitora
X-Balance-USDe recebe um alerta quando o crédito está baixo. - Seus termos declaram o público adulto, e o bot nunca produz conteúdo sexual envolvendo menores de idade.
O último ponto é compartilhado com o guia sobre segurança de chatbot adulto. O modelo por trás desta API é ajustado para responder sem recusas de conteúdo para uso adulto legal, o que torna suas próprias regras de verificação de idade e moderação mais importantes, não menos. Recargas aqui são apenas cripto (USDT em TRC20 ou USDC em Base), de $20 a $500, e novos usuários podem reivindicar um crédito de teste de $0,50 primeiro.
Mais guias
Perguntas e respostas
Por que não posso chamar a API diretamente do JavaScript no navegador?
Porque a chave ficaria visível para qualquer um que abrisse a aba de rede. Um proxy backend mantém a chave no seu servidor e permite adicionar limites por usuário.
A API suporta streaming?
Sim. Defina stream como true e a API envia eventos enviados pelo servidor, com o uso no final. Seu proxy pode retransmitir esses eventos para o navegador.
Qual SDK devo usar?
Qualquer SDK ou cliente HTTP da OpenAI funciona. Altere a URL base para https://api.uncensoredchatbotapi.com/v1, use sua chave e defina o modelo como uncensored.
O que acontece se muitos usuários conversarem ao mesmo tempo?
Uma chave completa permite 8 requisições simultâneas. Além disso, a API retorna 429 com o código concurrency, então faça fila de requisições extras no seu servidor e tente novamente em breve.
Sua chave está a um formulário de distância
Crie uma conta, copie a chave e altere a URL base. Essa é toda a configuração.