EN ▾

openaiapiproxy.comOpenAI Compatible API Proxy for Uncensored LLMs

OpenAI Compatible API Proxy for Uncensored LLMs

An openai compatible api proxy is an endpoint that accepts the same requests as the OpenAI API, so your SDK and tools keep working after you swap the address. Here that address fronts one uncensored open-weight model.

Updated

A gateway arch connecting many client windows to one glowing crystal, showing a compatible proxy in front of a model

Key points

  • The proxy speaks the OpenAI chat completions format. It does not forward your requests to OpenAI.
  • Point any client at https://api.openaiapiproxy.com/v1, use your key and set the model to uncensored.
  • Supported: chat completions, models list, streaming, tool calling and JSON mode. Not supported: images, audio, embeddings, fine-tuning.
  • Most failures come from a doubled /v1 in the path, the wrong model name or a 429 from the rate limits.

What the word proxy means here

People use "proxy" loosely, and it helps to be exact. In the case of an openai compatible api proxy like this one, the word describes the interface: the server accepts the OpenAI request shape and returns the OpenAI response shape. Your code cannot tell the difference from the wire format alone.

It does not mean your traffic is relayed to OpenAI, or to any other company. Requests go to a single open-weight model run by an independent provider, tuned to answer without content refusals for lawful adult use. This is not the official API of OpenAI, Meta, Mistral, Qwen, DeepSeek, Google, Anthropic or xAI, and it is not a router that picks among vendors. That distinction matters for expectations: there is one model, and its ID is uncensored.

Why developers put a compatible layer in front of a model

The OpenAI request format became the common language of LLM tooling. Libraries, editors, agent frameworks and no-code tools all know how to speak it. A compatible endpoint lets you reuse all of that without writing a client.

  • No new SDK. The official OpenAI libraries work after a base URL change.
  • Tool support for free. Anything that has a custom endpoint field is a candidate: chat front ends, editor plugins, scripts.
  • Easy rollback. If the new model is not right, you set the old URL back and nothing else in the code changes.
  • One place for policy. You choose the model behavior you want at the endpoint, instead of fighting refusals in every prompt.

The trade is that you accept the limits of the surface that is implemented. The table in the next section is the full list.

What is and is not supported

FeatureStatus
POST /v1/chat/completionsSupported
GET /v1/modelsSupported, returns the model uncensored
Streaming (SSE)Supported with stream: true, usage reported at the end
Tool callingSupported: tools, tool_choice, streamed tool_calls, role: "tool" results
JSON modeSupported through response_format
Sampling parameterstemperature, top_p, stop, seed and the penalties are passed through
Images, audio, videoNot available, text only
EmbeddingsNot available
Fine-tuningNot available
Other model IDsNot available, a single model

The context window is 100,000 tokens counting prompt and completion together. The request body can be 8 MB. Client code that depends on endpoints beyond the two above, such as an embeddings call inside a retrieval library, will fail at that call, so plan to keep that part with another service.

Connect in under five minutes

The fastest route is environment variables. The OpenAI Python and Node SDKs read OPENAI_API_KEY and OPENAI_BASE_URL when you do not pass them in code, which means many existing scripts work without editing a line.

export OPENAI_API_KEY="YOUR_KEY"
export OPENAI_BASE_URL="https://api.openaiapiproxy.com/v1"

curl "$OPENAI_BASE_URL/chat/completions" \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model":"uncensored","messages":[{"role":"user","content":"Reply with the word ready."}]}'

If you prefer explicit configuration, which is safer in a codebase that also talks to other providers, pass the values to the client:

from openai import OpenAI

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

for model in client.models.list():
    print(model.id)

out = client.chat.completions.create(
    model="uncensored",
    messages=[{"role": "user", "content": "Summarize the plot of a heist film in two sentences."}],
)
print(out.choices[0].message.content)

You need a key first. New accounts can claim $0.50 of trial credit with one click on the API key page. It is valid for 7 days and needs no card. If you work in Claude Code, the site has a separate page about using it with Claude Code.

Request headers matter on the way out as well. Always send Content-Type: application/json and keep the body under 8 MB. A request that mixes a huge pasted document with a long chat history can reach that limit sooner than the 100,000-token limit, so check the body size when you upload large text.

A five-minute test before you trust any proxy

