FR ▾
Base URL https://api.uncensoredaiapis.com/v1Modèle uncensored
Obtenir une clé API
Uncensored AIExemples de code

Exemples de code de l'API Uncensored AI en Python, Node.js et cURL

Cette page recueille du code à copier-coller pour l'API IA sans censure, qui utilise le format OpenAI chat completions. Vous y trouverez les premières requêtes en Python, Node.js et cURL, le streaming avec le SDK et avec fetch nu, l'appel de fonctions, la logique de nouvelle tentative pour les erreurs 429 et 503, la gestion de l'état multi-tours et le contrôle des coûts avec max_tokens.

Exemples de code de l'API Uncensored AI en Python, Node.js et cURL

Mis à jour le

Points clés

  • Utilisez le SDK openai officiel avec base_url défini sur https://api.uncensoredaiapis.com/v1 et le modèle "uncensored" ; aucun client personnalisé n'est nécessaire.
  • Le streaming renvoie des blocs SSE, et un dernier bloc d'utilisation arrive automatiquement avec une liste choices vide.
  • Renouveler uniquement les erreurs 429 et 503 (upstream_busy) ; les erreurs 400, 401, 402 et 403 nécessitent une correction, pas une nouvelle tentative.
  • L'API est sans état : renvoyez l'historique à chaque tour et limitez la sortie avec max_tokens (optionnel ; si non défini, la réponse peut s'étendre jusqu'à la fin de la fenêtre de contexte).

Premier appel : Python, Node.js et cURL

Les exemples utilisent https://api.uncensoredaiapis.com/v1, le modèle uncensored, et POST /v1/chat/completions ou GET /v1/models. Envoyez votre clé actuelle dans l'en-tête Authorization: Bearer <key>. Si nécessaire, créez un compte, demandez un crédit d'essai éligible et vérifiez que le solde affiché est prêt avant d'envoyer des requêtes.

Les exemples lisent la clé depuis une variable d'environnement nommée API_KEY. Exportez-la une fois dans votre shell et aucun des extraits ne nécessitera d'édition. Ne collez jamais une clé dans du code source ou ne l'expédiez pas dans du JavaScript côté navigateur ; appelez l'API depuis votre backend.

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

Python, en utilisant le package officiel openai (v1 ou plus récent). Les seules différences par rapport à une configuration OpenAI standard sont base_url et le nom du modèle.

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, en utilisant le package npm openai (v4 ou plus récent) en tant que module 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);

Et du cURL brut, qui est le moyen le plus rapide de vérifier qu'une clé fonctionne :

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 réponse a la forme habituelle d'OpenAI : choices[0].message.content pour le texte et un objet usage avec les compteurs de tokens de prompt et de complétion, que vous pouvez multiplier par les prix par token pour suivre les dépenses. Consultez la documentation pour la liste complète des paramètres.

Streaming (SSE) avec le SDK

Définissez stream: true et l'API retourne des événements envoyés par le serveur au lieu d'un seul corps JSON. Les deux SDK officiels transforment cela en itérateur, donc votre code boucle sur les chunks et imprime chaque delta. Un dernier chunk contenant l'utilisation de token usage est ajouté automatiquement ; vous n'avez pas besoin de le demander. Ce chunk a une liste choices vide, donc protégez l'index avant de le lire.

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 version Node.js utilise 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);
}

Le streaming ne change pas la tarification. Vous payez pour les mêmes tokens d'entrée et de sortie ; vous voyez simplement les premiers mots plus tôt, ce qui est important pour les interfaces de chat et de jeu de rôle où attendre une réponse complète de 500 tokens semble lent.

Streaming avec fetch brut

Si vous préférez ne pas dépendre du SDK, par exemple dans une fonction edge ou un petit script, vous pouvez lire le flux vous-même. Le format filaire est du SSE brut : chaque événement est une ligne commençant par data: suivie d'un chunk JSON, et les événements sont séparés par des lignes vides. Les chunks réseau ne s'alignent pas sur les limites d'événements, vous devez donc mettre en tampon et diviser sur les sauts de ligne. L'exemple ci-dessous s'exécute sur Node 18 ou plus récent (enregistrez-le sous stream.mjs) et fonctionne également dans n'importe quel runtime avec fetch et ReadableStream standards.

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

Vérifiez res.ok avant de commencer à lire. Les erreurs telles que 401, 402 ou 403 arrivent sous forme de corps JSON normal avec un objet error, pas comme un flux d'événements, donc les analyser comme du SSE produirait silencieusement rien. Dans un navigateur, vous pouvez utiliser la même logique avec res.body.getReader(), mais rappelez-vous qu'un navigateur doit appeler votre propre backend, jamais cette API directement avec une clé secrète.

Appel de fonctions avec outils et tool_choice

L'appel d'outils utilise le format OpenAI. Vous décrivez des fonctions dans tools, le modèle répond avec tool_calls au lieu de texte lorsqu'il en veut un, vous exécutez la fonction vous-même, et vous renvoyez le résultat en tant que message avec role: "tool" et l'identifiant tool_call_id correspondant. Une deuxième requête retourne ensuite la réponse finale en langage naturel. tool_choice contrôle le comportement : "auto" laisse le modèle décider, "none" interdit les outils, et un objet tel que {"type": "function", "function": {"name": "get_order_status"}} force cette fonction.

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)

La même boucle 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);
}

Deux notes pratiques. Premièrement, arguments est une chaîne JSON produite par un modèle de langage, donc enveloppez toujours json.loads dans la gestion des erreurs en production et validez les champs avant de toucher à une base de données. Deuxièmement, les définitions d'outils comptent comme des tokens d'entrée sur chaque requête, donc gardez les descriptions courtes et n'envoyez que les outils pertinents pour l'étape actuelle.

