Build a No Filter AI Chatbot With an API

What "no filter" can and cannot mean

Searchers who want a no-filter chatbot usually mean one thing: they want a chatbot that does not interrupt a conversation with warnings, moralizing or refusals when the topic is legal and the user is an adult. That is a reasonable thing to want for fiction, companion apps, dark humor, debate practice and frank advice conversations.

The model on this API is one open-weight model, run by an independent provider and tuned to answer without content refusals for lawful adult use. It is not the official API of Meta, Mistral, Qwen, DeepSeek, OpenAI, xAI, Google or Anthropic. There is one hard limit that no prompt changes: no sexual content involving minors. As the person building the app, you also carry duties the model cannot carry for you, such as checking that your users are adults, and following the laws that apply where you operate.

The rest of this guide treats "unfiltered" as a design choice you make deliberately. Your chatbot will do what your system prompt and your users ask, so the quality of the bot depends mostly on the prompt and the surrounding code.

Pick your path: code or no code

Path	Best for	Time
Frontend with a custom endpoint (SillyTavern or similar)	Personal use, character chat, trying prompts quickly	5 minutes
Small script with the OpenAI SDK	Learning, command-line bots, Discord or Telegram bots	20 minutes
Your own backend and web UI	A product other people use	A weekend or more

All three paths need the same ingredients: a key, the base URL and the model ID. You get the key on the API key page after signing up with Google or with an email and password. New users can claim $0.50 of trial credit there with one click, valid for 7 days, no payment needed. Top-ups later are crypto only: USDT on TRC20 or USDC on Base.

A working chatbot in Node

Install the official OpenAI package, set your key as an environment variable, and save this as bot.mjs. The .mjs extension lets you use import without extra configuration.

Copy# base URL https://api.nofilterapi.com/v1, model uncensored
npm install openai
export NOFILTER_API_KEY="YOUR_API_KEY"
node bot.mjs

Copyimport OpenAI from "openai";
import readline from "node:readline/promises";
import { stdin as input, stdout as output } from "node:process";

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

const history = [
  {
    role: "system",
    content:
      "You are Dex, a blunt, funny late-night radio host. Speak plainly, " +
      "keep replies under 120 words, and never lecture. All users are adults.",
  },
];

const rl = readline.createInterface({ input, output });

while (true) {
  const text = await rl.question("you> ");
  if (text.trim() === "") break;
  history.push({ role: "user", content: text });

  const stream = await client.chat.completions.create({
    model: "uncensored",
    messages: history,
    temperature: 0.8,
    max_tokens: 400,
    stream: true,
  });

  let reply = "";
  process.stdout.write("dex> ");
  for await (const chunk of stream) {
    const piece = chunk.choices[0]?.delta?.content ?? "";
    reply += piece;
    process.stdout.write(piece);
  }
  process.stdout.write("\n");
  history.push({ role: "assistant", content: reply });
}
rl.close();

That is the whole bot. The history array is the conversation memory, because the API itself keeps nothing between calls. Each turn sends the entire array, so the model sees everything that came before. Streaming prints the reply as it is generated, and the usage numbers arrive at the end of the stream.

If you want to put this behind a web page, keep the key on your server. Build a small endpoint that receives the user's message, adds it to that user's history, calls the API and returns the reply. A key placed in browser JavaScript can be read by anyone who opens the developer tools, and your credit would go with it. The documentation lists every parameter the endpoint accepts.

Give the bot a persona that holds

Unfiltered models still need direction. Without it they answer in a flat, neutral voice. A good system prompt for a chatbot has five short parts:

1. Identity. Name, role, one or two defining traits.
2. Voice. Sentence length, vocabulary, humor, formality. Give an example line.
3. Boundaries you choose. Topics this character avoids, if any. These are your product decisions.
4. Format. Reply length, whether to use lists, whether to stay in first person.
5. Facts. Anything the bot must remember about the user or the world.

Keep it under about 400 words. A long prompt is not a stronger prompt, and you pay for it on every request because it is part of the input each time. At $0.15 per 1M input tokens, a 600-token system prompt costs $0.00009 per call, which is small for one chat and noticeable at 100,000 calls: $9.

Sampling matters too. A temperature around 0.7 to 0.9 suits conversation. The parameters top_p, stop, seed and the frequency and presence penalties are all passed through to the model, so you can tune repetition without tricks.

The no-code route with SillyTavern

SillyTavern is a free, self-hosted chat frontend popular for character conversations, and it lets you add an OpenAI-compatible endpoint. Open the API connection panel, choose the chat completion type, then select the custom or OpenAI-compatible source. Enter:

• Endpoint or base URL: https://api.nofilterapi.com/v1
• API key: the key from your account
• Model: uncensored

Menu labels differ between versions, so use these three values and follow your version's own prompts. Once connected, create or import a character, write the persona in its description, and start talking. Other community frontends have the same kind of option, usually labelled custom OpenAI endpoint or proxy.

If you want to understand how this service treats your data before you pick a route, read No Log AI API: Myths vs Facts. One fact from our side is simple: prompts are not used for training.

Memory: the 100,000-token window and what to do with it

The context window is 100,000 tokens, covering prompt and completion together. That is enough for a very long conversation, but the cost of resending history grows with it. A turn with 10,000 tokens of history and a 300-token reply costs 10,000 x $0.15 / 1M plus 300 x $0.50 / 1M, which is $0.0015 plus $0.00015, or $0.00165. The $0.50 trial credit covers about 303 of those turns.

A practical memory design uses two layers. Keep the last 15 to 20 messages verbatim, and keep a compact list of long-term facts in the system prompt. You can have the model maintain that list for you with JSON mode, which constrains the output to valid JSON:

Copycurl https://api.nofilterapi.com/v1/chat/completions \
  -H "Authorization: Bearer $NOFILTER_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "uncensored",
    "response_format": {"type": "json_object"},
    "messages": [
      {"role": "system", "content": "Extract durable facts about the user from the chat. Reply as JSON: {\"facts\": [string]}."},
      {"role": "user", "content": "User: I work night shifts at a bakery and my cat is called Biscuit."}
    ]
  }'

Run that every 10 or 20 turns on the latest messages, merge the new facts into your stored list, and put the list in the system prompt. The model's job stays small, and your bot appears to remember months of conversation.

Costs, limits and going public

The price is $0.15 per 1M input tokens and $0.50 per 1M output tokens, from prepaid credit with no subscription. You can top up any whole amount from $20 to $500, with +5% bonus from $50, +10% from $100 and +15% from $200. Credit never expires, and failed or refused requests are not charged. The pricing page has the full picture.

A bot with 200 users who each send 30 messages a day, at the $0.00165 turn above, makes 6,000 calls and spends about $9.90 a day. Shorter histories bring that down quickly, because the input side dominates.

When the bot grows, respect the limits. A full key allows 8 concurrent requests and 300 requests per minute. Beyond that the API returns HTTP 429 with the code rate_limited or concurrency, and on temporary overload a 429 with Retry-After: 5. The OpenAI SDKs retry 429 responses by default, and you can raise the count with the maxRetries client option. A streamed reply holds its concurrency slot until it ends, so queue incoming messages per key if you expect bursts.

Add a daily cap per user in your own code. It protects your credit from one chatty user or a script, and it costs you ten lines.

More guides

• Does Janitor AI Have a Filter? Your Options
• No Log AI API: Myths vs Facts on Private Text Generation