Compare AI Models and Pricing: Hosted, Local, This API
To compare ai models and pricing fairly you need your own token counts, not a price list. This article gives you the formula, the four options worth comparing, and an honest account of when this API is the wrong pick.

Four ways to get a model, and what each costs you
Most comparisons mix up things that are not alike. A model, a provider and a billing scheme are three separate choices. For text generation in an app, there are four realistic routes, and each one has its own cost shape.
- A closed vendor's own API. You get that vendor's flagship models, their feature set and their usage policy. Pricing is per token, and it changes, so check their current pricing instead of trusting a blog post, including this one.
- A router or marketplace. One account, many models from many vendors. Convenient for experiments, with a markup or a fee layer on top of the underlying price, depending on the service.
- Running an open-weight model yourself. No per-token fee. You pay for GPUs or a capable workstation, power, setup time and maintenance, and your throughput is whatever the hardware gives you.
- A hosted open-weight API with a narrow job. That is what this site is: one open-weight model, run by an independent provider, tuned to answer without content refusals for lawful adult use, behind an OpenAI-compatible endpoint. It is not the official API of Meta, Mistral, Qwen, DeepSeek, OpenAI, xAI, Google or Anthropic, and it is not a router.
The rest of this article gives you a way to put numbers on each route without relying on anyone's marketing page.
What this API offers, in facts you can check
Start with the side you can verify. Everything here is published on the pricing page and in the docs.
| Item | This API |
|---|---|
| Model ID | uncensored (one model) |
| Endpoints | POST /v1/chat/completions, GET /v1/models |
| Compatibility | OpenAI SDKs and clients, by changing base URL and key |
| Context window | 100,000 tokens, prompt plus completion |
| Input price | $0.15 per 1M tokens |
| Output price | $0.50 per 1M tokens |
| Billing | Prepaid credit, no subscription, no expiry, failed or refused requests not charged |
| Features | Streaming, tool calling, JSON mode, seed and sampling controls |
| Limits | Full key: 8 concurrent, 300 requests per minute. Trial key: 2 concurrent, 60 per minute |
| Not offered | Images, audio, video, embeddings, fine-tuning |
Use the same table as a template for the other routes. If you cannot fill a row for a competing service from its documentation, treat that as a finding. Concurrency and rate limits especially are often missing from marketing pages and decisive for batch work.
The cost formula, with exact examples
Monthly cost is input tokens divided by a million times the input rate, plus output tokens divided by a million times the output rate. Nothing else is hidden in it here. Three examples at $0.15 and $0.50:
- Small tool. 2M input and 0.5M output tokens in a month: 2 x $0.15 = $0.30, plus 0.5 x $0.50 = $0.25, total $0.55.
- Busy product. 50M input and 10M output: 50 x $0.15 = $7.50, plus 10 x $0.50 = $5.00, total $12.50.
- Output-heavy writing app. 5M input and 5M output: 5 x $0.15 = $0.75, plus 5 x $0.50 = $2.50, total $3.25.
The third line shows why the input-to-output ratio matters. At equal volumes, output costs more than three times as much as input here, so a use case that writes long replies from short prompts behaves differently from one that reads long documents and answers briefly. When you compare any two services, run both ratios through both price lists.
Now ask the same question of the other options. For a closed vendor or a router, take their current per-token rates and run the same three scenarios. For a local run, divide your monthly hardware cost, power and the time you spend maintaining it by the tokens it actually produces in a month. Idle GPUs make a local run look expensive per token, and a fully loaded one can look very cheap. Which of those you get depends on your load, so measure.
Measure it on your own prompts
Published prices tell you the rate and nothing about your token counts. Different models tokenise differently, and verbose models write longer answers for the same question. The only honest comparison is to run your real prompts and log what came back. This script does that against this API; point the base URL and model at another service to get the same numbers from it.
import os, time
from openai import OpenAI
client = OpenAI(
base_url="https://api.uncensoredaimodels.com/v1",
api_key=os.environ["UNCENSORED_KEY"],
)
IN_PER_M, OUT_PER_M = 0.15, 0.50 # dollars per 1M tokens
def cost(prompt_tokens, completion_tokens):
return prompt_tokens / 1e6 * IN_PER_M + completion_tokens / 1e6 * OUT_PER_M
def trial(prompt):
t0 = time.time()
r = client.chat.completions.create(
model="uncensored",
messages=[{"role": "user", "content": prompt}],
max_tokens=500,
)
u = r.usage
return {
"seconds": round(time.time() - t0, 2),
"in": u.prompt_tokens,
"out": u.completion_tokens,
"dollars": round(cost(u.prompt_tokens, u.completion_tokens), 6),
"text": r.choices[0].message.content,
}
for p in open("my_real_prompts.txt").read().split("\n---\n"):
print(trial(p))
Put 20 to 50 real prompts in my_real_prompts.txt separated by a line containing three dashes. Read the output yourself. Cost per prompt is useful only if the answers meet your bar, and a cheaper model that needs two attempts per task is not cheaper. A trial key is enough for this: new users can claim $0.50 of credit with one click on the API key page, valid for 7 days, no card needed. Note that the trial key is limited to 2 concurrent requests and 60 requests per minute, so run the script serially.
When a closed frontier API is the better choice
Be clear about this before you spend anything. If your task depends on the strongest general reasoning available, on vision input, on audio, on embeddings for search, or on a vendor's fine-tuning service, a closed vendor's API is the right tool and this one cannot substitute. This API has one text model. It does not generate or read images or audio, it does not produce embeddings, and it does not fine-tune.
The same applies to policy. Closed vendors apply their own content rules, and for a customer-support bot or a children's tutoring tool, those rules are a feature. An API tuned to answer without refusals is a poor match for a product where you want the model to push back on borderline requests. You can add your own filtering on top, but if refusals are what you want, choose a service built around them.
Finally, check enterprise needs. If you need a signed data-processing agreement, region guarantees or uptime commitments, ask each provider for them in writing. This site publishes the facts listed above and nothing beyond them.
When running locally wins
A local run is the right answer when data must never leave your hardware, when you need offline operation, when your volume is high and steady enough to keep a GPU busy, or when you want full control of the model files and sampling. You can also pick any open-weight model you like and swap it at will.
The price of that control is real. You handle drivers, serving software, quantisation choices, memory limits and updates. Long contexts are expensive in memory, so a 100,000-token window that is a single parameter on an API can be a hardware project locally. For a prototype, or for an app whose traffic comes in bursts, an API usually reaches a working product sooner. If you want a feel for the engineering trade-offs on the coding side, the production checklist for an uncensored coding LLM goes through them.
Where this API fits, and how to start
It fits when you want an OpenAI-compatible endpoint, a model that does not refuse lawful adult requests, prepaid billing with no subscription, and clear limits. Typical jobs are fiction and roleplay backends, companion apps for adults, red-team and writing tools, and agent loops that fail on refusals elsewhere. Sexual content involving minors is a hard limit. Prompts are not used for training.
Switching an existing client takes two lines: change the base URL to https://api.uncensoredaimodels.com/v1 and the model to uncensored. Top-ups are whole amounts from $20 to $500 with bonuses of +5% from $50, +10% from $100 and +15% from $200, payable by crypto (USDT on TRC20, USDC on Base). Credit never expires, so a first top-up of $20 is a low-risk way to run the measurement script above with real volume. The quickstart has the full request format.
More guides
Questions and answers
How do I compare AI model pricing correctly?
Collect the input and output rates, then multiply each by your own monthly token volumes and add them. Run real prompts through each service to get true token counts, since models differ in verbosity and tokenisation.
Is a hosted API cheaper than running a model locally?
For low or bursty traffic, usually yes, because you pay only for tokens used. For high, steady load that keeps a GPU busy, local can be cheaper per token. Include hardware, power and your own time in the local figure.
Does this API offer several models?
No. It exposes one model, with the ID uncensored. It is not a router across vendors and it is not the official API of any vendor.
What does 1M tokens cost for input and output here?
Input is $0.15 per 1M tokens and output is $0.50 per 1M tokens. Billing is from prepaid credit, and failed or refused requests are not charged.
Your key is one form away
Create an account, copy the key, change the base URL. That is the whole setup.