Key points
- The uncensored API follows standard OpenAI syntax but lacks advanced features like embeddings or multiple model routing, so your client must be configured for a single endpoint.
- Streaming responses require specific SSE handling; if your SDK defaults to JSON parsing, you will encounter parsing errors on large uncensored outputs.
- Tool calling works but requires strict JSON schema adherence because the model may hallucinate arguments more frequently than instruction-tuned models.
- You are limited to 300 requests per minute and an 8MB body size, which necessitates careful batching strategies for high-volume applications.
Understanding the Uncensored AI API Endpoint
When integrating an uncensored AI API, the first mistake is assuming it behaves identically to standard commercial models. Our endpoint is a hosted, OpenAI-compatible chat-completions service. It serves a single, dedicated uncensored large language model. This means you do not need to manage model routing or versioning. You send requests to POST /v1/chat/completions and receive text in return.
Unlike aggregators that bundle image, video, and multiple vendors, this service focuses purely on high-performance, unrestricted text generation. The model is open-weight and tuned to answer without content refusals for lawful adult use. However, it is not GPT, Claude, Gemini, or any other vendor's model. It runs on our own GPU servers.
The base URL is https://api.uncensoredgptapi.com/v1. To use it, you change the base_url in your existing OpenAI SDKs or any OpenAI-compatible client and provide your API key. The model ID you must send is simply "uncensored". This simplicity reduces integration time but requires you to verify that your client can handle a single-model endpoint without expecting fallbacks.
Common Authentication Errors
Authentication errors usually stem from misconfigured headers or expired keys. The API uses standard Bearer token authentication. You must include your API key in the Authorization header for every request.
A common mistake is caching the API key without verifying its validity. If you regenerate your key, the old one is immediately revoked. You must update your client configuration to use the new key. If you receive a 401 Unauthorized error, check two things: first, ensure the key is copied correctly without leading or trailing whitespace. Second, verify that you are using the correct base URL. Even a slight deviation in the domain or path will result in authentication failure.
Another frequent issue is using the wrong model ID. The endpoint expects "uncensored". If you send "gpt-4" or another standard model ID, the endpoint may reject the request or return an error because it only serves one model. Always double-check the model field in your request payload.
curl https://api.uncensoredgptapi.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."}]
}'Handling Streaming Responses Correctly
Streaming responses via Server-Sent Events (SSE) are supported but often mishandled by developers accustomed to synchronous JSON responses. When you set "stream": true in your request, the API returns a stream of partial JSON objects, not a single complete JSON response.
If your client attempts to parse the entire response as JSON at once, it will fail. You must read the stream line by line. Each line starts with data: and contains a partial JSON object. The final line is data: [DONE]. Your code should aggregate these chunks to reconstruct the final text.
Some SDKs handle this automatically, but custom implementations need explicit SSE parsing. Ensure your client buffer can handle large outputs without timing out. The uncensored model can generate long responses, and streaming helps manage memory usage. If you experience dropped connections, consider implementing exponential backoff for retry logic.
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)Tool Calling Configuration Mistakes
Tool calling is supported, but the uncensored model may hallucinate arguments more frequently than instruction-tuned models. This requires stricter validation on your end. When defining tools, ensure your JSON schema is precise. The model will attempt to fill in the arguments, but it may omit required fields or provide incorrect types.
Always validate the tool call arguments before executing the function. If the model returns invalid JSON for the arguments, you must handle the error gracefully. Do not assume the output will be perfectly structured. You may need to implement a retry mechanism or a post-processing step to clean up the arguments.
Additionally, be aware that the uncensored model might ignore tool definitions if the prompt is complex. If you encounter issues, simplify the tool descriptions and ensure the system prompt clearly instructs the model to use the tools when appropriate. Test with a few sample inputs to verify the behavior.
Context Window Limits (100k Tokens)
The uncensored API supports a context window of 100,000 tokens, combining both prompt and completion. This is significantly larger than many standard models, allowing for extensive conversations or large document processing. However, it is not infinite. If your input exceeds this limit, the API will return an error.
To avoid hitting this limit, monitor your token usage. Most SDKs provide utilities to count tokens. Keep track of the cumulative tokens in your conversation history. If you are processing large documents, consider chunking them or summarizing earlier parts of the conversation to free up context space.
Remember that the context window includes all messages in the messages array. Each message contributes to the total. If you are sending many small messages, the overhead can add up. Optimize your prompt structure to minimize unnecessary tokens. For example, avoid repeating system instructions in every turn if they remain constant.
Rate Limiting Explained (300 RPM)
The API enforces a rate limit of 300 requests per minute per key. This is a hard limit to ensure fair usage across all users. If you exceed this limit, you will receive a 429 Too Many Requests error. Your client should handle this by implementing a retry strategy.
A common mistake is not accounting for burst traffic. If you send 300 requests in rapid succession, you may hit the limit even if your average rate is lower. Spread your requests evenly over the minute. If you are processing a large dataset, consider batching requests or using a queue to manage the flow.
Rate limits are applied per API key. If you have multiple services using the same key, they share the limit. To increase capacity, you can generate a new key, but note that only one key is active per account. You can regenerate the key at any time, but this revokes the old one, so ensure all clients are updated.
Request Body Size Limits (8MB)
Each request body is limited to 8 MB. This limit applies to the JSON payload, including the messages array and any tool definitions. If your request exceeds this size, the API will reject it with a 413 Payload Too Large error.
This limit is important when sending large files as base64-encoded data or when including extensive conversation histories. If you are working with large documents, consider compressing the text or removing unnecessary whitespace before sending. You can also use streaming to reduce memory usage, but the initial request body must still fit within the 8 MB limit.
Monitor your request sizes during development. If you encounter this error, review your prompt structure and remove any redundant information. For example, if you are including the entire system prompt in every message, move it to the system role once and reference it.
API Key Management and Regeneration
Each account is limited to one API key. This key is generated during signup and is shown immediately. You can regenerate the key at any time from your dashboard. When you regenerate, the old key is instantly revoked. Any client using the old key will receive a 401 Unauthorized error.
To manage this effectively, update all your clients before regenerating the key. If you have multiple services or devices using the key, ensure they are all updated simultaneously. You can generate a new key as many times as needed, but only one will be active at a time.
The API key is tied to your email and password. If you lose your key, you can regenerate it. There is no limit to the number of regenerations. However, frequent regeneration may indicate a security concern, so use it when necessary. Keep your key secure and do not share it publicly.
Troubleshooting Content Filters
The uncensored model does not refuse lawful adult, fictional, security-research, or controversial topics. However, there is one hard content limit that always applies: no sexual content involving minors. Requests containing this content are blocked.
If you encounter unexpected refusals, check your prompt for subtle indicators of prohibited content. The model is tuned for unrestricted use, but it may still apply basic safety filters. If you are testing with edge cases, document the behavior to understand the model's boundaries.
Another common issue is hallucination. The uncensored model may generate plausible-sounding but incorrect information. Always verify critical outputs, especially when using tool calls or generating code. The model prioritizes fluency over strict factual accuracy in some cases.
