Przykłady kodu API Uncensored AI w Pythonie, Node.js i cURL
Ta strona zbiera kod do skopiowania dla API AI bez cenzury, które używa formatu OpenAI chat completions. Znajdziesz tu pierwsze wywołania w Pythonie, Node.js i cURL, strumieniowanie z użyciem SDK i surowego fetch, wywoływanie funkcji, logikę ponawiania dla 429 i 503, stan wieloetapowy oraz kontrolę kosztów z max_tokens.

Kluczowe punkty
- Użyj oficjalnego SDK openai z base_url ustawionym na https://api.uncensoredaiapis.com/v1 i modelem "uncensored"; nie jest potrzebny niestandardowy klient.
- Strumieniowanie zwraca chunki SSE, a finalny chunk usage przychodzi automatycznie z pustą listą choices.
- Ponawiaj tylko 429 i 503 (upstream_busy); 400, 401, 402 i 403 wymagają naprawy, a nie ponowienia.
- API jest bezstanowe: wysyłaj historię przy każdej turze i ogranicz output za pomocą max_tokens (opcjonalnie; jeśli nie ustawione, odpowiedź może trwać do końca okna kontekstowego).
Pierwsze wywołanie: Python, Node.js i cURL
Przykłady używają https://api.uncensoredaiapis.com/v1, modelu uncensored oraz POST /v1/chat/completions lub GET /v1/models. Prześlij swój aktualny klucz w nagłówku Authorization: Bearer <key>. Jeśli to konieczne, utwórz konto, poproś o kwalifikujący się kredyt próbny i sprawdź, czy wyświetlone saldo jest gotowe przed wysłaniem żądań.
Przykłady odczytują klucz ze zmiennej środowiskowej o nazwie API_KEY. Wyeksportuj go raz w powłoce i żaden z fragmentów kodu nie wymaga edycji. Nigdy nie wklejaj klucza do kodu źródłowego ani nie wysyłaj go w JavaScript w przeglądarce; wywołuj API z poziomu swojego backendu.
export API_KEY="paste-your-key-here"Python, z użyciem oficjalnego pakietu openai (v1 lub nowszego). Jedyne różnice w porównaniu do standardowej konfiguracji OpenAI to base_url i nazwa modelu.
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, z użyciem pakietu npm openai (v4 lub nowszego) jako modułu ES.
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);I zwykłe cURL, które jest najszybszym sposobem na sprawdzenie, czy klucz działa:
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
}'Odpowiedź ma standardowy kształt OpenAI: choices[0].message.content dla tekstu oraz obiekt usage z liczbą tokenów prompt i completion, które możesz przemnożyć przez ceny za token, aby śledzić wydatki. Zobacz dokumentację, aby uzyskać pełną listę parametrów.
Strumieniowanie (SSE) z użyciem SDK
Ustaw stream: true, a API zwróci zdarzenia wysyłane przez serwer zamiast jednego obiektu JSON. Oba oficjalne SDK zamieniają to w iterator, dzięki czemu Twój kod może iterować po fragmentach i wypisywać każdy delta. Końcowy fragment zawierający token usage jest dodawany automatycznie; nie musisz go żądać. Ten fragment ma pustą listę choices, więc zabezpiecz indeks przed jego odczytem.
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)Wersja Node.js używa 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);
}Strumieniowanie nie zmienia zasad rozliczeń. Płacisz za te same tokeny wejściowe i wyjściowe; po prostu widzisz pierwsze słowa szybciej, co ma znaczenie w interfejsach czatu i roleplay, gdzie oczekiwanie na pełną odpowiedź 500 tokenów wydaje się wolne.
Strumieniowanie z surowym fetch
Jeśli wolisz nie polegać na SDK, np. w funkcji edge lub małym skrypcie, możesz odczytać strumień samodzielnie. Format sieciowy to zwykłe SSE: każde zdarzenie to linia zaczynająca się od data:, za którą następuje chunk JSON, a zdarzenia są oddzielone pustymi liniami. Chunki sieciowe nie pokrywają się z granicami zdarzeń, więc musisz buforować i dzielić po nowych liniach. Poniższy przykład działa w Node 18 lub nowszym (zapisz go jako stream.mjs) i działa również w dowolnym środowisku z standardowym fetch i 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);
}
}Sprawdź res.ok przed rozpoczęciem odczytu. Błędy takie jak 401, 402 lub 403 przychodzą jako zwykły obiekt JSON z obiektem error, a nie jako strumień zdarzeń, więc ich parsowanie jako SSE cicho zwróci nic. W przeglądarce możesz użyć tej samej logiki z res.body.getReader(), ale pamiętaj, że przeglądarka musi wywołać Twój backend, a nie to API bezpośrednio z tajnym kluczem.
Wywoływanie funkcji z użyciem narzędzi i tool_choice
Wywoływanie narzędzi używa formatu OpenAI. Opisujesz funkcje w tools, model odpowiada tool_calls zamiast tekstem, gdy chce je uruchomić, Ty wykonujesz funkcję samodzielnie i zwracasz wynik jako wiadomość z role: "tool" oraz pasującym tool_call_id. Drugie zapytanie zwraca ostateczną odpowiedź w języku naturalnym. tool_choice kontroluje zachowanie: "auto" pozwala modelowi zdecydować, "none" zabrania narzędzi, a obiekt taki jak {"type": "function", "function": {"name": "get_order_status"}} wymusza tę funkcję.
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)Ta sama pętla w 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);
}Dwie praktyczne uwagi. Po pierwsze, arguments to ciąg JSON wygenerowany przez model językowy, więc zawsze opakuj json.loads w obsługę błędów w produkcji i waliduj pola przed dotknięiem bazy danych. Po drugie, definicje narzędzi liczą się jako tokeny wejściowe przy każdym zapytaniu, więc trzymaj opisy krótkie i wysyłaj tylko narzędzia istotne dla bieżącego kroku.
Ponawianie z opóźnieniem przy 429 i 503
Dwa błędy są warte ponowienia. 429 oznacza, że przekroczyłeś limit 300 zapytań na minutę dla swojego klucza. 503 z kodem upstream_busy oznacza, że usługa jest chwilowo przeciążona; oczekiwanie kilku sekund to zamierzona reakcja. Nie ponawiaj 400 (napraw zapytanie), 401 (napraw klucz), 402 no_credit (doładuj saldo) ani 403 content_blocked (zapytanie zostanie zablokowane ponownie). Błędy mają jeden kształt JSON, {"error":{"code":...,"message":...}}, więc możesz logować kod bezpośrednio.
SDK OpenAI już ponawiają błędy połączenia, 429 i 5xx kilka razy domyślnie, a możesz to podnieść za pomocą max_retries. Jeśli chcesz kontrolować opóźnienia, wyłącz wbudowane ponowienia i opakuj wywołanie samodzielnie, używając wykładniczego opóźnienia z jitterem, aby pracownicy równolegli nie ponawiali w tym samym czasie.
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)Równoważnik z surowym fetch w 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);Jeśli regularnie trafiasz na 429, lepszym rozwiązaniem jest zazwyczaj ograniczenie współbieżności po stronie klienta (semafor lub kolejka z pięcioma do dziesięciu pracownikami), a nie dłuższe spania. Przy 300 zapytaniach na minutę możesz utrzymać pięć zapytań na sekundę, co jest wystarczające dla większości aplikacji.
Stan rozmowy wieloetapowej
API jest bezstanowe. Nie pamięta wcześniejszych zapytań, więc każde wywołanie musi zawierać historię, którą model ma zobaczyć. Trzymaj listę wiadomości, dołącz turę użytkownika, wywołaj API, dołącz odpowiedź asystenta i powtarzaj. Wiadomość systemowa na indeksie 0 zawiera personę lub instrukcje i jest wysyłana za każdym razem.
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?"))Ponieważ cała historia jest wysyłana ponownie, koszt wejścia rośnie z każdą turą. Okno kontekstu wynosi 100 000 tokenów i obejmuje prompt i completion łącznie, więc bardzo długa sesja w końcu zwróci błąd 400, gdy sam prompt przekroczy limit (przy prompt + max_tokens ponad limitem odpowiedź kończy się po prostu na końcu okna). Powszechne strategie to odrzucanie najstarszych par użytkownik/asystent przy jednoczesnym zachowaniu wiadomości systemowej lub proszenie modelu o zsumowanie starszych tur w jedną krótką wiadomość i ich zastąpienie. Przechowuj historię we własnej bazie danych kluczowanej po id rozmowy, aby restart nie utracił wątku. Przykłady długich sesji z realistycznymi szacunkami kosztów znajdziesz na stronie przypadków użycia.
Kontrola kosztów z użyciem max_tokens
Ceny to $0,15 za milion tokenów wejściowych i $0,50 za milion tokenów wyjściowych, naliczane z salda przedpłaconego. Output jest około 3,3 razy droższy niż input, a max_tokens to opcjonalny limit outputu dla pojedynczego zapytania. Jeśli go nie ustawisz, odpowiedź może sięgać do końca okna kontekstowego. Świadome jego ustawienie to najprostsza kontrola kosztów, jaką masz.
Matematyka najgorszego przypadku pomaga. Jeśli nie ustawisz limitu dla outputu, odpowiedź może sięgnąć końca okna kontekstowego, więc sam output może kosztować nawet 100,000 × $0,50 / 1 000 000 = $0,05. Jeśli ustawisz max_tokens na 300 dla odpowiedzi czatu, najgorszy przypadek spada do $0,00015. Typowa tura z 1 500 tokenami wejściowymi i 300 tokenami wyjściowymi kosztuje około $0,000225 plus $0,00015, co jest poniżej $0,001.
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)Obserwuj finish_reason. Wartość length oznacza, że odpowiedź osiągnęła Twój limit i została ucięta; jeśli dzieje się to często, zwiększ limit lub poproś o krótszą odpowiedź w promptcie, ponieważ sam limit powoduje ucięcie, a nie skondensowanie odpowiedzi przez model. Połącz limit z instrukcjami, np. docelową liczbą słów, i loguj usage przy każdym wywołaniu, aby zobaczyć rzeczywiste średnie, a nie zgadywać. Twój darmowy kredyt próbny i szczegóły salda znajdziesz na stronie z cenami.
Pytania i odpowiedzi
Czy potrzebujesz specjalnego SDK do tego API AI bez cenzury?
Nie. Oficjalny pakiet openai dla Pythona (v1+) i pakiet openai npm (v4+) działają. Ustaw base_url na https://api.uncensoredaiapis.com/v1, przekaż klucz i użyj id modelu uncensored.
Czy strumieniowanie obejmuje użycie tokenów?
Tak. Przy stream: true API dodaje ostatni chunk, który automatycznie zawiera usage. Ten chunk ma pustą tablicę choices, więc sprawdź, czy choices istnieje, zanim odczytasz delta.
Które błędy powinien powtarzać mój kod?
Ponawiaj 429 (limit zapytań, 300 zapytań na minutę na klucz) i 503 upstream_busy z wykładniczym opóźnieniem i jitterem. Nie ponawiaj 400, 401, 402 ani 403, ponieważ to samo zapytanie i tak się nie powiedzie.
Czy historia rozmowy jest przechowywana między wywołaniami?
Nie. Każde zapytanie jest niezależne, więc za każdym razem wysyłasz pełną listę messages. Okno kontekstu wynosi 100 000 tokenów dla promptu i completion łącznie.
Twój klucz jest o jeden formularz stąd
Utwórz konto, skopiuj klucz, zmień bazowy URL. To cała konfiguracja.