EN ▾
Get API key
Uncensored LLM API pricing guide

How Token-Based API Pricing Works, Explained Plainly

The openai api pricing model is pay-per-token: you are billed for the tokens you send and the tokens the model writes back, at two different rates. This page explains each part in plain language and shows how our own OpenAI-compatible API applies the same idea.

Updated

Small cubes flowing into a meter and larger cubes flowing out, picturing input and output token pricing
Key points
  • You pay per token, with one rate for input and a higher rate for output.
  • Conversation history is resent every turn, so long chats cost more per message than short ones.
  • Rate limits restrict how fast you can send requests. They do not change the price per token.
  • Our API charges $0.15 and $0.50 per 1M tokens from prepaid credit and is a separate product from any vendor's.

The model in one paragraph

Hosted language model APIs are usually sold by usage, not by seat. Your program sends text, the service counts how many tokens went in and how many came out, and the bill is those counts multiplied by per-million-token prices. Input and output have separate prices. Different models carry different prices. A few extra rules sit on top: rate limits, context windows and the way you pay in (prepaid or invoiced). That is the whole pricing model, and the rest of this page unpacks each piece.

A clarification first. When people type this phrase into a search box, they often mean OpenAI's own price list. We are not OpenAI, and we do not quote their prices here, since those change and you should read them at the source. What we can explain accurately is the structure, which is shared by most providers, and how it works on the API we run: a hosted, OpenAI-compatible, text-only API with one open-weight model, uncensored, operated by an independent provider.

Tokens are the unit

A token is a chunk of text the model reads or writes. It may be a whole short word, part of a long word, a number or a punctuation mark. For ordinary English prose a rough rule of thumb is that one token is around four characters, or three quarters of a word. Other languages, code and unusual formatting usually take more tokens for the same visible length, so treat any rule of thumb as an estimate and read the real counts from the API instead.

Every response from our API includes a usage object with prompt_tokens and completion_tokens. For streamed responses the usage arrives at the end. Those two numbers are what you are billed on. Nothing else, such as the number of requests or the time a call took, enters the price.

Because the unit is tokens, not characters or calls, the same feature can be cheap or expensive depending on how you build it. A one-line classification prompt may cost a fraction of a cent for a thousand calls. A prompt that pastes a 60-page document into every request costs far more, even if it is called the same number of times.

Input and output have different prices

Input tokens are everything you send: the system message, the conversation history, the user's latest message, tool definitions and tool results. Output tokens are what the model generates, including any tool call it writes. Generating text takes more compute than reading it, so providers price output higher. On our API the rates are:

Per 1M tokensPer token
Input$0.15$0.00000015
Output$0.50$0.0000005

Output is 0.50 / 0.15, or about 3.3 times more expensive per token. That ratio drives design decisions. If your app sends a 3,000-token prompt and gets back a 100-token label, input is $0.00045 and output is $0.00005, so the prompt is 90 percent of the cost, and shortening it matters more than anything else. If your app asks for 2,000-token stories from a 200-token prompt, input is $0.00003 and output is $0.001, so the output is 97 percent of the cost, and the lever is the length of the story.

Check those numbers yourself: 3,000 x 0.15 / 1,000,000 = 0.00045. 100 x 0.50 / 1,000,000 = 0.00005. 200 x 0.15 / 1,000,000 = 0.00003. 2,000 x 0.50 / 1,000,000 = 0.001.

Why history makes chats cost more over time

The API is stateless. The model does not remember your last request, so a chat application resends the earlier messages with each new one. The input for turn 10 therefore contains turns 1 through 9 again, and you pay for those tokens every time.

Take a chat where every turn adds 400 tokens in total. Turn 1 sends about 400 tokens of context, turn 10 about 4,000 and turn 50 about 20,000. The model's context window on our API is 100,000 tokens, prompt and completion together, so a very long session will eventually need trimming whether or not cost matters. Typical fixes are:

  • Keep the system prompt and the last N turns, and drop the middle.
  • Summarize old turns into a short note and send the note instead.
  • Store long-term facts outside the chat and insert only the relevant ones.

