Uncensored API-Referenz, Feld für Feld erklärt

Konventionen und Transport

Die Base URL ist https://api.uncensoredapis.com/v1. Alle Bodies sind JSON und UTF-8. Jede Anfrage enthält Authorization: Bearer <key>; ein fehlender oder falscher Schlüssel gibt 401 zurück. Es gibt nur zwei Routen, jeder andere Pfad gibt 404 zurück.

Methode	Pfad	Zweck
POST	/v1/chat/completions	Generiere eine Assistenten-Nachricht, optional gestreamt
GET	/v1/models	Liste die Modell-ID auf, die du anfordern kannst

Die API ist nur Text. Es gibt keine Embeddings-, Bild-, Audio- oder Video-Routen und kein Fine-Tuning, und es gibt genau ein Modell, angesprochen als uncensored. Da das Wire-Format mit der Chat-Completions-Konvention kompatibel ist, funktionieren die offiziellen Python- und Node-SDKs, wenn du base_url überschreibst. Die Dokumentation deckt die Ersteinrichtung ab; diese Seite ist der Feld-Level-Begleiter.

Anfragekörper-Felder

Die Tabelle listet die Felder auf, die der Endpunkt versteht. Sampling-Felder werden unverändert an die Generierung weitergegeben, daher verhalten sich die von dir gewählten Werte wie in jeder Chat-Completions-API.

Feld	Typ	Hinweise
model	Zeichenkette	Immer "uncensored".
messages	Array	Geordnete Objekte mit role (system, user, assistant, tool) und content.
max_tokens	Ganzzahl	Completion-Limit. Standard 2048, Maximum 32.000.
temperature	Zahl	Zufälligkeit. Niedriger ist deterministischer.
top_p	Zahl	Nucleus-Sampling-Abschneidewert.
stop	Zeichenkette oder Array	Sequenzen, die die Generierung beenden.
stream	Boolesch	true schaltet die Antwort auf Server-Sent Events um.
tools	Array	Funktionsdefinitionen im Standard-JSON-Schema-Format.

Hier ist eine vollständige kommentierte Anfrage. Die Systemnachricht legt das Verhalten fest, die Benutzernachricht enthält die Aufgabe, und stop beendet die Generierung bei der ersten Leerzeile.

Copycurl https://api.uncensoredapis.com/v1/chat/completions \
  -H "Authorization: Bearer $API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "uncensored",
    "messages": [
      {"role": "system", "content": "You are a terse release-notes writer."},
      {"role": "user", "content": "Summarize: fixed login bug, added dark mode."}
    ],
    "max_tokens": 120,
    "temperature": 0.4,
    "stop": ["\n\n"]
  }'

Zwei Budgetregeln sind wichtig. Erstens müssen Prompt plus Completion in 100.000 Token passen, also wird eine Anfrage abgelehnt, deren Prompt-Token plus max_tokens dieses Limit überschreiten (HTTP 400). Zweitens darf der serialisierte Body 8 MB nicht überschreiten. Wenn du lange Historien sendest, kürze alte Einträge auf deiner Seite, bevor sie einem der beiden Limits nahekommen.

Das Antwortobjekt

Ein Aufruf ohne Streaming gibt ein einzelnes JSON-Objekt zurück. Lies es von oben nach unten wie folgt.

Copy{
  "id": "chatcmpl-example123",
  "object": "chat.completion",
  "created": 1767225600,
  "model": "uncensored",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "v1.4: Login bug fixed. Dark mode added."
      },
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 38,
    "completion_tokens": 14,
    "total_tokens": 52
  }
}

• id: eine eindeutige Kennung für die Completion. Speichere sie neben deiner eigenen request_id, wenn du Ereignisse korrelieren musst.
• object: die Konstante chat.completion.
• created: Unix-Zeitstempel in Sekunden.
• model: spiegelt uncensored wider.
• choices: ein Array. Du erhältst genau einen Eintrag, daher ist choices[0] die Antwort. index gibt die Position an.
• choices[].message: role ist assistant; content enthält den Text oder ist null, wenn das Modell tool_calls zurückgegeben hat.
• choices[].finish_reason: Grund für das Ende der Generierung; siehe nächster Abschnitt.
• usage: Token-Buchhaltung für die Abrechnung, weiter unten beschrieben.

