Integración de API de chatbot: conecta un endpoint de chat en tu aplicación
Una integración de API de chatbot tiene una regla que no puedes saltarte: el navegador nunca guarda la clave de API. Pon un pequeño proxy de backend en el medio, transmite las respuestas a través de él y el resto es desarrollo web habitual.
Actualizado

Puntos clave
- El navegador habla con tu servidor; tu servidor habla con la API de chat con la clave.
- Transmite con eventos enviados por el servidor para que las respuestas aparezcan palabra por palabra.
- Limita el historial, establece límites por usuario y gestiona las respuestas 429 con una breve espera.
- El endpoint es compatible con OpenAI, por lo que el SDK oficial funciona tras cambiar la URL base.
El patrón en una imagen
Toda integración de API de chatbot segura se ve igual desde arriba. Una página en el navegador envía el mensaje del usuario a tu propio endpoint. Tu servidor añade el prompt del sistema, recorta el historial, adjunta la clave de API y reenvía la petición. La respuesta vuelve en streaming de la misma manera.
Browser --POST /api/chat--> Your server --POST /v1/chat/completions--> Chat API
Browser <--SSE stream------ Your server <--SSE stream----------------- Chat API
El proxy existe por cuatro razones: oculta la clave, te permite verificar quién está llamando, te permite limitar el costo por usuario y te da un solo lugar para cambiar la configuración del modelo más tarde. Una clave colocada en JavaScript del frontend es pública en el momento en que la página se carga, y alguien más gastaría tu crédito prepago.
La API sigue el formato de OpenAI. La URL base es https://api.uncensoredchatbotapi.com/v1, el modelo es uncensored, y la autenticación es Authorization: Bearer YOUR_KEY. Obtén una clave en la página de claves.
Paso 1: el proxy del servidor
Este servidor Express acepta una conversación, añade un prompt del sistema, llama a la API con streaming y retransmite el texto. Instala las dependencias con npm i express openai y establece CHAT_API_KEY en el entorno.
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);
Nota el filtro. El cliente puede enviar cualquier cosa, así que el servidor solo guarda mensajes user y assistant, los trunca e ignora cualquier mensaje system que el navegador intente inyectar. El prompt del sistema siempre proviene de tu código.
Paso 2: el lado del navegador
El navegador lee el stream con fetch y añade texto a medida que llega. No se requiere ninguna biblioteca.
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 });
}
El búfer es importante. Los fragmentos de red no se alinean con los límites de eventos, así que divides por la línea en blanco y mantienes la cola incompleta para la siguiente lectura. Para un recorrido por la página en sí, consulta el tutorial de chat web, y para una visión más amplia de cómo añadir un bot a un sitio, cómo implementar un chatbot en un sitio web.
Límites, errores y reintentos
Una clave completa permite 8 peticiones concurrentes y 300 por minuto. Una clave de prueba permite 2 y 60. Una petición transmitida ocupa su espacio hasta que termina el stream, así que con 8 espacios puedes servir como máximo 8 respuestas activas a la vez. Si tu sitio tiene más usuarios simultáneos que eso, encola peticiones en tu servidor y responde "un momento" en lugar de fallar.
- 429 con
concurrency: demasiadas peticiones en curso. Encola y reintenta. - 429 con
rate_limited: demasiadas peticiones por minuto. Ralentiza. - 429 con un encabezado
Retry-After: 5: sobrecarga temporal. Espera 5 segundos e inténtalo de nuevo. - 401: clave incorrecta o faltante.
- Cuerpo superior a 8 MB: rechazado, así que recorta lo que envías.
Añade un contador mínimo en memoria para que tu propio servidor nunca abra más de 8 transmisiones 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();
});
Registra este middleware antes de la ruta de chat. El evento close se dispara cuando la respuesta termina o el usuario se va, así que el contador no se filtra.
Controla el costo de cada conversación
El precio es $0,15 por 1M de tokens de entrada y $0,50 por 1M de tokens de salida. Debido a que cada turno reenvía el historial, el límite en el historial es tu mayor palanca. Con los últimos 20 mensajes de aproximadamente 60 tokens cada uno más un prompt del sistema de 100 tokens, una petición lleva aproximadamente 1.300 tokens de entrada. Una respuesta de 150 tokens añade salida.
Costo por turno: 1.300 / 1.000.000 x $0,15 = $0,000195, más 150 / 1.000.000 x $0,50 = $0,000075, es decir $0,00027. Una sesión de 30 turnos de ese tamaño cuesta $0,0081 como máximo, ya que los primeros turnos son más cortos. Límites diarios por usuario, por ejemplo 100 mensajes, limitan tu peor caso a 100 x $0,00027 = $0,027 por usuario por día. Para más información sobre cómo cobrar por un bot de sitio, lee la página sobre costo de chatbot en sitio web, y usa la documentación para parámetros como max_tokens.
Quién está llamando a tu proxy
El proxy protege la clave, pero también se convierte en un endpoint de chat gratuito para cualquiera que encuentre la URL. Decide quién puede usarlo antes de lanzarlo.
Para un sitio público, una cookie de sesión firmada establecida al inicio de sesión es la respuesta habitual. Verifícala en la parte superior de la ruta y devuelve 401 cuando falta. Para un prototipo rápido, un límite por IP con un paquete como express-rate-limit es mejor que nada, aunque las redes compartidas hacen que los límites de IP sean poco precisos. Lo que elijas, cuenta mensajes por usuario, no por conexión, y guarda el conteo donde un reinicio no pueda restablecerlo.
Mantén el historial de conversaciones en el servidor una vez que la aplicación crezca. Enviar todo el historial desde el navegador en cada turno es fácil de construir, pero los usuarios pueden editarlo. Guarda mensajes en una base de datos bajo un id de conversación, carga los últimos 20 en cada petición y añade la respuesta después de que termine el stream. Eso también permite que un usuario cierre la pestaña y vuelva al mismo chat.
Antes de lanzar
Una lista de verificación corta mantiene tranquilo el día del lanzamiento.
- La clave vive solo en una variable de entorno en el servidor, y el repositorio no la contiene.
- El servidor ignora cualquier mensaje del sistema del cliente.
- Cada usuario tiene un límite de mensajes por día y un límite de longitud de mensaje.
- Los errores muestran un mensaje amigable y nunca imprimen detalles internos.
- Registra los identificadores de petición del encabezado
X-Request-Idy los recuentos de tokens, no el texto completo. - Vigila
X-Balance-USDy recibe una alerta cuando el crédito esté bajo. - Tus términos establecen la audiencia solo para adultos, y el bot nunca produce contenido sexual que involucre a menores de edad.
El último punto se comparte con la guía sobre seguridad de chatbot para adultos. El modelo detrás de esta API está ajustado para responder sin rechazos de contenido para uso adulto legal, lo que hace que tus propias reglas de verificación de edad y moderación sean más importantes, no menos. Las recargas aquí son solo cripto (USDT en TRC20 o USDC en Base), desde $20 hasta $500, y los nuevos usuarios pueden reclamar un $0,50 de prueba primero.
Más guías
Preguntas y respuestas
¿Por qué no puedo llamar a la API directamente desde JavaScript en el navegador?
Porque la clave sería visible para cualquiera que abra la pestaña de red. Un proxy de backend mantiene la clave en tu servidor y te permite añadir límites por usuario.
¿La API admite streaming?
Sí. Establece stream a true y la API envía eventos enviados por el servidor, con el uso al final. Tu proxy puede retransmitir esos eventos al navegador.
¿Qué SDK debo usar?
Funciona cualquier SDK de OpenAI o cliente HTTP. Cambia la URL base a https://api.uncensoredchatbotapi.com/v1, usa tu clave y establece el modelo en uncensored.
¿Qué pasa si demasiados usuarios chatean al mismo tiempo?
Una clave completa permite 8 peticiones concurrentes. Más allá de eso, la API devuelve 429 con el código de concurrencia, así que encola las peticiones adicionales en tu servidor y reintenta brevemente.
Tu clave está a un formulario de distancia
Crea una cuenta, copia la clave, cambia la URL base. Esa es toda la configuración.