Start with our uncensored API

Base URL and authentication setup

Point your SDK to our endpoint and pass your key in the authorization header. We provide a single, hosted base URL that works with any standard OpenAI-compatible client. You receive one active key per account, and signing up takes seconds via Google or email without requiring a phone number. Your key grants access to the uncensored model immediately upon creation.

Authentication relies on standard Bearer tokens. If you send an invalid key, the API returns a 401 error. You can generate a new key at any time, and the old one stops working immediately. This design keeps your usage private and your access simple.

You do not need to manage multiple model versions or worry about opaque routing. The endpoint serves one specific large language model tuned for adult content and lack of refusals. Keep your key secure, as it is the only way to access your prepaid credit.

Chat completions endpoint (POST /v1/chat_completions)

Send your prompts to the chat completions endpoint to receive text responses. This is the core interaction method for our API. You structure your request with a system message to set behavior and user messages for your actual query. The model processes the input and returns a text response.

Our API is strict about what it does. We do not support embeddings, image generation, or audio processing. You get text in and text out. The context window supports 100,000 tokens for both prompt and completion combined. This allows for long conversations or large document processing.

Keep your requests clean and structured. The endpoint expects a specific JSON format. If you send the wrong data type, you will receive an error. We handle the heavy lifting of inference on our own servers.

Python SDK integration example

Use the official Python SDK to interact with our API easily. The code below shows how to initialize the client with our base URL and your key. You can then call the chat completion function with your messages.

This setup works because our API is fully OpenAI-compatible. You do not need a custom client library. Just update the base URL and your API key. The rest of the SDK features remain the same. This makes migration from other providers straightforward if you need to switch later.

We recommend using the latest version of the SDK for the best experience. The library handles retries and JSON parsing for you. You just need to focus on your prompt logic and model parameters.

Node SDK integration example

Integrate with Node.js using the standard npm package. The structure mirrors the Python example. You set the base URL to our endpoint and provide your API key. This ensures compatibility with existing Node.js applications.

The Node SDK handles the HTTP requests automatically. You pass the messages array and receive the response object. This includes the content of the generated text. You can then process this text in your application logic.

Remember that we only support text completion. Do not expect image or audio data in the response. The SDK will parse the JSON response and give you access to the text. This consistency across languages simplifies your development process.

Streaming responses and token usage

Enable streaming to receive the response token by token. This provides a faster perceived latency for your users. You can display the text as it generates rather than waiting for the full response. This is crucial for chat interfaces.

The last chunk of the stream contains the token usage statistics. You can use this data to track your costs and monitor your account balance. Streaming does not change the pricing model. You still pay per token used.

Our API supports server-sent events for streaming. The SDK handles the event parsing. You just need to set the stream parameter to true. This works with both Python and Node clients. It is the recommended way to build interactive applications.

Limits, errors, and model details

Understand your rate limits and potential errors to build a robust application. You are limited to 300 requests per minute and 8 concurrent requests per key. The request body size is capped at 8 MB. If you exceed these limits, you will receive a 429 error. You can implement exponential backoff to handle this gracefully.

Common errors include 401 for invalid keys and 402 for insufficient credit. If you run out of credit, you must top up via crypto to continue. Errors and refusals are free, so you do not pay for failed requests. The model refuses only sexual content involving minors, which is a hard limit.

You can check the available models via the GET /v1/models endpoint. This will return the single uncensored model ID. We do not offer multiple models or routing. This simplicity reduces complexity and ensures consistent behavior. Your prepaid credit never expires, so you can pause usage without losing funds.

cURL

Copycurl https://api.keyapiunlimited.com/v1/chat/completions \
  -H "Authorization: Bearer $API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "uncensored",
    "messages": [{"role": "user", "content": "list the python libraries for web scraping"}]
  }'

Python

Copyfrom openai import OpenAI

client = OpenAI(base_url="https://api.keyapiunlimited.com/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.keyapiunlimited.com/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)