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 size | Precision | Weights alone (rule of thumb) |
|---|---|---|
| 8B parameters | 16-bit | about 16 GB |
| 8B parameters | 4-bit | about 4 to 5 GB |
| 70B parameters | 4-bit | about 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 situation | Better fit |
|---|---|
| No GPU, want to start today | Hosted API |
| Spiky or low traffic | Hosted API, since you pay per token |
| Data must stay on your hardware | Self-hosted |
| Need fine-tuning or a specific model | Self-hosted |
| Need a 100k context without buying big GPUs | Hosted API |
| Steady heavy load and an ops team | Compare 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.
