IT ▾
Base URL https://api.uncensoredaiapis.com/v1Modello uncensored
Ottieni la chiave API
Uncensored AIEsempi di codice

Esempi di codice API Uncensored AI in Python, Node.js e cURL

Questa pagina raccoglie codice copia-incolla per l'API AI senza censura, che utilizza il formato delle chat completions di OpenAI. Troverai le prime chiamate in Python, Node.js e cURL, lo streaming con l'SDK e con fetch grezzo, la chiamata di funzioni, la logica di ritentativo per 429 e 503, lo stato multi-turno e il controllo dei costi con max_tokens.

Esempi di codice API Uncensored AI in Python, Node.js e cURL

Aggiornato

Punti chiave

  • Usa l'SDK openai ufficiale con base_url impostato su https://api.uncensoredaiapis.com/v1 e modello "uncensored"; non è necessario un client personalizzato.
  • Lo streaming restituisce chunk SSE e un chunk finale di utilizzo arriva automaticamente con un elenco choices vuoto.
  • Riprova solo su 429 e 503 (upstream_busy); 400, 401, 402 e 403 richiedono una correzione, non un nuovo tentativo.
  • L'API è stateless: invia di nuovo la cronologia ogni turno e limita l'output con max_tokens (opzionale; se non impostato, la risposta può estendersi fino alla fine della finestra di contesto).

Prima chiamata: Python, Node.js e cURL

Gli esempi usano https://api.uncensoredaiapis.com/v1, il modello uncensored, e POST /v1/chat/completions o GET /v1/models. Invia la tua chiave corrente nell'intestazione Authorization: Bearer <key>. Se necessario, crea un account, richiedi credito di prova idoneo e verifica che il saldo visualizzato sia pronto prima di eseguire le richieste.

Gli esempi leggono la chiave da una variabile d'ambiente chiamata API_KEY. Esportala una volta nel tuo terminale e nessuno degli snippet richiederà modifiche. Non incollare mai una chiave nel codice sorgente o spedirla nel JavaScript del browser; chiama l'API dal tuo backend.

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

Python, usando il pacchetto ufficiale openai (v1 o più recente). Le uniche differenze rispetto a un'installazione OpenAI standard sono base_url e il nome del modello.

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 il pacchetto npm openai (v4 o più recente) come modulo 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, che è il modo più veloce per verificare che una chiave funzioni:

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 risposta ha la solita forma OpenAI: choices[0].message.content per il testo e un oggetto usage con i conteggi dei token di prompt e completamento, che puoi moltiplicare per i prezzi per token per tenere traccia delle spese. Consulta la documentazione per l'elenco completo dei parametri.

Streaming (SSE) con l'SDK

Imposta stream: true e l'API restituisce eventi server-sent invece di un corpo JSON unico. Entrambi gli SDK ufficiali lo trasformano in un iteratore, così il tuo codice scorre i chunk e stampa ogni delta. Un chunk finale contenente usage viene aggiunto automaticamente; non devi richiederlo. Questo chunk ha una lista choices vuota, quindi controlla l'indice prima di leggerlo.

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 versione Node.js utilizza 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);
}

Lo streaming non cambia il pricing. Paghi gli stessi token di input e output; vedi semplicemente le prime parole prima, il che conta per le interfacce di chat e roleplay dove aspettare una risposta completa di 500 token sembra lento.

Streaming con fetch grezzo

Se preferisci non dipendere dall'SDK, ad esempio in una funzione edge o in uno script piccolo, puoi leggere lo stream da solo. Il formato sul wire è SSE puro: ogni evento è una riga che inizia con data: seguita da un chunk JSON, e gli eventi sono separati da righe vuote. I chunk di rete non si allineano ai confini degli eventi, quindi devi fare buffering e dividere a capo. L'esempio qui sotto funziona su Node 18 o più recente (salvalo come stream.mjs) e funziona anche in qualsiasi runtime con fetch e ReadableStream standard.

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 prima di iniziare a leggere. Errori come 401, 402 o 403 arrivano come un corpo JSON normale con un oggetto error, non come un flusso di eventi, quindi analizzarli come SSE produrrebbe silenziosamente nulla. In un browser puoi usare la stessa logica con res.body.getReader(), ma ricorda che un browser deve chiamare il tuo backend, non questa API direttamente con una chiave segreta.

Chiamata di funzioni con strumenti e tool_choice

La chiamata di strumenti utilizza il formato OpenAI. Descrivi le funzioni in tools, il modello risponde con tool_calls invece che testo quando ne vuole eseguire uno, esegui la funzione tu stesso e invia il risultato come messaggio con role: "tool" e il corrispondente tool_call_id. Una seconda richiesta restituisce quindi la risposta finale in linguaggio naturale. tool_choice controlla il comportamento: "auto" lascia decidere al modello, "none" vieta gli strumenti e un oggetto come {"type": "function", "function": {"name": "get_order_status"}} forza quella funzione.

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)

Lo stesso loop 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);
}

Due note pratiche. Primo, arguments è una stringa JSON prodotta da un modello linguistico, quindi avvolgi sempre json.loads nella gestione degli errori in produzione e valida i campi prima di toccare un database. Secondo, le definizioni degli strumenti contano come token di input su ogni richiesta, quindi mantieni le descrizioni brevi e invia solo gli strumenti rilevanti per il passaggio corrente.

