NL ▾
Base URL https://api.uncensoredaiapis.com/v1Model uncensored
API-sleutel aanvragen
Uncensored AICodevoorbeelden

Voorbeelden van Uncensored AI API-code in Python, Node.js en cURL

Deze pagina verzamelt copy-paste-code voor de ongecensureerde AI-API, die het OpenAI chat-completions-formaat spreekt. Je vindt eerste calls in Python, Node.js en cURL, streaming met de SDK en met raw fetch, function calling, retry-logica voor 429 en 503, multi-turn state, en kostenbeheer met max_tokens.

Voorbeelden van Uncensored AI API-code in Python, Node.js en cURL

Bijgewerkt

Belangrijkste punten

  • Gebruik de officiële openai SDK met base_url ingesteld op https://api.uncensoredaiapis.com/v1 en model "uncensored"; geen aangepaste client is nodig.
  • Streaming retourneert SSE-chunks, en een laatste usage-chunk komt automatisch aan met een lege choices-lijst.
  • Probeer alleen 429 en 503 (upstream_busy) opnieuw; 400, 401, 402 en 403 vereisen een fix, geen retry.
  • De API is stateless: stuur geschiedenis elke beurt opnieuw, en beperk output met max_tokens (optioneel; als dit niet is ingesteld, kan de respons tot het einde van het contextvenster lopen).

Eerste call: Python, Node.js en cURL

De voorbeelden gebruiken https://api.uncensoredaiapis.com/v1, model uncensored, en POST /v1/chat/completions of GET /v1/models. Stuur je huidige sleutel in de Authorization: Bearer <key> header. Maak indien nodig een account aan, vraag in aanmerking komend trialtegoed aan en controleer of het weergegeven saldo klaar is voordat je verzoeken uitvoert.

De voorbeelden lezen de sleutel uit een omgevingsvariabele met de naam API_KEY. Exporteer deze één keer in je shell en geen van de snippets hoeft bewerkt te worden. Plak nooit een sleutel in broncode of stuur deze mee in browser JavaScript; bel de API vanuit je backend.

export API_KEY="paste-your-key-here"

Python, met het officiële openai pakket (v1 of nieuwer). De enige verschillen met een standaard OpenAI-setup zijn base_url en de modelnaam.

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, met het openai npm-pakket (v4 of nieuwer) als ES-module.

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);

En platte cURL, wat de snelste manier is om te controleren of een sleutel werkt:

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
  }'

Het antwoord heeft de gebruikelijke OpenAI-vorm: choices[0].message.content voor de tekst en een usage object met prompt- en completion-tokenaantallen, die je kunt vermenigvuldigen met de tokens-prijzen om de uitgaven bij te houden. Zie de docs voor de volledige parameterlijst.

Streaming (SSE) met de SDK

Stel stream: true in en de API retourneert server-sent events in plaats van één JSON-lichaam. Beide officiële SDKs zetten dit om in een iterator, zodat je code kan lopen over chunks en elke delta afdrukt. Een laatste chunk met token usage wordt automatisch toegevoegd; je hoeft het niet aan te vragen. Die chunk heeft een lege choices-lijst, dus bewaar de index voordat je deze leest.

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)

De Node.js-versie gebruikt 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 verandert de prijzen niet. Je betaalt voor dezelfde input- en output-tokens; je ziet de eerste woorden gewoon eerder, wat belangrijk is voor chat- en roleplay-interfaces waar wachten op een volledige 500-token-antwoord langzaam aanvoelt.

Streaming met raw fetch

Als je liever niet afhankelijk wilt zijn van de SDK, bijvoorbeeld in een edge-functie of een klein script, kun je de stream zelf lezen. Het wire-formaat is platte SSE: elk evenement is een regel die begint met data: gevolgd door een JSON-chunk, en evenementen worden gescheiden door lege regels. Netwerkchunks komen niet overeen met evenementgrenzen, dus je moet bufferen en splitsen op nieuwe regels. Het onderstaande voorbeeld draait op Node 18 of nieuwer (sla het op als stream.mjs) en werkt ook in elke runtime met de standaard fetch en 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);
  }
}

Controleer res.ok voordat je begint met lezen. Fouten zoals 401, 402 of 403 komen als normaal JSON-lichaam met een error object, niet als een evenementstream, dus het parseren ervan als SSE zou stil niets produceren. In een browser kun je dezelfde logica gebruiken met res.body.getReader(), maar onthoud dat een browser je eigen backend moet aanroepen, nooit deze API direct met een geheime sleutel.

Function calling met tools en tool_choice

Tool calling gebruikt het OpenAI-formaat. Je beschrijft functies in tools, het model antwoordt met tool_calls in plaats van tekst wanneer het er één wil uitvoeren, je voert de functie zelf uit en je stuurt het resultaat terug als een bericht met role: "tool" en de bijbehorende tool_call_id. Een tweede verzoek retourneert dan het definitieve natuurlijke taalantwoord. tool_choice regelt het gedrag: "auto" laat het model beslissen, "none" verbiedt tools, en een object zoals {"type": "function", "function": {"name": "get_order_status"}} forceert die functie.

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)

Dezelfde lus 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);
}

Twee praktische opmerkingen. Ten eerste is arguments een JSON-string die door een taalmodel is geproduceerd, dus wikkel json.loads altijd in foutafhandeling in productie en valideer de velden voordat je een database raakt. Ten tweede tellen de tool-definities als input-tokens bij elk verzoek, dus houd beschrijvingen kort en stuur alleen de tools die relevant zijn voor de huidige stap.

