Try with trial credit

Best Unfiltered LLMs: Hosted API vs Self-Hosting

There is no single list of the best unfiltered llms, because the right pick depends on your hardware, volume and privacy needs. This page explains what makes a model unfiltered, then compares running open weights yourself with calling a hosted API.

Last updated

Isometric scene comparing a local GPU server rack with a hosted cloud endpoint on a balanced seesaw

Summary

  1. Unfiltered describes behavior (few or no content refusals), not a benchmark score, so you have to test it.
  2. Self-hosting suits people with GPUs, steady load and a need for full control or fine-tuning.
  3. A hosted API suits people who want a working endpoint today and pay only for tokens used.
  4. A 15-minute side-by-side test with your own prompts beats any ranking.

The short answer

If you own a capable GPU and enjoy operating it, run an open-weight model locally. If you want a working endpoint in minutes, no hardware and a bill that follows your usage, use a hosted API. Both are legitimate, and many developers end up using one for experiments and the other for production.

This site runs the hosted kind: an OpenAI-compatible API with one model, ID uncensored, priced at $0.15 per 1M input tokens and $0.50 per 1M output tokens. That makes this page biased toward one side of the comparison, so it also says where self-hosting wins.

Whatever you read, judge a candidate on five things: how it behaves on your prompts, how much memory or money it needs, how long a context it handles, how stable it is under load, and what its license allows. A model that tops somebody's chart but fails two of those is the wrong choice for you. A smaller model you can run all day may beat a larger one you can afford only for brief tests.

What makes an LLM unfiltered

"Unfiltered" is not a technical standard. In practice it means the model answers requests that a more cautious model would decline or water down, within the law. It tends to come from one of four places:

  • Less safety tuning in the first place. Some base or lightly tuned models simply refuse less.
  • Community fine-tunes. Developers retrain an open model on data that does not teach refusals.
  • Refusal-removal edits. Some releases modify a model's weights to suppress its refusal behavior.
  • Your own system prompt. A prompt can set tone and scope, but it cannot reliably override strong refusal training.

Two cautions. First, fewer refusals does not mean better answers. Heavy edits can hurt reasoning or make output erratic. Second, always read the model card and license. Open weights come with terms, and those terms are worth checking before you build a product on them.

This page does not rank named models. Releases change month to month, and we cannot verify benchmark claims. The method in the last sections works for any candidate.

Option A: run open weights yourself

Tools such as llama.cpp, Ollama and vLLM can load open-weight models and expose an OpenAI-style endpoint, so your client code does not change. The first question is memory. A rough rule: weight memory is the parameter count times the bytes per weight, and you need extra room for the context cache and overhead.

Model sizePrecisionWeights alone (rule of thumb)
8B parameters16-bitabout 16 GB
8B parameters4-bitabout 4 to 5 GB
70B parameters4-bitabout 35 GB

Self-hosting wins when:

  • You need prompts to never leave your machine or network.
  • You want to choose the exact model, swap it freely or fine-tune it.
  • Your load is high and steady enough that owned hardware pays off. Work this out with your own power and hardware costs.

It costs you in other ways: setup time, updates, monitoring, and the quality drop that comes from squeezing a big model into small memory with heavy quantization. A single consumer GPU runs small models comfortably and large ones slowly, if at all.

Option B: use a hosted API

A hosted API removes the hardware question. You get a base URL, a key and a price per token. Here that looks like this:

  • OpenAI-compatible, so any OpenAI SDK works after you change the base URL and key.
  • One open-weight model run by an independent provider, tuned to answer without content refusals for lawful adult use. It is not the official API of any model vendor and not a router across vendors.
  • 100,000-token context window, streaming, tool calling and JSON mode.
  • A full key allows 8 concurrent requests and 300 requests per minute.
  • Prepaid credit that never expires. $20 buys 40 million output tokens, or 133 million input tokens, at the posted rates.
  • Prompts are not used for training.

The trade-offs are real. You get one model, not a menu. There is no fine-tuning, no image or audio generation and no embeddings. Your prompts travel to a provider, so you should read the privacy page and decide whether that fits your data. Top-ups are crypto only, USDT on TRC20 or USDC on Base.

Which one fits you

Your situationBetter fit
No GPU, want to start todayHosted API
Spiky or low trafficHosted API, since you pay per token
Data must stay on your hardwareSelf-hosted
Need fine-tuning or a specific modelSelf-hosted
Need a 100k context without buying big GPUsHosted API
Steady heavy load and an ops teamCompare both with your own numbers

