OpenAI Compatible API Endpoints: What Is Supported
A list of the OpenAI compatible API endpoints this service supports, with working requests for each and a plain list of what is missing.
Key points
- Five paths: chat completions, responses, models and two balance routes.
- Model ID is uncensored, and one key works with any OpenAI SDK.
- No images, audio, video, embeddings or fine-tuning.
- Limits return HTTP 429 with a clear error code.

The endpoints at a glance
Which OpenAI-style paths does a provider really implement? Here is the short list for this API. Base URL: https://api.uncensoredendpoint.com/v1. Auth is a bearer key on every call.
| Method and path | Purpose |
|---|---|
POST /v1/chat/completions | Chat requests, streaming, tools, JSON mode |
POST /v1/responses | The newer Responses-style request format |
GET /v1/models | Lists the model; the ID is uncensored |
GET /v1/dashboard/billing/credit_grants | Balance in the OpenAI-style shape |
GET /v1/balance | Balance in a simple form |
That is the whole surface. Anything not in the table is not offered. Keep reading for working requests and a list of what is missing, so you can plan around it before you write code.
Chat completions
This is the endpoint most clients use. Point any OpenAI SDK at the base URL and use the model name uncensored.
from openai import OpenAI
client = OpenAI(base_url="https://api.uncensoredendpoint.com/v1", api_key="YOUR_KEY")
resp = client.chat.completions.create(
model="uncensored",
messages=[
{"role": "system", "content": "You are a concise assistant."},
{"role": "user", "content": "List three uses of a webhook."},
],
temperature=0.7,
)
print(resp.choices[0].message.content)
print(resp.usage)Supported parameters include stream, tools, tool_choice, response_format with json_object, and the sampling set: temperature, top_p, stop, seed and the penalties. max_tokens is optional, because a completion can use whatever remains of the 100,000 token window.
With stream: true the reply arrives as server-sent events and usage is included at the end, so you can still log token counts.
Multi-turn chats
The API keeps no conversation state. For a multi-turn chat you send the full message list each time: system message first, then alternating user and assistant turns. That means input tokens grow with every turn, and so does cost, so trim or summarise old turns once a conversation gets long. The window is 100,000 tokens for prompt plus completion, which is plenty for most chats but easy to fill with pasted documents.
Responses, models and balance
Responses
Newer OpenAI examples use /v1/responses. It is available here too, so code written for that format needs no rewrite.
curl https://api.uncensoredendpoint.com/v1/responses \
-H "Authorization: Bearer YOUR_KEY" \
-H "Content-Type: application/json" \
-d '{"model": "uncensored", "input": "Write a haiku about caching."}'Use whichever your client expects. If you are starting from scratch, chat completions has the widest tool support.
Models and balance
List the models to check that your key works. You should see a single entry, uncensored, because the service runs one model and is not a router across vendors.
curl https://api.uncensoredendpoint.com/v1/models -H "Authorization: Bearer YOUR_KEY"
# remaining credit, OpenAI-style
curl https://api.uncensoredendpoint.com/v1/dashboard/billing/credit_grants -H "Authorization: Bearer YOUR_KEY"
# remaining credit, short form
curl https://api.uncensoredendpoint.com/v1/balance -H "Authorization: Bearer YOUR_KEY"You also get the balance on every response in the X-Balance-USD header, which is handy for a low-credit warning in your app without an extra request. Other headers include X-Request-Id for support questions, plus X-RateLimit-Limit-Requests and X-RateLimit-Limit-Concurrency.
Tools and JSON mode in practice
Two features turn a chat endpoint into something you can build a product on. Tool calling lets the model ask your code to run a function. JSON mode makes it return parseable output. Both use the standard request fields.
A tool call looks like this. The model returns a tool_calls entry, you run the function, and you send the result back as a message with role: "tool".
import json
from openai import OpenAI
client = OpenAI(base_url="https://api.uncensoredendpoint.com/v1", api_key="YOUR_KEY")
tools = [{
"type": "function",
"function": {
"name": "get_weather",
"description": "Current weather for a city",
"parameters": {
"type": "object",
"properties": {"city": {"type": "string"}},
"required": ["city"],
},
},
}]
msgs = [{"role": "user", "content": "Weather in Oslo?"}]
r = client.chat.completions.create(model="uncensored", messages=msgs, tools=tools)
call = r.choices[0].message.tool_calls[0]
args = json.loads(call.function.arguments)
msgs.append(r.choices[0].message)
msgs.append({"role": "tool", "tool_call_id": call.id, "content": '{"temp_c": 4}'})
final = client.chat.completions.create(model="uncensored", messages=msgs, tools=tools)
print(final.choices[0].message.content)For JSON mode, add response_format={"type": "json_object"} and say in the prompt that you want JSON, ideally with the keys you expect. Always parse inside a try block: no model guarantees your schema on every call, so validate the result before you trust it.
Moving an existing OpenAI project over
If your app already uses an OpenAI SDK, migration is three edits and no new library. Most SDKs read the same two environment variables, so you can often change nothing in code at all.
export OPENAI_BASE_URL=https://api.uncensoredendpoint.com/v1
export OPENAI_API_KEY=YOUR_KEYimport OpenAI from "openai";
const client = new OpenAI({ baseURL: "https://api.uncensoredendpoint.com/v1", apiKey: process.env.KEY });
const r = await client.chat.completions.create({
model: "uncensored",
messages: [{ role: "user", content: "Ping" }],
});
console.log(r.choices[0].message.content);Then search your code for model names such as a GPT model ID and replace them with uncensored, because the service has one model. Remove calls to embeddings, images or audio, and route those to another provider. Keep a short checklist: base URL changed, model name changed, key stored in an environment variable and not in the repository, retry logic for 429, and a low-balance alert based on the balance header. For key setup, see how to get an uncensored AI API key. Then run a single test request and check that X-Balance-USD comes back, before you switch real traffic.
What is not offered
Knowing the gaps saves a day of debugging. This API is text only. These OpenAI endpoints are not available:
- Images and vision generation. No image generation or editing.
- Audio. No speech-to-text or text-to-speech.
- Video. Not offered.
- Embeddings. If you build retrieval, you need a separate embedding service.
- Fine-tuning. You cannot train on the service.
Calls to those paths will fail, so keep them out of any shared client config. A typical setup pairs this API for chat with another provider for embeddings, and your app chooses the base URL per task.
Limits, errors and retries
A full key allows 8 concurrent requests and 300 requests per minute. A trial key allows 2 concurrent and 60 per minute. The maximum body is 8 MB. When you cross a limit you get HTTP 429 with an error code that says which one: rate_limited for requests per minute, concurrency for too many requests at once. On temporary overload you also get 429, with a Retry-After: 5 header.
One detail catches people out: a streamed request holds its concurrency slot until the stream ends, so slow readers count against the limit. A simple retry wrapper handles all of this:
import time
from openai import OpenAI, RateLimitError
client = OpenAI(base_url="https://api.uncensoredendpoint.com/v1", api_key="YOUR_KEY")
def ask(prompt, tries=4):
for i in range(tries):
try:
r = client.chat.completions.create(
model="uncensored",
messages=[{"role": "user", "content": prompt}],
)
return r.choices[0].message.content
except RateLimitError:
time.sleep(5 * (i + 1))
raise RuntimeError("still rate limited")Failed or refused requests are not charged, so retries on errors cost nothing extra. For batch jobs, cap your worker pool at 8 on a full key, or 2 on a trial key, instead of relying on retries. A fixed pool is simpler to reason about, and it keeps one slow stream from starving the others.
Cost and access
Pricing is $0.15 per 1M input tokens and $0.50 per 1M output tokens, from prepaid credit with no subscription and no expiry. Top up with any whole amount from $20 to $500, by crypto (USDT on TRC20, USDC on Base). Larger top-ups add a bonus: +5% from $50, +10% from $100, +15% from $200. See the pricing page.
To try it, sign up with Google or email, then claim the $0.50 trial credit with one click on the API key page. The docs cover each parameter, and the endpoint overview explains what the service is: one open-weight model for lawful adult use, with no content refusals and a firm ban on sexual content involving minors.
More guides
Questions and answers
Does it support streaming and tool calling?
Yes. Use stream: true for server-sent events with usage at the end, and tools with tool_choice for function calling.
Is there an embeddings endpoint?
No. The service is text chat only, so use another provider for embeddings.
How do I check my balance?
Call GET /v1/balance or the OpenAI-style credit_grants path, or read the X-Balance-USD header on any response.
What happens when I hit a rate limit?
You get HTTP 429 with the code rate_limited or concurrency. Wait and retry; on temporary overload the Retry-After header says 5 seconds.
Your key is one form away
Create an account, copy the key, change the base URL. That is the whole setup.