Chatbot-API-Integration: Ein Chat-Endpunkt in deine App einbinden
Eine Chatbot-API-Integration hat eine Regel, die du nicht überspringen darfst: Der Browser hält niemals den API-Schlüssel. Platziere einen kleinen Backend-Proxy dazwischen, stream die Antworten darüber, und der Rest ist normale Webentwicklung.
Aktualisiert

Wichtige Punkte
- Der Browser kommuniziert mit deinem Server; dein Server kommuniziert mit der Chat-API mit dem Schlüssel.
- Stream mit Server-Sent Events, damit Antworten wortweise erscheinen.
- Begrenze den Verlauf, setze pro-Nutzer-Limits und behandle 429-Antworten mit einer kurzen Wartezeit.
- Der Endpunkt ist OpenAI-kompatibel, daher funktioniert das offizielle SDK nach einer Änderung der Base URL.
Das Muster in einem Bild
Jede sichere Chatbot-API-Integration sieht von oben gleich aus. Eine Seite im Browser sendet die Nachricht des Nutzers an deinen eigenen Endpunkt. Dein Server fügt den System-Prompt hinzu, kürzt den Verlauf, hängt den API-Schlüssel an und leitet die Anfrage weiter. Die Antwort streamt auf die gleiche Weise zurück.
Browser --POST /api/chat--> Your server --POST /v1/chat/completions--> Chat API
Browser <--SSE stream------ Your server <--SSE stream----------------- Chat API
Der Proxy existiert aus vier Gründen: Er verbirgt den Schlüssel, er erlaubt dir zu prüfen, wer aufruft, er erlaubt dir, die Kosten pro Nutzer zu begrenzen, und er gibt dir einen Ort, an dem du die Modelleinstellungen später ändern kannst. Ein Schlüssel, der in Frontend-JavaScript platziert wird, ist öffentlich, sobald die Seite lädt, und jemand anderes würde dein Prepaid-Guthaben ausgeben.
Die API folgt dem OpenAI-Format. Die Base URL ist https://api.uncensoredchatbotapi.com/v1, das Modell ist uncensored, und die Authentifizierung ist Authorization: Bearer YOUR_KEY. Hole einen Schlüssel auf der Schlüsselseite.
Schritt 1: Der Server-Proxy
Dieser Express-Server akzeptiert eine Konversation, fügt einen System-Prompt hinzu, ruft die API mit Streaming auf und leitet den Text weiter. Installiere die Abhängigkeiten mit npm i express openai und setze CHAT_API_KEY in der Umgebung.
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);
Beachte den Filter. Der Client kann alles senden, daher hält der Server nur user- und assistant-Nachrichten, kürzt jede und ignoriert jede system-Nachricht, die der Browser einzuschleusen versucht. Der System-Prompt kommt immer von deinem Code.
Schritt 2: Die Browser-Seite
Der Browser liest den Stream mit fetch und hängt Text an, sobald er eintrifft. Keine Bibliothek ist erforderlich.
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 });
}
Der Puffer ist wichtig. Netzwerk-Chunks stimmen nicht mit Ereignisgrenzen überein, also teilst du an der leeren Zeile und behältst den unvollendeten Schwanz für den nächsten Lesevorgang. Für eine Anleitung zur Seite selbst sieh dir das Web-Chat-Tutorial an, und für das größere Bild, wie man einen Bot in eine Website integriert, wie man einen Chatbot in einer Website implementiert.
Limits, Fehler und Wiederholungen
Ein vollständiger Schlüssel erlaubt 8 parallele Anfragen und 300 pro Minute. Ein Test-Schlüssel erlaubt 2 und 60. Eine gestreamte Anfrage belegt ihren Slot, bis das Streaming endet, also kannst du mit 8 Slots maximal 8 Live-Antworten gleichzeitig ausliefern. Wenn deine Website mehr gleichzeitige Nutzer hat als das, stelle Anfragen auf deinem Server in eine Warteschlange und antworte mit „einen Moment“, statt dass die Anfrage fehlschlägt.
- 429 mit
concurrency: zu viele Anfragen sind aktiv. Warteschlange und erneut versuchen. - 429 mit
rate_limited: zu viele Anfragen pro Minute. Verlangsame. - 429 mit einem
Retry-After: 5-Header: temporäre Überlastung. Warte 5 Sekunden und versuche es erneut. - 401: falscher oder fehlender Schlüssel.
- Body über 8 MB: abgelehnt, also kürze, was du sendest.
Füge einen kleinen In-Memory-Zähler hinzu, damit dein eigener Server niemals mehr als 8 Upstream-Streams öffnet:
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();
});
Registriere dieses Middleware vor dem Chat-Endpunkt. Das close-Event wird ausgelöst, wenn die Antwort endet oder der Nutzer die Verbindung abbricht, sodass der Zähler nicht undicht wird.
Steuere die Kosten jeder Konversation
Der Preis ist $0,15 pro 1M Eingabe-Token und $0,50 pro 1M Ausgabe-Token. Da jede Runde den Verlauf erneut sendet, ist das Limit des Verlaufs dein größter Hebel. Mit den letzten 20 Nachrichten zu jeweils etwa 60 Token plus einem 100-Token-System-Prompt trägt eine Anfrage etwa 1.300 Eingabe-Token. Eine 150-Token-Antwort fügt Ausgabe-Token hinzu.
Kosten pro Runde: 1.300 / 1.000.000 x $0,15 = $0,000195, plus 150 / 1.000.000 x $0,50 = $0,000075, also $0,00027. Eine Sitzung mit 30 Runden in dieser Größe kostet maximal $0,0081, da frühe Runden kürzer sind. Tägliche Limits pro Nutzer, z. B. 100 Nachrichten, begrenzen deinen Worst Case auf 100 x $0,00027 = $0,027 pro Nutzer und Tag. Mehr zur Preisgestaltung eines Website-Bots erfährst du auf der Seite zu Chatbot-Websitekosten und nutze die Dokumentation für Parameter wie max_tokens.
Wer ruft deinen Proxy auf
Der Proxy schützt den Schlüssel, wird aber auch zu einem kostenlosen Chat-Endpunkt für jeden, der die URL findet. Entscheide, wer ihn nutzen darf, bevor du veröffentlichst.
Für eine öffentliche Website ist ein signiertes Session-Cookie, das beim Login gesetzt wird, die übliche Antwort. Prüfe es an der Spitze der Route und gib 401 zurück, wenn es fehlt. Für einen schnellen Prototyp ist ein pro-IP-Limit mit einem Paket wie express-rate-limit besser als nichts, obwohl gemeinsame Netzwerke IP-Limits ungenau machen. Was auch immer du wählst, zähle Nachrichten pro Nutzer, nicht pro Verbindung, und speichere die Zählung an einem Ort, der einen Neustart nicht zurücksetzen kann.
Halte den Konversationsverlauf auf dem Server, sobald die App wächst. Den gesamten Verlauf vom Browser bei jeder Runde zu senden ist einfach zu bauen, aber Nutzer können ihn bearbeiten. Speichere Nachrichten in einer Datenbank unter einer Konversations-ID, lade die letzten 20 bei jeder Anfrage und hänge die Antwort an, nachdem der Stream endet. Das erlaubt auch einem Nutzer, den Tab zu schließen und zu derselben Konversation zurückzukehren.
Bevor du veröffentlichst
Eine kurze Checkliste hält den Launch-Tag ruhig.
- Der Schlüssel lebt nur in einer Environment-Variable auf dem Server, und das Repository enthält ihn nicht.
- Der Server ignoriert jede System-Nachricht vom Client.
- Jeder Nutzer hat ein Nachrichtenlimit pro Tag und ein Nachrichtenlängenlimit.
- Fehler zeigen eine freundliche Nachricht und geben niemals interne Details aus.
- Du loggst Request-Ids aus dem
X-Request-Id-Header und Token-Anzahlen, nicht den vollständigen Text. - Du beobachtest
X-Balance-USDund erhältst eine Warnung, wenn das Guthaben niedrig wird. - Deine Nutzungsbedingungen nennen ein reines Erwachsenenpublikum, und der Bot produziert niemals sexuelle Inhalte mit Minderjährigen.
Der letzte Punkt wird mit der Anleitung zu Erwachsenen-Chatbot-Sicherheit geteilt. Das Modell hinter dieser API ist darauf abgestimmt, ohne Inhaltsablehnungen für legale Erwachsenennutzung zu antworten, was deine eigenen Altersfreigaben und Moderationsregeln wichtiger macht, nicht weniger. Aufladungen hier sind nur Krypto (USDT auf TRC20 oder USDC auf Base), von $20 bis $500, und neue Nutzer können zuerst ein $0,50 Trial beanspruchen.
Weitere Anleitungen
Fragen und Antworten
Warum kann ich die API nicht direkt aus JavaScript im Browser aufrufen?
Denn der Schlüssel wäre für jeden sichtbar, der die Netzwerk-Tab öffnet. Ein Backend-Proxy hält den Schlüssel auf deinem Server und erlaubt dir, Limits pro Nutzer festzulegen.
Unterstützt die API das Streaming?
Ja. Setze stream auf true, und die API sendet Server-Sent Events, mit der Nutzung am Ende. Dein Proxy kann diese Events an den Browser weiterleiten.
Welches SDK soll ich verwenden?
Jedes OpenAI-SDK oder jeder HTTP-Client funktioniert. Ändere die Base URL zu https://api.uncensoredchatbotapi.com/v1, verwende deinen Schlüssel und setze das Modell auf uncensored.
Was passiert, wenn zu viele Nutzer gleichzeitig chatten?
Ein Voll-Key erlaubt 8 parallele Anfragen. Darüber hinaus gibt die API 429 mit dem Code concurrency zurück, also queue zusätzliche Anfragen auf deinem Server und versuche es kurz erneut.
Dein Schlüssel ist nur ein Formular entfernt
Erstelle ein Konto, kopiere den Schlüssel, ändere die Basis-URL. Das ist die gesamte Einrichtung.