Billing

Eterial is prepaid and charged per request. There is no subscription, no minimum and no monthly commitment: you hold a dollar balance, and each request draws against it.

Holds, and why your balance moves twice

Before a request is sent to a model, an estimate of what it could cost is reserved against your balance — your prompt, plus the most the answer could be under your max_tokens, plus a small margin. The reservation is deliberately generous, because its job is to guarantee the request is covered, not to predict it.

When the request finishes, that reservation is settled: the real cost is charged and the rest comes back. So during a request your available balance dips further than the final charge explains, and then recovers.

Settlement runs immediately after your response is delivered, not during it. That is why a cost is marked provisional for a short while before it firms up.

What a failed request costs

The exception is a stream that broke partway through: tokens were generated and delivered to you, so those are billed. It appears in the log with the partial disposition. See Request dispositions.

Charges that change after the fact

A cost can be corrected once, shortly after the request:

• Token counts. Usually the backend reports exactly what was used. When it cannot — a stream that broke before the final figures arrived — the counts are estimated, and the log says so.
• Currency. The network is paid in its own token while your balance is in dollars, so a request is charged at the rate captured when it ran and reconciled once the network confirms the actual amount.

Corrections arrive as their own entry rather than by rewriting the original charge. Your history stays as it happened, and you can see exactly what moved.

The fee on fallback requests

Requests served by the GPU network are charged at the network's rates. Requests that fall back to OpenRouter carry a fee on top of OpenRouter's own price, and we would rather state that here than let you find it in a bill.

It is not a margin we invented. Buying credit on OpenRouter costs a payment fee of its own — if you were using OpenRouter directly, you would be paying it yourself. We pay that same fee on the credit that serves your fallback requests, and pass it through instead of quietly absorbing it into the rate.

So it is not money you would have saved by going elsewhere; it is the same fee, made visible. Set against what inference costs here in the first place, it is not a number worth planning around — but it is your money, so it is written down.

Reading the usage log

The Usage page in the dashboard has one row per request:

• when it ran, and its request id
• the model, and which key sent it
• prompt, completion, cached and reasoning tokens
• what it cost, and whether that cost is still provisional
• how it ended — disposition and reason
• how long it took, and whether it was streamed
• any tools it used

Above the rows, the same data summarised: total spend, request count, failures, success rate and average latency.

Three questions it is built to answer: why is this bill bigger than I expected — sort by cost and look at the token counts; which key is spending it — group by key prefix, which is why a separate key per environment is worth the trouble; and why did this request fail — find it by request id and read its reason.