Uncensored LLM: What It Means and How to Use One

What an uncensored LLM actually is

Most chat products wrap a language model in layers of refusal behavior. Some of it is trained into the weights, some of it is a system prompt, and some of it is a separate filter that reads your input and the reply. An uncensored LLM is a model whose weights were tuned so that the first layer, the trained-in refusals, is much weaker. It answers questions about dark themes in fiction, blunt medical or legal topics, and other adult material that a mainstream assistant often declines or waters down.

The word is a bit of a misnomer. Nothing was removed from the model like a cut cable. What changes is the training data and the tuning steps. A base model learns language from a huge text collection. A later stage teaches it to follow instructions and, usually, to refuse a long list of requests. An uncensored variant skips most of that refusal training, or adds tuning that pushes the other way.

The service behind this site runs one open-weight model of this kind, operated by an independent provider. It is not the official API of any large lab, and it is not a router that picks between vendors. You get one model, with the ID uncensored, behind a standard chat completions endpoint.

What uncensored does not mean

It does not mean the model has no limits. There is one hard line here: no sexual content involving minors, ever. The service is built for lawful adult use only. If you need a model for anything outside that, this is the wrong tool.

It also does not mean the model is smarter, more honest, or more accurate. A model with fewer refusals still makes mistakes, still invents facts when it does not know something, and still needs the same care with prompts. Dropping refusals changes what it is willing to say, not how well it reasons. Treat its output as you would from any other model: check anything that matters.

Finally, it does not mean you can skip your own responsibility. If you build an app on top, you decide what your users may do, and you carry the duty to follow the law where you and they live. A model that does not refuse is a tool without a guard, so the guard has to come from your product.

Refusals, hedging and moralizing are different things

People lump three behaviors together. A refusal is a flat "I can't help with that". Hedging is an answer buried under disclaimers. Moralizing is an unrequested lecture. A mainstream assistant often does all three on the same topic. An uncensored model typically drops the refusal and most of the lecture, which is why fiction writers and roleplay developers like it: the output stays in character instead of stepping out of the scene to comment on it.

Where the behavior comes from

If a model refuses less, the cause sits in one of four places, and it helps to know which, because only some of them are under your control.

1. Training data and tuning. This is the main source. It is fixed when the provider builds the model, and you cannot change it from the API.
2. The system prompt. You control this one. A clear system message that sets a role, a setting and a tone changes the answers a lot, even on a permissive model.
3. Sampling settings. Temperature and top_p do not decide what the model will discuss, but they change how varied and how coherent the text is. These are passed through to the model.
4. Platform filters. Many hosted APIs add a moderation layer in front of the model. That layer is the reason a request can fail even when the underlying weights would answer it. Check how a provider handles this before you build on it.

A practical consequence: you cannot "jailbreak" your way to a different model. If a mainstream assistant refuses, a clever prompt only helps until the next update. An uncensored model skips the problem at the source.

Legitimate uses for fewer refusals

The honest list of reasons people want fewer refusals is longer than the stereotype suggests.

• Fiction and worldbuilding. Novels deal with violence, crime, grief and cruelty. A writing assistant that breaks the scene to warn you is useless for a thriller or a war story.
• Roleplay and companion apps for adults. Character-driven chat needs a model that stays in character across long sessions without stopping to editorialize.
• Safety and moderation testing. Teams that build content filters need realistic examples of the text they want to catch. A model that will produce hard cases helps them test.
• Research and analysis. Summarizing extremist texts, studying propaganda, or discussing sensitive history sometimes trips a cautious model's filters even though the purpose is plain.
• Frank advice topics. Questions about drugs, harm reduction, or legal gray areas deserve direct answers rather than a wall of caveats. Remember that the model can be wrong, so do not treat it as a doctor or lawyer.

None of these require anything unlawful, and all of them work better with a model that treats the user as an adult.

How to call it: base URL, key and model ID

The API follows the OpenAI chat completions format, so any OpenAI SDK or compatible client works once you change two values. The base URL is https://api.ornith.top/v1, the key goes in an Authorization: Bearer header, and the model ID is uncensored. Two methods are available: POST /v1/chat/completions and GET /v1/models.

Start with a plain curl request to confirm your key works:

Copycurl https://api.ornith.top/v1/chat/completions \
  -H "Authorization: Bearer $API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "uncensored",
    "messages": [
      {"role": "system", "content": "You are a blunt editor for adult fiction."},
      {"role": "user", "content": "Rewrite this scene so the villain sounds more menacing."}
    ]
  }'

In Python, use the official openai package and point it at the new base URL:

Copyfrom openai import OpenAI

client = OpenAI(
    base_url="https://api.ornith.top/v1",
    api_key="YOUR_API_KEY",
)

resp = client.chat.completions.create(
    model="uncensored",
    messages=[
        {"role": "system", "content": "You write dark fantasy for adult readers."},
        {"role": "user", "content": "Describe a siege from the point of view of a tired defender."},
    ],
    temperature=0.9,
)
print(resp.choices[0].message.content)

And the same in Node:

Copyimport OpenAI from "openai";

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

const resp = await client.chat.completions.create({
  model: "uncensored",
  messages: [{ role: "user", content: "Give me three bleak opening lines for a noir story." }],
  stream: true,
});

for await (const chunk of resp) {
  process.stdout.write(chunk.choices[0]?.delta?.content ?? "");
}

Streaming works over SSE with stream: true, tool calling and JSON mode are supported, and the context window is 100,000 tokens counting prompt and reply together. The API docs cover each parameter and the response headers, including X-Balance-USD, which shows your remaining credit on every call.

What it costs, with real numbers

Pricing is pay as you go from prepaid credit: $0.15 per 1M input tokens and $0.50 per 1M output tokens. There is no subscription, failed or refused requests are not charged, and credit never expires.

Take a typical chat turn with a 2,000-token prompt (system message plus history) and a 500-token reply:

• Input: 2,000 tokens at $0.15 per 1M is $0.0003.
• Output: 500 tokens at $0.50 per 1M is $0.00025.
• Total per turn: $0.00055.

A thousand such turns cost $0.55. The $0.50 trial credit therefore covers roughly 900 turns of that size, which is plenty to judge the writing quality before you pay anything. For a heavier job, say 10M input tokens and 2M output tokens in a month, the bill is $1.50 plus $1.00, so $2.50.

When you do top up, any whole amount from $20 to $500 works, with a bonus of 5% from $50, 10% from $100 and 15% from $200. You can pay by card (Visa, Mastercard, Apple Pay, Google Pay) or with crypto (USDT on TRC20, USDC on Base). See the pricing page for the full table.

Trying it and choosing between options

New users can claim $0.50 of trial credit with one click on the API key page after signing up with Google or with email and password. It needs no card, it is one per person, and it is valid for 7 days. A trial key allows 2 concurrent requests and 60 requests per minute; a full key allows 8 concurrent and 300 per minute. You can get an API key in a minute and run the examples above.

A hosted model is not the only way to get fewer refusals. You can also download an open-weight model and run it on your own hardware, which gives you full control and works offline, at the price of a capable GPU and some setup. Our open source LLM API guide compares the options and the costs. The hosted route wins when you want no hardware, a stable endpoint for an app, and billing that scales to zero when nobody uses it.

One more point for people who handle sensitive text: prompts sent to the service are not used for training. Read the privacy page for details.

More guides

• Best Uncensored LLM to Run Locally With Ollama
• Uncensored LLM API for SillyTavern: Setup Steps
• Open Source LLM API Guide: Setup, Costs and Alternatives