What is the context window size for this API?

The API supports a 100,000 token context window, combining both input and output tokens. This allows for extensive document processing or long conversation histories without immediate truncation.

How do I handle rate limits?

You are limited to 300 requests per minute and 8 concurrent requests per key. Exceeding these limits returns a 429 status code. Implement exponential backoff in your client to handle retries automatically.

Why is the base URL different from OpenAI?

Our API is an independent service hosting a specific uncensored model. While compatible with OpenAI SDKs, the base URL points to our infrastructure. This ensures you get the intended model behavior without routing through OpenAI's network.

Documentation: OpenAI-Compatible Uncensored API

Base URL and Authentication

Start every request against our specific endpoint using your unique API key. We provide a dedicated base URL that replaces the standard OpenAI endpoint in your client configuration. This ensures all traffic routes directly to our uncensored model without middleware interference. You must include your key in the Authorization header as a Bearer token. Authorization: Bearer YOUR_API_KEY. No additional headers are required for basic text generation. This setup works with any library that respects the OpenAI protocol standard.

Your First Request

Send a simple chat completion to verify connectivity and response quality. The following curl command demonstrates a standard interaction with the uncensored model. Replace YOUR_API_KEY with the credential issued during signup. The request targets the /v1/chat/completions endpoint. This confirms the API is responsive and ready for production traffic. You can adjust the model ID or messages as needed for your specific use case.

curl https://api.iasanscensuretexte.com/v1/chat/completions \
  -H "Authorization: Bearer $API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "uncensored",
    "messages": [{"role": "user", "content": "List the top five Python libraries for web scraping."}]
  }'

Python Integration

Use the official openai Python package to integrate our API into your scripts. Set the base_url to our endpoint and provide your key. The client handles JSON serialization automatically. This approach allows you to keep existing code structures while switching the backend model. Error handling remains consistent with standard OpenAI SDK behavior. You can easily swap between different model IDs if needed in the future.

from openai import OpenAI

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

Integrate the API into your JavaScript or TypeScript projects using the Node SDK. Configure the apiKey and baseURL properties in the client instance. This ensures all subsequent calls route through our uncensored infrastructure. The SDK supports modern async/await patterns for clean asynchronous code. You can stream responses or process full JSON objects depending on your application needs. This method is ideal for web servers and backend services.

import OpenAI from "openai";

const client = new OpenAI({ baseURL: "https://api.iasanscensuretexte.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 real-time token generation by setting stream: true in your request. The API returns a Server-Sent Events (SSE) stream instead of a single JSON blob. Each chunk contains partial text until the final chunk includes usage statistics. This reduces perceived latency for end-users significantly. You can process tokens incrementally to display progress indicators. The last chunk always contains the total token count for billing accuracy.

stream = 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)

Limits, Errors, and Context

Monitor your usage against strict rate limits to avoid service interruption. Each key allows 300 requests per minute and 8 concurrent connections. The context window supports up to 100,000 tokens for prompt and completion combined. Errors like 401 indicate an invalid key, while 402 means insufficient credit. A 429 status signals you have exceeded the rate limit. Requests fail gracefully without charging tokens for errors. Manage your key rotation to maintain high availability.

Developer Documentation