A concrete number: a 1,000-token system prompt sent with each of 1,000 requests is 1,000,000 input tokens, which is $0.15. Fine on its own. But a 10,000-token character sheet sent with each of 100,000 requests is 1,000,000,000 input tokens, or $150. Fixed overhead multiplies by volume, and that multiplication is the thing to watch.

Prepaid credit, not a subscription

Providers differ in how money moves. Some bill you after the month ends, some deduct from a prepaid balance, and some mix the two with monthly plans. On our API it is simple: you add credit, usage draws it down, and nothing renews by itself. Credit never expires. Failed or refused requests are not charged.

Top-ups are any whole amount from $20 to $500, with a bonus of +5% from $50, +10% from $100 and +15% from $200. So $100 gives $110 of credit, and $200 gives $230. You can pay with crypto (USDT on TRC20, USDC on Base). The practical result is that your worst case is capped by what you loaded: a bug that loops cannot spend more than the balance. The balance after each call is in the X-Balance-USD response header.

New users can try the service first. After sign-up, one click on the API key page claims $0.50 of trial credit, valid for 7 days, one per person, no card needed.

Rate limits are a separate dial

Two APIs with the same price per million tokens can still feel very different, because rate limits decide how much you can push through per minute. Providers usually set limits per account tier. On our API a full key allows 8 concurrent requests and 300 requests per minute, and a trial key allows 2 concurrent and 60 per minute. The maximum body is 8 MB.

When you exceed a limit you get HTTP 429. The error code is rate_limited when you went over requests per minute and concurrency when too many requests were in flight. On temporary overload the API also returns 429 with a Retry-After: 5 header. One detail that catches people: a streamed request holds its concurrency slot until the stream ends, so slow clients that read tokens one at a time can fill the 8 slots faster than the request count suggests.

Limits change throughput, not price. If you need to push a large batch, the arithmetic is simple: at 300 requests per minute, 10,000 requests take about 34 minutes, assuming each finishes quickly enough to stay within 8 at a time.

Applying the model to this API

The OpenAI-compatible part is what makes the pricing model portable. Any OpenAI SDK works once you change the base URL and key, so cost tracking code you wrote for one provider can usually be reused. This script reads usage and prices a call at our rates:

from openai import OpenAI

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

resp = client.chat.completions.create(
    model="uncensored",
    messages=[
        {"role": "system", "content": "You are a concise assistant."},
        {"role": "user", "content": "Explain what a token is in two sentences."},
    ],
)

u = resp.usage
input_cost = u.prompt_tokens * 0.15 / 1_000_000
output_cost = u.completion_tokens * 0.50 / 1_000_000
print(f"in={u.prompt_tokens} out={u.completion_tokens} total={input_cost + output_cost:.7f}")

What this API is, in the terms above: one model, text only, a 100,000-token context window, tool calling, JSON mode and streaming, and prompts that are not used for training. The model is tuned to answer without content refusals for lawful adult use, and there is a hard limit on sexual content involving minors. It is not a router across vendors and not any vendor's official endpoint. Details for setup are in the quickstart, and the full price list sits on the pricing page. For a worked comparison against other services, see the ChatGPT API cost page.

Questions and answers

What does the OpenAI API pricing model mean in plain terms?

You pay for tokens: one rate for tokens you send and a higher rate for tokens the model returns. Rates depend on the model, and the bill is the token counts times the per-million prices.

Is input or output more expensive?

Output. On our API it is $0.50 per 1M tokens against $0.15 per 1M for input, about 3.3 times as much.

Why does a long chat cost more per message?

The API does not remember earlier turns, so each request resends the history as input tokens. The longer the history, the more input you pay for on every turn.

Do rate limits change what I pay?

No. They cap requests per minute and concurrent requests. The price per token stays the same.

Is your API the same as OpenAI's?

No. It follows the OpenAI request format so existing SDKs work, but it runs a different open-weight model operated by an independent provider.

Your key is one form away

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