Retries met backoff op 429 en 503

Twee fouten zijn het proberen waard. Een 429 betekent dat je de limiet van 300 verzoeken per minuut voor je sleutel hebt overschreden. Een 503 met de code upstream_busy betekent dat de dienst tijdelijk verzadigd is; een paar seconden wachten is de bedoelde reactie. Probeer 400 niet opnieuw (fix het verzoek), 401 niet opnieuw (fix de sleutel), 402 no_credit (laad saldo op), of 403 content_blocked (het verzoek wordt opnieuw geblokkeerd). Fouten delen één JSON-vorm, {"error":{"code":...,"message":...}}, dus je kunt de code direct loggen.

De OpenAI SDKs proberen verbindingsfouten, 429 en 5xx standaard een paar keer opnieuw, en je kunt dat verhogen met max_retries. Als je controle wilt over de vertragingen, schakel de ingebouwde retries uit en wikkel de call zelf, met exponentiële backoff met jitter zodat parallelle werkers niet in lockstep opnieuw proberen.

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)

De equivalente met 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);

Als je regelmatig 429 krijgt, is de betere fix meestal een kleine client-side concurrency cap (een semaphore of een wachtrij met vijf tot tien workers) in plaats van langere slaapperiodes. Bij 300 verzoeken per minuut kun je vijf verzoeken per seconde volhouden, wat meer dan genoeg is voor de meeste apps.

Multi-turn conversatiestatus

De API is stateless. Hij onthoudt eerdere verzoeken niet, dus elke call moet de geschiedenis bevatten die je het model wilt laten zien. Houd een lijst van berichten bij, voeg de user-turn toe, bel de API, voeg de assistant-antwoord toe, en herhaal. Een systeembericht op index 0 houdt de persona of instructies vast en wordt elke keer verzonden.

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?"))

Omdat de volledige geschiedenis opnieuw wordt verzonden, groeit de inputkosten met elke beurt. Het contextvenster is 100.000 tokens en omvat de prompt en de completion samen, dus een zeer lange sessie zal uiteindelijk een 400-fout retourneren wanneer de prompt zelf de limiet overschrijdt (bij prompt + max_tokens boven de limiet stopt het antwoord alleen aan het einde van het venster). Veelgebruikte strategieën zijn het verwijderen van de oudste user- en assistant-paren terwijl je het systeembericht altijd behoudt, of het model vragen om oudere beurten samen te vatten tot één kort bericht en ze te vervangen. Sla de geschiedenis op in je eigen database, gekoppeld aan conversation id, zodat een restart de draad niet verliest. Voor voorbeelden van lange sessies met realistische kostenramingen, zie de use cases page.

Kostenbeheer met max_tokens

Prijzen zijn $0.15 per miljoen input tokens en $0.50 per miljoen output tokens, gefactureerd van een prepaid saldo. Output is ongeveer 3,3 keer zo duur als input, en max_tokens is een optionele cap op output voor een enkel verzoek. Als je het niet instelt, kan de response tot het einde van het context window lopen. Het bewust instellen is de eenvoudigste kostenbeheer die je hebt.

Worst-case berekening helpt. Als je de output niet beperkt, kan een antwoord tot het einde van het contextvenster lopen, dus de output alleen kan tot 100,000 × $0,50 / 1.000.000 = $0,05 kosten. Als je max_tokens op 300 zet voor een chatantwoord, daalt de worst case naar $0,00015. Een typische beurt met 1.500 input-tokens en 300 output-tokens kost ongeveer $0,000225 plus $0,00015, wat onder de $0,001 blijft.

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)

Houd finish_reason in de gaten. Een waarde van length betekent dat het antwoord je cap heeft geraakt en afgekapt is; als dit vaak gebeurt, verhoog dan de cap of vraag om kortere output in de prompt, omdat een cap alleen afkapt in plaats van het model beknopt te maken. Combineer de cap met instructies zoals een target woordtelling, en log usage voor elke call zodat je echte gemiddelden kunt zien in plaats van raden. Je gratis proeftegoed en saldetails staan op de pricing page.

Vragen en antwoorden

Heb je een speciale SDK nodig voor deze ongecensureerde AI-API?

Nee. De officiële openai Python-pakket (v1+) en openai npm-pakket (v4+) werken. Stel base_url in op https://api.uncensoredaiapis.com/v1, voer je sleutel in en gebruik het model met id uncensored.

Omvat streaming tokengebruik?

Ja. Met stream: true voegt de API een laatste chunk toe die usage automatisch bevat. Die chunk heeft een lege choices-array, dus controleer of choices bestaat voordat je de delta leest.

Welke fouten moet mijn code opnieuw proberen?

Probeer 429 (rate limit, 300 verzoeken per minuut per sleutel) en 503 upstream_busy opnieuw met exponentiële backoff en jitter. Probeer 400, 401, 402 of 403 niet opnieuw omdat hetzelfde verzoek opnieuw zal falen.

Wordt de gespreksgeschiedenis tussen calls voor mij opgeslagen?

Nee. Elk verzoek is onafhankelijk, dus je stuurt de volledige messages-lijst elke keer. Het contextvenster is 100.000 tokens voor prompt en completion samen.

Je sleutel is nog maar één formulier verwijderd

Maak een account aan, kopieer de sleutel, pas de base URL aan. Dat is de hele setup.