Uncensored Endpoint: Base URL, Model ID and Limits

The connection settings at a glance

If you only need the values, here they are. Everything else on this page explains how they behave in practice.

Setting	Value
Base URL	https://api.uncensoredendpoint.com/v1
Model ID	uncensored
Auth header	Authorization: Bearer YOUR_KEY
Methods	POST /v1/chat/completions, GET /v1/models
Context window	100,000 tokens, prompt plus completion
Max request body	8 MB
Full key limits	8 concurrent requests, 300 requests per minute
Trial key limits	2 concurrent requests, 60 requests per minute
Price	$0.15 per 1M input tokens, $0.50 per 1M output tokens

The service speaks the same wire format as the OpenAI chat completions API. If a tool lets you type a custom base URL and an API key, it can talk to this one. You get a key on the API key page, and the documentation carries the same reference in a shorter form.

What each method does

Only two routes exist, which keeps the surface small.

• GET /v1/models returns the model list. You will see one entry, uncensored. Many clients call this route to fill a model dropdown, so it is also a quick way to confirm that your key and URL are correct.
• POST /v1/chat/completions is the workhorse. It takes a list of messages and returns a completion, either as one JSON response or as a server-sent event stream.

The old text completions route, the responses route, embeddings, image routes and audio routes are not part of the product. If a library tries one of those, expect an error and switch the library to its chat mode.

A quick check from a terminal:

Copycurl https://api.uncensoredendpoint.com/v1/models \
  -H "Authorization: Bearer $API_KEY"

A JSON list that contains uncensored means the key works. An HTTP 401 means the key is missing, mistyped or has a stray space or newline in it, which is the most common cause when the key came from a shell variable.

Your first request in curl, Python and Node

All three examples send the same thing: one system message, one user message, a low temperature. Replace YOUR_KEY or set the API_KEY environment variable.

Copycurl https://api.uncensoredendpoint.com/v1/chat/completions \
  -H "Authorization: Bearer $API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "uncensored",
    "messages": [
      {"role": "system", "content": "You are a concise assistant."},
      {"role": "user", "content": "Explain what a context window is in two sentences."}
    ],
    "temperature": 0.7
  }'

With the official Python SDK, you only pass two extra arguments to the client:

Copyfrom openai import OpenAI

client = OpenAI(
    base_url="https://api.uncensoredendpoint.com/v1",
    api_key="YOUR_KEY",
)

resp = client.chat.completions.create(
    model="uncensored",
    messages=[
        {"role": "system", "content": "You are a concise assistant."},
        {"role": "user", "content": "Explain what a context window is in two sentences."},
    ],
    temperature=0.7,
)
print(resp.choices[0].message.content)
print(resp.usage)

And in Node with the same SDK:

Copyimport OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.uncensoredendpoint.com/v1",
  apiKey: process.env.API_KEY,
});

const resp = await client.chat.completions.create({
  model: "uncensored",
  messages: [
    { role: "system", content: "You are a concise assistant." },
    { role: "user", content: "Explain what a context window is in two sentences." },
  ],
});
console.log(resp.choices[0].message.content);

The response includes a usage object with prompt and completion token counts. Keep an eye on it: those two numbers are what you are billed on. The response headers also carry X-Request-Id, X-Balance-USD, X-RateLimit-Limit-Requests and X-RateLimit-Limit-Concurrency. Log the request ID with every call, since it is the first thing support will ask for if something looks wrong.

Streaming, tool calling and JSON mode

Three features cover most real applications, and all three follow the OpenAI shapes you already know.

Streaming

Set stream: true and read server-sent events. Usage is reported at the end of the stream, so you can still count tokens without a second request. One detail matters for capacity planning: a streamed request holds its concurrency slot until the stream finishes. A slow client that reads a long answer at a trickle keeps a slot busy for the whole time.

