EN ▾
Get API key

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.

Updated

Four platforms with a cloud, network hub, GPU box and cube linked to a central balance, for comparing model options

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.

  1. 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.
  2. 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.
  3. 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.
  4. 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.

ItemThis API
Model IDuncensored (one model)
EndpointsPOST /v1/chat/completions, GET /v1/models
CompatibilityOpenAI SDKs and clients, by changing base URL and key
Context window100,000 tokens, prompt plus completion
Input price$0.15 per 1M tokens
Output price$0.50 per 1M tokens
BillingPrepaid credit, no subscription, no expiry, failed or refused requests not charged
FeaturesStreaming, tool calling, JSON mode, seed and sampling controls
LimitsFull key: 8 concurrent, 300 requests per minute. Trial key: 2 concurrent, 60 per minute
Not offeredImages, 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.

01

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.

Get API key