Uncensored LLM Hub: One Endpoint for Chat and Agents

What you get from one endpoint

People search for the uncensored llm hub when they want a model that answers without content refusals for lawful adult use, but do not want to run GPUs. The service is a plain HTTPS API. You point an OpenAI client at https://api.uncensoredllmhub.com/v1, send the model ID uncensored, and authenticate with Authorization: Bearer YOUR_KEY. Two methods exist: POST /v1/chat/completions for conversations and GET /v1/models for listing.

It helps to be clear about what sits behind that endpoint. It is one open-weight model, run by an independent provider and tuned to skip content refusals. It is not the official API of any large vendor, and it is not a router that picks between models. It handles text only: no images, audio, video, embeddings or fine-tuning. One hard rule applies without exception: no sexual content involving minors.

That narrow scope is the point. A single stable endpoint is easy to build around. The sections below show a small chat backend, then an agent loop, then the limits you need to design for.

Step 1: connect an existing client

Because the API follows the OpenAI format, you rarely write new client code. Open your SDK or tool, change the base URL and the key, and set the model to uncensored. First sign up on the API key page (Google, or email and password), then claim the $0.50 trial credit with one click. The trial needs no card, lasts 7 days and is limited to one per person.

A minimal request in Python:

Copyfrom openai import OpenAI

client = OpenAI(
    base_url="https://api.uncensoredllmhub.com/v1",
    api_key="YOUR_API_KEY",
)

resp = client.chat.completions.create(
    model="uncensored",
    messages=[
        {"role": "system", "content": "You are a concise assistant for a writing tool."},
        {"role": "user", "content": "Give me three opening lines for a mystery set on a ferry."},
    ],
    temperature=0.9,
    top_p=0.95,
)
print(resp.choices[0].message.content)

Sampling settings such as temperature, top_p, stop, seed and the frequency and presence penalties are passed through to the model, so the knobs you know from other providers behave the same way. The same call works in tools that accept a custom OpenAI-compatible endpoint, for example SillyTavern or Open WebUI: paste the base URL, add the key, type the model ID by hand.

Step 2: stream answers into a chat interface

Chat apps feel slow if the user stares at a blank box until the full answer arrives. Streaming fixes that. Set stream: true and the API sends the answer as server-sent events, with usage reported at the end of the stream. Here is a Node version that forwards tokens as they arrive:

Copyimport OpenAI from "openai";

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

export async function streamReply(history, onToken, signal) {
  const stream = await client.chat.completions.create(
    { model: "uncensored", messages: history, stream: true },
    { signal }
  );
  let text = "";
  for await (const chunk of stream) {
    const piece = chunk.choices[0]?.delta?.content ?? "";
    if (piece) {
      text += piece;
      onToken(piece);
    }
  }
  return text;
}

Two habits save trouble later. First, always pass an abort signal and cancel it when the user closes the tab or presses stop. A streamed request occupies its concurrency slot until the stream ends, so abandoned streams eat into your allowance. Second, keep the full text you assembled, because you will append it to the history as the assistant message for the next turn.

If you see vague errors in your front end while streaming, our note on diagnosing streaming failures covers the usual causes, such as a wrong base URL, a proxy that buffers events and the two 429 codes.

Step 3: use the long context deliberately

The context window is 100,000 tokens, shared by the prompt and the completion. For a story-writing tool, a character chat or a document assistant, that is room for a long history, a large system prompt and reference material at the same time. You do not need to set max_tokens; the completion can use whatever is left.

Long context is cheap to try at these prices. Filling the whole window with input costs 0.1 × $0.15 = $0.015 for 100,000 input tokens. Add a 2,000 token answer (0.002 × $0.50 = $0.001) and a nearly full call costs $0.016. You will still want to manage the window, for three reasons: latency grows with prompt size, each turn re-sends the history so costs add up across a session, and very long histories dilute the instructions at the top.

A simple policy works well:

