Try with trial credit

Unfiltered LLM API: Make Your First Call in 5 Minutes

An unfiltered llm api is just an OpenAI-compatible endpoint backed by a model that does not refuse lawful requests. If you can call the OpenAI API, you can call this one by changing two values: the base URL and the key.

Last updated

Glowing cable plugging into a terminal socket with a stream of light flowing out, symbolizing a first API call

Summary

  1. Base URL https://api.unfilteredllms.com/v1, model ID uncensored, header Authorization: Bearer plus your key.
  2. Endpoints: /v1/chat/completions, /v1/responses and /v1/models.
  3. Context window is 100,000 tokens for prompt plus completion; max_tokens is optional.
  4. HTTP 429 means a rate or concurrency limit; wait and retry.

Before you start: key, URL and a models check

Three values are enough for every example below:

  1. Base URL: https://api.unfilteredllms.com/v1
  2. Model ID: uncensored
  3. An API key, sent as Authorization: Bearer YOUR_KEY

Sign up with Google, or with email and password, then open the API key page. A new account can claim $0.50 of trial credit with one click (7 days, one per person, no card), which is more than enough for everything here. Keep the key in an environment variable called API_KEY; never paste it into source code you commit.

The cheapest sanity check lists the available models and costs nothing:

export API_KEY="paste-your-key-here"

# the list contains the model id "uncensored"
curl https://api.unfilteredllms.com/v1/models \
  -H "Authorization: Bearer $API_KEY"

A JSON list means the key and URL are right. A 401 means the key is wrong or has been regenerated. A connection error usually means a typo in the host name.

Step 2: your first chat completion

curl https://api.unfilteredllms.com/v1/chat/completions \
  -H "Authorization: Bearer $API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "uncensored",
    "messages": [
      {"role": "system", "content": "You answer directly and keep it short."},
      {"role": "user", "content": "Describe a rainy harbor town in two sentences."}
    ],
    "temperature": 0.7
  }'

The reply follows the standard shape. The text sits at choices[0].message.content, and usage reports prompt and completion tokens:

{
  "model": "uncensored",
  "choices": [
    {
      "index": 0,
      "message": {"role": "assistant", "content": "Rain drums on the tin roofs..."},
      "finish_reason": "stop"
    }
  ],
  "usage": {"prompt_tokens": 32, "completion_tokens": 41, "total_tokens": 73}
}

Messages use three roles: system for standing instructions, user for what the person says, and assistant for earlier replies you send back. The model keeps no state between calls, so a conversation is the list you resend each time.

Step 3: Python and Node.js

import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.unfilteredllms.com/v1",
    api_key=os.environ["API_KEY"],
)

resp = client.chat.completions.create(
    model="uncensored",
    messages=[
        {"role": "system", "content": "You answer directly and keep it short."},
        {"role": "user", "content": "Describe a rainy harbor town in two sentences."},
    ],
)
print(resp.choices[0].message.content)
print(resp.usage)

The same client also works with client.responses.create(...), because POST /v1/responses is supported next to chat completions.

import OpenAI from "openai";

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

const resp = await client.chat.completions.create({
  model: "uncensored",
  messages: [{ role: "user", content: "Suggest three names for a smuggler's ship." }],
});

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

Save the file with an .mjs extension, or set "type": "module" in package.json, so top-level await works.

Step 4: streaming

Set stream: true and tokens arrive over server-sent events as they are generated. Usage is reported at the end of the stream.

import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.unfilteredllms.com/v1",
    api_key=os.environ["API_KEY"],
)

stream = client.chat.completions.create(
    model="uncensored",
    messages=[{"role": "user", "content": "Tell a two-paragraph ghost story."}],
    stream=True,
)

for chunk in stream:
    if chunk.choices and chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="", flush=True)
    if getattr(chunk, "usage", None):
        print("\n", chunk.usage)

One thing to remember: a streamed request holds its concurrency slot until the stream ends. If your code opens a stream and never reads it to the end, that slot stays busy and later calls may be rejected.