Retries avec backoff sur 429 et 503

Deux erreurs méritent un retry. Un 429 signifie que vous avez dépassé la limite de 300 requêtes par minute pour votre clé. Un 503 avec le code upstream_busy signifie que le service est momentanément saturé ; attendre quelques secondes est la réponse prévue. Ne réessayez pas sur 400 (corrigez la requête), 401 (corrigez la clé), 402 no_credit (rechargez le solde), ou 403 content_blocked (la requête sera à nouveau bloquée). Les erreurs partagent une forme JSON unique, {"error":{"code":...,"message":...}}, donc vous pouvez logger le code directement.

Les SDK OpenAI réessayent déjà les erreurs de connexion, 429 et 5xx quelques fois par défaut, et vous pouvez augmenter cela avec max_retries. Si vous voulez contrôler les délais, désactivez les retries intégrés et enveloppez l'appel vous-même, en utilisant un backoff exponentiel avec jitter pour que les travailleurs parallèles ne réessayent pas en synchronisation.

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'équivalent avec fetch brut 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 vous atteignez régulièrement 429, la meilleure correction est généralement un cap de concurrence côté client (un sémaphore ou une file d'attente avec cinq à dix travailleurs) plutôt que des temps d'attente plus longs. À 300 requêtes par minute, vous pouvez soutenir cinq requêtes par seconde, ce qui est suffisant pour la plupart des applications.

État de conversation multi-tours

L'API est sans état. Elle ne se souvient pas des requêtes précédentes, donc chaque appel doit inclure l'historique que vous voulez que le modèle voie. Gardez une liste de messages, ajoutez le tour utilisateur, appelez l'API, ajoutez la réponse de l'assistant, et répétez. Un message système à l'index 0 contient la personnalité ou les instructions et est envoyé à chaque fois.

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

Parce que tout l'historique est renvoyé, le coût d'entrée augmente à chaque tour. La fenêtre de contexte est de 100 000 tokens et couvre le prompt et la complétion ensemble, donc une session très longue finira par retourner une erreur 400 lorsque le prompt seul dépasse la limite, tandis que si prompt + max_tokens la dépasse, la réponse s'arrête simplement à la fin de la fenêtre. Les stratégies courantes consistent à supprimer les paires utilisateur et assistant les plus anciennes tout en gardant toujours le message système, ou à demander au modèle de résumer les tours anciens en un seul message court et de les remplacer. Stockez l'historique dans votre propre base de données avec l'identifiant de conversation comme clé pour qu'un redémarrage ne perde pas le fil. Pour des exemples de longues sessions avec des estimations de coût réalistes, consultez la page des cas d'utilisation.

Contrôle des coûts avec max_tokens

La tarification est de $0,15 par million de tokens d'entrée et de $0,50 par million de tokens de sortie, facturés depuis un solde prépayé. La sortie est environ 3,3 fois plus chère que l'entrée, et max_tokens est un cap optionnel sur la sortie pour une seule requête. Si vous ne le définissez pas, la réponse peut s'étendre jusqu'à la fin de la fenêtre. Le définir délibérément est le contrôle de coût le plus simple dont vous disposez.

L'arithmétique du pire cas aide. Si vous ne limitez pas la sortie, une réponse peut s'étendre jusqu'à la fin de la fenêtre contextuelle, donc la sortie seule pourrait coûter jusqu'à 100 000 × $0,50 / 1 000 000 = $0,05. Si vous définissez max_tokens à 300 pour une réponse de chat, le pire cas tombe à $0,00015. Un tour typique avec 1 500 tokens d'entrée et 300 tokens de sortie coûte environ $0,000225 plus $0,00015, ce qui est inférieur à $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)

Surveillez finish_reason. Une valeur de length signifie que la réponse a atteint votre cap et a été coupée ; si cela arrive souvent, augmentez le cap ou demandez une sortie plus courte dans le prompt, car un cap seul tronque plutôt que de rendre le modèle concis. Associez le cap à des instructions telles qu'un nombre de mots cible, et loggez usage pour chaque appel pour voir les moyennes réelles au lieu de deviner. Votre crédit d'essai gratuit et les détails de votre solde sont sur la page de tarification.

Questions et réponses

Dois-je utiliser un SDK spécial pour cette API IA sans censure ?

Non. Les packages officiels openai pour Python (v1+) et npm (v4+) fonctionnent. Définissez base_url sur https://api.uncensoredaiapis.com/v1, passez votre clé et utilisez l'identifiant de modèle uncensored.

Le streaming inclut-il l'utilisation de tokens ?

Oui. Avec stream: true, l'API ajoute un dernier chunk qui contient automatiquement les informations d'utilisation. Ce chunk a un tableau choices vide, donc vérifiez que choices existe avant de lire le delta.

Quelles erreurs mon code doit-il réessayer ?

Reessayez sur 429 (limite de débit, 300 requêtes par minute par clé) et 503 upstream_busy avec un backoff exponentiel et du jitter. Ne réessayez pas sur 400, 401, 402 ou 403 car la même requête échouera à nouveau.

L'historique de conversation est-il conservé pour moi entre les appels ?

Non. Chaque requête est indépendante, vous devez donc envoyer la liste complète des messages à chaque fois. La fenêtre de contexte est de 100 000 tokens pour le prompt et la complétion combinés.

Votre clé n'est qu'à un formulaire d'ici

Créez un compte, copiez la clé, modifiez l'URL de base. C'est toute la configuration.