1. Keep the system prompt and any fixed reference text at the start.
2. Keep the most recent turns verbatim.
3. When the history passes a threshold you choose, for example 60,000 tokens, ask the model to summarise the oldest part into a short note and replace those turns with it.
4. Read usage.prompt_tokens from each response to know how big the next request will be, instead of estimating by characters.

Step 4: tools and structured output for agents

Agents need two things from a model: a way to call functions, and output you can parse. Both are supported. Tool calling uses the standard tools and tool_choice parameters, tool calls can be streamed, and results go back as messages with role: "tool". A single round trip looks like this:

Copyimport json
from openai import OpenAI

client = OpenAI(
    base_url="https://api.uncensoredllmhub.com/v1",
    api_key="YOUR_API_KEY",
)

tools = [{
    "type": "function",
    "function": {
        "name": "lookup_order",
        "description": "Find an order by its number.",
        "parameters": {
            "type": "object",
            "properties": {"order_id": {"type": "string"}},
            "required": ["order_id"],
        },
    },
}]

messages = [{"role": "user", "content": "Where is order A-1042?"}]
first = client.chat.completions.create(model="uncensored", messages=messages, tools=tools)
msg = first.choices[0].message

if msg.tool_calls:
    call = msg.tool_calls[0]
    args = json.loads(call.function.arguments)
    result = {"order_id": args["order_id"], "status": "shipped"}  # your real lookup goes here
    messages.append(msg)
    messages.append({"role": "tool", "tool_call_id": call.id, "content": json.dumps(result)})
    final = client.chat.completions.create(model="uncensored", messages=messages, tools=tools)
    print(final.choices[0].message.content)

Always validate the arguments before you run anything with side effects. A model can produce a malformed or unexpected value, and your code is the last line of defence.

For plain structured output without tools, use JSON mode with response_format set to {"type": "json_object"}. Describe the shape you want in the prompt as well, and parse the reply inside a try block so a bad response triggers a retry instead of a crash.

Copycurl https://api.uncensoredllmhub.com/v1/chat/completions   -H "Authorization: Bearer $API_KEY"   -H "Content-Type: application/json"   -d '{
    "model": "uncensored",
    "response_format": {"type": "json_object"},
    "messages": [
      {"role": "system", "content": "Reply with JSON: {"title": string, "tags": [string]}"},
      {"role": "user", "content": "Describe a noir story set in a rainy port city."}
    ]
  }'

Limits to design around

A full key allows 8 concurrent requests and 300 requests per minute. A trial key allows 2 and 60. The body can be up to 8 MB. Each response carries X-Request-Id, X-Balance-USD, X-RateLimit-Limit-Requests and X-RateLimit-Limit-Concurrency, which are useful to log.

When you pass a limit, the API returns HTTP 429. The code is rate_limited for too many requests per minute and concurrency for too many at once. A temporary overload also returns 429, with Retry-After: 5. For a multi-user app, put a small queue in front of the API: a semaphore sized below the concurrency limit and a retry that honours Retry-After. For an agent that fans out into parallel tool calls, cap the fan-out at the same number.

The full parameter list and error format are in the API documentation.

Cost, top-ups and data handling

Pricing is $0.15 per 1M input tokens and $0.50 per 1M output tokens, from prepaid credit. There is no subscription, credit never expires, and failed or refused requests are not charged. A chat turn of 1,500 input and 500 output tokens costs 0.0015 × $0.15 + 0.0005 × $0.50 = $0.000225 + $0.00025 = $0.000475, so $20 of credit covers about 42,000 such turns.

You can top up any whole amount from $20 to $500. The bonus is +5% from $50, +10% from $100 and +15% from $200. Pay by card (Visa, Mastercard, Apple Pay, Google Pay) or crypto (USDT on TRC20, USDC on Base). The pricing page has the current table.

On data: prompts are not used for training. Read the privacy policy for the full wording. You remain responsible for what you build with the model, and the service is meant for lawful adult use only.

More guides

• Unknown Error From LLM Stream: Causes and Fixes
• How to Host an LLM Yourself, or Skip It With an API
• Uncensored Ollama Models vs Hosted APIs