API Documentation

Authentication & Base URL

The base URL is https://api.localllmnsfw.com/v1. Pass your key in the Authorization: Bearer <key> header. Keys are issued instantly on signup via Google or email. No phone number. One active key per account. A new key replaces the old one.

Authentication is simple. Use the official SDKs. Change the base URL and API key. Everything else remains standard. This ensures compatibility with your existing tools. Your prompts are not used for training. Privacy is straightforward.

First Request

Send a POST request to /v1/chat/completions. The model ID is uncensored. Input is text. Output is text. No image or audio generation. No embeddings. Just pure inference. The model answers without refusals for lawful adult content. It is not GPT or Claude. It is an open-weight model tuned for freedom. Test it immediately.

Here is a basic request using cURL. Replace <API_KEY> with your key. The model ID is fixed.

Copycurl https://api.localllmnsfw.com/v1/chat/completions \
  -H "Authorization: Bearer $API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "uncensored",
    "messages": [{"role": "user", "content": "List the current UTC time and timezone for Tokyo"}]
  }'

This returns a standard OpenAI-style response. You get the generated text. You can parse it directly. No complex setup. Just start chatting.

Python SDK Integration

Use the official OpenAI Python library. Set the base URL to our endpoint. Set the API key. The rest works exactly as documented. This is a drop-in replacement for GPT-4 or GPT-3.5. Roleplay apps benefit from the lack of content filters. The model handles controversial topics well.

Initialize the client. Point it to our API. Call chat.completions.create(). The response contains the generated text. Handle errors gracefully. Token usage is tracked in the response. This makes billing transparent.

Copyfrom openai import OpenAI

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

resp = client.chat.completions.create(
    model="uncensored",
    messages=[{"role": "user", "content": "Summarise this thread without softening it."}],
)
print(resp.choices[0].message.content)

The Python SDK simplifies the process. You get structured data. You can loop through responses. Streaming is supported. Function calling works too. This is the standard way to integrate.

Node SDK Implementation

The Node.js SDK follows the same pattern. Set the base URL. Set the API key. Import the library. Call the completion method. This works for web servers and scripts. Node developers get full access to the uncensored model. No vendor lock-in. Just standard API calls.

Configure the client. Pass your key. Make a request. The response is a JSON object. Parse the content. Use it in your app. The model handles long contexts well. Up to 16,000 tokens per output. This is ideal for detailed roleplay. Keep your code clean.

Copyimport OpenAI from "openai";

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

const resp = await client.chat.completions.create({
  model: "uncensored",
  messages: [{ role: "user", content: "Draft a villain monologue for my game." }],
});
console.log(resp.choices[0].message.content);

Node.js developers appreciate the simplicity. The SDK handles retries. It manages connections. You focus on your logic. The API does the rest. No extra dependencies. Just the standard OpenAI package.

Streaming & SSE

Enable streaming by setting stream: true. The API returns Server-Sent Events (SSE). Each chunk contains part of the response. Token usage is reported in the last chunk. This provides real-time feedback. Users see text as it generates. Latency feels lower. Engagement increases. This is critical for chat apps.

Handle the stream. Iterate over chunks. Append text to your UI. Stop on demand. The model supports this natively. It works with all SDKs. No custom parsing needed. Just follow the standard SSE format. Errors are also streamed. You get immediate feedback on failures.

Copystream = client.chat.completions.create(
    model="uncensored",
    messages=[{"role": "user", "content": "Tell the story in second person."}],
    stream=True,
)
for chunk in stream:
    if chunk.choices and chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="", flush=True)

Streaming is efficient. It reduces perceived wait time. Users stay engaged. The uncensored model handles diverse topics. It does not break character. This is perfect for immersive experiences. Try it now.

Limits, Errors & Context

Context window is 100,000 tokens. Max output is 16,000 tokens. Default max is 2,048. Rate limit is 300 requests per minute. Concurrent limit is 8 requests per key. Request body max is 8 MB. Errors are standard. 401 means invalid key. 402 means no credit. 429 means rate limit exceeded. Refusals are free. Errors are free. Pay only for tokens.

Handle errors correctly. Check the status code. Retry on 429 with backoff. Inspect 402 for credit. Update your UI. Inform users. The API is reliable. No downtime claims. Just consistent performance. Your credit never expires. Top up with crypto. USDT or USDC. Bonus credits available. Start building today.