# Pricing your models

> How provider prices work on Numes, from meters and currencies to reference prices, markups, price protection and price changes.

Source: https://0.0.0.0:3000/docs/providers/pricing
Documentation index: https://0.0.0.0:3000/docs/llms.txt

You set an exact price for every meter of every model you sell. Customers pay your price for inference, and your full price is what you earn. Prices are part of each offer revision, so they're reviewed and protected like the rest of your terms.

## Meters and units

A meter is a quantity your source reports for each request. Your source's reported usage decides which meters a model has, and you must price every required meter before you can publish.

| Meter | Charged per | Typical use |
| --- | --- | --- |
| `prompt` | token, character, image or audio second | Input |
| `completion` | token, image or audio second | Output |
| `internal_reasoning` | token | Reasoning tokens, where the source reports them separately |
| `cached_prompt` | token | Prompt tokens read from cache |
| `cache_write` | token | Prompt tokens written to cache |
| `request` | request | A flat price per request. Starts at `0` in setup. |
| `sku` | call | One call of a hosted tool, such as web search |

You can price only what your source reports. Token prices are entered and displayed **per 1M tokens** and stored per token; every other meter is priced per its own unit.

Vision chat can accept images with token-only prices. The
upstream's prompt-token receipt includes image processing; image input does not
require a separate per-image price. Request and image counts are billable only
when the source reports qualified receipts for those quantities.

Prices are exact decimal strings with up to 30 decimal places, and every charge is computed from that exact value: `0.15` per 1M tokens is stored as exactly `0.00000015` per token. Customers are charged your published rates for the usage the platform accepts from your source; what the upstream charges you never enters the calculation.

### Cache and reasoning prices

Cache-read and cache-write prices must each be less than or equal to the model's input price, so a cached token never costs more than an uncached one. If your upstream charges a premium for cache writes, recover it in your input price. Setup never prefills a cache price above the input price, and the dashboard asks you to lower one you enter.

Cache meters exist only when the source reports cache usage exactly; see [Inference sources](/docs/providers/sources). When a request uses the cache, its prompt is split into uncached, cache-read and cache-write tokens, each charged at its own rate.

| Meter | Without a price | At `0` |
| --- | --- | --- |
| `cached_prompt`, `cache_write` | Charged at the input rate | Free |
| `internal_reasoning` | Charged at the output rate | Free |

Leave these unpriced unless you mean to give a discount. When a source reports cache usage but has no reference cache price, setup starts the cache price at your input price, so charges are unchanged until you lower it. Customers still see their cache hits in `prompt_tokens_details` when you give no discount.

## Currencies

Every customer key is charged in one currency, USD or BTC, chosen when the key is created. An offer reaches a key only if it has prices in that key's currency, so pricing in both reaches both groups of customers.

| Schedule | You enter | Customers with BTC keys pay |
| --- | --- | --- |
| USD | Dollars per unit | Not available to them |
| Fixed BTC | Sats per unit, for example `₿1,295 / 1M` | Exactly your sats price |
| USD-indexed BTC | Dollars per unit | Your dollar price converted to sats at the platform's reference rate, locked for each request |

USD and BTC schedules are independent: they're never converted into each other, and your earnings in each currency stay separate.

- **Fixed BTC** prices never follow the exchange rate. The terminal UI can suggest a sats price from a current BTC/USD quote while you edit, but saving fixes the number until you publish a new one.
- **USD-indexed BTC** prices in dollars and pays you in sats at the rate locked for each request. Customers see the price as "Variable · USD-indexed". If no reference rate is available, indexed offers stop receiving requests without any effect on your health, and fixed schedules keep serving. Bitcoin you earn stays exposed to later price movements.

Switching a Bitcoin schedule between fixed and indexed requires entering the affected rates again; a saved number is never reinterpreted in another denomination.

## Reference prices and markup

Setup prefills every price it can from a **reference price**. A reference price is a starting point: customers are never charged it unless you save it as your price. There are two kinds.

| Kind | Shown as | Where it comes from | Adjusted by |
| --- | --- | --- | --- |
| Upstream cost | `upstream reference` | The upstream's exact list price for metered API keys. OpenRouter, PPQ.ai, DeepInfra, Novita AI, Venice and Tinfoil report it during discovery; for OpenAI, Anthropic, Google Gemini and OpenCode Zen it comes from public model catalogues. | Markup |
| Market price | `market reference`, with its basis and age, such as "Market median of 7 hosts · 3h ago" | What hosts charge for the same public model, from public model catalogues (OpenRouter and models.dev). Used for Ollama, vLLM, llama.cpp, OpenAI-compatible servers and Kimi Code. | Market adjustment |

A market price is the median host's complete set of rates. When few hosts serve the model, it falls back to the model publisher's own list price, then OpenRouter's. Setup shows the basis and the catalogue's age; an old catalogue is marked stale but still shown.

List prices are fixed published rates. Subscription credits, partner discounts, variable or tiered rates, and premium cache-write rates are never imported as references; set those models' prices yourself.