Whatever endpoint you adopt, run the same checks. They take a few minutes and catch most surprises before they reach users.

  1. List the models. A GET /v1/models call confirms the key and the address in one step. Here you should see uncensored.
  2. Send a tiny completion. Ask for one word and cap max_tokens. Look at the response headers, in particular X-Balance-USD, and confirm it dropped by a plausible amount.
  3. Stream a longer answer. Check that tokens arrive gradually and that the stream ends cleanly with usage at the end.
  4. Call a tool. Send one function schema, check that tool_calls comes back, return a role: "tool" message and read the final answer.
  5. Break it on purpose. Send nine requests at once with a full key, or three with a trial key, and confirm that you get a 429 with the code concurrency, and that your retry code recovers.

If all five pass, the integration is sound at the protocol level. What remains is judging the model itself, which only your own prompts can do.

Fixing the usual problems

Compatibility problems are rarely about the model. They are almost always about configuration. These are the ones that come up most.

A not-found error on every call

The base URL already ends in /v1, and your client adds /v1 again, or the reverse. Check the final URL in the client log. The correct request path is https://api.openaiapiproxy.com/v1/chat/completions.

An authentication error

The key is missing, has a stray space or newline, or was sent in the wrong header. The format is Authorization: Bearer <key>. Keys pasted from a terminal often carry a trailing newline.

The model name is rejected

Use uncensored, in lowercase. Names like a vendor model ID will not match, because there is only one model here. Some tools hold a hard-coded dropdown, in which case add a custom model name.

HTTP 429

The error code says which limit you hit. rate_limited means you exceeded requests per minute (300 on a full key, 60 on trial). concurrency means too many requests at once (8 on a full key, 2 on trial). A temporary overload also gives 429 with Retry-After: 5. Wait the stated time and retry. Remember that a streamed request keeps its slot until the stream ends.

Cost, billing and privacy

Pricing is $0.15 per 1M input tokens and $0.50 per 1M output tokens, from prepaid credit. There is no subscription and credit never expires. Failed or refused requests are not charged. Prompts are not used for training.

A worked example: a support-style tool sends 3,000 input tokens and receives 400 output tokens per call. The input is 3,000 / 1,000,000 x $0.15 = $0.00045 and the output is 400 / 1,000,000 x $0.50 = $0.0002, so a call costs $0.00065 and 10,000 calls cost $6.50.

Top-ups are any whole amount from $20 to $500, by crypto (USDT on TRC20, USDC on Base). A $200 top-up includes a 15% bonus, giving $230 of credit. The pricing page has the rest.

What to look for in a compatible endpoint

The category is crowded, so it helps to have criteria. Be wary of any provider that does not state which model it runs, because that tells you what behavior to expect and whom to blame for it. Here, the model is an open-weight one run by an independent provider, and the pages say so plainly.

  • Published limits. You should know the request and concurrency caps before you design retry logic. Here they are 300 requests per minute and 8 concurrent on a full key.
  • Clear billing rules. Look for prepaid credit, no subscription and a statement on failed calls. In this case failed or refused requests are not charged and credit does not expire.
  • A privacy statement. Prompts are not used for training here. Read the docs and the terms for the details that matter to you.
  • Honest scope. A short list of what is missing is a good sign. Text only, no embeddings, no fine-tuning, one model.

Payment methods are part of the picture too. Top-ups are available by by crypto (USDT on TRC20, USDC on Base), from $20 up to $500.

Before you rely on it

A model without refusals is a tool with fewer guardrails, so use it with care. The service has one hard limit, no sexual content involving minors, and your own product should add whatever filtering fits your users and your local law. Read the docs for the full parameter list, and keep a second provider configured for the tasks this endpoint does not cover.

Questions and answers

Does this proxy send my requests to OpenAI?

No. Requests go to one open-weight model run by an independent provider. The service uses the OpenAI request format but is not connected to OpenAI's API.

Which tools can use it?

Any tool or library that lets you set a custom OpenAI-compatible base URL and API key, including the official OpenAI SDKs for Python and Node.

Can I use other model names?

No. There is a single model with the ID uncensored. GET /v1/models returns it.

Is streaming supported?

Yes. Set stream to true to receive server-sent events, with token usage reported at the end of the stream.

Your key is one form away

Create an account, copy the key, change the base URL. That is the whole setup.

Get API key