What the hosting handles for you
Running a language model in production involves more than downloading weights. A hosted API takes on the following so that your code does not have to:
| Handled by the host | Still yours |
|---|---|
| GPUs, drivers and the inference server | Writing and testing your prompts |
| Loading the model and keeping it warm | Choosing temperature, max_tokens and other settings |
| Batching many requests together | Retry logic for 429 responses |
| Authentication and rate limiting | Keeping your API key secret |
| Metering and a prepaid balance | Watching your spend |
| Software updates on the serving side | Handling model output in your app |
The service here is an OpenAI-compatible chat API serving one open-weight model, run by an independent provider. It is not the official API of any model vendor and not a router across several. Text only: no image, audio or video generation, no embeddings and no fine-tuning.
Your first request
Create an account with Google or with email and password, then copy a key from the API key page. Claiming the one-click trial there adds $0.50 of credit, valid for 7 days, without a card.
curl
curl https://api.uncensoredmodelhub.com/v1/chat/completions \
-H "Authorization: Bearer $API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "uncensored",
"messages": [{"role": "user", "content": "Explain what a hosted LLM API does in two sentences."}]
}'
Python
from openai import OpenAI
client = OpenAI(base_url="https://api.uncensoredmodelhub.com/v1", api_key="YOUR_KEY")
resp = client.chat.completions.create(
model="uncensored",
messages=[{"role": "user", "content": "Explain what a hosted LLM API does in two sentences."}],
)
print(resp.choices[0].message.content)
Node
import OpenAI from "openai";
const client = new OpenAI({
baseURL: "https://api.uncensoredmodelhub.com/v1",
apiKey: process.env.API_KEY,
});
const resp = await client.chat.completions.create({
model: "uncensored",
messages: [{ role: "user", content: "Explain what a hosted LLM API does in two sentences." }],
});
console.log(resp.choices[0].message.content);
The same endpoints also include POST /v1/responses and GET /v1/models. The documentation lists parameters.
Streaming, tools and JSON mode
Most of what developers use from a chat API is available.
- Streaming. Set
stream: trueto receive server-sent events as tokens are generated; usage is reported at the end. Chat UIs depend on this. - Tool calling. Pass
toolsandtool_choice, readtool_callsfrom the reply (they also stream), and return results as messages withrole: "tool". - JSON mode.
response_format: {"type":"json_object"}makes the model return a JSON object, useful for extraction and classification. - Sampling controls. temperature, top_p, stop, seed and the penalties are passed through.
A streaming call in Python looks like this:
stream = client.chat.completions.create(
model="uncensored",
messages=[{"role": "user", "content": "Write a four-line poem about servers."}],
stream=True,
)
for chunk in stream:
if chunk.choices and chunk.choices[0].delta.content:
print(chunk.choices[0].delta.content, end="", flush=True)
Libraries that already speak the OpenAI format, such as LangChain, work by changing the base URL; our page on LangChain with open-source models shows an example.
Limits and how to handle them
Hosting is shared, so there are limits. Know them before you build a loop around the API.
- Context: 100,000 tokens, prompt plus completion. The completion can use whatever the prompt leaves unused, and
max_tokensis optional. - Concurrency and rate: a full key allows 8 concurrent requests and 300 per minute; a trial key allows 2 and 60. A streamed request holds its slot until the stream ends.
- Body size: 8 MB per request.
- 429 responses: the error code is
rate_limitedfor requests per minute,concurrencyfor too many at once, and aRetry-After: 5header appears on temporary overload.
A simple retry that waits and tries again is enough in most apps. If a request fails because the prompt is too long, the page on context window exceeded errors covers fixes such as summarising or truncating history.
Response headers help with monitoring: X-Request-Id to quote in a support ticket, X-RateLimit-Limit-Requests and X-RateLimit-Limit-Concurrency for your caps, and X-Balance-USD for what is left.
Moving an existing app over
If your code already uses an OpenAI client, you rarely need to rewrite it. The official SDKs read two environment variables, so a switch can happen outside the code:
export OPENAI_BASE_URL="https://api.uncensoredmodelhub.com/v1"
export OPENAI_API_KEY="YOUR_KEY"
Then set the model name to uncensored wherever your code names a model. Three things are worth checking before you go live:
- Features you rely on. Chat, streaming, tools and JSON mode work. Calls to embeddings, image or audio endpoints will not, because this is a text-only service.
- Prompt length. Anything above 100,000 tokens in total must be cut or summarised first.
- Concurrency. If your app can fire more than 8 requests at once, put a queue or semaphore in front of the client so you do not trigger 429 errors on peaks.
Keep the key on the server. Never ship it in browser code or a mobile app, because anyone who extracts it can spend your balance. Store it in an environment variable or a secrets manager, and rotate it if it leaks.
Cost and billing
Billing is per token: $0.15 per 1M input and $0.50 per 1M output. Credit is prepaid and does not expire, and there is no subscription. Failed or refused requests are not charged.
A quick example. A request with 2,000 tokens in and 500 tokens out costs 2,000 × $0.15 / 1M + 500 × $0.50 / 1M = $0.0003 + $0.00025 = $0.00055. That is 1,818 such requests per dollar. Top-ups are any whole amount from $20 to $500, by crypto (USDT on TRC20, USDC on Base), with +5% bonus from $50, +10% from $100 and +15% from $200. See the pricing page.
To check your balance in code, call GET /v1/balance or the OpenAI-style GET /v1/dashboard/billing/credit_grants, or read X-Balance-USD from any response.
Hosted or self-run: a quick check
A hosted API fits when you want to ship quickly, have uneven traffic, or do not want to operate GPUs. You give up choice of model and the ability to fine-tune. Prompts are sent to the provider, though they are not used for training.
If you are weighing it against running your own hardware, compare the per-token figures above with your own hardware quote. For background on the model type, read what an uncensored AI model is. Content-wise, the model is tuned to answer without refusals for lawful adult use, with one hard limit: nothing sexual involving minors.