| Where | Starts at | How to change it |
| --- | --- | --- |
| Terminal UI and desktop setup | 0% markup and 0% market adjustment | **Markup on upstream %**, **Adjust vs market %** or any individual price in the Review step |
| CLI setup, interactive | Asks, suggesting 0% for both | Enter different percentages |
| CLI setup, non-interactive | No prefill | `--markup-percent 15`, `--market-adjustment -5`, or `--accept-reference-prices` for the references themselves |
| Dashboard, hosted sources | 0% | **Markup on … prices** or **Market adjustment** under **Add a markup** |
| [Autopilot](/docs/providers/autopilot) | 0% markup over upstream list prices | **Markup** in the endpoint's autopilot settings, or `numes provider autopilot set --markup-percent` |

Markups apply exactly, from 0% to 10,000%. Market adjustments may be negative, down to just above -100%, so you can undercut the market. Refreshing a source never changes your prices unless you accept new references or turn on [autopilot](/docs/providers/autopilot).

The upstream reference is your cost at the upstream. A 0% markup earns you nothing after upstream costs, and platform checks also use upstream capacity. A market reference says nothing about your own costs: check it against your hardware and power costs before you publish.

## What customers pay

Customers pay your price for inference, with no platform markup on top; the platform fee is charged when customers buy credits. For a model priced at $0.50 per 1M prompt tokens and $1.50 per 1M completion tokens, a request with 2,000 prompt and 800 completion tokens costs:

| Line | Calculation | Amount |
| --- | --- | --- |
| Prompt | 2,000 × $0.0000005 | $0.001 |
| Completion | 800 × $0.0000015 | $0.0012 |
| Customer pays, you earn | | $0.0022 |

If 1,500 of those prompt tokens were read from cache at $0.10 per 1M, the prompt line becomes 500 × $0.0000005 + 1,500 × $0.0000001 = $0.0004, and the request costs $0.0016.

Customers see your earnings for each request as `upstream_inference_cost` in the usage details, and the total as `cost`.

- **Failed requests.** A request that delivers no output to the customer costs nothing and earns nothing, even if your source did work.
- **Interrupted requests.** Provider-caused interruptions may be excluded from earnings. See [Earnings and payouts](/docs/providers/earnings).
- **Price ceilings.** Customers can set `provider.max_price` per prompt and completion unit. It's compared directly with your prices, so a ceiling of `0.000001` per prompt token admits your offer at $1.00 per 1M or less.
- **Routing.** Routing balances price, reliability and performance across eligible offers close to the lowest estimated price. Customers can also sort by throughput, latency or measured quality. See [Measurements and quality](/docs/providers/measurements#how-routing-uses-measurements).

## Price protection

Price protection keeps providers from raising prices sharply on customers who rely on an offer, and keeps listings close to the market.

Price changes that stay close to your last reviewed price and to comparable market prices activate automatically, once verification passes, or right away for a [hosted](/docs/providers/hosted) offer. New listings, large changes, changes to price structure, and listings without enough market comparison are reviewed by an administrator.

While a price change is in review, your model shows **Update in review** and the previously approved prices keep serving. New prices are never shown or charged before approval. If review returns or rejects the change, your approved prices stay in effect; correct them and publish again. A listing that has never had approved prices shows **In review** and doesn't serve until approval.

## Changing prices

Published prices change only when you publish a new offer revision:

1. Open the source in the [terminal UI](/docs/providers/terminal-ui) or [desktop app](/docs/providers/desktop), edit the model's prices, and publish. For hosted sources, use **Edit models** in the dashboard.
2. The new revision goes through price protection and, for self-hosted endpoints, verification.
3. When these pass, it replaces the old revision.

For a change that touches only prices or presentation, the old revision keeps serving at the old prices until the new one is active, so customers see no gap. A change to capabilities, limits, the source or data handling stops the old offer until the new revision is eligible.

Upstream price changes never alter your published prices unless [autopilot](/docs/providers/autopilot) is on for the endpoint. Without it, publish new prices yourself when your upstream raises its prices. The [cost guard](/docs/providers/autopilot#cost-guard), on in both modes, holds a model from customers while its upstream cost is above its live price.

In the terminal UI, **Regenerate prices** and markup changes replace rates from the current references; changing currencies keeps your saved rates for each currency that stays selected. In the desktop app, pricing choices in model selection apply only to newly added models.

### Prices from the CLI

Before a profile's first publication, you can draft prices from the command line. `prices show` also works after it and shows the published prices, or refuses if it can't show them exactly:

```bash
numes provider prices show --profile NAME
numes provider prices set --profile NAME --model example-model \
  --meter prompt --currency USD --cost 0.50 --unit token
numes provider prices set --profile NAME --model example-model \
  --meter completion --currency BTC --cost 1295 --unit token
numes provider prices unset --profile NAME --model example-model \
  --meter cached_prompt --currency USD
```

Token costs are entered per 1M tokens, other units per unit. For USD-indexed Bitcoin, use `--currency BTC --pricing-basis usd_indexed` with a dollar cost, or `--currency BTC-indexed` in `setup`. Once a profile has published, `set` and `unset` refuse to run: edit and publish prices in the terminal UI or desktop app instead.

## Next steps

:::cards
- {badge} [Review and lifecycle](/docs/providers/lifecycle) What "In review", "Update in review" and "Checking" mean.
- {gauge} [Measurements and quality](/docs/providers/measurements) What besides price decides how much traffic you get.
- {wallet} [Earnings and payouts](/docs/providers/earnings) How settled earnings become withdrawable.
- {console} [CLI reference](/docs/providers/cli#setup) Every price flag for `setup`.
:::