Abliterated Models Hosted: Use an API, Skip the GPU

What "hosted" means for an abliterated-style model

People searching for abliterated models hosted usually hit the same wall. The weights are free to download, but running a capable model needs a lot of video memory, a compatible inference stack, and patience for setup. A hosted service moves all of that to someone else's machines. You keep the part you care about: a model that answers without content refusals for lawful adult use.

On this site the model is one open-weight model run by an independent provider. It is tuned to skip refusals, the same goal that abliteration pursues. It is not the official API of Meta, Mistral, Qwen, DeepSeek or any other vendor, and it is not a router that forwards your request to different models. There is one model ID, uncensored, and every request goes to it.

If you want background on the technique itself first, the page on abliterated models covers the idea, and the article on choosing an abliterated LLM for roleplay covers what matters for character work.

Local download or hosted API: what changes

Neither option is always better. This table lists the practical differences.

Question	Local weights	Hosted API
Hardware	You supply GPU memory sized to the model and quantization	None on your side
Setup	Download, convert, configure a runtime	Create a key, set a base URL
Cost shape	Upfront hardware and power	Per token, from prepaid credit
Context length	Limited by your memory	100,000 tokens, prompt plus completion
Privacy	Everything stays on your machine	Requests go to a server; prompts are not used for training
Offline use	Works	Needs a connection

If your prompts must never leave your own hardware, run locally and accept the setup work. If you want to test an idea this afternoon, or your app already talks to an OpenAI-style endpoint, hosting is faster. Many people start hosted and move local later, or the reverse.

Make your first request

Create an account, open the API key page, and copy your key. Then point any OpenAI SDK at the base URL. The endpoint supports POST /v1/chat/completions, POST /v1/responses and GET /v1/models.

Python

Copyfrom openai import OpenAI

client = OpenAI(
    base_url="https://api.abliterated.cc/v1",
    api_key="YOUR_KEY",
)

resp = client.chat.completions.create(
    model="uncensored",
    messages=[
        {"role": "system", "content": "You are a blunt, helpful writing partner."},
        {"role": "user", "content": "Draft a tense opening scene for a noir story."},
    ],
    temperature=0.8,
)
print(resp.choices[0].message.content)
print(resp.usage)

curl

Copycurl https://api.abliterated.cc/v1/chat/completions \
  -H "Authorization: Bearer YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model":"uncensored","messages":[{"role":"user","content":"Say hello in one sentence."}]}'

The full parameter list is on the documentation page. max_tokens is optional; the completion can use whatever is left of the 100,000-token window after your prompt.

Streaming and tool calls work as they do elsewhere

Because the API follows the OpenAI format, features you already use carry over. Set stream: true and you receive server-sent events, with token usage at the end. Tool calling accepts tools and tool_choice, streams tool_calls, and expects results as messages with role: "tool". JSON mode is available through response_format.

Copyimport OpenAI from "openai";

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

const stream = await client.chat.completions.create({
  model: "uncensored",
  stream: true,
  messages: [{ role: "user", content: "Write two lines of dialogue between a smuggler and a customs officer." }],
});

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

Sampling settings such as temperature, top_p, stop, seed and the repetition penalties are passed through. If you are building an interface around this, the walkthrough on building a chatbot from an LLM shows how to keep conversation history and handle streaming in a small app.

What it costs, with real numbers

Pricing is $0.15 per 1M input tokens and $0.50 per 1M output tokens. There is no subscription. You top up credit and spend it; credit never expires, and failed or refused requests are not charged.

Here are three examples, each computed from those two rates.

• Short chat turn: 2,000 input tokens and 500 output tokens. Input is 2,000 / 1,000,000 x $0.15 = $0.0003. Output is 500 / 1,000,000 x $0.50 = $0.00025. Total $0.00055, so about 1,800 such turns cost $1.
• Long story session: a 40,000-token history resent with 1,000 tokens of output. Input is $0.006, output is $0.0005, total $0.0065.
• Batch of 1,000 requests: 1,500 input and 700 output tokens each. That is 1.5M input tokens, $0.225, plus 0.7M output tokens, $0.35. Total $0.575.

Long histories cost more because you pay for input on every call. Keep a summary of earlier turns instead of resending everything when the story gets long. Current rates and bonuses are listed on the pricing page.

Adding credit and the free trial

Top-ups take any whole amount from $20 to $500. Larger amounts earn a bonus: +5% from $50, +10% from $100 and +15% from $200. You can pay with crypto (USDT on TRC20, USDC on Base).

To test before paying, sign up with Google or with email and password, then claim the trial on the API key page. It is $0.50 of credit, valid for 7 days, one per person, and needs no card. At the short-turn rate above, that covers roughly 900 requests. A trial key is limited to 2 concurrent requests and 60 requests per minute. A full key allows 8 concurrent requests and 300 requests per minute.

Ready to try it? Get an API key and run the Python snippet above.

Mistakes people make when moving from a local setup

A local runtime hides some details that a hosted API makes explicit. These are the ones that trip people up most often.

• Wrong model name. Local tools often expect a file name or a tag. Here the model ID is always uncensored. Any other value will not do what you expect.
• Missing /v1 in the base URL. The base URL ends in /v1. Clients add /chat/completions themselves, so do not append it twice.
• Hard-coded chat templates. Local runners sometimes need a prompt template for the model. With the API you send plain messages and the server applies the template.
• Resending the whole history forever. A local model costs nothing per token, so people paste entire transcripts. On an API that habit adds up, as the cost examples show. Trim or summarize old turns.
• Ignoring 429 responses. Retry with a short delay instead of firing the same request in a tight loop.

Fix those five and a script written for a local server usually runs against the hosted endpoint with no other change.

Limits to plan for

Hosted does not mean unlimited. Over the request rate you get HTTP 429 with the error code rate_limited. Too many simultaneous requests return 429 with concurrency. During temporary overload the API also sends 429 with a Retry-After: 5 header, so wait five seconds and retry. A streamed request holds its concurrency slot until the stream ends, so a UI that opens many streams at once can hit the concurrency limit sooner than expected.

Check the X-Balance-USD response header to see your remaining credit without a separate call. The API is text only: no images, audio, video, embeddings or fine-tuning. One rule is fixed: sexual content involving minors is never allowed.

More guides

• How Are Abliterated Models Made? A Plain Explanation
• Uncensored LLM API: OpenAI-Compatible & JSON Mode