API Documentation for Uncensored Model

Base URL and Authentication

Use our base URL for all requests and pass your API key in the header. This setup works with any standard OpenAI SDK or HTTP client without modification. You receive a key immediately after signing up with Google or email, with no phone number required. The key authenticates your account against our servers for every request you make.

Keep your key secure, as it provides access to your prepaid credit. You can generate a new key at any time, which replaces the old one instantly. There is no need to manage multiple keys or navigate complex permission scopes for basic usage.

First Request

Send your first message to the chat completions endpoint with a simple prompt. The model responds with text output, ready for your application logic. You can test connectivity and response quality with a minimal request structure. This confirms your key works and the uncensored model is active.

The response includes the generated text and token usage details. You can parse this data to display results or feed them into subsequent prompts. This is the fastest way to verify your integration before building complex workflows.

Copycurl https://api.unfilterchatgpt.com/v1/chat/completions \
  -H "Authorization: Bearer $API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "uncensored",
    "messages": [{"role": "user", "content": "list the top ten best practices for react state management"}]
  }'

Python SDK Integration

Install the official OpenAI Python package and point it to our base URL. This allows you to use familiar methods like client.chat.completions.create() without changing your code structure. Pass your API key as the default value for the library. This approach simplifies integration for existing projects that already use OpenAI-compatible clients.

You can set parameters like temperature or top_p to control response randomness. The library handles serialization and error parsing automatically. This reduces boilerplate code and speeds up development for both simple scripts and complex applications.

Copyfrom openai import OpenAI

client = OpenAI(base_url="https://api.unfilterchatgpt.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 SDK Setup

Initialize the OpenAI Node.js client with our base URL and your API key. This ensures compatibility with standard JavaScript and TypeScript projects. You can use the same completion methods available in the Python SDK. The client handles network requests and response parsing efficiently.

Configure the client options to match your application needs. You can adjust request timeouts or retry logic as necessary. This setup works seamlessly with existing Node.js environments, making it easy to add uncensored AI capabilities to your backend services.

Copyimport OpenAI from "openai";

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

Enable streaming by setting the stream parameter to true in your request. This sends responses token-by-token as they are generated. It provides a better user experience for real-time applications. You can display partial results immediately while the model continues working.

Parse the stream chunks to extract the content. The final chunk contains the total token usage for the request. This allows you to track costs accurately while providing instant feedback to users. Streaming is ideal for chat interfaces and interactive tools.

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)

Rate Limits, Errors, and Context

The context window supports 100,000 tokens for both prompt and completion. You can send long documents or extended conversations without truncation. However, the maximum output per request is 16,000 tokens, or 2,048 if you do not set the limit. This ensures consistent performance for large responses.

Rate limits allow 300 requests per minute and 8 concurrent requests per key. Errors include 401 for invalid keys and 402 for insufficient credit. Refusals due to content limits are free, while errors do not consume credit. Manage your requests efficiently to avoid throttling during high traffic periods.