Credits

What credits are

A credit balance represents usage accounting for inference and API calls. It is not a deposit account the network holds on a user's behalf as funds — Basis takes no custody. The balance is the unit of account that the deterministic pricing math draws down as jobs run.

Dynamic pricing epochs

BASIS-per-credit is set by a versioned pricing epoch — a dated, identified record of the active rate, the per-model credit prices, and the multipliers in force. Only the active epoch prices new quotes and reservations; superseded epochs are retained for audit and for the receipts locked under them.

BASIS-per-credit can adjust over time based on token market price, model cost, network utilization, worker supply, demand, provider reward floors, and operator-approved pricing epochs.

Quote / reservation locks the price (TTL)

Before a job runs, Basis locks a pricing snapshot. That snapshot records the active epoch, model price, multipliers, BASIS-per-credit rate, and quote expiry. The job receipt uses that snapshot, so users are not silently repriced and workers are not paid from a different formula after the fact.

Receipts preserve the snapshot

The locked snapshot is carried onto the inference receipt as its hashed economic core. The receipt's total charge equals the snapshot's required $BASIS amount, and the worker reward is drawn from the same locked snapshot — the identical rate, multipliers, and worker pool — never a formula applied after the fact.

The full receipt shape, the canonical-JSON hashing scheme, and how to re-derive the hash yourself live under Inference receipts.

Credits → $BASIS

Usage is priced in credits — per token, per model — and credits convert to $BASIS base units at the active epoch's rate (basisPerCreditRaw). The credit cost of a job depends only on the model and the authoritative token counts; the credit → $BASIS rate is the layer that can move between epochs, always within the capped epoch-to-epoch bound.

The one place a live market quote is needed is converting a sell token — ETH, WETH, or USDC — into the required amount of $BASIS at payment time. That conversion, and only that conversion, uses a fresh exact-output quote (next section).

Paying with tokens

You can fund credits two ways. Deposit $BASIS directly, or route ETH / WETH / USDC into $BASIS at payment time. ETH/WETH/USDC payments use a fresh exact-output quote to acquire the required amount of BASIS at payment time — bounded by a TTL and a slippage floor so a stale or unfavorable quote is never honored.

Deposits & pending state

Credit lifecycle

The result: a failed job never overcharges. A job is only ever debited for what it actually consumed, priced at the snapshot it was reserved under, and anything reserved beyond that is returned.

Determinism & units

All amounts are integer base units, carried as decimal strings and computed with big-integer math and floor division. There is no floating point anywhere in the money path, so a request, its locked snapshot, and its receipt always agree — to the last unit, for the life of that quote.

Worked example

Model basis-default (multiplier 10000 bps = 1x), with 1000 prompt tokens and 500 output tokens, priced at the placeholder epoch's locked snapshot. All values are $BASIS base units. Prices are placeholder economics, not final.

epoch            epoch-placeholder-001   (basisPerCreditRaw = 1e15)
model            basis-default           (modelMultiplier = 10000 bps = 1x)
promptTokens     1000
outputTokens     500

# usage priced in credits, then converted to $BASIS at the LOCKED snapshot rate
promptCharge = 1000000000000 * 1000 * 10000 / 10000
             = 1000000000000000          # 1e15
outputCharge = 4000000000000 *  500 * 10000 / 10000
             = 2000000000000000          # 2e15

total        = promptCharge + outputCharge
             = 3000000000000000          # 3e15  (basisRequired at this epoch)
protocolFee  = total * 1000 / 10000      # 10%
             = 300000000000000           # 3e14
workerPool   = total - protocolFee
             = 2700000000000000          # 2.7e15  (>= provider floor)

The user's credit balance is debited the total (3e15 base units), priced at the snapshot the job was reserved under. The protocol fee (3e14) is withheld, and the worker pool (2.7e15) — drawn from the same locked snapshot — is what a contributor worker's reward is computed from on the receipt. A later epoch would not change this receipt.

Reading a balance

Available credits for an address are returned as a raw $BASIS base-unit string. The response also reports whether deposits are enabled.

curl -s https://basis.watch/api/credits/0xYourAddress

# {
#   "address": "0xYourAddress",
#   "balanceRaw": "2700000000000000",
#   "tokenSymbol": "BASIS",
#   "depositsEnabled": false
# }

The active pricing epoch, the BASIS-per-credit rate, and the per-model credit table are served by the pricing API — see the API reference. The $BASIS token is planned, not live.