Context, output length and useful options

The context window is 100,000 tokens, counted as prompt plus completion together. The completion may use whatever room the prompt leaves, so max_tokens is optional. Set it anyway when you want a hard ceiling on cost or length. Pricing is $0.15 per 1M input tokens and $0.50 per 1M output tokens, so a 2,000-token prompt with a 500-token answer costs $0.0003 + $0.00025 = $0.00055.

These options are passed through: temperature, top_p, stop, seed and the frequency and presence penalties. Also supported are tool calling (tools, tool_choice, results sent back as role: "tool") and JSON mode:

import os
from openai import OpenAI

client = OpenAI(base_url="https://api.unfilteredllms.com/v1", api_key=os.environ["API_KEY"])

resp = client.chat.completions.create(
    model="uncensored",
    messages=[{"role": "user", "content": "Return a JSON object with keys name and mood for a grumpy lighthouse keeper."}],
    response_format={"type": "json_object"},
)

Mention JSON in the prompt itself, as above, so the model knows what shape you expect. The request body can be up to 8 MB. The documentation has the full parameter notes.

A worked context example: a prompt that uses the whole window, 100,000 tokens, costs 100,000 x $0.15 / 1,000,000 = $0.015 in input alone, and leaves no room for an answer. Leave headroom. Prompt plus completion must fit together, so a 90,000-token prompt leaves up to about 10,000 tokens for the reply. Check finish_reason in the response: stop means the model finished, and length means it hit a limit such as your max_tokens or the end of the window.

The newer responses route works with the same key and model. A minimal call looks like this:

curl https://api.unfilteredllms.com/v1/responses \
  -H "Authorization: Bearer $API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model": "uncensored", "input": "Name three moods for a rainy-day playlist."}'

Handle 429 responses

A full key allows 8 concurrent requests and 300 requests per minute. A trial key allows 2 and 60. Go over and you get HTTP 429 with the code rate_limited (too many requests per minute) or concurrency (too many at once). On temporary overload the API also returns 429, with a Retry-After: 5 header. Failed requests are not charged.

import os
import time
from openai import OpenAI, RateLimitError

client = OpenAI(
    base_url="https://api.unfilteredllms.com/v1",
    api_key=os.environ["API_KEY"],
    max_retries=0,
)

def ask(messages, tries=4):
    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", 2 ** attempt))
            time.sleep(wait)
    raise RuntimeError("still rate limited after retries")

Response headers such as X-RateLimit-Limit-Requests, X-RateLimit-Limit-Concurrency and X-Balance-USD help you tune this. Before you go live, read our production checklist and check the pricing for top-up bonuses.

The service is meant for lawful adult use, and sexual content involving minors is blocked without exception. It is text only, so there is no image, audio or video generation.

Quick fixes for first-call problems

  • 401 Unauthorized. The key is missing, mistyped or has been regenerated. Check that the header reads Authorization: Bearer followed by a space and the key, with no quotes inside the value.
  • 404 Not Found. The base URL probably lacks /v1, or the path is misspelled. The chat route is /v1/chat/completions.
  • Model not found. The model field must be exactly uncensored, in lower case.
  • Timeouts on long answers. Raise the client timeout, or stream, so you see tokens as they arrive instead of waiting for the full reply.
  • Body too large. The request body limit is 8 MB. Trim attachments or history before sending.
  • Replies cut short. If finish_reason is length, raise max_tokens or shorten the prompt.

Read the balance and headers

Every response carries headers worth logging. X-Request-Id identifies the call if you ever need to trace it. X-Balance-USD shows your remaining credit. X-RateLimit-Limit-Requests and X-RateLimit-Limit-Concurrency show the ceilings for your key. With the Python SDK, the raw-response helper exposes them:

import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.unfilteredllms.com/v1",
    api_key=os.environ["API_KEY"],
)

