How Pricing Works

Qubax bills per token, not per request or per month. You load credits with crypto, and each API call deducts the precise cost down to the micro-cent. There are no subscriptions, no seat fees, and no minimum spend beyond the per-token math.

Per-token billing

Every response is priced by the number of tokens consumed — both the prompt tokens you send and the completion tokens the model generates. The unit is the micro(one-millionth of a US dollar, i.e. $0.000001). One million tokens at $3/M costs exactly 3,000,000 micros.

Text
1 micro     = $0.000001
1 token     = price-per-million / 1,000,000  (in micros)
1,000,000 tokens @ $3/M = 3,000,000 micros = $3.00

Each completion response includes a usageobject showing prompt, completion, and total token counts, so you can track exactly what each call cost.

JSON
{
  "usage": {
    "prompt_tokens": 42,
    "completion_tokens": 128,
    "total_tokens": 170
  }
}

Credits

Your balance is a pool of prepaid credits denominated in US dollars. Every API call deducts the micro-cost from your credit balance in real time. When the balance reaches zero, requests return a 402 Payment Required(surfaced as a rate-limit error in the SDKs) until you top up.

Note: Minimum top-up is $3, payable in 350+ cryptocurrencies including BTC, ETH, SOL, USDT, and USDC. Credits are account-wide and shared across every model and every API key on your account. There are no per-key wallets to manage.

How discounts work

Qubax negotiates wholesale rates and passes the savings on as a discount against OpenRouter's published price for each model. Discounts run up to 99% off OpenRouterdepending on the model and current wholesale capacity.

Text
OpenRouter price (per model): $X per million tokens
Qubax price:                  up to 99% off $X

You pay: $X * (1 - discount)
Example: $10/M on OpenRouter, 90% off  ->  $1.00/M  ->  1,000,000 micros/M

The effective per-token price is always shown in the dashboard next to each model, so you know the exact rate before you send a request.

Check your balance

Query your remaining balance and usage at any time with the billing endpoint. The response returns your credit balance in micros and USD.

Shell
curl https://api.qubax.ai/v1/billing/balance \
  -H "Authorization: Bearer $QUBAX_API_KEY"
JSON
{
  "balance_micros": 15000000,
  "balance_usd": 15.0,
  "currency": "USD"
}

You can also poll this endpoint from your application to alert users when their balance runs low, or to gate expensive agent runs behind a minimum balance threshold.

Top up from code (any coin)

Your app can refill its own balance with no browser. Ask for a top-up in any supported coin and you get back a deposit address and the exact amount to send. Once the payment confirms on-chain, your balance goes up automatically. Amounts run from $5 to $5,000.

Shell
curl https://api.qubax.ai/v1/billing/top-up \
  -H "Authorization: Bearer $QUBAX_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"amountUsd": 20, "payCurrency": "usdcbase"}'
JSON
{
  "id": "cm2x...",
  "status": "PENDING",
  "amountUsd": 20,
  "payAddress": "0x4f1c...",
  "payAmount": 20.04,
  "payCurrency": "usdcbase",
  "network": "base",
  "payExtraId": null,
  "expiresAt": "2026-10-17T00:19:17.836Z",
  "paymentUrl": "https://nowpayments.io/payment/?iid=..."
}

Send exactly payAmount of payCurrency to payAddress. If payExtraId is not null (XRP, XLM, TON and similar), include it as the memo or destination tag, or the payment can be lost. Leave out payCurrency to get only a paymentUrl where a person can pick the coin.

List every supported coin (BTC, ETH, SOL, DOGE, XRP, TRX, TON, USDT and USDC on most chains, 350+ in total), then check a top-up until its status is CONFIRMED:

Shell
curl https://api.qubax.ai/v1/billing/coins

curl https://api.qubax.ai/v1/billing/top-up/cm2x... \
  -H "Authorization: Bearer $QUBAX_API_KEY"
Python
import requests, os
H = {"Authorization": f"Bearer {os.environ['QUBAX_API_KEY']}"}
API = "https://api.qubax.ai/v1/billing"

bal = requests.get(f"{API}/balance", headers=H).json()["balance_usd"]
if bal < 5:
    t = requests.post(f"{API}/top-up", headers=H,
                      json={"amountUsd": 20, "payCurrency": "usdcbase"}).json()
    send_usdc(t["payAddress"], t["payAmount"])   # your wallet code
Note: Small coins have a higher minimum (at least twice the network minimum, never below $5); the error message tells you the exact amount. At most 5 unpaid top-ups per hour. Unpaid top-ups expire on their own.
Tip: Because pricing is per-token and credits never expire, the cheapest strategy is simply to load credits once and let them deplete with real usage — there is no benefit to “using up” a plan each month.

Ready to build?

380+ models through one OpenAI & Anthropic-compatible API, up to 99% below OpenRouter.

Get your API key →