Uncensored AI API Documentation

Quick Start: Connect your client

Send requests to https://api.isgeminiuncensored.com/v1 using standard OpenAI SDKs. Our service acts as a drop-in replacement for other providers, so you only need to update the base URL and provide your API key. You can generate your key instantly via the dashboard using Google or email. This setup eliminates the need for complex proxying or custom jailbreak prompts.

Authentication relies on a single active API key per account. If you generate a new key, the previous one becomes invalid immediately. This ensures tight control over your usage while maintaining the privacy of your data. Your prompts are not used for training, so your creative works remain yours.

First Request: curl example

Verify your connection by sending a simple text completion request. Use the standard chat completions endpoint with the model identifier uncensored. The response will return generated text based on your input without standard content refusals.

This basic test confirms that your key is valid and the endpoint is reachable. You can then integrate this pattern into your application logic. The response structure mirrors the OpenAI format, ensuring compatibility with most existing tools.

Copycurl https://api.isgeminiuncensored.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 Linux commands for network troubleshooting."}]
  }'

Start with simple prompts to verify the output quality. You can then scale up to more complex interactions as needed. The system handles the heavy lifting of context management for you.

Python SDK Integration

Use the official Python library to integrate our API into your scripts. Set the base URL to our endpoint and provide your API key. This approach lets you leverage existing codebases with minimal changes. You can use streaming or synchronous calls depending on your needs.

The Python SDK handles the serialization of your requests automatically. You can pass parameters like temperature and top_p to control the output. This flexibility allows you to fine-tune the model's behavior for your specific use case. Whether you are building a chatbot or an analysis tool, the SDK simplifies the process.

Copyfrom openai import OpenAI

client = OpenAI(base_url="https://api.isgeminiuncensored.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 you handle the response objects correctly. The SDK returns structured data that you can parse easily. This makes debugging and testing straightforward. You can also use async clients for high-throughput applications.

Node SDK Integration

Integrate with Node.js applications using the official OpenAI npm package. Point the client to our base URL and set the API key. This allows you to use familiar patterns in your JavaScript projects. You can make synchronous or asynchronous requests with ease.

The Node SDK supports modern JavaScript features like promises and async/await. This makes error handling and response processing clean. You can pass the same parameters as the Python SDK to adjust the model's behavior. This consistency across languages reduces the learning curve for teams using multiple technologies.

Copyimport OpenAI from "openai";

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

Test your integration with a simple query. The response will confirm that your setup is correct. You can then proceed to build more complex interactions. The SDK handles the HTTP requests efficiently, ensuring low latency.

Streaming Responses

Enable streaming by setting the stream parameter to true. This allows you to receive tokens as they are generated. This feature is ideal for chat interfaces where immediate feedback is crucial. It reduces the perceived latency for the end user significantly.

The response is delivered as a sequence of Server-Sent Events (SSE). Each chunk contains part of the generated text. You can concatenate these chunks to form the complete response. The final chunk also includes token usage statistics for billing.

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 network interruptions gracefully. Streaming can be paused or resumed depending on your client's capabilities. This flexibility ensures a smooth user experience even on unstable connections. You can stop the stream early if the user changes their input.

Limits, Errors, and Context

Your account has a rate limit of 300 requests per minute and 8 concurrent requests per key. If you exceed this, you will receive a 429 error. You can monitor your usage in the dashboard to avoid interruptions. This limit ensures fair access for all users.

Context window support is up to 100,000 tokens for prompt and completion combined. You can set a maximum output of 16,000 tokens per request. If you do not specify a limit, the default is 2,048 tokens. Errors and refusals do not consume your prepaid credit.

Common errors include 401 for invalid keys and 402 for insufficient credit. You can top up with crypto only. USDT on TRC20 or USDC on Base are accepted. Mistakes like double charges are fixed via Support. Your prepaid credit never expires, so you can top up at your own pace. This structure keeps costs predictable and transparent.