finish_reason-Werte

Branching basierend auf finish_reason, bevor du dem Inhalt vertraust. Eine abgeschnittene Antwort und eine vollständige Antwort sehen identisch aus, bis du den Grund prüfst.

Wert	Bedeutung	Was dein Code tun sollte
stop	Das Modell hat ein natürliches Ende erreicht oder eine deiner stop-Sequenzen getroffen.	Verwende den Inhalt unverändert.
length	Das max_tokens-Limit (oder das Kontextfenster) wurde während der Antwort erreicht.	Erhöhe max_tokens, kürze den Prompt oder bitte das Modell, fortzufahren.
tool_calls	Das Modell möchte eine oder mehrere Funktionen ausführen.	Führe sie aus und sende die Ergebnisse als tool-Nachrichten zurück.

Wenn der Wert tool_calls ist, sieht die Nachricht so aus, mit als JSON-string übergebenen Argumenten, die du selbst parsen musst:

Copy{
  "choices": [{
    "index": 0,
    "message": {
      "role": "assistant",
      "content": null,
      "tool_calls": [{
        "id": "call_abc1",
        "type": "function",
        "function": {"name": "get_order", "arguments": "{\"order_id\": 8841}"}
      }]
    },
    "finish_reason": "tool_calls"
  }]
}

Packe json.loads oder JSON.parse für arguments immer in eine Fehlerbehandlung, da generiertes JSON gelegentlich fehlerhaft sein kann.

Der usage-Block und die Kosten

usage meldet prompt_tokens, completion_tokens und total_tokens. Dies sind die Zahlen, gegen die dein Guthaben belastet wird: Input zu $0,25 pro Million Token und Output zu $1,00 pro Million. Prepaid-Guthaben wird pro Anfrage abgezogen, ohne Abonnement.

Ein durchgerechnetes Beispiel unter genannten Annahmen: Nehmen wir an, eine Anfrage verwendet 2.000 Prompt-Token und 500 Completion-Token. Input-Kosten: 2.000 / 1.000.000 x $0,25 = $0,0005. Output-Kosten: 500 / 1.000.000 x $1,00 = $0,0005. Die Anfrage kostet insgesamt $0,0010. Diese Token-Anzahlen sind Annahmen zur Arithmetik, keine Messung einer echten Arbeitslast. Die Preisseite hat die Preise an einem Ort.

Da Output-Token viermal so viel kosten wie Input-Token, ist ein strenges max_tokens deine direkteste Möglichkeit zur Kostenkontrolle.

Streaming-Chunk-Format

Setze "stream": true, und die Antwort wird zu text/event-stream. Jedes Ereignis ist eine Zeile, die mit data: beginnt, gefolgt von JSON, getrennt durch eine Leerzeile. Der Objekttyp ändert sich zu chat.completion.chunk, und message wird durch delta ersetzt.

Copydata: {"id":"chatcmpl-example123","object":"chat.completion.chunk","choices":[{"index":0,"delta":{"role":"assistant","content":""},"finish_reason":null}]}

data: {"id":"chatcmpl-example123","object":"chat.completion.chunk","choices":[{"index":0,"delta":{"content":"v1.4: "},"finish_reason":null}]}

data: {"id":"chatcmpl-example123","object":"chat.completion.chunk","choices":[{"index":0,"delta":{"content":"Login bug fixed."},"finish_reason":null}]}

data: {"id":"chatcmpl-example123","object":"chat.completion.chunk","choices":[{"index":0,"delta":{},"finish_reason":"stop"}]}

data: {"id":"chatcmpl-example123","object":"chat.completion.chunk","choices":[],"usage":{"prompt_tokens":38,"completion_tokens":14,"total_tokens":52}}

data: [DONE]

1. Der erste Chunk setzt normalerweise delta.role auf assistant mit leerem Inhalt.
2. Content-Chunks enthalten einen Fragment in delta.content. Verknüpfe sie in der Reihenfolge des Eintreffens.
3. Der abschließende Content-Chunk hat ein leeres delta und einen nicht-null finish_reason.
4. Ein letzter Chunk mit einem leeren choices-Array enthält usage. Du fragst ihn nicht explizit an; er wird automatisch hinzugefügt.
5. Das wörtliche data: [DONE] beendet den Stream.

