Uncensored AI Tool Online Free: Build Your Own Web Tool

What free really means

There is no permanent free tier behind an uncensored ai tool online free, whatever the landing page says. Somebody pays for GPUs. Here, new users can claim $0.50 of trial credit with one click on the API key page, valid for 7 days and needing no payment details. After that you pay $0.15 per 1M input tokens and $0.50 per 1M output tokens from prepaid credit.

That price is low enough that a personal tool costs cents per week. The trade is that you build the front end yourself. In return you know exactly where your text goes: from your browser to your server, then to https://api.unsensoredai.com/v1, and nowhere else. Prompts are not used for training on the API side.

The shape of the tool

Three parts, each small.

1. A web page with a text box, a button and an output area.
2. A server route that receives the text, adds your system prompt and calls the chat completions method.
3. The API, which streams the answer back as server-sent events.

The server in the middle is not decoration. If the page called the API directly, your key would sit in the page source for anyone to copy. With the server, the key lives in an environment variable and the browser only ever talks to your own route.

The server in about 40 lines

This uses only Node 18 or newer, with no packages. Save it as server.mjs next to an index.html.

Copyimport { createServer } from "node:http";
import { readFileSync } from "node:fs";

const BASE_URL = "https://api.unsensoredai.com/v1";
const API_KEY = process.env.API_KEY;
const page = readFileSync("index.html", "utf8");

createServer(async (req, res) => {
  if (req.method === "GET" && req.url === "/") {
    res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
    return res.end(page);
  }
  if (req.method === "POST" && req.url === "/ask") {
    let body = "";
    for await (const chunk of req) body += chunk;
    const { prompt } = JSON.parse(body);

    const upstream = await fetch(`${BASE_URL}/chat/completions`, {
      method: "POST",
      headers: {
        Authorization: `Bearer ${API_KEY}`,
        "Content-Type": "application/json",
      },
      body: JSON.stringify({
        model: "uncensored",
        stream: true,
        max_tokens: 600,
        messages: [
          { role: "system", content: "You are a concise writing assistant." },
          { role: "user", content: String(prompt).slice(0, 4000) },
        ],
      }),
    });

    res.writeHead(upstream.status, {
      "Content-Type": upstream.headers.get("content-type") ?? "text/event-stream",
    });
    for await (const part of upstream.body) res.write(part);
    return res.end();
  }
  res.writeHead(404);
  res.end("not found");
}).listen(3000);

Two lines do the cost control. slice(0, 4000) caps the prompt at 4,000 characters, and max_tokens: 600 caps the reply. The parameter is optional in general, since a completion can use whatever is left of the 100,000-token window, but a public tool should not leave it open.

The page

Create index.html with a textarea with id q, a button with id go, and a pre with id out, then add this script at the bottom. It reads the event stream line by line and appends each text fragment as it arrives.

Copy// talks only to our own /ask route, never to the API directly
document.getElementById("go").onclick = async () => {
  const out = document.getElementById("out");
  out.textContent = "";
  const r = await fetch("/ask", {
    method: "POST",
    body: JSON.stringify({ prompt: document.getElementById("q").value }),
  });
  if (r.status === 429) {
    out.textContent = "Busy right now, try again in a few seconds.";
    return;
  }
  const reader = r.body.getReader();
  const decoder = new TextDecoder();
  let buffer = "";
  while (true) {
    const { done, value } = await reader.read();
    if (done) break;
    buffer += decoder.decode(value, { stream: true });
    const lines = buffer.split("\n");
    buffer = lines.pop();
    for (const line of lines) {
      if (line.startsWith("data: ") && line.includes("[DONE]") === false) {
        const delta = JSON.parse(line.slice(6)).choices?.[0]?.delta?.content;
        if (delta) out.textContent += delta;
      }
    }
  }
};

Using textContent instead of innerHTML matters. Model output is untrusted text, and inserting it as HTML is an easy way to create an injection hole.

Run it

Copyexport API_KEY="paste-your-key-here"
node server.mjs
# open http://localhost:3000 and send a prompt
# the server calls https://api.unsensoredai.com/v1/chat/completions with model uncensored

If the page stays empty, check three things in order: the key is exported in the same terminal, the model name in the request is exactly uncensored, and the server log shows a status other than 429. The docs list the response headers, including X-Request-Id, which is worth logging so you can match a failed request to a report.

Put a ceiling on spend

Work out the worst case before you share the link. With a 4,000-character prompt (roughly 1,000 tokens) and a 600-token reply cap:

• Input: 1,000 x $0.15 / 1,000,000 = $0.00015
• Output: 600 x $0.50 / 1,000,000 = $0.0003
• Worst case per request: $0.00045

The $0.50 trial then covers about 1,100 worst-case requests, and a $20 top-up covers about 44,000. In practice most requests are shorter, and failed or refused ones are not charged.

Then add limits on your side. A trial key allows 2 concurrent requests and 60 per minute; a full key allows 8 and 300. Because a streamed request holds its slot until the stream ends, a third visitor on a trial key gets a 429 with code concurrency. Keep a simple per-IP counter in your route, and return a friendly message instead of the raw error.

Three tools worth building first

A blank text box is a fine start, but a narrow tool is easier to use and easier to keep cheap. Each of these needs only a different system prompt in the same server.

• A rewriter. The system prompt says: rewrite the user's text in a blunter, plainer voice and keep the meaning. Short inputs, short outputs, almost no cost.
• A scene brainstormer. The user pastes a paragraph of fiction and gets five directions the story could take next. Set a higher temperature, around 1.0, for variety.
• A critique partner. The prompt asks for specific, unsparing feedback on pacing and dialogue. This is where a model that does not soften every answer is useful.

Keep each tool to one job and cap the reply length with max_tokens. A narrow tool also teaches you what your users actually ask for.

Test it before you share it

A tool that works for you on the first try can still fall over for a stranger. Spend ten minutes on this checklist before you send the link to anyone.

1. Empty input. Press the button with an empty box. The server should answer with a short message instead of sending a pointless request to the API.
2. Very long input. Paste 20,000 characters. The slice(0, 4000) line should cut it, and the cost should stay at the worst case worked out above.
3. Two tabs at once. On a trial key, start three requests together. The third should show your friendly busy message, not a blank page.
4. Dropped connection. Close the tab in the middle of a reply. Check that the server does not keep streaming into nothing and holding a concurrency slot longer than needed.
5. A wrong key. Start the server with a bad API_KEY and confirm the page shows a clear error rather than raw JSON.

Also check the balance now and then. Every response carries an X-Balance-USD header, and your server can read it from the upstream response and write one line to a log. If the number falls faster than your worst-case arithmetic predicts, someone is hitting the route more often than you planned, and a per-IP counter is the first fix.

Before you make it public

A private tool is your own business. A public one needs a few decisions. The model is tuned to answer without content refusals for lawful adult use, so show an 18+ notice and make the purpose clear. Sexual content involving minors is a hard limit that no prompt can change, and your tool should state the same rule. Do not log full prompts unless you tell users that you do.

When traffic grows, top up from $20 to $500 in crypto, with bonuses of 5% from $50, 10% from $100 and 15% from $200, as laid out on the pricing page. Our GPT integration guide goes deeper into SDK-based integration if you outgrow raw fetch calls.

More guides

• Build an Uncensored AI App on a Text API
• The Developer's Guide to Unsensored GPT Integration