No Filter AI Coder: Use It in Cursor and Python

What a no filter coder is, and what it is not

A no filter ai coder is a language model that answers programming requests without second-guessing your reasons. If you are writing a port scanner for a network you own, decompiling a legacy binary you lost the source for, or building a scraper that mimics a browser, you get code instead of a paragraph about responsible use.

It helps to be exact about what this service is. It is one open-weight model, tuned to answer without content refusals for lawful adult use, run by an independent provider. It is not the official API of any big vendor and it is not a router that picks between models. The model ID is uncensored. There is no claim here about benchmark scores, because none are published for it on this site. A model with fewer refusals is not automatically a better programmer, so treat the first week as an evaluation.

Lawful use is your responsibility. The tool removes friction for legitimate security work, research and unusual engineering. It is not a licence to attack systems you do not own.

Call it from Python or curl

The simplest test is a single request. This Python script asks for a small tool and prints the answer.

Copyfrom openai import OpenAI

client = OpenAI(base_url="https://api.nofilterai.cc/v1", api_key="YOUR_KEY")

resp = client.chat.completions.create(
    model="uncensored",
    temperature=0.2,
    messages=[
        {"role": "system", "content": "You are a senior engineer. Reply with code first, then at most five lines of notes."},
        {"role": "user", "content": "Write a Python script that scans TCP ports 1-1024 on a host I own, using asyncio, with a 0.5 s timeout."},
    ],
)
print(resp.choices[0].message.content)

Low temperature suits code. Values between 0.1 and 0.3 give steadier output, and seed lets you repeat a run when you compare prompts. The same request from the shell looks like this.

Copycurl https://api.nofilterai.cc/v1/chat/completions \
  -H "Authorization: Bearer YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "uncensored",
    "temperature": 0.2,
    "messages": [
      {"role": "user", "content": "Explain this regex and rewrite it without lookbehind: (?<=id=)\\d+"}
    ]
  }'

You can list what the endpoint exposes with GET /v1/models. Get a key from the key page; the one-click trial credit of $0.50 is enough for many hundreds of small coding requests.

Set it up in Cursor

Cursor lets you override the OpenAI base URL in its model settings, which is how you point it at any compatible provider. The exact menu names change between versions, so follow the idea rather than the labels.

1. Open Cursor settings and find the models section.
2. Paste your key into the OpenAI API key field.
3. Enable the option to override the OpenAI base URL and enter https://api.nofilterai.cc/v1.
4. Add a custom model named uncensored and select it in the chat panel.
5. Send a small test message before you try an edit across several files.

Cursor and similar editors may use their own servers for some features, and some features may not accept custom models at all. If a feature fails, check whether it is tied to the vendor's own models rather than assuming the endpoint is broken. Chat with a custom model is the dependable part.

Other tools that accept an OpenAI-compatible endpoint, such as Continue or Aider, use the same three values: base URL, key, model name.

Use it from LangChain

LangChain's ChatOpenAI class takes a base_url argument, so the endpoint drops in without a custom wrapper.

Copyfrom langchain_openai import ChatOpenAI

llm = ChatOpenAI(
    model="uncensored",
    base_url="https://api.nofilterai.cc/v1",
    api_key="YOUR_KEY",
    temperature=0.2,
)

print(llm.invoke("Write a bash one-liner that lists the 10 largest files under /var/log.").content)

Chains, prompt templates and output parsers work the same way they do with any chat model that follows the OpenAI schema. If you build an agent, remember the concurrency limit: a full key allows 8 requests at the same time and 300 per minute, a trial key 2 and 60. A parallel agent that fans out ten tool calls will get HTTP 429 with the code concurrency for the extras. Cap the fan-out, or retry with a short delay.

Tool calling and JSON mode for agents

Coding agents live on structured output. The API supports tools, tool_choice, streamed tool_calls, and tool results sent back as role: "tool" messages. Here is a minimal round trip with a function that reads a file.

Copyimport json
from openai import OpenAI

client = OpenAI(base_url="https://api.nofilterai.cc/v1", api_key="YOUR_KEY")

tools = [{
    "type": "function",
    "function": {
        "name": "read_file",
        "description": "Read a UTF-8 text file from the project",
        "parameters": {
            "type": "object",
            "properties": {"path": {"type": "string"}},
            "required": ["path"],
        },
    },
}]

messages = [{"role": "user", "content": "Open main.py and tell me what it does."}]
first = client.chat.completions.create(model="uncensored", messages=messages, tools=tools)
call = first.choices[0].message.tool_calls[0]

messages.append(first.choices[0].message)
messages.append({
    "role": "tool",
    "tool_call_id": call.id,
    "content": open(json.loads(call.function.arguments)["path"]).read(),
})
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 the model asks for. A path, a shell string or a URL that came from a model is untrusted input, whatever model produced it.

For output your code must parse, set response_format to {"type":"json_object"} and say in the prompt which keys you expect. JSON mode makes the reply valid JSON, but your schema checks still belong in your code.

Context size and what a coding call costs

The window is 100,000 tokens for prompt plus reply. As a rough guide, that holds many source files at once, so you can paste a module, its tests and the failing traceback in one go instead of summarising. Bigger prompts cost more, so send what the question needs.

The price is $0.15 per 1M input tokens and $0.50 per 1M output tokens. Examples:

Failed or refused requests are not charged. Credit is prepaid, does not expire, and top-ups run from $20 to $500 in any whole amount, with a bonus of 5% from $50, 10% from $100 and 15% from $200. Payment is crypto only: USDT on TRC20 or USDC on Base. See the pricing page for the current terms.

A review prompt that works on real diffs

One of the best uses of a large window is review. Instead of asking "is this code good?", paste the diff and the files it touches, then ask for findings in a fixed shape. Request a numbered list in which each item names the file, the line, the problem and a one-line fix, and say that an empty list is a valid answer. That last instruction matters: a model told to find problems will sometimes invent them to please you.

Keep temperature near 0.2 for review, because you want the same finding on a second run. If you run reviews in a continuous integration job, set seed and log the X-Request-Id header so you can trace a surprising result later. Combine this with JSON mode when a script has to post the findings somewhere, and ask for keys such as file, line, severity and fix.

When the answer is wrong or empty

Three problems cover most failed runs. If you get a 401, the key is missing or the header is not Authorization: Bearer followed by your key. If an editor says the model does not exist, check that the name is exactly uncensored and that the base URL ends in /v1 with no extra path. If the code compiles but misbehaves, give the model the failing output and ask it to explain the error before it rewrites anything; fixes made after a diagnosis tend to be smaller and safer than fixes made blind.

Where it fits and where it does not

Use an uncensored endpoint for the requests that other assistants decline or hedge, and keep your usual tool for the rest if it works better for you. Many developers run two models side by side and send each task to whichever answers it cleanly.

• Good fit: security lab work on systems you own, scraping and automation scripts, malware analysis write-ups for defenders, reverse engineering notes, odd data-munging jobs.
• Be careful: generated code can contain errors or invented library functions. Run it, test it, read it.
• Not offered: image or audio generation, embeddings and fine-tuning. This is a text chat endpoint only.
• Privacy: prompts are not used for training, which matters if you paste proprietary code.

The body limit is 8 MB per request, far more than the context window can use. Response headers include X-Request-Id, X-Balance-USD and the rate-limit values, which are useful in logs. The documentation lists every parameter that is passed through.

More guides

• No Filter AI Story Generator via API
• No Filter AI for Writing: Long-Form Fiction
• Uncensored LLM API: NoFilter AI vs Character AI