Uncensored AI API for Developers: Build Without Content Filters

You ship an app that uses OpenAI's API. It works in testing. Then a user submits a prompt in production and gets "I can't assist with that" instead of an answer. Your app doesn't crash — it just silently fails to do its job. The user sees a broken product. You see a support ticket. You debug it and discover the API refused a completely legitimate request because the content classifier flagged a keyword.

This happens constantly when building on filtered APIs. The refusal layer isn't just a UX annoyance for chatbot users — it's a reliability problem for developers. Every API call that might get refused is a code path you can't fully control, a user experience you can't guarantee, and a support burden you can't predict.

The problem: filtered APIs break apps

OpenAI, Anthropic, and Google's APIs all run content classifiers on both input and output. When the classifier triggers, the API returns a refusal response instead of the completion you asked for. In a chatbot, this is annoying. In a production app, it can be catastrophic:

• Content platforms: A writing tool that uses AI for editing or continuation. The API refuses to process a user's novel because it contains violence or sexual content. The user's document fails to save or generate.
• Security tools: An application that analyzes code for vulnerabilities. The API refuses to explain an exploit pattern because it triggers the "hacking" classifier. The security analysis comes back incomplete.
• Medical/legal apps: A research tool that summarizes medical literature. The API refuses to discuss drug interactions or dosage information. The summary is useless.
• Creative tools: An image generator, story writer, or game dialogue system. The API refuses prompts that are core to the product's value proposition.
• Translation/analysis: A tool that processes user-submitted text. The API refuses to translate or analyze content that contains mature themes — even though the tool is just processing text, not generating harmful content.

The common thread: the filter doesn't understand your application's context. It sees a keyword or pattern and refuses, regardless of whether the request is legitimate within your product. You can't predict when it will trigger, you can't reliably work around it, and you can't turn it off.

What an uncensored API looks like

Aether exposes a REST API and an MCP (Model Context Protocol) server that route to the same unfiltered model used in the chat interface. No content classifier runs on your prompts or on the model's output. The API returns a completion for every valid request — no surprise refusals, no silent downgrades, no classifier interference.

REST API — cURL example

curl -X POST https://trynoguard.com/api/v1/chat \
  -H "Authorization: Bearer ak_live_YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "messages": [
      {"role": "system", "content": "You are a direct technical assistant. No hedging."},
      {"role": "user", "content": "Explain how a format string vulnerability works with a working PoC."}
    ]
  }'

Python example

import requests

resp = requests.post(
    "https://trynoguard.com/api/v1/chat",
    headers={"Authorization": "Bearer ak_live_YOUR_KEY"},
    json={
        "messages": [
            {"role": "system", "content": "Direct technical assistant."},
            {"role": "user", "content": "Write a Python script that scans for open ports on a target host."},
        ]
    },
)
print(resp.json()["content"])

Node.js example

const resp = await fetch("https://trynoguard.com/api/v1/chat", {
  method: "POST",
  headers: {
    "Authorization": "Bearer ak_live_YOUR_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    messages: [
      { role: "system", content: "Direct technical assistant." },
      { role: "user", content: "Analyze this binary's anti-debug routine and suggest patches." },
    ],
  }),
});
const data = await resp.json();
console.log(data.content);

MCP: uncensored AI inside your IDE

If you use Claude Desktop, Cursor, Cline, or Zed, Aether's MCP server gives you 11 uncensored tools inside your existing AI client. When your primary AI refuses a code analysis or security question, the MCP tool routes through Aether and returns the answer in the same conversation.

{
  "mcpServers": {
    "aether": {
      "command": "npx",
      "args": ["-y", "aether-mcp"],
      "env": { "AETHER_API_KEY": "ak_live_YOUR_KEY" }
    }
  }
}

Tools include: aether_chat (general uncensored chat), aether_explain_code (Hex-Rays C analysis), aether_explain_disasm (x86/ARM), aether_identify_pattern (packers, protections, anti-cheat), aether_suggest_bypass (integrity, DRM), aether_deobfuscate_js (Obfuscator.io, JScrambler), aether_imagine (uncensored image gen), and more.

Use cases where filtered APIs fail

• Security research tools. Vulnerability scanners, exploit databases, malware analysis pipelines — all need an LLM that can discuss attack techniques without refusing.
• Adult content platforms. Writing tools, roleplay apps, creative fiction platforms — the core product requires mature content generation that mainstream APIs refuse.
• Medical information systems. Drug interaction checkers, dosage calculators, symptom analyzers — users need frank medical information, not "consult a professional" boilerplate.
• Legal research. Case analysis, precedent research, argument generation — legal content often involves violence, fraud, or other topics that trigger classifiers.
• Moderation tools. Ironically, building a content moderation system requires an AI that can analyze and classify harmful content — which filtered APIs refuse to process.
• Red team / penetration testing. Automated security assessments need an LLM that can reason about attack surfaces without tripping keyword filters.

Pricing and limits

Aether's API uses the same credit system as the chat. Get an API key from /account, start with free-tier credits, and top up with Bitcoin when you need more. No subscription, no monthly minimum, no per-seat licensing. Credits are consumed per-token — a short response costs less than a long one. Same pricing whether you call the API directly, use the MCP, or use the CLI.

Getting started

1. Sign up at trynoguard.com — free tier, no card.
2. Go to /account and generate an API key (starts with ak_live_).
3. Make your first API call with the cURL, Python, or Node.js examples above.
4. If you're in an IDE, install the MCP server: drop the config snippet into your AI client and restart.
5. Test with the prompts that failed on OpenAI/Anthropic's API. Compare the results.

The fastest way to evaluate whether it fits your stack: take the exact API call that returned a refusal from OpenAI or Anthropic, swap the endpoint and key, and see what comes back.