# Same model, different price: choose how your requests are routed

_2026-11-12. Each model on OpenUncensored runs on several providers with different prices and speeds. See every provider's input, output and cached price, get the cheapest fast provider by default, or route by lowest latency, fastest output or lowest cost per request or per key._

Most models on OpenUncensored are served by more than one provider. The model is the same and so are the
weights, but each provider sets its own price and runs at its own speed. Until today you had no say in which one
answered. Now you do, and the default got cheaper.

**In short:**

- Every model page now shows each provider's input, output and **cached input** price, plus its live speed.
- By default we send your request to the **cheapest provider that produces at least 150 tokens per second**.
- You can choose **lowest latency**, **fastest output** or **lowest cost** instead, for a single request or for
  everything your key sends.
- You still pay exactly the provider's price, with no markup, and every response tells you which provider answered.

## Same model, different prices

Here is DeepSeek V4.1 Flash 1017 Uncensored on two of its hosts, in dollars per million tokens:

| | Input | Output | Cached input |
|---|---|---|---|
| Host 1 | $0.33 | $1.32 | $0.00825 |
| Host 2 | $0.40 | $1.40 | $0.04 |

Input and output are within about 20% of each other. Cached input is five times apart, and for most of our
traffic that is the column that decides the bill.

## Why cached tokens decide the bill

A provider keeps the start of recent prompts in memory. When the next request begins with the same text, those
tokens are a **cache hit**, and providers charge much less for them.

Coding agents such as Claude Code, Codex and opencode resend the whole conversation on every step: the system
prompt, the tool definitions, every file they have read. On our traffic, **96 to 99% of agent prompt tokens are cache
hits**. Take one agent step with a 30,000 token prompt (97% cached) and a 500 token answer:

| | Fresh input | Cached input | Output | Total |
|---|---|---|---|---|
| Host 1 | $0.0003 | $0.0002 | $0.0007 | **$0.0012** |
| Host 2 | $0.0004 | $0.0012 | $0.0007 | **$0.0022** |

Same model, same answer, nearly twice the price. Over a day of agent work that is real money. Judged by the input
price alone, the two hosts look almost the same.

## What the default does now

When you don't ask for anything:

1. Providers that run the model on their own hardware go before resellers.
2. Among those, every provider averaging **150 tokens per second or more** counts as fast enough, and the
   **cheapest** goes first. The price is worked out for your request, counting the share of cached tokens the
   model usually gets.
3. Slower providers come after, as fallbacks.
4. If a provider fails before it has sent anything, the next one answers.

150 tokens per second is faster than anyone reads and quick enough for agent loops. Above that line, a faster
provider buys you little and can cost you a lot. Below it, speed matters more than price.

## Choose your own

| Strategy | Picks first | Use it for |
|---|---|---|
| `default` (or `quality`) | The cheapest provider over 150 tok/s | Almost everything |
| `speed` (or `latency`) | Fastest time to first token | Chat and voice, where waiting for the first word hurts |
| `throughput` | Most tokens per second | Long answers and batch jobs |
| `cost` (or `price`) | Lowest price, counting cached tokens | Background work where a slower answer is fine |
| `random` | Shuffled | Spreading load and A/B tests |

**For one request**, add a `routing` field:

```bash
curl https://api.openuncensored.com/v1/chat/completions \
  -H "Authorization: Bearer $OU_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model": "deepseek-v4.1-flash-1017-uncensored",
       "messages": [{"role": "user", "content": "hello"}],
       "routing": {"strategy": "cost"}}'
```

Or send the header `X-OU-Strategy: cost`, which helps when your client can't add body fields. Clients written
for OpenRouter work as they are: `"provider": {"sort": "price"}` (or `"throughput"` or `"latency"`) maps onto
the same strategies.

**For your whole key**, open the [credits page](https://openuncensored.com/credits#routing), enter your key and pick one. Every
request from that key then uses it, unless the request asks for something else. It takes effect within 30
seconds.

## What you'll be billed

You pay the price of the provider that answered, with no markup. Every response says which one it was:

- the `ou.provider` field in the response body and the `X-OU-Provider` header
- `usage`, with cache hits in `prompt_tokens_details.cached_tokens` where the provider reports them

Each provider's prices and live speed are on its model's page, for example
[DeepSeek V4.1 Flash 1017 Uncensored](https://openuncensored.com/models/deepseek-v4.1-flash-1017-uncensored).

## Caveats

- **Speeds are live averages** over each provider's recent requests, and they move through the day. A provider we
  have not measured yet counts as fast enough, so it gets tried, and it drops back if it turns out slower.
- **Switching providers can cost you cache hits.** Each provider only has a cache of the prompts it has seen.
  Changing strategy partway through an agent session can make the next few requests fully priced until the new
  provider has cached your context.
- **A fallback can cost more.** If the cheapest provider fails, the next one answers at its own price. Set
  `"allow_fallbacks": false` if you'd rather get the error.
- **The `pricing` on `/v1/models` is the cheapest provider's list price.** The per-provider prices, including
  cached input, are in each model's `providers` list.
- **When a provider reports its own charge, that is what we bill**, cache discount included. Otherwise we work it
  out from the provider's listed prices.

Full details are in the [routing docs](https://openuncensored.com/docs#routing).