raw = client.chat.completions.with_raw_response.create(
    model="uncensored",
    messages=[{"role": "user", "content": "Say hello in five words."}],
)
resp = raw.parse()
print(resp.choices[0].message.content)
for name in ("X-Request-Id", "X-Balance-USD", "X-RateLimit-Limit-Requests"):
    print(name, raw.headers.get(name))

You can also fetch the balance on its own with GET /v1/balance, or with the OpenAI-style GET /v1/dashboard/billing/credit_grants if a tool expects that route.

Tool calling in one example

Tool calling lets the model ask your code to do something, such as a lookup or a dice roll, and then use the result. You describe the function, the model returns a call with JSON arguments, you run it, and you send the result back with the role tool.

import json
import os
import random
from openai import OpenAI

client = OpenAI(
    base_url="https://api.unfilteredllms.com/v1",
    api_key=os.environ["API_KEY"],
)

tools = [{
    "type": "function",
    "function": {
        "name": "roll_die",
        "description": "Roll a die with the given number of sides",
        "parameters": {
            "type": "object",
            "properties": {"sides": {"type": "integer"}},
            "required": ["sides"],
        },
    },
}]

messages = [{"role": "user", "content": "Roll a 20-sided die and narrate the result."}]
first = client.chat.completions.create(
    model="uncensored", messages=messages, tools=tools, tool_choice="auto"
)
msg = first.choices[0].message

if msg.tool_calls:
    messages.append(msg.model_dump(exclude_none=True))
    for call in msg.tool_calls:
        args = json.loads(call.function.arguments)
        result = random.randint(1, args["sides"])
        messages.append(
            {"role": "tool", "tool_call_id": call.id, "content": str(result)}
        )
    final = client.chat.completions.create(
        model="uncensored", messages=messages, tools=tools
    )
    print(final.choices[0].message.content)
else:
    print(msg.content)

Always validate the arguments the model sends before you act on them. They come from generated text, so treat them like any untrusted input. Streaming works with tools too: the tool_calls arrive in pieces that you join before parsing.

A client checklist and a worked daily cost

Once the first call works, a few habits keep a small client dependable. None of them needs extra libraries.

  1. Set a timeout. Long answers take time, so use a generous client timeout, or stream so the first tokens show up quickly.
  2. Retry only on 429. Wait for the Retry-After value when it is present, and back off when it is not. Do not retry a request that failed because of a bad key or a malformed body.
  3. Log the request ID. Store the X-Request-Id header next to each call so an odd answer can be traced later.
  4. Watch the balance. Read X-Balance-USD and stop or alert before it reaches zero.
  5. Cap the output. Set max_tokens to the longest reply you actually want.
  6. Keep the key on a server. Never ship it in browser code. Accounts that have topped up can hold up to 5 labelled keys, so give each app its own and revoke one without touching the rest.

For budgeting, take a service that sends 1,000 requests a day with a 2,000-token prompt and a 500-token answer. Each request costs $0.0003 for input plus $0.00025 for output, which is $0.00055. A day is 1,000 x $0.00055 = $0.55, and a 30-day month is $16.50. Double the prompt size to 4,000 tokens and input rises to $0.0006 per request, so the month becomes 30 x 1,000 x ($0.0006 + $0.00025) = $25.50. Input size drives the bill more than answer length at these rates, which is a good reason to trim history before you send it.

Streaming does not change the price. You pay for the same tokens either way, and the usage block at the end of the stream tells you exactly how many there were.

Common questions

Is this the official API of a model vendor?

No. It is a hosted service running one open-weight model from an independent provider. It is not the official API of OpenAI, Meta, Mistral or any other vendor.

Which model name do I send?

Use uncensored in the model field.

Can I use the official OpenAI SDK?

Yes. Set the base URL to https://api.unfilteredllms.com/v1 and use your key. Python and Node SDKs both work.

How do I check my balance?

Read the X-Balance-USD response header, call GET /v1/balance, or use the OpenAI-style GET /v1/dashboard/billing/credit_grants.

What if my key leaks?

Regenerate it on the API key page. The old key stops working at once, and you do not need to contact support.

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