Copystream = client.chat.completions.create(
    model="uncensored",
    messages=[{"role": "user", "content": "Write a four-line poem about rain."}],
    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

Pass tools and optionally tool_choice. When the model decides to call a function, you get tool_calls in the reply (streamed too, if you stream). You run the function yourself and send the result back as a message with role: "tool". The model is a single open-weight model, so test your tool schemas with a few realistic prompts and keep parameter descriptions short and literal.

JSON mode

Send response_format: {"type":"json_object"} to ask for valid JSON output. Also say in the prompt that you want JSON and describe the fields you expect. Parse defensively anyway, and retry once on a parse failure instead of trusting the output blindly.

Sampling controls are passed through: temperature, top_p, stop, seed and the frequency and presence penalties.

The 100,000-token window in practice

The context window is 100,000 tokens, and that number covers the prompt and the completion together. The completion may use whatever the prompt leaves free, and max_tokens is optional. If you send 90,000 tokens of prompt, at most about 10,000 remain for the answer.

A rough rule for English text is that one token is a bit less than one word, so 100,000 tokens is on the order of 70,000 words. That is enough for a long manuscript chapter set, a large chunk of a codebase, or several hours of chat history. Three habits keep this useful:

• Trim history on purpose. Chat clients resend the whole conversation every turn, so cost and latency grow with it. Keep the system prompt, a summary of old turns and the last handful of messages.
• Set max_tokens when output size matters. It is optional, but a cap protects you from a runaway answer on a long prompt.
• Mind the 8 MB body limit. It is separate from the token window. Plain text rarely reaches 8 MB, but base64 blobs pasted into a prompt can.

Because billing is per token, a full-window request costs real money compared with a short one. The pricing page has the rates, and you can compute any request as input tokens times $0.15 plus output tokens times $0.50, each divided by one million.

Rate limits and the 429 family

A full key allows 8 requests at the same time and 300 requests per minute. The trial key is tighter: 2 at the same time and 60 per minute. When you cross a line the API answers with HTTP 429, and the error code tells you which line:

Error code	Meaning	What to do
rate_limited	Too many requests per minute	Slow down; spread calls over the minute
concurrency	Too many requests running at once	Queue on your side; cap parallel workers at 8 (2 on trial)
429 with Retry-After: 5	Temporary overload	Wait the 5 seconds, then retry

The simplest defence is a semaphore in your own code, sized to your key. In Python with asyncio, asyncio.Semaphore(8) around each call removes the concurrency error entirely. Add a retry that honours the Retry-After header and falls back to a short exponential delay when the header is absent. Remember that streams hold a slot for their full length, so a batch of eight long streams will block a ninth request even if the per-minute count is low.

Failed or refused requests are not charged, so a retry loop does not cost you for the attempts that bounced.

What the model is, and what it is not

The service runs one open-weight model, hosted by an independent provider and tuned to answer without content refusals for lawful adult use. It is not the official API of any large vendor, and it is not a router that picks between vendors. There is a single model, uncensored, so there is nothing to choose between and no pricing tier to compare.

The limits are plain. Text goes in and text comes out. There is no image, audio or video generation, no embeddings and no fine-tuning. The one fixed content rule is that sexual content involving minors is never permitted. Prompts are not used for training.

That framing helps when you plan a project. Fiction and roleplay tools for adults, companion apps, research on model behaviour, and tools that handle blunt or sensitive text without the model backing out are all natural fits. If you need embeddings for search, you will need a separate provider for that part and can still use this endpoint for generation.

Before you go to production

A working demo is five minutes of work. A dependable service takes a little more. Start with the trial: new users can claim $0.50 of credit with one click on the key page after sign-up, once per person, valid for 7 days and with no payment needed. Sign-up works with Google or with email and password. That is enough for hundreds of short test calls to check your integration.

When you move to real traffic, top up with any whole amount from $20 to $500. Payment is in crypto, either USDT on TRC20 or USDC on Base. Credit never expires and there is no subscription, so a balance simply sits until you spend it. The bonus is 5% from $50, 10% from $100 and 15% from $200.

Then work through a short list: store the key in an environment variable or a secrets manager, never in client-side code; log X-Request-Id; watch X-Balance-USD so you can alert before the balance runs dry; cap parallel workers; and handle 429 with delay rather than a tight loop. The production checklist for API keys goes through key handling in more detail, and the docs hold the parameter reference.

More guides

• Uncensored Endpoint Telegram Bot: Build It in Python
• Uncensored Endpoint Pricing: Per-Token Math Explained
• Uncensored AI API Key: Production Checklist