Ritentativi con attesa esponenziale su 429 e 503

Due errori valgono la pena di essere ritentati. Un 429 significa che hai superato il limite di 300 richieste al minuto per la tua chiave. Un 503 con il codice upstream_busy significa che il servizio è momentaneamente saturo; aspettare qualche secondo è la risposta prevista. Non ritentare 400 (correggi la richiesta), 401 (correggi la chiave), 402 no_credit (ricarica il saldo), o 403 content_blocked (la richiesta verrà bloccata di nuovo). Gli errori condividono una forma JSON unica, {"error":{"code":...,"message":...}}, così puoi registrare il codice direttamente.

Gli SDK OpenAI già ritentano gli errori di connessione, 429 e 5xx un paio di volte per impostazione predefinita, e puoi alzare questo valore con max_retries. Se vuoi controllare i ritardi, disabilita i ritentativi integrati e avvolgi la chiamata tu stesso, usando un'attesa esponenziale con jitter così i lavoratori paralleli non ritentano in sincrono.

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)

L'equivalente con fetch grezzo 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);

Se incontri spesso 429, la soluzione migliore è solitamente un limite di concorrenza lato client (un semaforo o una coda con cinque a dieci lavoratori) piuttosto che sleep più lunghi. A 300 richieste al minuto puoi sostenere cinque richieste al secondo, che sono sufficienti per la maggior parte delle app.

Stato conversazione multi-turn

L'API è stateless. Non ricorda le richieste precedenti, quindi ogni chiamata deve includere la cronologia che vuoi che il modello veda. Tieni un elenco di messaggi, aggiungi il turno utente, chiama l'API, aggiungi la risposta dell'assistente e ripeti. Un messaggio di sistema all'indice 0 contiene la persona o le istruzioni e viene inviato ogni volta.

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

Poiché l'intera cronologia viene rispedita, il costo dell'input cresce con ogni turno. La finestra di contesto è di 100.000 token e copre il prompt e il completamento insieme, quindi una sessione molto lunga restituirà un errore 400 quando il prompt supera il limite, mentre se prompt + max_tokens supera il limite la risposta si ferma alla fine della finestra. Le strategie comuni sono eliminare le coppie utente e assistente più vecchie mantenendo sempre il messaggio di sistema, oppure chiedere al modello di riassumere i turni più vecchi in un breve messaggio e sostituirli. Memorizza la cronologia nel tuo database con chiave per l'ID conversazione così un riavvio non perde il filo. Per esempi di sessioni lunghe con stime di costo realistiche, vedi la pagina dei casi d'uso.

Controllo dei costi con max_tokens

Il prezzo è $0,15 per milione di token di input e $0,50 per milione di token di output, fatturati da un saldo prepagato. L'output è circa 3,3 volte più costoso dell'input, e max_tokens è un limite opzionale sull'output per una singola richiesta. Se non lo imposti, la risposta può estendersi fino alla fine della finestra. Impostarlo deliberatamente è il controllo dei costi più semplice che hai.

I calcoli nel caso peggiore aiutano. Se non si imposta un limite all'output, una risposta può arrivare fino alla fine della finestra di contesto, quindi il solo output potrebbe costare fino a 100,000 × $0,50 / 1.000.000 = $0,05. Se imposti max_tokens a 300 per una risposta di chat, il caso peggiore scende a $0,00015. Un turno tipico con 1.500 token di input e 300 token di output costa circa $0,000225 più $0,00015, che è sotto $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)

Osserva finish_reason. Un valore di length significa che la risposta ha raggiunto il tuo limite ed è stata troncata; se succede spesso, alza il limite o chiedi output più brevi nel prompt, poiché un limite da solo tronca invece di rendere il modello conciso. Accoppia il limite con istruzioni come un conteggio di parole target, e registra usage per ogni chiamata così puoi vedere le medie reali invece di indovinare. Il tuo credito di prova gratuito e i dettagli del saldo sono nella pagina dei prezzi.

Domande e risposte

Mi serve un SDK speciale per questa API AI senza censura?

No. Il pacchetto Python ufficiale openai (v1+) e il pacchetto npm openai (v4+) funzionano. Imposta base_url su https://api.uncensoredaiapis.com/v1, passa la tua chiave e usa l'ID del modello uncensored.

Lo streaming include l'utilizzo dei token?

Sì. Con stream: true l'API aggiunge un chunk finale che trasporta automaticamente l'utilizzo. Questo chunk ha un array choices vuoto, quindi verifica che choices esista prima di leggere il delta.

Quali errori dovrebbe ritentare il mio codice?

Riprova su 429 (limite di richieste, 300 richieste al minuto per chiave) e 503 upstream_busy con backoff esponenziale e jitter. Non riprovare su 400, 401, 402 o 403 perché la stessa richiesta fallirà di nuovo.

La cronologia delle conversazioni viene salvata per me tra le chiamate?

No. Ogni richiesta è indipendente, quindi invii l'elenco completo dei messaggi ogni volta. La finestra di contesto è di 100.000 token per prompt e completamento combinati.

La tua chiave è a un modulo di distanza

Crea un account, copia la chiave, modifica l'URL di base. È tutta la configurazione.