Schütze dich vor diesem leeren choices-Array: Das Indizieren von choices[0] im usage-Chunk löst in naiven Schleifen einen Fehler aus. Das SDK-Beispiel unten behandelt dies.

Copyimport os
from openai import OpenAI

client = OpenAI(base_url="https://api.uncensoredapis.com/v1", api_key=os.environ["API_KEY"])

reason, usage = None, None
for chunk in client.chat.completions.create(
    model="uncensored",
    messages=[{"role": "user", "content": "Name three uses of a rubber duck in debugging."}],
    stream=True,
):
    if chunk.choices:
        piece = chunk.choices[0].delta.content
        if piece:
            print(piece, end="", flush=True)
        if chunk.choices[0].finish_reason:
            reason = chunk.choices[0].finish_reason
    if getattr(chunk, "usage", None):
        usage = chunk.usage

print("\nfinish:", reason, "| tokens:", usage.total_tokens if usage else "n/a")

Für gestreamte tool_calls kommt delta.tool_calls in Fragmenten an; akkumuliere den arguments-String pro Call-Index und parse einmal, wenn finish_reason tool_calls ist.

Der models-Endpunkt

GET /v1/models benötigt nur den Bearer-Header und gibt ein Listenobjekt zurück. Da es nur ein Modell gibt, enthält data einen Eintrag, uncensored. Clients, die eine Modellauswahl aus diesem Endpunkt füllen, zeigen daher nur eine einzige Auswahlmöglichkeit.

Copycurl https://api.uncensoredapis.com/v1/models -H "Authorization: Bearer $API_KEY"

{
  "object": "list",
  "data": [
    {"id": "uncensored", "object": "model"}
  ]
}

Es ist auch die günstigste Methode, einen Schlüssel zu überprüfen: 200 bedeutet, dass der Schlüssel gültig ist, 401 bedeutet, dass er falsch ist oder neu generiert wurde. Der Aufruf dieses Endpunkts generiert keine Token. Für die Fehlerbehandlung und Wiederholungsregeln siehe den Leitfaden zu Fehlern und Ratenlimits.

Referenz-Checkliste für Client-Autoren

Wenn du eine Client-Bibliothek schreibst oder den Endpunkt in einem Gateway verpackst, prüfe vor der Veröffentlichung jedes dieser Verhaltensweisen gegen die obige Spezifikation.

1. Header-Hygiene. Sende den Schlüssel nur im Authorization-Header, niemals in der Query-String, und protokolliere den Header-Wert niemals.
2. Defensives Parsen. Behandle unbekannte zusätzliche Felder in Antworten als ignoriierbar. Fixiere deinen Parser auf die hier dokumentierten Felder, nicht auf die exakte JSON-Schlüsselreihenfolge.
3. Prüfe finish_reason bei jeder Antwort. Zeige einen sichtbaren Indikator an, wenn er length ist, da Nutzer sonst abgeschnittenen Text als vollständige Antwort lesen.
4. Budget vor dem Senden abschätzen. Schätze die Prompt-Token ab, addiere deine max_tokens und vergleiche die Summe mit 100.000. Lokales Ablehnen ist schneller, als auf ein 400 zu warten.
5. Behandle das Stream-Ende. Erwarte einen Chunk mit einer leeren choices-Liste und einem usage-Objekt, dann [DONE]. Schließe die Verbindung nach dem Sentinel.
6. Nutzung protokollieren. Speichere total_tokens pro Anfrage, damit du deine eigene Abrechnung später mit dem Prepaid-Guthaben abgleichen kannst.
7. Die Decke respektieren. Das Konto erlaubt 300 Anfragen pro Minute pro Schlüssel, daher muss ein Gateway, das viele Benutzer ausstrahlt, seine eigene Warteschlange haben.

Keine dieser Schritte hängt von einem Vendor-SDK ab. Ein einfacher HTTP-Client, der den Bearer-Header setzt und JSON decodiert, reicht aus, und die SDK-Beispiele auf dieser Seite sind Komfortfunktionen, keine Anforderungen. Kombiniere diese Checkliste mit der Fehlerliste im playbook und du deckst den gesamten Anfragelebenszyklus ab: erstellen, senden, streamen, parsen, abrechnen und wiederherstellen.