Uncensored AI API-Codebeispiele in Python, Node.js und cURL
Diese Seite sammelt Copy-Paste-Code für die unzensierte KI-API, die das OpenAI-Format für Chat-Vervollständigungen verwendet. Du findest erste Aufrufe in Python, Node.js und cURL, Streaming mit dem SDK und mit raw fetch, Function Calling, Retry-Logik für 429 und 503, Multi-Turn-Status und Kostenkontrolle mit max_tokens.

Wichtige Punkte
- Verwende das offizielle openai SDK mit base_url, das auf https://api.uncensoredaiapis.com/v1 gesetzt ist, und dem Modell "uncensored"; kein benutzerdefinierter Client ist erforderlich.
- Streaming gibt SSE-Chunks zurück, und ein finaler Usage-Chunk kommt automatisch mit einer leeren choices-Liste an.
- Wiederhole nur 429 und 503 (upstream_busy); 400, 401, 402 und 403 benötigen eine Korrektur, keinen Wiederholungsversuch.
- Die API ist zustandslos: Sende den Verlauf bei jedem Durchlauf erneut und begrenze die Ausgabe mit max_tokens (optional; wenn nicht festgelegt, kann die Antwort bis zum Ende des Context window laufen).
Erster Aufruf: Python, Node.js und cURL
Die Beispiele verwenden https://api.uncensoredaiapis.com/v1, das Modell uncensored sowie POST /v1/chat/completions oder GET /v1/models. Sende deinen aktuellen Schlüssel im Authorization: Bearer <key>-Header. Falls erforderlich, erstelle ein Konto, fordere das berechtigte Testguthaben an und prüfe, ob das angezeigte Guthaben vor dem Ausführen von Anfragen bereit ist.
Die Beispiele lesen den Schlüssel aus einer Umgebungsvariable mit dem Namen API_KEY. Exportiere ihn einmal in deiner Shell, und keine der Snippets muss bearbeitet werden. Füge einen Schlüssel niemals in den Quellcode ein oder gib ihn im Browser-JavaScript aus; rufe die API von deinem Backend aus auf.
export API_KEY="paste-your-key-here"Python, unter Verwendung des offiziellen openai-Pakets (v1 oder neuer). Die einzigen Unterschiede zu einer Standard-OpenAI-Einrichtung sind base_url und der Modellname.
import os
from openai import OpenAI
client = OpenAI(
base_url="https://api.uncensoredaiapis.com/v1",
api_key=os.environ["API_KEY"],
)
resp = client.chat.completions.create(
model="uncensored",
messages=[{"role": "user", "content": "Write a two-line villain monologue."}],
max_tokens=200,
)
print(resp.choices[0].message.content)
print(resp.usage)Node.js, unter Verwendung des openai npm-Pakets (v4 oder neuer) als ES-Modul.
import OpenAI from "openai";
const client = new OpenAI({
baseURL: "https://api.uncensoredaiapis.com/v1",
apiKey: process.env.API_KEY,
});
const resp = await client.chat.completions.create({
model: "uncensored",
messages: [{ role: "user", content: "Write a two-line villain monologue." }],
max_tokens: 200,
});
console.log(resp.choices[0].message.content);
console.log(resp.usage);Und reines cURL, was der schnellste Weg ist, um zu prüfen, ob ein Schlüssel funktioniert:
curl https://api.uncensoredaiapis.com/v1/chat/completions \
-H "Authorization: Bearer $API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "uncensored",
"messages": [{"role": "user", "content": "Write a two-line villain monologue."}],
"max_tokens": 200
}'Die Antwort hat die übliche OpenAI-Struktur: choices[0].message.content für den Text und ein usage-Objekt mit Prompt- und Completion-Token-Anzahlen, die du mit den Preisen pro Token multiplizieren kannst, um die Ausgaben zu verfolgen. Siehe die Dokumentation für die vollständige Parameterliste.
Streaming (SSE) mit dem SDK
Setze stream: true, und die API gibt Server-Sent-Events statt eines einzelnen JSON-Objekts zurück. Beide offiziellen SDKs wandeln das in einen Iterator um, sodass dein Code über die Chunks iteriert und jeden delta ausgibt. Ein finaler Chunk mit Token-usage wird automatisch hinzugefügt; du musst ihn nicht anfordern. Dieser Chunk hat eine leere choices-Liste, also prüfe den Index, bevor du ihn liest.
import os
from openai import OpenAI
client = OpenAI(
base_url="https://api.uncensoredaiapis.com/v1",
api_key=os.environ["API_KEY"],
)
stream = client.chat.completions.create(
model="uncensored",
messages=[{"role": "user", "content": "Describe a rainy harbor town in 120 words."}],
max_tokens=300,
stream=True,
)
for chunk in stream:
if chunk.choices and chunk.choices[0].delta.content:
print(chunk.choices[0].delta.content, end="", flush=True)
if chunk.usage:
print("\n\nusage:", chunk.usage)Die Node.js-Version verwendet for await:
import OpenAI from "openai";
const client = new OpenAI({
baseURL: "https://api.uncensoredaiapis.com/v1",
apiKey: process.env.API_KEY,
});
const stream = await client.chat.completions.create({
model: "uncensored",
messages: [{ role: "user", content: "Describe a rainy harbor town in 120 words." }],
max_tokens: 300,
stream: true,
});
for await (const chunk of stream) {
const text = chunk.choices?.[0]?.delta?.content;
if (text) process.stdout.write(text);
if (chunk.usage) console.log("\n\nusage:", chunk.usage);
}Streaming ändert die Preisgestaltung nicht. Du zahlst für dieselben Input- und Output-Token; du siehst die ersten Wörter einfach früher, was für Chat- und Roleplay-Schnittstellen wichtig ist, bei denen das Warten auf eine vollständige Antwort mit 500 Token langsam wirkt.
Streaming mit raw fetch
Wenn du lieber nicht vom SDK abhängen möchtest, zum Beispiel in einer Edge-Funktion oder einem kleinen Skript, kannst du den Stream selbst lesen. Das Drahtformat ist reines SSE: Jedes Ereignis ist eine Zeile, die mit data: beginnt, gefolgt von einem JSON-Chunk, und Ereignisse sind durch Leerzeilen getrennt. Netzwerk-Chunks stimmen nicht mit Ereignisgrenzen überein, daher musst du puffern und an Newlines aufteilen. Das folgende Beispiel läuft auf Node 18 oder neuer (speichere es als stream.mjs) und funktioniert auch in jeder Laufzeitumgebung mit dem Standard-fetch und ReadableStream.
const res = await fetch("https://api.uncensoredaiapis.com/v1/chat/completions", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.API_KEY}`,
"Content-Type": "application/json",
},
body: JSON.stringify({
model: "uncensored",
messages: [{ role: "user", content: "Tell a 100-word ghost story." }],
max_tokens: 250,
stream: true,
}),
});
if (!res.ok) {
throw new Error(`HTTP ${res.status}: ${await res.text()}`);
}
const decoder = new TextDecoder();
let buffer = "";
for await (const bytes of res.body) {
buffer += decoder.decode(bytes, { stream: true });
const lines = buffer.split("\n");
buffer = lines.pop(); // keep the incomplete tail for the next round
for (const line of lines) {
if (!line.startsWith("data:")) continue;
const data = line.slice(5).trim();
if (data === "[DONE]") continue;
const chunk = JSON.parse(data);
const text = chunk.choices?.[0]?.delta?.content;
if (text) process.stdout.write(text);
if (chunk.usage) console.log("\n\nusage:", chunk.usage);
}
}Prüfe res.ok, bevor du mit dem Lesen beginnst. Fehler wie 401, 402 oder 403 kommen als normaler JSON-Körper mit einem error-Objekt an, nicht als Ereignis-Stream, daher würde das Parsen als SSE stillschweigend nichts ergeben. In einem Browser kannst du dieselbe Logik mit res.body.getReader() verwenden, aber denke daran, dass ein Browser immer dein eigenes Backend aufrufen muss, niemals diese API direkt mit einem geheimen Schlüssel.
Function Calling mit Tools und tool_choice
Tool Calling verwendet das OpenAI-Format. Du beschreibst Funktionen in tools, das Modell antwortet mit tool_calls anstelle von Text, wenn es eine Ausführung möchte, du führst die Funktion selbst aus und sendest das Ergebnis als Nachricht mit role: "tool" und der passenden tool_call_id zurück. Eine zweite Anfrage gibt dann die endgültige Antwort in natürlicher Sprache zurück. tool_choice steuert das Verhalten: "auto" lässt das Modell entscheiden, "none" verbietet Tools, und ein Objekt wie {"type": "function", "function": {"name": "get_order_status"}} erzwingt diese Funktion.
import json
import os
from openai import OpenAI
client = OpenAI(
base_url="https://api.uncensoredaiapis.com/v1",
api_key=os.environ["API_KEY"],
)
def get_order_status(order_id: str) -> dict:
# Replace with a real lookup.
return {"order_id": order_id, "status": "shipped", "eta_days": 2}
tools = [{
"type": "function",
"function": {
"name": "get_order_status",
"description": "Look up the shipping status of an order by its id.",
"parameters": {
"type": "object",
"properties": {"order_id": {"type": "string"}},
"required": ["order_id"],
},
},
}]
messages = [{"role": "user", "content": "Where is order A-1042?"}]
first = client.chat.completions.create(
model="uncensored",
messages=messages,
tools=tools,
tool_choice="auto",
max_tokens=500,
)
msg = first.choices[0].message
if msg.tool_calls:
messages.append(msg) # keep the assistant turn that contains tool_calls
for call in msg.tool_calls:
args = json.loads(call.function.arguments)
result = get_order_status(**args)
messages.append({
"role": "tool",
"tool_call_id": call.id,
"content": json.dumps(result),
})
final = client.chat.completions.create(
model="uncensored",
messages=messages,
tools=tools,
max_tokens=500,
)
print(final.choices[0].message.content)
else:
print(msg.content)Die gleiche Schleife in Node.js:
import OpenAI from "openai";
const client = new OpenAI({
baseURL: "https://api.uncensoredaiapis.com/v1",
apiKey: process.env.API_KEY,
});
const getOrderStatus = ({ order_id }) => ({ order_id, status: "shipped", eta_days: 2 });
const tools = [{
type: "function",
function: {
name: "get_order_status",
description: "Look up the shipping status of an order by its id.",
parameters: {
type: "object",
properties: { order_id: { type: "string" } },
required: ["order_id"],
},
},
}];
const messages = [{ role: "user", content: "Where is order A-1042?" }];
const first = await client.chat.completions.create({
model: "uncensored", messages, tools, tool_choice: "auto", max_tokens: 500,
});
const msg = first.choices[0].message;
if (msg.tool_calls?.length) {
messages.push(msg);
for (const call of msg.tool_calls) {
const result = getOrderStatus(JSON.parse(call.function.arguments));
messages.push({ role: "tool", tool_call_id: call.id, content: JSON.stringify(result) });
}
const final = await client.chat.completions.create({
model: "uncensored", messages, tools, max_tokens: 500,
});
console.log(final.choices[0].message.content);
} else {
console.log(msg.content);
}Zwei praktische Hinweise. Erstens ist arguments ein JSON-String, der von einem Sprachmodell erzeugt wurde, also packe json.loads in der Produktion immer in eine Fehlerbehandlung und validiere die Felder, bevor du eine Datenbank berührst. Zweitens zählen die Tool-Definitionen bei jeder Anfrage als Input-Token, also halte die Beschreibungen kurz und sende nur die Tools, die für den aktuellen Schritt relevant sind.
Wiederholungsversuche mit Backoff bei 429 und 503
Zwei Fehler sind es wert, erneut versucht zu werden. Ein 429 bedeutet, dass du das Limit von 300 Anfragen pro Minute für deinen Schlüssel überschritten hast. Ein 503 mit dem Code upstream_busy bedeutet, dass der Dienst vorübergehend gesättigt ist; ein paar Sekunden zu warten ist die beabsichtigte Reaktion. Wiederhole 400 nicht (fixe die Anfrage), 401 nicht (fixe den Schlüssel), 402 no_credit (lade das Guthaben auf) oder 403 content_blocked (die Anfrage wird erneut blockiert). Fehler haben eine gemeinsame JSON-Struktur, {"error":{"code":...,"message":...}}, sodass du den Code direkt protokollieren kannst.
Die OpenAI-SDKs wiederholen Verbindungsfehler, 429 und 5xx standardmäßig ein paar Mal, und du kannst das mit max_retries erhöhen. Wenn du die Verzögerungen steuern möchtest, deaktiviere die integrierten Wiederholungen und verpacke den Aufruf selbst, unter Verwendung von exponentiellem Backoff mit Jitter, damit parallele Worker nicht im Takt wiederholen.
import os
import random
import time
from openai import OpenAI, APIStatusError, APIConnectionError
client = OpenAI(
base_url="https://api.uncensoredaiapis.com/v1",
api_key=os.environ["API_KEY"],
max_retries=0, # we handle retries ourselves
)
RETRYABLE = {429, 503}
def chat_with_retry(messages, max_attempts=5, **kwargs):
for attempt in range(max_attempts):
try:
return client.chat.completions.create(
model="uncensored", messages=messages, **kwargs
)
except APIStatusError as e:
if e.status_code not in RETRYABLE or attempt == max_attempts - 1:
raise
except APIConnectionError:
if attempt == max_attempts - 1:
raise
delay = min(30, 2 ** attempt) + random.uniform(0, 1)
time.sleep(delay)
resp = chat_with_retry(
[{"role": "user", "content": "Give me three names for a tavern."}],
max_tokens=100,
)
print(resp.choices[0].message.content)Das Äquivalent mit raw fetch in Node.js:
const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
async function chatWithRetry(body, maxAttempts = 5) {
for (let attempt = 0; attempt < maxAttempts; attempt++) {
const res = await fetch("https://api.uncensoredaiapis.com/v1/chat/completions", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.API_KEY}`,
"Content-Type": "application/json",
},
body: JSON.stringify({ model: "uncensored", ...body }),
});
if (res.ok) return res.json();
const retryable = res.status === 429 || res.status === 503;
if (!retryable || attempt === maxAttempts - 1) {
throw new Error(`HTTP ${res.status}: ${await res.text()}`);
}
const delay = Math.min(30000, 2 ** attempt * 1000) + Math.random() * 1000;
await sleep(delay);
}
}
const data = await chatWithRetry({
messages: [{ role: "user", content: "Give me three names for a tavern." }],
max_tokens: 100,
});
console.log(data.choices[0].message.content);Wenn du regelmäßig 429 triffst, ist die bessere Lösung normalerweise eine kleine Client-seitige Concurrency-Begrenzung (ein Semaphore oder eine Warteschlange mit fünf bis zehn Arbeitern) anstelle längerer Schlafzeiten. Bei 300 Anfragen pro Minute kannst du fünf Anfragen pro Sekunde aufrechterhalten, was für die meisten Apps mehr als ausreichend ist.
Multi-Turn-Gesprächszustand
Die API ist zustandslos. Sie erinnert sich nicht an frühere Anfragen, daher muss jeder Aufruf den Verlauf enthalten, den das Modell sehen soll. Halte eine Liste von Nachrichten, hänge den Benutzer-Turn an, rufe die API auf, hänge die Assistenten-Antwort an und wiederhole. Eine Systemnachricht an Index 0 hält die Persona oder Anweisungen und wird jedes Mal gesendet.
import os
from openai import OpenAI
client = OpenAI(
base_url="https://api.uncensoredaiapis.com/v1",
api_key=os.environ["API_KEY"],
)
messages = [
{"role": "system", "content": "You are a dry-witted ship's AI. Keep replies under 80 words."}
]
def say(text: str) -> str:
messages.append({"role": "user", "content": text})
resp = client.chat.completions.create(
model="uncensored", messages=messages, max_tokens=300
)
reply = resp.choices[0].message.content
messages.append({"role": "assistant", "content": reply})
return reply
print(say("We just lost the main engine. Options?"))
print(say("Which of those is the least risky?"))Da die gesamte Historie erneut gesendet wird, steigen die Eingabekosten mit jeder Runde. Das Kontextfenster umfasst 100.000 Token und deckt den Prompt und die Completion zusammen ab, sodass bei einer sehr langen Sitzung die Antwort am Ende des Fensters abbricht, wenn prompt + max_tokens das Limit überschreitet; einen 400-Fehler gibt es nur, wenn der Prompt selbst nicht ins Fenster passt. Übliche Strategien sind, die ältesten Benutzer- und Assistenten-Paare zu entfernen, während die Systemnachricht immer beibehalten wird, oder das Modell zu bitten, ältere Runden in eine kurze Nachricht zusammenzufassen und sie zu ersetzen. Speichere die Historie in deiner eigenen Datenbank, gruppiert nach Konversations-ID, sodass ein Neustart den Faden nicht verliert. Beispiele für lange Sitzungen mit realistischen Kostenschätzungen findest du auf der Use-Cases-Seite.
Kostenkontrolle mit max_tokens
Die Preise betragen $0,15 pro Million Eingabe-Token und $0,50 pro Million Ausgabe-Token, abgerechnet von einem Prepaid-Guthaben. Ausgabe ist etwa 3,3-mal so teuer wie Eingabe, und max_tokens ist eine optionale Obergrenze für die Ausgabe einer einzelnen Anfrage. Wenn du sie nicht festlegst, kann die Antwort bis zum Ende des Context window laufen. Das gezielte Setzen ist die einfachste Kostenkontrolle, die du hast.
Die Worst-Case-Rechnung hilft. Wenn du die Ausgabe nicht begrenzst, kann eine Antwort bis zum Ende des Context Windows reichen, sodass die Ausgabe allein bis zu 100,000 × $0,50 / 1.000.000 = $0,05 kosten könnte. Wenn du max_tokens auf 300 für eine Chat-Antwort setzt, sinkt der Worst Case auf $0,00015. Ein typischer Durchlauf mit 1.500 Input-Token und 300 Output-Token kostet etwa $0,000225 plus $0,00015, was unter $0,001 liegt.
import os
from openai import OpenAI
client = OpenAI(
base_url="https://api.uncensoredaiapis.com/v1",
api_key=os.environ["API_KEY"],
)
INPUT_PER_M = 0.25
OUTPUT_PER_M = 1.00
resp = client.chat.completions.create(
model="uncensored",
messages=[{"role": "user", "content": "Summarise the plot of Hamlet in 5 sentences."}],
max_tokens=250,
)
u = resp.usage
cost = u.prompt_tokens * INPUT_PER_M / 1_000_000 + u.completion_tokens * OUTPUT_PER_M / 1_000_000
print(f"in={u.prompt_tokens} out={u.completion_tokens} cost=${cost:.6f}")
print("finish_reason:", resp.choices[0].finish_reason)Beobachte finish_reason. Ein Wert von length bedeutet, dass die Antwort deine Obergrenze erreicht hat und abgeschnitten wurde; wenn das oft passiert, erhöhe die Obergrenze oder fordere kürzere Ausgaben im Prompt an, da eine Obergrenze allein kürzt, anstatt das Modell prägnant zu machen. Kombiniere die Obergrenze mit Anweisungen wie einer Zielwortanzahl und protokolliere usage für jede Anfrage, damit du echte Durchschnittswerte statt Schätzungen siehst. Dein kostenloses Testguthaben und die Kontostand-Details findest du auf der Preisseite.
Fragen und Antworten
Brauche ich ein spezielles SDK für diese unzensierte KI-API?
Nein. Das offizielle openai Python-Paket (v1+) und das openai npm-Paket (v4+) funktionieren. Setze base_url auf https://api.uncensoredaiapis.com/v1, gib deinen Schlüssel ein und verwende die Modell-ID uncensored.
Beinhaltet das Streaming die Token-Nutzung?
Ja. Mit stream: true fügt die API einen letzten Chunk hinzu, der die Nutzung automatisch überträgt. Dieser Chunk hat ein leeres choices-Array, also prüfe, ob choices existiert, bevor du den Delta liest.
Welche Fehler sollte mein Code wiederholen?
Wiederhole 429 (Ratenlimit, 300 Anfragen pro Minute pro Schlüssel) und 503 upstream_busy mit exponentiellem Backoff und Jitter. Wiederhole nicht 400, 401, 402 oder 403, da dieselbe Anfrage erneut fehlschlägt.
Wird der Konversationsverlauf zwischen den Anfragen für mich gespeichert?
Nein. Jede Anfrage ist unabhängig, daher sendest du jedes Mal die vollständige Nachrichtenliste. Das Kontextfenster umfasst 100.000 Token für Prompt und Completion zusammen.
Dein Schlüssel ist nur ein Formular entfernt
Erstelle ein Konto, kopiere den Schlüssel, ändere die Basis-URL. Das ist die gesamte Einrichtung.