# Tokens and billing

> Output is free and you pay for input tokens only, EUR 0.05 per million. What counts, how a charge is computed and the prepaid balance.

Output is free: you pay for input tokens only. Every response tells you exactly how many tokens you were billed for and what the call cost, and you know the charge before the request runs.

The price is EUR 0.05 per million input tokens (5 micro-cents per token), flat at every volume, excluding VAT. Billing starts when the API opens to the public.

## What you pay for

Every response has a `usage` object:

| Field | Meaning |
| --- | --- |
| `input_tokens` | The billed tokens: `state_tokens` plus `question_tokens`. |
| `state_tokens` | The tokens of the rendered state. |
| `question_tokens` | The tokens of all rendered questions: instructions, criteria, and options or levels with their answer codes. |
| `charge_micro_cents` | What was debited from your balance. |
| `unit_price_micro_cents` | The price per token for this request: 5 at launch, or 0 for a test key. |
| `tier` | `t1`, `t2`, `t3` or `test`. At launch t1, t2 and t3 have the same price. |

Three rules follow:

- **Output is free.** The answers are never counted.
- **Scaffolding is free.** The fixed prompt text Dex adds around your content (its prefix, delimiters and answer cue) is not billed.
- **The state is billed once.** However many questions share it. See [State](/docs/concepts/state/#sent-once-billed-once).

## The tokenizer

Tokens are counted with the pinned tokenizer of the model family: the tokenizer of the base model that `dex-1` resolves to. It stays the same for every version in major version 1, because a new tokenizer means a new major version.

Requests served by the fallback are counted with the same tokenizer, so a request costs the same on either path.

## The charge

```text
charge_micro_cents = input_tokens * unit_price_micro_cents
```

- One euro is 100,000,000 micro-cents.
- Prices are whole micro-cents per token, so every charge is an exact whole number. Nothing is rounded.
- Because output is free, the exact charge is known before the request runs.

## Price and tiers

Prices are per million input tokens, excluding VAT. The API keeps volume tiers, counted per account on billable tokens since the start of the UTC calendar month, so that volume discounts can be added later without a contract change. The price is flat: the same at every volume.

| Tier | Billable input tokens this month | EUR per million input tokens | Micro-cents per token |
| --- | --- | --- | --- |
| t1 | first 1 billion | 0.05 | 5 |
| t2 | 1 billion to 10 billion | 0.05 | 5 |
| t3 | above 10 billion | 0.05 | 5 |

The launch price is flat: EUR 0.05 per million input tokens at every volume. The API still reports a `tier` (t1, t2 or t3) on every response; at launch every tier has the same price. Prices exclude VAT. Output tokens are free.

- A request is priced at the tier in force before it.
- `GET /v1/balance` shows your month-to-date tokens, your tier, its unit price and `next_tier_at_tokens`, the count at which the next tier starts.
- The [pricing page](/pricing/) shows the same price.

## Worked examples

| Call | Billable tokens | Charge |
| --- | --- | --- |
| One check on a short message | 150 | EUR 0.0000075 |
| The Dutch support example in the docs | 273 | EUR 0.00001365 |
| A typical 450-token call | 450 | EUR 0.0000225 |
| A 1,000-token state with 8 questions of 60 tokens | 1,480 | EUR 0.000074 |

One million calls of 450 tokens cost EUR 22.50.

## Test keys

Test keys (`dex_test_`) are counted the same way and charged 0, with `tier` `test`. Each account gets 250,000 free test tokens per UTC day, shared by all its test keys and by console playground calls. Test calls always run on the GPU path. See [Rate limits](/docs/reference/rate-limits/).

## Prepaid balance

Dex is prepaid. You top up a balance in euros, and each request is debited from it.

- **Stored exactly.** The balance is an integer number of micro-cents. There are no credits or rounding.
- **Top-ups** of EUR 10 to EUR 2,500 go through Stripe Checkout in the console.
- **Payment methods:** cards, iDEAL, Bancontact and SEPA Direct Debit.
- **New accounts** can top up at most EUR 500 in total in their first 30 days.
- **Credited when paid.** The net amount, excluding VAT, is credited when Stripe reports the payment as settled. SEPA Direct Debit settles later than cards, so the balance arrives later too.
- **VAT.** Prices exclude VAT. Stripe Tax applies it at checkout: the EU reverse charge for businesses with a validated VAT id, and 21% Dutch VAT for customers in the Netherlands.
- **No expiry.** Balances do not expire. When you close your account, you can ask for the unused balance to be refunded.

## When you are charged

1. Dex validates the request and counts its tokens. A request that fails validation (any 4xx) is never charged.
2. At admission, it debits the exact charge in one atomic step. If your balance is too low, you get `402 insufficient_balance` with `balance_micro_cents` and `required_micro_cents`, and nothing is charged.
3. If the request then fails with a 500 or 503, the charge is refunded in full before the response is sent.

A replay of a completed request with the same [idempotency key](/docs/reference/idempotency/) is never charged.

## Checking usage and balance

- `GET /v1/balance` returns your balance in micro-cents and as a decimal euro string, your tier and your month-to-date tokens. See the [API reference for getBalance](/docs/api/getBalance/).
- `GET /v1/usage` returns usage per key by day (up to 93 days) or by hour (up to 7 days), with requests, tokens, charges and the split between GPU and fallback. See the [API reference for getUsage](/docs/api/getUsage/).
- The console shows the same data as charts.