Integrate the uncensored Model in Minutes

Authentication and Base URL

Start by generating your API key on the dashboard. Use Continue with Google or a simple email and password to create an account instantly. No phone number is required. Your key appears immediately on the screen. Copy it securely. You will need it for every request. The base URL for all endpoints is https://api.abliteration.cc/v1. This URL works with any OpenAI-compatible client. Change the base URL in your SDK configuration. Pass your key in the Authorization header. Use the format Bearer YOUR_API_KEY. One active key per account. Generate a new key to replace the old one. Errors and refusals consume no tokens. Your prepaid credit covers only actual usage. Credit never expires. Top up via USDT or USDC. Get bonus credit for larger deposits. No subscriptions. No hidden fees. Just raw token access.

Chat Completions Endpoint

Call the POST /v1/chat/completions endpoint to generate text. This is the core function of our uncensored API. Send your prompt as a list of messages. The model ID is always uncensored. This model ignores standard content filters for lawful adult use. It does not refuse controversial or explicit topics. Set the max_tokens parameter to control output length. Default is 2,048 tokens. The context window supports up to 100,000 tokens total. This includes both input and output. You can adjust temperature and top_p for creativity. Use the stop parameter to halt generation. The response contains the generated text and token usage. Use the official OpenAI SDKs for easy integration. They handle the HTTP details for you. This approach ensures compatibility with existing tools. You avoid vendor lock-in. Scale usage without surprise bills.

Python SDK Integration

Install the OpenAI Python package to interact with the API easily. Configure the client with your base URL and API key. Pass messages as a list of dictionaries. Define roles like system, user, or assistant. The model ID remains uncensored. This setup works for simple text generation. It also supports complex multi-turn conversations. You can stream responses in Python too. Handle errors gracefully in your code. Check for rate limits or credit issues. The SDK abstracts the HTTP layer. Focus on your application logic. Import the client class. Set the base URL to https://api.abliteration.cc/v1. Add your API key to the headers. Make a completion call. Retrieve the generated text. This method is reliable and fast. It fits into existing Python workflows. No extra dependencies needed. Just the standard OpenAI library.

Node.js SDK Usage

Use the openai Node.js package for quick integration. Initialize the client with your base URL. Set the API key in the environment. Send chat completions with standard message formats. The model ID is uncensored. This ensures consistent uncensored behavior. Configure parameters like temperature and top_p. Use async functions for non-blocking calls. Handle promises or async/await syntax. Check for errors in the response. Rate limits may apply. Handle them with retry logic. The Node.js SDK simplifies HTTP requests. It manages headers and payloads. Integrate into Express routes or serverless functions. Stream data if needed. Process tokens in real-time. This approach keeps your code clean. No complex HTTP logic required. Just standard SDK methods. Deploy your app with confidence. Scale easily with prepaid credits. Crypto billing keeps costs transparent. No monthly subscriptions.

Streaming Responses

Enable streaming by setting stream: true in your request. The API returns data in chunks via Server-Sent Events (SSE). Each chunk contains partial text. Process these chunks in real-time. This reduces perceived latency for users. The final chunk includes total token usage. Read each chunk and append the text. Update your UI as data arrives. This works with both Python and Node SDKs. Configure the SDK to handle streaming. Iterate over the response object. Display tokens as they generate. This improves user experience significantly. Users see results instantly. No waiting for full completion. Handle interruptions gracefully. Abort streams if needed. Monitor token usage per chunk. Budget your credits effectively. Streaming adds no extra cost. It uses the same token pricing. Your prepaid credit covers all chunks. Errors during streaming are rare. Handle them with standard error codes. This feature is essential for chat interfaces.

Limits, Errors, and Context

You have 300 requests per minute per key. Max eight concurrent requests. Request body size is limited to 8 MB. If your key is invalid, you get a 401 error. Check your API key in the dashboard. If you lack credit, you receive a 402 error. Top up via crypto to continue. Rate limits trigger a 429 response. Wait before retrying. The context window is 100,000 tokens. This includes prompt and completion. Exceeding this limit causes an error. Set max_tokens to 16,000 max. Default output is 2,048 tokens. Errors do not charge tokens. Refusals do not charge tokens. Only successful completions bill you. JSON mode and function calling are supported. Use these for structured data output. Handle errors in your code. Log them for debugging. This ensures smooth operation. Scale your usage efficiently. Monitor your token consumption. Avoid unexpected charges. Keep your code robust.

cURL

Copycurl https://api.abliteration.cc/v1/chat/completions \
  -H "Authorization: Bearer $API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "uncensored",
    "messages": [{"role": "user", "content": "List the top 5 arguments for open source AI models."}]
  }'

Python

Copyfrom openai import OpenAI

client = OpenAI(base_url="https://api.abliteration.cc/v1", api_key="YOUR_KEY")

resp = client.chat.completions.create(
    model="uncensored",
    messages=[{"role": "user", "content": "Summarise this thread without softening it."}],
)
print(resp.choices[0].message.content)

Node.js

Copyimport OpenAI from "openai";

const client = new OpenAI({ baseURL: "https://api.abliteration.cc/v1", apiKey: process.env.API_KEY });

const resp = await client.chat.completions.create({
  model: "uncensored",
  messages: [{ role: "user", content: "Draft a villain monologue for my game." }],
});
console.log(resp.choices[0].message.content);

Streaming

Copystream = client.chat.completions.create(
    model="uncensored",
    messages=[{"role": "user", "content": "Tell the story in second person."}],
    stream=True,
)
for chunk in stream:
    if chunk.choices and chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="", flush=True)