Exemplos de código da API Uncensored AI em Python, Node.js e cURL
Esta página reúne código para copiar e colar da API de IA sem censura, que segue o formato de completions de chat da OpenAI. Você encontrará as primeiras chamadas em Python, Node.js e cURL, streaming com o SDK e com fetch bruto, chamada de funções, lógica de retentativa para 429 e 503, estado multi-turno e controle de custo com max_tokens.

Pontos principais
- Use o SDK openai oficial com base_url definido para https://api.uncensoredaiapis.com/v1 e modelo "uncensored"; nenhum cliente personalizado é necessário.
- O streaming retorna blocos SSE, e um bloco de uso final chega automaticamente com uma lista choices vazia.
- Retente apenas 429 e 503 (upstream_busy); 400, 401, 402 e 403 precisam de correção, não de retentativa.
- A API é sem estado: reenvie o histórico a cada turno e limite a saída com max_tokens (opcional; se não definido, a resposta pode continuar até o final da janela de contexto).
Primeira chamada: Python, Node.js e cURL
Os exemplos usam https://api.uncensoredaiapis.com/v1, o modelo uncensored e POST /v1/chat/completions ou GET /v1/models. Envie sua chave atual no cabeçalho Authorization: Bearer <key>. Se necessário, crie uma conta, solicite crédito de teste elegível e verifique se o saldo exibido está pronto antes de enviar as requisições.
Os exemplos leem a chave de uma variável de ambiente chamada API_KEY. Exporte-a uma vez no seu shell e nenhum dos trechos precisará de edição. Nunca cole uma chave no código-fonte ou a envie em JavaScript no navegador; chame a API a partir do seu backend.
export API_KEY="paste-your-key-here"Python, usando o pacote oficial openai (v1 ou mais recente). As únicas diferenças em relação a uma configuração OpenAI padrão são base_url e o nome do modelo.
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, usando o pacote npm openai (v4 ou mais recente) como um módulo 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);E cURL puro, que é a maneira mais rápida de verificar se uma chave funciona:
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
}'A resposta tem a forma usual da OpenAI: choices[0].message.content para o texto e um objeto usage com contagens de tokens de prompt e conclusão, que você pode multiplicar pelos preços por token para acompanhar o gasto. Consulte a documentação para a lista completa de parâmetros.
Streaming (SSE) com o SDK
Defina stream: true e a API retorna eventos enviados pelo servidor em vez de um único corpo JSON. Ambos os SDKs oficiais convertem isso em um iterador, então seu código itera sobre os fragmentos e imprime cada delta. Um fragmento final carregando o usage de tokens é adicionado automaticamente; você não precisa solicitá-lo. Esse fragmento tem uma lista choices vazia, então proteja o índice antes de lê-lo.
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)A versão Node.js usa 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);
}O streaming não altera o preço. Você paga pelos mesmos tokens de entrada e saída; você apenas vê as primeiras palavras mais cedo, o que é importante para interfaces de chat e jogos de interpretação onde esperar por uma resposta completa de 500 tokens parece lento.
Streaming com fetch bruto
Se você preferir não depender do SDK, por exemplo em uma função de borda ou um script pequeno, você pode ler o fluxo você mesmo. O formato de rede é SSE simples: cada evento é uma linha começando com data: seguida por um fragmento JSON, e os eventos são separados por linhas em branco. Os fragmentos de rede não se alinham com os limites de evento, então você deve armazenar em buffer e dividir por quebras de linha. O exemplo abaixo roda no Node 18 ou mais recente (salve-o como stream.mjs) e também funciona em qualquer fluxo com o fetch e ReadableStream padrão.
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);
}
}Verifique res.ok antes de começar a ler. Erros como 401, 402 ou 403 chegam como um corpo JSON normal com um objeto error, não como um fluxo de eventos, então analisá-los como SSE produziria silenciosamente nada. Em um navegador, você pode usar a mesma lógica com res.body.getReader(), mas lembre-se que um navegador deve chamar seu próprio backend, nunca esta API diretamente com uma chave secreta.
Chamada de funções com ferramentas e tool_choice
A chamada de ferramentas usa o formato OpenAI. Você descreve funções em tools, o modelo responde com tool_calls em vez de texto quando quer executar uma, você executa a função você mesmo e envia o resultado de volta como uma mensagem com role: "tool" e o tool_call_id correspondente. Uma segunda requisição retorna então a resposta final em linguagem natural. tool_choice controla o comportamento: "auto" permite que o modelo decida, "none" proíbe ferramentas, e um objeto como {"type": "function", "function": {"name": "get_order_status"}} força essa função.
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)O mesmo loop em 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);
}Duas notas práticas. Primeiro, arguments é uma string JSON produzida por um modelo de linguagem, então sempre envolva json.loads em tratamento de erros em produção e valide os campos antes de acessar ou modificar um banco de dados. Segundo, as definições de ferramenta contam como tokens de entrada em cada requisição, então mantenha as descrições curtas e envie apenas as ferramentas relevantes para o turno atual.
Retentativas com recuo em 429 e 503
Dois erros valem a pena retentar. Um 429 significa que você excedeu o limite de 300 requisições por minuto para sua chave. Um 503 com o código upstream_busy significa que o serviço está momentaneamente saturado; esperar alguns segundos é a resposta esperada. Não retente 400 (corrija a requisição), 401 (corrija a chave), 402 no_credit (recarregue o saldo) ou 403 content_blocked (a requisição será bloqueada novamente). Os erros compartilham uma única forma JSON, {"error":{"code":...,"message":...}}, então você pode registrar o código diretamente.
Os SDKs da OpenAI já tentam novamente erros de conexão, 429 e 5xx algumas vezes por padrão, e você pode aumentar isso com max_retries. Se você quiser controle sobre os atrasos, desative as retentativas internas e envolva a chamada você mesmo, usando recuo exponencial com jitter para que os workers paralelos não tentem novamente em sincronia.
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)O equivalente com fetch bruto em 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);Se você atingir 429 regularmente, a melhor solução geralmente é um limite de concorrência pequeno no lado do cliente (um semáforo ou uma fila com cinco a dez workers) em vez de tempos de espera mais longos. Em 300 requisições por minuto, você pode sustentar cinco requisições por segundo, o que é suficiente para a maioria dos aplicativos.
Estado de conversa multi-turno
A API é sem estado. Ela não lembra das requisições anteriores, então cada chamada deve incluir o histórico que você quer que o modelo veja. Mantenha uma lista de mensagens, anexe o turno do usuário, chame a API, anexe a resposta do assistente e repita. Uma mensagem de sistema no índice 0 contém a persona ou instruções e é enviada toda vez.
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?"))Como todo o histórico é reenviado, o custo de entrada cresce a cada turno. A janela de contexto é de 100.000 tokens e cobre o prompt e a conclusão juntos, então uma sessão muito longa eventualmente retornará um erro 400 quando o prompt sozinho exceder o limite (com prompt + max_tokens acima do limite, a resposta só termina no fim da janela). Estratégias comuns são remover os pares de usuário e assistente mais antigos enquanto mantém sempre a mensagem de sistema, ou pedir ao modelo para resumir os turnos mais antigos em uma única mensagem curta e substituí-los. Armazene o histórico em seu próprio banco de dados com chave pelo id da conversa para que uma reinicialização não perca o fio. Para exemplos de sessões longas com estimativas de custo realistas, consulte a página de casos de uso.
Controlando o custo com max_tokens
O preço é $0,15 por milhão de tokens de entrada e $0,50 por milhão de tokens de saída, cobrados de um saldo pré-pago. A saída é cerca de 3,3 vezes mais cara que a entrada, e max_tokens é um limite opcional de saída para uma única requisição. Se você não definir, a resposta pode ir até o fim da janela. Definir isso deliberadamente é o controle de custo mais simples que você tem.
A aritmética do pior caso ajuda. Se você não limitar a saída, uma resposta pode atingir o final da janela de contexto, então a saída sozinha pode custar até 100,000 × $0,50 / 1.000.000 = $0,05. Se você definir max_tokens para 300 para uma resposta de chat, o pior caso cai para $0,00015. Uma rodada típica com 1.500 tokens de entrada e 300 tokens de saída custa cerca de $0,000225 mais $0,00015, que é menos de $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)Observe finish_reason. Um valor de length significa que a resposta atingiu seu limite e foi cortada; se isso acontecer com frequência, aumente o limite ou peça uma saída mais curta no prompt, já que um limite sozinho truncará em vez de tornar o modelo conciso. Combine o limite com instruções como uma contagem de palavras alvo e registre usage para cada chamada para que você possa ver as médias reais em vez de adivinhar. Seu crédito de teste grátis e detalhes do saldo estão na página de preços.
Perguntas e respostas
Preciso de um SDK especial para esta API de IA sem censura?
Não. O pacote Python openai oficial (v1+) e o pacote npm openai (v4+) funcionam. Defina base_url para https://api.uncensoredaiapis.com/v1, passe sua chave e use o id do modelo uncensored.
O streaming inclui o uso de tokens?
Sim. Com stream: true, a API adiciona um último chunk que carrega o uso automaticamente. Esse chunk tem um array choices vazio, então verifique se choices existe antes de ler o delta.
Quais erros meu código deve tentar novamente?
Retentativa em 429 (limite de requisições, 300 requisições por minuto por chave) e 503 upstream_busy com backoff exponencial e jitter. Não retente 400, 401, 402 ou 403 porque a mesma requisição falhará novamente.
O histórico de conversas é armazenado para mim entre as chamadas?
Não. Cada requisição é independente, então você envia a lista completa de mensagens toda vez. A janela de contexto é de 100.000 tokens para prompt e conclusão combinados.
Sua chave está a um formulário de distância
Crie uma conta, copie a chave e altere a URL base. Essa é toda a configuração.