ES ▾
URL base https://api.uncensoredaiapis.com/v1Modelo uncensored
Obtener clave de API
Uncensored AIEjemplos de código

Ejemplos de código de la API de Uncensored AI en Python, Node.js y cURL

Esta página recopila código para copiar y pegar de la API de IA uncensored, que usa el formato de finalizaciones de chat de OpenAI. Encontrarás primeras llamadas en Python, Node.js y cURL, streaming con el SDK y con fetch sin envoltorio, llamadas a funciones, lógica de reintento para 429 y 503, estado multi-turno y control de costos con max_tokens.

Ejemplos de código de la API de Uncensored AI en Python, Node.js y cURL

Actualizado

Puntos clave

  • Usa el SDK oficial de openai con URL base establecida en https://api.uncensoredaiapis.com/v1 y modelo "uncensored"; no se necesita un cliente personalizado.
  • Streaming devuelve fragmentos SSE, y un fragmento de uso final llega automáticamente con una lista choices vacía.
  • Reintenta solo 429 y 503 (upstream_busy); 400, 401, 402 y 403 requieren una corrección, no un reintento.
  • La API es sin estado: reenvía el historial en cada turno y limita la salida con max_tokens (opcional; si no se establece, la respuesta puede extenderse hasta el final de la ventana de contexto).

Primera llamada: Python, Node.js y cURL

Los ejemplos utilizan https://api.uncensoredaiapis.com/v1, el modelo uncensored, y POST /v1/chat/completions o GET /v1/models. Envía tu clave actual en el encabezado Authorization: Bearer <key>. Si es necesario, crea una cuenta, solicita crédito de prueba elegible y comprueba que el saldo mostrado está listo antes de enviar peticiones.

Los ejemplos leen la clave desde una variable de entorno llamada API_KEY. Exporta una vez en tu shell y ninguno de los fragmentos necesita edición. No pegues nunca una clave en el código fuente ni la envíes en JavaScript del navegador; llama a la API desde tu backend.

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

Python, usando el paquete oficial openai (v1 o superior). Las únicas diferencias con una configuración estándar de OpenAI son base_url y el nombre del 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 el paquete npm openai (v4 o superior) como 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);

Y cURL puro, que es la forma más rápida de comprobar que una clave 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
  }'

La respuesta tiene la forma habitual de OpenAI: choices[0].message.content para el texto y un objeto usage con los recuentos de tokens del prompt y la completación, que puedes multiplicar por los precios por token para controlar el gasto. Consulta la documentación para la lista completa de parámetros.

Streaming (SSE) con el SDK

Establece stream: true y la API devuelve eventos enviados por el servidor en lugar de un único cuerpo JSON. Ambos SDK oficiales convierten eso en un iterador, por lo que tu código recorre los fragmentos e imprime cada delta. Un fragmento final que contiene el uso de tokens usage se añade automáticamente; no necesitas solicitarlo. Ese fragmento tiene una lista choices vacía, así que protege el índice antes de leerlo.

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)

La versión de 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);
}

El streaming no cambia la facturación. Pagas por los mismos tokens de entrada y salida; simplemente ves las primeras palabras antes, lo cual importa para interfaces de chat y roleplay donde esperar una respuesta completa de 500 tokens se siente lento.

Streaming con fetch sin envoltorio

Si prefieres no depender del SDK, por ejemplo en una función de borde o un script pequeño, puedes leer el stream tú mismo. El formato de red es SSE plano: cada evento es una línea que comienza con data: seguida de un fragmento JSON, y los eventos se separan con líneas en blanco. Los fragmentos de red no se alinean con los límites de evento, así que debes hacer buffer y dividir por saltos de línea. El ejemplo de abajo se ejecuta en Node 18 o superior (guárdalo como stream.mjs) y también funciona en cualquier entorno con fetch y ReadableStream estándar.

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

Verifica res.ok antes de empezar a leer. Los errores como 401, 402 o 403 llegan como un cuerpo JSON normal con un objeto error, no como un stream de eventos, así que analizarlos como SSE no produciría nada. En un navegador puedes usar la misma lógica con res.body.getReader(), pero recuerda que un navegador debe llamar a tu propio backend, nunca a esta API directamente con una clave secreta.

Llamadas a funciones con herramientas y tool_choice

Las llamadas a herramientas usan el formato de OpenAI. Describes funciones en tools, el modelo responde con tool_calls en lugar de texto cuando quiere ejecutar una, ejecutas la función tú mismo y envías el resultado de vuelta como un mensaje con role: "tool" y el matching tool_call_id. Una segunda petición devuelve entonces la respuesta final en lenguaje natural. tool_choice controla el comportamiento: "auto" permite que el modelo decida, "none" desactiva las herramientas, y un objeto como {"type": "function", "function": {"name": "get_order_status"}} fuerza esa función.

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)

El mismo bucle en 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);
}

Dos notas prácticas. Primero, arguments es una cadena JSON producida por un modelo de lenguaje, así que siempre envuelve json.loads en manejo de errores en producción y valida los campos antes de modificar una base de datos. Segundo, las definiciones de herramientas cuentan como tokens de entrada en cada petición, así que mantén las descripciones cortas y envía solo las herramientas relevantes para el paso actual.

