NSFW Uncensored API vs Filtered: What Changes

What filtered and uncensored mean for a text API

A filtered text API applies a content policy chosen by the provider. Some requests are declined, and the reply is a refusal or a softened answer. That is a reasonable choice for a general assistant used by anyone. It is a poor fit when your product is adult fiction, a companion app or a roleplay platform for verified adults, because the refusals arrive at random and break the experience.

An uncensored API makes the opposite default. The model is an open-weight one tuned to answer without content refusals for lawful adult use, and it is run by an independent provider. It is not the official API of any model vendor, and it is not a router across several models. You get a single model ID, uncensored, behind an OpenAI-compatible endpoint at https://api.nsfwuncensored.com/v1.

The technical interface is identical. The same messages, streaming, tool calling and JSON mode work. What differs is behaviour on sensitive prompts, and therefore who has to make the decisions the model no longer makes.

Uncensored is not the same as unlimited

Two limits stay in force. The first is the law. The service is for lawful adult use, and you are responsible for making sure your own use stays lawful where you and your users are. The second is a fixed rule on the service itself: no sexual content involving minors, ever. Do not build prompts, characters or features that try to approach it. Treat it as a line your product enforces too, not only the provider.

The service is also limited by what it is. It is text only. It generates no images, audio or video, and offers no embeddings and no fine-tuning. If your product needs those, you will combine this API with something else.

Where responsibility moves to you

With a filtered API, the provider is a safety net. Remove the net and four jobs land on your side:

• Audience. Decide who may see adult output and verify it to the standard your jurisdiction and your payment or app-store partners expect.
• Policy. Write down what your product allows and forbids, beyond the hard rule. Platforms that host adult content usually set rules stricter than the law.
• Enforcement. Check inputs and outputs, and act on violations by blocking, warning or banning accounts.
• Records. Keep logs sufficient to investigate abuse reports, while respecting your own privacy promises to users.

None of that is exotic. It is the same work any platform that hosts user-generated content already does. The difference is that you now do it deliberately rather than inheriting a hidden policy.

Layer 1 and 2: age gate and input checks

The age gate sits outside the API. It is a sign-up step, a verification flow or both, and it decides whether a session may reach the generator at all. Do not rely on a system prompt that says "the user is an adult". A prompt is not a gate.

The input check runs before you call the model. A simple version blocks terms you never allow and strips attempts to override your instructions. A better version asks the model itself to classify a message, with JSON mode giving a parseable answer. Here is a classifier you can adapt:

Copyimport json, os
from openai import OpenAI

client = OpenAI(base_url="https://api.nsfwuncensored.com/v1", api_key=os.environ["NSFWU_KEY"])

POLICY = """You are a content policy checker for an adult fiction app.
Return JSON: {"allowed": true or false, "reason": "short text"}.
Set allowed to false if the message involves anyone under 18 in a sexual context,
real named people in sexual scenarios, or requests for illegal acts.
Otherwise set allowed to true."""

def check(text):
    r = client.chat.completions.create(
        model="uncensored",
        messages=[{"role": "system", "content": POLICY},
                  {"role": "user", "content": text}],
        response_format={"type": "json_object"},
        temperature=0,
    )
    return json.loads(r.choices[0].message.content)

verdict = check("Write a scene between two adult characters at a masquerade ball.")
print(verdict)

Run the check on user messages and refuse to forward blocked ones. Set temperature to 0 so the verdicts are stable, and test the policy text against a list of your own examples, including borderline ones. Because a classifier is itself a model, treat it as a filter that reduces risk, not a guarantee. Pair it with plain string rules for the cases you never want to risk.

Layer 3: output checks and character rules

The same pattern works on the way out. Generate the reply, run it through a check, and only then show it. For streamed replies, buffer by paragraph and check each chunk before releasing it, or run the check on the finished text and retract when it fails. The first option is smoother for users and the second is simpler to build.

Put standing rules in the system prompt for every call: all characters are adults, no real people, keep the register you promise your users. These rules do not replace your checks, but they reduce how often the checks need to fire. For roleplay and companion apps it also helps to give each character an explicit age and description in the persona, so the story stays coherent.

Finally, set sensible technical limits. Cap max_tokens to the length your product shows, and put a stop sequence on speaker tags. That keeps replies on topic and keeps your costs predictable.

Cost, limits and next steps

Moderation calls cost tokens like everything else, but they are short. A check with 400 tokens in and 40 out costs 400 × $0.15 / 1,000,000 + 40 × $0.50 / 1,000,000 = $0.00006 + $0.00002 = $0.00008. Checking both the input and the output of every turn adds about $0.00016 per turn, which is $0.16 per thousand turns. The prices are $0.15 per 1M input and $0.50 per 1M output tokens, billed from prepaid credit that never expires. Failed or refused requests are not charged.

A full key allows 8 concurrent requests and 300 per minute, so moderation calls share the same budget as generation. Plan for this if you check every message. If you hit a limit the API returns HTTP 429, and you should retry after the Retry-After delay when it is present.

To start, claim the $0.50 trial credit on the API key page, then read the docs for the parameter list and the pricing page for top-ups, which are crypto only (USDT on TRC20, USDC on Base). For an application walkthrough with persona prompts and chat memory, see how to build an NSFW chatbot with an uncensored API.

More guides

• Low-Cost NSFW Uncensored API Alternatives Compared
• How to build an NSFW Chatbot with an Uncensored API