Uncensored LLM Online: Chat Through an API Client
An uncensored LLM online means a hosted model you reach over HTTP, with no GPU on your side. This walkthrough takes you from a blank terminal to a streaming chat loop using the OpenAI SDK.

Key points
- Any OpenAI-compatible client works: change the base URL, set the key, use the model ID uncensored.
- Streaming returns tokens as they are generated, and usage arrives at the end of the stream.
- The 100,000-token window covers prompt plus completion, so long chats need trimming eventually.
- A 429 response means slow down or wait; the error code tells you which limit you hit.
What you need before you start
To use an uncensored LLM online through your own code or a chat client, you need three things: an account, an API key, and a client that can talk to an OpenAI-style endpoint. The service is text only, with one model, and it answers without content refusals for lawful adult use. It does not generate images, audio or video, and it will not produce sexual content involving minors under any circumstances.
Here is the path in order.
- Sign up with Google or with an email and password on the API key page.
- Claim the trial credit with one click. It is $0.50, needs no card, lasts 7 days and is limited to one per person.
- Copy your key. Every request sends it as
Authorization: Bearer YOUR_KEY. - Point your client at the base URL
https://api.uncensoredllmonline.com/v1and set the model touncensored.
Two endpoints are available: POST /v1/chat/completions for conversations and GET /v1/models to list what the key can use.
First request with curl
Before writing any code, confirm the key works. This request asks for a short reply and prints the full JSON response.
curl https://api.uncensoredllmonline.com/v1/chat/completions \
-H "Authorization: Bearer YOUR_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "uncensored",
"messages": [
{"role": "system", "content": "You are a blunt, helpful writing partner."},
{"role": "user", "content": "Pitch me a noir story set on a space station."}
],
"max_tokens": 250
}'
You get a standard chat completion object with choices[0].message.content and a usage block. The response headers include X-Request-Id, which is useful if you ever contact support, and X-Balance-USD, which shows your remaining credit. To check the key without spending tokens, call GET /v1/models with the same header.
A streaming chat loop in Python
Waiting for a full reply feels slow in a chat. Setting stream: true makes the server send tokens over SSE as they are produced, and the OpenAI SDK turns that into an iterator. The script below keeps the whole conversation in a list, prints tokens as they arrive, and appends each answer so the model remembers the context.
from openai import OpenAI
client = OpenAI(
base_url="https://api.uncensoredllmonline.com/v1",
api_key="YOUR_KEY",
)
history = [
{"role": "system", "content": "You are a direct, imaginative conversation partner."}
]
while True:
user = input("you: ").strip()
if user in ("", "quit"):
break
history.append({"role": "user", "content": user})
stream = client.chat.completions.create(
model="uncensored",
messages=history,
stream=True,
temperature=0.9,
)
reply = ""
print("bot: ", end="", flush=True)
for chunk in stream:
if chunk.choices and chunk.choices[0].delta.content:
piece = chunk.choices[0].delta.content
reply += piece
print(piece, end="", flush=True)
if getattr(chunk, "usage", None):
usage = chunk.usage
print()
history.append({"role": "assistant", "content": reply})
The final chunks carry token usage, so you can log what each turn cost. Temperature, top_p, stop sequences, seed and the frequency and presence penalties are passed through to the model. For creative chat, a temperature around 0.8 to 1.0 gives more varied prose. For extraction or structured tasks, lower it.
Working with the 100,000-token window
The context window is 100,000 tokens, and it covers the prompt and the completion together. A chat loop like the one above resends the entire history on every turn, so the input grows with each exchange. That is fine for a long time. A typical English page of text is on the order of 500 to 700 tokens, so a conversation can run to many hours before it approaches the limit.
Because you pay for input tokens on every request, a long history is also where your bill comes from. Take a chat that has reached 40,000 tokens of history, with 500 tokens of reply. Input costs 0.04 x $0.15 = $0.006, and output costs 0.0005 x $0.50 = $0.00025, so one more turn costs about $0.0063. Even at that size, $20 of credit covers more than 3,000 turns. Still, trimming saves money and keeps replies focused.
Three simple strategies work well:
- Sliding window. Keep the system message and the last N turns, drop older ones.
- Summarize and replace. When history passes a threshold, ask the model to summarize the oldest part, then store the summary as a single message.
- Pinned facts. Keep character sheets, world rules or settings in the system message and let the rest of the conversation scroll away.
Set max_tokens if you want to cap reply length. It is optional, and without it the completion can use whatever remains of the window.
Using a ready-made chat client instead
You may not want to write code. Many chat front ends let you add a custom OpenAI-compatible endpoint, and SillyTavern is one example that does. The settings are the same everywhere, only the labels differ:
- API type: OpenAI-compatible, sometimes called custom or chat completion.
- Base URL:
https://api.uncensoredllmonline.com/v1. Some clients want the full path ending in/chat/completions, in which case append it. - API key: the key from your account.
- Model:
uncensored. If the client has a model list button, it callsGET /v1/modelsand fills it in.
If the client reports an authentication error, check for a leading or trailing space in the key. If it reports that the model does not exist, retype the model ID by hand. The docs list the supported parameters if a client sends a field you want to turn off.
The same call from Node
If your project is JavaScript, the official OpenAI package works the same way. This example streams to standard output.
import OpenAI from "openai";
const client = new OpenAI({
baseURL: "https://api.uncensoredllmonline.com/v1",
apiKey: "YOUR_KEY",
});
const stream = await client.chat.completions.create({
model: "uncensored",
messages: [{ role: "user", content: "Describe a rainy market town in three sentences." }],
stream: true,
});
for await (const chunk of stream) {
process.stdout.write(chunk.choices[0]?.delta?.content ?? "");
}
process.stdout.write("\n");
Tool calling and JSON mode (response_format set to json_object) work through the same interface. For tools, define them in tools, optionally set tool_choice, and return results as messages with the tool role. Streamed responses deliver tool_calls in pieces that you assemble on the client.
Rate limits and what a 429 means
A full key allows 8 concurrent requests and 300 requests per minute. A trial key allows 2 concurrent requests and 60 per minute. The request body can be up to 8 MB. Headers on each response, X-RateLimit-Limit-Requests and X-RateLimit-Limit-Concurrency, tell you the ceilings that apply to your key.
When you pass a limit you get HTTP 429, and the error code says which one:
rate_limited: too many requests per minute. Wait and retry.concurrency: too many requests at once. Remember that a streamed request holds its slot until the stream ends, so a UI that opens several streams at the same time uses them up quickly.- A 429 with a
Retry-After: 5header means temporary overload. Wait five seconds, then retry.
A short retry loop with backoff is enough for most apps. Failed or refused requests are not charged. When your trial ends or your balance runs low, you can top up any whole amount from $20 to $500 with crypto (USDT on TRC20 or USDC on Base); see the pricing page for bonuses.
A retry wrapper
Here is a small wrapper that retries on 429 using the Retry-After header when it exists and an exponential delay when it does not. It uses the SDK's exception type, so other errors still surface immediately.
import time
from openai import OpenAI, RateLimitError
client = OpenAI(
base_url="https://api.uncensoredllmonline.com/v1",
api_key="YOUR_KEY",
)
def ask(messages, tries=5):
delay = 2
for attempt in range(tries):
try:
return client.chat.completions.create(
model="uncensored",
messages=messages,
max_tokens=400,
)
except RateLimitError as err:
wait = err.response.headers.get("Retry-After")
time.sleep(int(wait) if wait else delay)
delay *= 2
raise RuntimeError("still rate limited after retries")
If you see concurrency errors often, the fix is rarely a longer delay. Cap the number of calls you run in parallel at 8 for a full key, or 2 on a trial key, with a semaphore or a worker pool of that size.
Getting better results from the model
A model that does not refuse still needs clear direction. Most disappointing output comes from vague prompts, not from the model. These habits help in fiction, roleplay and companion-style chat for adults.
- Put the setup in the system message. State the setting, the tone, the point of view and the length you want. Models follow a system message more consistently than a request buried in turn twelve.
- Describe the character, not only the task. A few lines on voice, habits and what the character wants produce more consistent dialogue than a bare name.
- Use examples. One short sample paragraph in the style you want often does more than a page of adjectives.
- Control repetition. If the model loops on the same phrases in long sessions, raise the frequency or presence penalty slightly, or lower the temperature a little.
- Ask for what you want, once. If a reply drifts, edit your last message rather than stacking corrections on top of each other. Your history is part of every future prompt and part of every bill.
The hard rule against sexual content involving minors applies to every prompt and every character, no matter how the scenario is framed. The model is tuned for lawful adult use only.
More guides
Questions and answers
Do I need to install anything to get started?
Only a client. The OpenAI Python or Node package, curl, or any chat app that accepts a custom OpenAI-compatible endpoint will do. No GPU or model download is needed.
Which model ID do I use?
Use uncensored in the model field. You can confirm it by calling GET /v1/models with your key.
Does streaming cost more than a normal request?
No. You pay the same per-token price, $0.15 per 1M input and $0.50 per 1M output. A streamed request does hold one concurrency slot until it finishes.
Are my prompts stored for training?
No. Prompts are not used for training.
Can I use it for images or voice?
No. The service is text only, with no image, audio or video generation and no embeddings.
Your key is one form away
Create an account, copy the key, change the base URL. That is the whole setup.