Pricing & credits

Every model has an input (prompt) and output (completion) price, quoted per million tokens. Models whose page also lists a cached input price bill the prompt tokens the provider serves from its prompt cache at that lower rate, and models whose page lists a cache write price (for example Claude, which writes a cache entry only when your request carries cache_control) bill the tokens written to the cache at that price instead. A request's cost is (uncached_prompt_tokens × input) + (cached_prompt_tokens × cached input) + (cache_write_tokens × cache write) + (cache_write_1h_tokens × 1-hour cache write) + (completion_tokens × output), where cached_prompt_tokens is the provider-reported cached share of the prompt (prompt_tokens_details.cached_tokens), cache_write_tokens is the share written to the cache with the default (5-minute) lifetime (prompt_tokens_details.cache_write_tokens minus the 1-hour share), cache_write_1h_tokens is the share written with a 1-hour lifetime (prompt_tokens_details.cache_write_1h_tokens, billed at the 1-hour cache-write price shown on the model page) and uncached_prompt_tokens is the rest of prompt_tokens. A model without a cached input price bills those tokens at the input rate. A request that can write to a provider's prompt cache on a model with no cache-write price is refused (error UB-GW-299) rather than billed at a price the model page does not show. Prompt caches are private to your workspace: we add a short workspace marker (10 tokens) to the start of each prompt so no other customer can ever read your cached prompt; those 10 tokens are never billed to you and are not included in the usage we report. Reasoning tokens are billed as output. Terminal usage is recorded before delivery and posted through durable metering. The ledger is kept in paise (minor units) for exact accounting.

Current catalog prices, in ₹, are on each model page.

Prices shown include our 5% platform fee — you pay exactly what you see. Each listed ₹ rate is the provider's cost plus our platform fee (currently 5% on most models). A model can carry its own fee, and a limited-time offer can lower it; the model's page always shows the price you pay (and, during an offer, the regular price struck through). Nothing further is added to a request's token charge. Billing is exact cost + the model's platform fee, debited in whole paise as it accumulates: every request is charged exactly the provider's cost for what it used plus our platform fee, from the exact counts. Money moves in whole paise, so the fraction of a paisa not yet debited (or debited in advance) is carried on your wallet to your next request, across all models and request types; your total debits always equal your exact total rounded up to the next whole paisa. A single request can therefore be debited up to one paisa more or less than its own exact amount, and a very small one nothing at all. The response's unoblox.transaction_cost (and, for a non-streamed response, the x-unoblox-transaction-cost header; a streamed response's header is only the amount held while it runs, and its exact cost is on the final usage frame) shows that exact amount as total_inr (also exact_base_inr, an exact decimal) and the most that request alone could be debited as max_debit_inr; the whole paise actually debited for it appear on its generation record once it settles. Each per-million ₹ rate shown is the exact rate rounded up to the next whole paisa. The rate and the fee are pinned when the request starts, so the price can never move mid-request.

Long-context models. A few models charge a higher rate once a prompt is long (the exact token threshold differs by model). Every such tier is listed on the model page and in the playground, and the catalog API returns it as pricing_tiers. Which tier applies is decided by the prompt tokens the provider reports for the request, and that one tier prices the whole request. The upfront hold may be sized on the higher tier as a safe upper bound, but you are charged only the tier your actual prompt tokens fall in.

Billing is reserve then settle: an upper-bound hold is placed on your balance when the request begins, then the final charge is settled from actual usage when it completes and the difference is released. A refusal before admission places no hold; if an admitted request is abandoned before provider dispatch, durable processing releases its hold without an inference usage charge.

The hold covers your prompt plus a reply allowance (your max_tokens if you send one, else the model's published output limit). unoblox never injects or lowers a max_tokens on your request — it is forwarded to the provider exactly as you send it, or omitted. A request is refused before dispatch, with nothing billed, only when your balance cannot cover the prompt itself. If a provider generates more than the hold covered and your balance cannot cover the difference, the request is still billed in full and the shortfall shows as ₹X outstanding: your next top-up clears it first, and new requests are declined until it is cleared.

unoblox does not apply a blanket zero-completion waiver. An empty answer can still follow real prompt processing or provider work, so billing uses the terminal usage and cost evidence recorded for that request. This is a deliberate compatibility boundary: do not treat completion_tokens: 0 by itself as proof that a request is free.

For BYOK, a normally completed request charges only unoblox's pinned BYOK fee; your provider bills your provider account directly and separately. A partial comp removes the unoblox workspace charge, but is not a promise that your provider will waive its charge. On a freemium model, a free request — balance at or above the admin-set minimum — leaves the workspace wallet untouched through an explicit platform subsidy. Below the minimum, or with paid access enabled on the key, published prices apply as in the usage-based rule above. The fair-use rate limit applies to every workspace on a freemium model at any balance; only a key with paid access enabled is exempt. BYOK is exempt from all of this — it is never rate-limited by the freemium fair-use limit and never gated by the freemium balance minimum, on a freemium model or any other; see Bring your own key.

If a response ends without complete accounting evidence, keep its x-generation-id and reconcile that request. A blind replay is not known to be charge-safe.

Add credits from the Credits page. Top-ups are processed in ₹ (UPI, cards, net-banking via our payments partner) when enabled. The authoritative payment flow shows the current limits, supported methods, fees and documents before funding.

GST is charged on top of the amount you add. Per-token prices exclude GST: at 18%, paying 118 rupees credits 100 rupees to your wallet, and the tax invoice shows 100 rupees plus 18 rupees GST. One tax invoice is issued for each top-up when the credit is added; individual requests carry no GST and no separate invoice. Payment-processing fees are absorbed by unoblox. Credits do not expire.

Usage rollups expose token counts and cost per model or provider, in hourly or daily buckets. They carry metadata only — never prompt or completion content. The inference API response returns token usage, not ₹ — read rupee cost from these rollups or a per-request generation lookup.

GET /workspaces/{id}/usage/activity  →
{
  "data": [
    {
      "bucket_unix_ms": 1756700000000,
      "dimension": "catalog/model-id",
      "requests": 128,
      "prompt_tokens": 84000,
      "completion_tokens": 21000,
      "cache_hits": 37
    }
  ]
}

Identical, deterministic requests can be served from cache — and a cache hit is free: it short-circuits before any upstream call, costing zero tokens and zero ₹. But caching is opt-in per request, not automatic: send the header below, or it bypasses even when everything else about the request is cacheable.

X-Unoblox-Cache: opt-in

A request is cacheable only when it is non-streaming, uses temperature: 0 with no other sampling knobs, no tools, no file input, and no provider pin — and only once you’ve opted in. Send Cache-Control: no-store to force a bypass even on an otherwise-eligible, opted-in request.

Every response carries X-Unoblox-Cache (HIT / MISS / BYPASS) and X-Unoblox-Cache-Reason (why — e.g. not_opted_in if you forgot the header). A HIT also carries X-Unoblox-Cache-Source-Generation, naming the earlier request whose response is being replayed. Full header reference is in API reference.

Cap spend before it happens: set a per-key limit_minor spend cap, or a workspace / org budget. A request that would breach a hard cap is failed closed with a budget_exceeded error rather than silently overspending. Enterprise budgets are managed in the Enterprise portal.

Route to a provider on your own upstream credentials and unoblox charges a 2% overage instead of the full token price — the provider bills your own account for the tokens. BYOK traffic can optionally count against your key limits (include_byok_in_limit) so budgets still apply. Full details in Bring your own key.