Reintentos con retroceso en 429 y 503

Dos errores merecen reintento. Un 429 significa que excediste el límite de 300 peticiones por minuto para tu clave. Un 503 con el código upstream_busy significa que el servicio está momentáneamente saturado; esperar unos segundos es la respuesta prevista. No reintentes 400 (corrige la petición), 401 (corrige la clave), 402 no_credit (recarga el saldo), o 403 content_blocked (la petición se bloqueará de nuevo). Los errores comparten una forma JSON única, {"error":{"code":...,"message":...}}, así que puedes registrar el código directamente.

Los SDKs de OpenAI ya reintentan errores de conexión, 429 y 5xx un par de veces por defecto, y puedes aumentar eso con max_retries. Si quieres control sobre los retrasos, desactiva los reintentos incorporados y envuelve la llamada tú mismo, usando retroceso exponencial con variación aleatoria para que los trabajadores paralelos no reintenten al mismo tiempo.

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)

Lo equivalente con fetch crudo en 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);

Si recibes un 429 regularmente, la mejor solución suele ser un límite de concurrencia en el lado del cliente (un semáforo o una cola con cinco a diez trabajadores) en lugar de esperas más largas. A 300 peticiones por minuto puedes sostener cinco peticiones por segundo, lo cual es suficiente para la mayoría de las aplicaciones.

Estado de conversación multi-turno

La API es sin estado. No recuerda las peticiones anteriores, así que cada llamada debe incluir el historial que quieres que vea el modelo. Mantén una lista de mensajes, añade el turno del usuario, llama a la API, añade la respuesta del asistente y repite. Un mensaje de sistema en el índice 0 contiene la personalidad o instrucciones y se envía cada 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 se reenvía todo el historial, el costo de entrada crece con cada turno. La ventana de contexto es de 100.000 tokens y cubre el prompt y el completado juntos, así que una sesión muy larga acabará devolviendo un error 400 cuando el prompt por sí solo exceda el límite, mientras que si prompt + max_tokens lo excede, la respuesta simplemente se detiene al final de la ventana. Las estrategias comunes son eliminar los pares de usuario y asistente más antiguos mientras se mantiene siempre el mensaje del sistema, o pedirle al modelo que resuma los turnos antiguos en un mensaje corto y reemplazarlos. Almacena el historial en tu propia base de datos indexado por id de conversación para que un reinicio no pierda el hilo. Para ejemplos de sesiones largas con estimaciones de costo realistas, consulta la página de casos de uso.

Control de costos con max_tokens

Los precios son $0,15 por millón de tokens de entrada y $0,50 por millón de tokens de salida, facturados desde un saldo prepago. La salida es unas 3,3 veces más cara que la entrada, y max_tokens es un límite opcional de salida para una única petición. Si no lo estableces, la respuesta puede extenderse hasta el final de la ventana. Establecerlo deliberadamente es el control de costos más simple que tienes.

Los cálculos del peor caso ayudan. Si no se limita la salida, una respuesta puede extenderse hasta el final de la ventana, por lo que solo la salida podría costar hasta 100,000 × $0.50 / 1,000,000 = $0.05. Si estableces max_tokens en 300 para una respuesta de chat, el peor caso baja a $0.00015. Un turno típico con 1,500 tokens de entrada y 300 tokens de salida cuesta unos $0.000225 más $0.00015, que es 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)

Observa finish_reason. Un valor de length significa que la respuesta alcanzó tu límite y fue cortada; si eso pasa a menudo, sube el límite o pide una salida más corta en el prompt, ya que un límite solo truncará en lugar de hacer que el modelo sea conciso. Combina el límite con instrucciones como un recuento de palabras objetivo, y registra usage para cada llamada para ver promedios reales en lugar de adivinar. Tu crédito de prueba gratis y los detalles del saldo están en la página de precios.

Preguntas y respuestas

¿Necesito un SDK especial para esta API de IA uncensored?

No. El paquete oficial de Python de openai (v1+) y el paquete npm de openai (v4+) funcionan. Establece la URL base en https://api.uncensoredaiapis.com/v1, proporciona tu clave y usa el id de modelo uncensored.

¿El streaming incluye el uso de tokens?

Sí. Con stream: true la API añade un fragmento final que lleva el uso automáticamente. Ese fragmento tiene un array choices vacío, así que verifica que choices exista antes de leer el fragmento de respuesta.

¿Qué errores debería reintentar mi código?

Reintenta 429 (límite de peticiones, 300 peticiones por minuto por clave) y 503 upstream_busy con retroceso exponencial y variación aleatoria. No reintentes 400, 401, 402 ni 403 porque la misma petición volverá a fallar.

¿Se almacena el historial de la conversación entre llamadas?

No. Cada petición es independiente, por lo que envías la lista completa de mensajes cada vez. La ventana de contexto es de 100.000 tokens combinando el prompt y la respuesta generada.

Tu clave está a un formulario de distancia

Crea una cuenta, copia la clave, cambia la URL base. Esa es toda la configuración.