Quickstart: Integrate the LLM Proxy

Base URL & Authentication

Replace your standard OpenAI base URL with our endpoint. Authentication is handled via a Bearer token in the Authorization header. This approach works with any OpenAI-compatible client library. You do not need to change your code logic, only the configuration values. Our API mimics the standard OpenAI interface structure, ensuring that your existing integration code remains valid. This reduces integration time to minutes rather than days. You can regenerate your key at any time from your dashboard, which immediately invalidates the old key. This provides security without requiring complex token rotation logic in your application.

First Request

Send a standard chat completion request to test connectivity. The endpoint accepts JSON payloads with a model identifier and message history. Our model ID is "uncensored". This identifier tells the proxy which uncensored model to route your request to. The response structure mirrors the OpenAI format, containing the assistant's message content. You can verify the response by checking the content field in the JSON output. This confirms that your authentication and payload structure are correct. The endpoint supports both streaming and non-streaming modes for standard requests.

Copycurl https://api.llmproxyapi.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."}]
  }'

Python SDK Integration

Use the official OpenAI Python library to interact with our API. Set the api_key to your proxy key and the base_url to our endpoint. The rest of the library behavior remains identical to standard OpenAI usage. This includes support for async clients, retries, and standard error handling. You can pass the same parameters you would normally use, such as temperature and max tokens. The proxy handles the routing to the uncensored model behind the scenes. This allows you to maintain your existing Python codebase while gaining access to our model's capabilities.

Copyfrom openai import OpenAI

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

Node SDK Integration

The Node.js SDK works with our API by overriding the base URL. Initialize the client with your proxy API key and the correct endpoint. All other methods, such as chat.completions.create, function as expected. This includes handling standard response objects and error types. You can use the same message structures and parameters as you would with OpenAI. The proxy ensures that the request is processed by the uncensored model. This compatibility allows developers to swap providers quickly without rewriting their client logic. It is ideal for microservices that already use the OpenAI SDK pattern.

Copyimport OpenAI from "openai";

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

Streaming Responses

Enable streaming by setting the stream parameter to true in your request. The API returns a Server-Sent Events (SSE) stream. Each chunk contains partial token updates, allowing for real-time display of the response. This is critical for chat interfaces and applications requiring immediate feedback. The stream ends with a final chunk containing the full response metadata. You can parse the chunks using standard SSE libraries in your preferred language. This feature works seamlessly with the OpenAI SDKs, which handle the parsing logic automatically. It provides a smooth user experience without waiting for the entire response to generate.

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)

Rate Limits & Constraints

Our API enforces a limit of 300 requests per minute per key. If you exceed this, you will receive a 429 status code. Ensure you implement retry logic with exponential backoff for these cases. The request body size is capped at 8 MB. This constraint applies to the total JSON payload, including prompt and context. Pricing is usage-based: $0.25 per million input tokens and $1.00 per million output tokens. Credits are prepaid and do not expire. If your balance is insufficient, requests will return a 402 error. Authentication errors return a 401 status. There is no complex routing or vendor selection; the model is fixed.