Why Use an Uncensored.chat API?
Standard LLM APIs often apply rigid content filters that refuse lawful adult content, creative fiction, or controversial topics. An uncensored chat api removes these guardrails, allowing the model to respond to prompts based on relevance rather than policy compliance. This is critical for applications that need raw model capability without artificial constraints.
Our API serves a single, open-weight model tuned specifically for this behavior. It does not route between vendors or offer multiple model choices. You get consistent, predictable outputs from one tuned engine. This simplifies debugging and performance tuning because you are not dealing with variable model personalities or hidden filtering layers.
Unlike general-purpose providers, we do not bundle embeddings, image generation, or audio processing. This keeps the API lightweight and fast. If your application requires multi-modal capabilities, you should integrate those separately and use this API solely for text generation. The focus here is purely on high-quality, unrestricted text output with a 100,000-token context window.
Setting Up Your Environment
Integration begins by configuring your development environment to point to our base URL. This is a standard OpenAI-compatible endpoint, so you can use any official OpenAI SDK or compatible client library. You only need to change the base URL and provide an API key.
The base URL is https://api.nofilteraichat.com/v1. The model ID to send in your requests is uncensored. This model is run on our own servers and is not GPT, Claude, or any other vendor's model. It is an open-weight model tuned for uncensored responses.
Ensure your environment supports streaming via Server-Sent Events (SSE) if you plan to use real-time outputs. The API supports standard parameters like temperature, top_p, stop, and seed. You can also enable JSON mode by setting response_format to {"type": "json_object"}.
Context window: 100,000 tokens total (prompt + completion). There is no separate output cap, and if max_tokens is not set, the response can run to the end of the window.
Authentication with API Keys
Authentication is handled via an API key passed in the Authorization header. You can sign up using Continue with Google or an email and password on the Get API key page. No phone number is required.
When you create an account, you receive one active API key. This key is shown immediately upon creation. If you generate a new key, the old one is replaced; we do not support multiple simultaneous keys per account. This simplifies key management but means you cannot have separate keys for different environments on the same account.
The key is used to authorize requests to the /v1/chat/completions endpoint. Errors and refusals (except for the hard limit on minor sexual content) do not consume your prepaid credit. Credit is charged only for real token usage.
Privacy: Prompts are not used for training. An account only needs an email address.
Making Your First Request
Your first request should be a simple chat completion to verify connectivity. Use the POST /v1/chat/completions endpoint with the uncensored model ID.
Here is an example of a basic request:
curl https://api.nofilteraichat.com/v1/chat/completions \
-H "Authorization: Bearer $API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "uncensored",
"messages": [{"role": "user", "content": "Write a blunt product review of a cheap VPN."}]
}'This request sends a prompt and receives a text response. The model will answer without filtering for lawful adult content. If you need to enforce a specific tone or format, use the system message to set instructions.
Remember that the API has a 300 requests per minute limit per key and allows 8 concurrent requests. If you exceed these limits, you will receive a rate limit error. The request body size is limited to 8 MB. Ensure your client handles these limits gracefully by implementing exponential backoff for retries.
Implementing Streaming Responses
Streaming is supported via Server-Sent Events (SSE). This allows you to receive tokens as they are generated, providing a better user experience for long responses. Each chunk contains a partial delta of the response.
Important: Token usage statistics (input and output tokens) are only included in the last chunk of the stream. You must aggregate the deltas and then process the final chunk to get accurate usage data for billing purposes.
Here is an example of how to handle streaming in your code:
from openai import OpenAI
client = OpenAI(base_url="https://api.nofilteraichat.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)This approach ensures you can display text in real-time while still tracking token consumption accurately. If an error occurs during streaming, the stream may end prematurely. Check the final chunk or error status for details.
Using Function Calling
Function calling is supported via the tools and tool_choice parameters. This allows the model to output structured data that your application can execute. Define your functions in the tools array, and the model will return a tool_calls field in the response when appropriate.
Set tool_choice to "auto" to let the model decide when to call a function, or specify a specific function ID to force a call. The model will return the function name and arguments in JSON format.
Example structure:
import OpenAI from "openai";
const client = new OpenAI({ baseURL: "https://api.nofilteraichat.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);Ensure your client parses the tool_calls array and executes the functions. The model does not execute the functions itself; it only generates the call instructions. This is a standard OpenAI-compatible pattern, so any library that supports function calling with OpenAI should work here.
Handling JSON Mode
JSON mode ensures the model outputs strictly valid JSON. This is useful for applications that need structured data, such as API responses or configuration files. Set response_format to {"type": "json_object"} in your request.
When JSON mode is enabled, the model will attempt to output a single valid JSON object. If the output is invalid, the API may return an error or a malformed response. Always validate the JSON on the client side.
Example:
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)This mode is particularly useful for building agents or applications that require deterministic output formats. It reduces the need for post-processing to extract structured data from free-form text. Note that JSON mode may slightly increase latency due to the additional constraint on the model's output.
Managing Rate Limits and Errors
Rate limits are enforced at 300 requests per minute per key and 8 concurrent requests per key. The request body is limited to 8 MB. If you exceed these limits, you will receive a 429 status code. Implement exponential backoff in your client to handle retries.
Errors such as invalid parameters or server issues do not consume credit. Refusals for lawful adult content also do not consume credit. The only hard limit that always applies is the refusal of sexual content involving minors, which will consume tokens if the request is processed.
Pricing is transparent: $0.15 per 1M input tokens and $0.50 per 1M output tokens. Credit is prepaid and never expires. Errors are free, so you can experiment without worrying about costs. If you encounter a billing issue, use the Support page for assistance.