A common middle path is to prototype on the hosted endpoint, learn what your prompts need, and only then decide whether owning the stack is worth it. Because both sides speak the same API shape, moving between them is a config change.

Here is the cost side in numbers for the hosted option. A reply of 500 tokens costs 500 x $0.50 / 1,000,000 = $0.00025 in output. Add a 2,000-token prompt at $0.0003 and one request costs $0.00055, so $20 of credit covers about 36,000 such requests. Put your own typical prompt size into the same sum, then compare the result with what a local GPU would cost you in hardware and power over the same period.

Licenses, privacy and the hybrid setup

Two checks apply whichever way you go. First, licenses. Open-weight models ship under different terms, and some limit commercial use or require attribution. Read the license on the model page before you build a product on it. Second, data. Self-hosting keeps text on your machines, which helps if you handle sensitive drafts. A hosted API sends prompts to a provider. Here prompts are not used for training, and the privacy page gives the details to review.

Because both sides speak the OpenAI API shape, a hybrid setup is cheap to build. Put the endpoint in configuration and nothing else changes:

import os
from openai import OpenAI

BASE_URL = os.environ.get("LLM_BASE_URL", "https://api.unfilteredllms.com/v1")
MODEL = os.environ.get("LLM_MODEL", "uncensored")

client = OpenAI(base_url=BASE_URL, api_key=os.environ["API_KEY"])

reply = client.chat.completions.create(
    model=MODEL,
    messages=[{"role": "user", "content": "Draft a tense opening scene in six sentences."}],
)
print(reply.choices[0].message.content)

Point LLM_BASE_URL at a local server for private drafts and at the hosted endpoint for everything else. The code path is identical, which also makes outages less painful: if one backend is down, switch the variable and carry on.

Test any candidate in 15 minutes

Collect five to ten prompts from your real use: the awkward ones, the ones other models refused, a long-context one and one that needs structured output. Then send the same prompts to each candidate and read the answers yourself. This script compares a hosted endpoint with a local Ollama server, which exposes an OpenAI-style API on port 11434:

import os
from openai import OpenAI

targets = {
    "hosted": OpenAI(
        base_url="https://api.unfilteredllms.com/v1",
        api_key=os.environ["API_KEY"],
    ),
    "local": OpenAI(base_url="http://localhost:11434/v1", api_key="local"),
}
models = {"hosted": "uncensored", "local": "your-local-model-name"}

prompts = [
    "Write a cold, menacing monologue for a fantasy villain in four sentences.",
    "Give brutally honest feedback on this opening line: 'It was a dark night.'",
    "Explain how lock picking works, at the level of a hobbyist guide.",
]

for p in prompts:
    print("PROMPT:", p)
    for name, client in targets.items():
        r = client.chat.completions.create(
            model=models[name],
            messages=[{"role": "user", "content": p}],
            temperature=0.8,
            max_tokens=300,
        )
        text = r.choices[0].message.content or ""
        print(f"  [{name}] {repr(text[:200])}")

Score each answer on three things: did it answer, was it correct, and was the style usable. Run each prompt a few times, since sampling makes single runs misleading. Replace the placeholder local model name with whatever your server lists.

Mistakes that skew the comparison

  • Judging from one prompt. One refusal or one great answer tells you little.
  • Comparing different quantization levels. A 4-bit local copy and a full-precision hosted model are not the same experiment.
  • Ignoring limits. Count requests per minute, concurrency and context size against your real traffic. The docs list this API's limits.
  • Skipping operations. Rate limits, key handling, logging and fallbacks matter the same way in either setup. Our production checklist covers them.

The hard line is the same everywhere: no sexual content involving minors. Whatever you pick, you are responsible for lawful use and for who can reach your app. To try the hosted route at no cost, the API key page offers $0.50 of trial credit with one click, valid 7 days and needing no card.

Common questions

Which model is the best unfiltered LLM?

There is no honest single answer. It depends on your task, hardware and tolerance for quality trade-offs, so test candidates with your own prompts. This service offers one model, ID uncensored.

Is a hosted unfiltered API cheaper than self-hosting?

It depends on volume. Low or uneven traffic favors paying per token, while heavy steady load may favor owned hardware. Compare using your own power and hardware costs.

Can I switch between a local model and a hosted API?

Yes, if both expose an OpenAI-style endpoint. You change the base URL, key and model name in your client.

Does the hosted API support fine-tuning?

No. It is text only, with no fine-tuning, embeddings, or image, audio or video generation.

Get your API key now

Sign up, grab your key, point to the new base URL. You are ready to go.

Try with trial credit