Integrate the Uncensored Local LLM API

Base URL and Authentication

Our API is fully compatible with the OpenAI SDKs. You only need to update the base_url and provide your API key. Sign up on the Get API key page to receive your key immediately. No phone number or credit card is required to start with the trial credit. The base URL is https://api.uncensoredlocalllm.com/v1. Keep your key secure; you can regenerate it at any time, which instantly revokes the old one. This ensures you always have a single, stable endpoint for your applications without the complexity of local inference management.

First Request

Make your first API call using your preferred HTTP client. The endpoint supports standard chat-completions format. Below is a cURL example demonstrating a basic request. Replace YOUR_API_KEY with your actual key. This request sends a prompt and expects a text response. The model id is uncensored. This open-weight model is tuned to answer without content refusals for lawful adult use, providing direct outputs for your use case.

Copycurl https://api.uncensoredlocalllm.com/v1/chat/completions \
  -H "Authorization: Bearer $API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "uncensored",
    "messages": [{"role": "user", "content": "Write a blunt product review of a cheap VPN."}]
  }'

The response will contain the generated text in the choices array. If you encounter a 401 error, your API key is invalid or missing. Ensure you are using the correct base URL and that your key has not been revoked after regeneration.

Python SDK Integration

Use the official OpenAI Python SDK to integrate quickly. Set the base_url and api_key in your client initialization. This approach allows you to use familiar methods like chat.completions.create(). The SDK handles JSON serialization and HTTP requests automatically. This is ideal for backend services or scripts that need to process large amounts of text. Remember that the model id remains uncensored regardless of the SDK version you use.

Copyfrom openai import OpenAI

client = OpenAI(base_url="https://api.uncensoredlocalllm.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)

This method is efficient for batch processing or when you need to handle the response logic in Python. Ensure your environment has the openai package installed. The SDK supports both synchronous and asynchronous operations, fitting various architectural needs.

Node SDK Integration

For JavaScript or TypeScript environments, the OpenAI Node SDK provides a similar experience. Initialize the client with your base URL and API key. This is particularly useful for web applications or serverless functions. The SDK abstracts the HTTP details, allowing you to focus on application logic. You can call the completions endpoint with the same structure as other OpenAI-compatible services.

Copyimport OpenAI from "openai";

const client = new OpenAI({ baseURL: "https://api.uncensoredlocalllm.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);

Use this integration for real-time web interfaces or Node.js microservices. The SDK supports promises and async/await patterns, making error handling straightforward. Ensure you handle potential network errors gracefully, especially in distributed systems.

Streaming Responses

Enable streaming by setting stream: true in your request. This allows you to receive partial responses as they are generated, improving perceived latency for users. The API supports Server-Sent Events (SSE) for streaming. This is crucial for chat interfaces where immediate feedback is expected. Streaming does not affect the model's output quality or context window.

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)

Handle the stream events in your client code. Each chunk contains a portion of the final response. Aggregate these chunks to reconstruct the full message. This approach works seamlessly with the OpenAI SDKs in both Python and Node.js.

Rate Limits, Errors, and Context Window

The API enforces a limit of 300 requests per minute per key. The maximum request body size is 8 MB. You will receive a 429 error if you exceed the rate limit. A 402 error indicates insufficient prepaid credit. Ensure you monitor your usage and top up your account via the dashboard. Credit does not expire, and you can pay with crypto (USDT or USDC).

The context window is 100,000 tokens, covering both prompt and completion. This allows for extensive conversations or large document processing. If you exceed the limit, the API will reject the request. The model id is uncensored, and it supports tool/function calling for extended capabilities.