Qwen Abliterated API: Call a Hosted Model, No GPU

Short answer: change the base URL

If you are looking for a qwen abliterated api, the practical route is a hosted endpoint that speaks the OpenAI protocol. You keep your client code, change two values, and send requests to a server that runs the model for you. No GGUF download, no quantisation choice, no VRAM budget.

A necessary note on naming: this is an independent service, not the official Qwen API, and the hosted model is addressed as uncensored rather than by a Qwen checkpoint name. It is one open-weight model, run by an independent provider and tuned to answer without content refusals for lawful adult use. If you need one particular abliterated file, run that file locally. If you need a dependable chat endpoint for an app, read on.

Get a key

Sign up with Google, or with an email and password, then open the API key page. New users can claim $0.50 of trial credit with one click, one per person, valid for 7 days and without a card. That is enough to run through every example below several times.

Trial keys have lower limits than full keys: 2 concurrent requests and 60 requests per minute, against 8 and 300 on a full key. Keep that in mind if you test with parallel workers.

Store the key in an environment variable rather than in source control:

Copyexport QWENABL_KEY="paste-your-key-here"

First request in Python

Install the official SDK with pip install openai, then:

Copyimport os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.qwenabliterated.top/v1",
    api_key=os.environ["QWENABL_KEY"],
)

resp = client.chat.completions.create(
    model="uncensored",
    messages=[
        {"role": "system", "content": "You are a blunt technical assistant."},
        {"role": "user", "content": "Explain what a KV cache is in three sentences."},
    ],
    temperature=0.7,
)

print(resp.choices[0].message.content)
print(resp.usage)

The response carries a normal usage block, so you can log prompt and completion tokens and compute spend yourself. The headers include X-Request-Id for support questions and X-Balance-USD so you can watch the remaining credit without opening a dashboard.

Why use an API rather than GGUF files

The usual route to an uncensored model is to find a quantised file, load it in a local runtime and talk to a local server. That works, and for experiments it is a good way to learn. The friction shows up when you move from experiments to something other people use.

First, hardware. A file that fits on your desktop card at a short context may not fit at a long one, because the attention cache grows with every token. Second, concurrency. A single local process handles one or two chats comfortably, but ten users at once mean queues. Third, availability. A home machine sleeps, loses power and gets a driver update at the wrong time. A hosted API turns these into someone else's job, and you pay only for tokens used.

What you give up is the freedom to choose a specific checkpoint and the guarantee that bytes never leave your network. Decide which of those matters more for your project before you pick.

Node.js and curl

The Node SDK takes the same two options:

Copyimport OpenAI from "openai";

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

const resp = await client.chat.completions.create({
  model: "uncensored",
  messages: [{ role: "user", content: "Give me five names for a fantasy tavern." }],
});

console.log(resp.choices[0].message.content);

And with curl, which is handy for checking a key before wiring anything up:

Copycurl -s https://api.qwenabliterated.top/v1/models \
  -H "Authorization: Bearer $QWENABL_KEY"

A successful call returns a JSON list that includes uncensored. A 401 means the key is wrong or missing. The documentation covers the error format in detail.

Streaming, JSON mode and tools

Streaming

Set stream: true and read server-sent events. Usage is reported at the end of the stream.

Copystream = client.chat.completions.create(
    model="uncensored",
    messages=[{"role": "user", "content": "Write a short scene on a night train."}],
    stream=True,
)
for chunk in stream:
    if chunk.choices and chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="", flush=True)

A streamed request holds its concurrency slot until the stream finishes, so a client that opens a stream and walks away will block capacity. Always consume or close the stream.

JSON mode

Pass response_format={"type": "json_object"} and mention JSON in your prompt. Parse defensively anyway; no model follows a schema perfectly every time.

Tool calling

Send tools and optionally tool_choice. When the model asks for a tool, run it and return the output as a message with role: "tool". Tool calls also stream. The sampling parameters temperature, top_p, stop, seed and the frequency and presence penalties are passed through.

Putting it into a real application

A single script is easy. An application needs a few more habits, and they are the same ones you would use with any OpenAI-style API.

Keep the key on the server

Never ship the key in browser code or a mobile app. Call the API from your backend and expose your own route to the front end, where you can add authentication and per-user limits. Anyone who finds a key in a bundle can spend your credit.

Set timeouts and cap output

The completion can use whatever is left of the 100,000-token window, and max_tokens is optional. For a chat feature, set a cap that matches your interface so an unusually long answer cannot run up the bill. Pair that with a client timeout and you have a ceiling on both time and money for each call.

Log the request ID

Every response carries X-Request-Id. Store it next to your own record of the call. When a result looks wrong or a request fails, that identifier is what lets support find the exact request. The X-Balance-USD header is useful for a simple alert: if the number falls below a threshold, send yourself a message before a job runs dry.

Check the models list on start-up

A health check that calls GET /v1/models costs nothing in tokens and confirms the key, the URL and the network path in one step. Run it when your service boots and fail loudly if it returns an error.

Limits and error handling

Requests over a limit get HTTP 429. The error code tells you which limit you hit: rate_limited means too many requests per minute, and concurrency means too many at once. During temporary overload the API also returns 429 with a Retry-After: 5 header. The maximum body is 8 MB.

Respect the header and back off:

Copyimport time
from openai import OpenAI, RateLimitError

def ask(client, messages, tries=5):
    for attempt in range(tries):
        try:
            return client.chat.completions.create(model="uncensored", messages=messages)
        except RateLimitError as e:
            wait = int(e.response.headers.get("Retry-After", 5))
            time.sleep(wait * (attempt + 1))
    raise RuntimeError("still rate limited")

If you run a worker pool, cap it at 8 threads for a full key. Going above that only converts work into 429s. Failed or refused requests are not charged, so retries do not cost you anything extra when they fail.

What a request costs

Input tokens are $0.15 per 1M and output tokens $0.50 per 1M. Some examples, computed exactly:

• A chat turn with 2,000 prompt tokens and 500 completion tokens: 2,000 x $0.15 / 1M = $0.0003, plus 500 x $0.50 / 1M = $0.00025, so $0.00055. One thousand turns cost $0.55.
• A batch job that sends 10M input tokens and receives 2M output tokens: $1.50 plus $1.00, so $2.50.
• A long-context call with 90,000 prompt tokens and 1,000 output tokens: $0.0135 plus $0.0005, so $0.014.

Credit is prepaid, never expires and there is no subscription. Top up any whole amount from $20 to $500; $50 adds 5%, so a $50 top-up gives $52.50 of credit. Pay by crypto (USDT on TRC20, USDC on Base). See the pricing page for the full bonus table.

Hosted or local files: which fits

A local GGUF gives you privacy by isolation and complete control over the exact weights. A hosted API gives you no hardware work, long context and a URL that other services can call. Most teams that build a bot, a writing tool or a game backend find hosting simpler, since a spare GPU box is another thing to keep running.

For a wider look at paying per token compared with other ways of reaching a Qwen-style model, see the comparison guide. Prompts sent to the API are not used for training. The model is text only, and sexual content involving minors is not permitted under any circumstances.

More guides

• Qwen 3.5 Abliterated: What It Means and Hosted Options
• Qwen Abliterated Roleplay: Settings and API Setup
• Uncensored API Alternative