API Documentation

Authentication and base URL

Use your API key to authenticate every request. Our API is fully compatible with the OpenAI SDK ecosystem, so you only need to adjust the base URL and key in your client configuration. The base URL is HTTPS://api.nocensoraichatbot.com/v1. You can generate a key immediately after signing up with Google or email. Each account holds one active key that replaces the previous one when regenerated. No phone number is required for signup, and your prompts are not used for training.

First request

Send a standard chat completion request to the /v1/chat/completions endpoint. Use the model identifier "uncensored" to access our tuned large language model. The model responds to lawful adult, fictional, and controversial topics without standard refusals. A hard limit applies: content involving minors is always refused. You can test connectivity with a simple curl command.

Copycurl https://api.nocensoraichatbot.com/v1/chat/completions \
  -H "Authorization: Bearer $API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "uncensored",
    "messages": [{"role": "user", "content": "Generate a 400 word review of the new gpu"}]
  }'

If the key is invalid, you receive a 401 error. If credits are exhausted, you receive a 402 error. Errors and refusals do not consume tokens, so you only pay for successful completions. Credits never expire, giving you total control over your spending.

Python SDK integration

Install the official OpenAI Python package and configure the base URL to point to our service. This allows you to use familiar methods like client.chat.completions.create. Set the model to "uncensored" and pass your system or user messages as usual. The SDK handles tokenization and response parsing automatically. This approach works for both simple text generation and complex multi-turn conversations. You can also stream responses if you prefer incremental output.

Copyfrom openai import OpenAI

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

Ensure your API key is passed in the header or environment variable. The SDK supports all standard parameters like temperature and top_p. You can adjust these to control creativity or determinism. The model context window is 100,000 tokens for prompt and completion combined.

Node SDK integration

Use the @openai/openai npm package to integrate with your Node.js application. Configure the base URL and API key before making any calls. This ensures compatibility with our uncensored AI chatbot API. The Node SDK provides type definitions and async/await support for modern development. You can send messages and receive responses just like with any OpenAI-compatible endpoint. Error handling is built-in, so you can catch 401, 402, and 429 errors easily. This makes it ideal for serverless functions or backend services.

Copyimport OpenAI from "openai";

const client = new OpenAI({ baseURL: "https://api.nocensoraichatbot.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);

Remember that the model identifier is "uncensored". Do not use GPT-3.5 or GPT-4 identifiers. The SDK handles the rest, including JSON parsing and retry logic. You can also enable streaming for real-time user experiences.

Streaming and SSE support

Enable streaming by setting stream to true in your request. The API returns Server-Sent Events (SSE) for real-time token delivery. Each chunk contains partial content, allowing you to display output as it generates. The final chunk includes the full token usage statistics. This is useful for chat interfaces where users expect immediate feedback. Streaming reduces perceived latency, especially for long responses. You can stop streaming early if the user sends a new message. This saves tokens and improves responsiveness.

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)

Handle SSE events carefully to avoid memory leaks in long-running connections. The API supports up to 8 concurrent requests per key. This limit helps maintain stability under load. You can adjust the stream behavior using standard parameters like max_tokens and stop sequences.

Rate limits and context window

The API enforces a limit of 300 requests per minute per key. You can have 8 requests active simultaneously. The request body must not exceed 8 MB. The context window is 100,000 tokens, combining prompt and completion. Max output is 16,000 tokens per request, or 2,048 if max_tokens is unset. If you exceed the rate limit, you receive a 429 error. Wait and retry with exponential backoff. Credits are charged only for successful token usage. Errors do not consume credits. This transparent pricing model ensures you know exactly what you pay for.