Pay for GPU-seconds. See every number before you fund.
Hosts set their own price per GPU-hour for each GPU class. You pay for the GPU-seconds your job actually used, rounded up to the host's billing unit, plus one platform fee added on top and shown before you fund — so the host receives its full rate. Failed compute is never charged.
How pricing works
The exact formula
Integer math in micro-dollars, the same function for the quote and the final charge. Compute rounds up to the next micro-dollar so a host is never paid below its rate. At settlement the fee is added on top in payment-token units and rounded down, so the escrow contract's split pays the host side exactly the compute charge and you never pay more than quoted (the quote rounds the fee up).
- You pay compute + fee. The platform fee is added on top of the compute charge, never taken out of the host's rate.
- The host receives its full compute rate — minus the farm owner's
commissiononly when the job ran in a farm whose owner registered one onchain (max 20%). That commission comes out of the host's share, not your bill. - The fee goes to the protocol fee recipient. Its rate is snapshotted into the escrow when you fund, so a later fee change never touches your job.
- Unused escrow comes back to you: the escrowed maximum minus the final charge is credited to your wallet at release.
runtimeis the shorter of what the host reported and what the coordinator observed, capped at the job's max runtime — neither side can inflate it alone.
billableSeconds = max(unit, ceil(runtime / unit) × unit)
gpuSeconds = gpuCount × billableSeconds
compute = ceil(gpuSeconds × pricePerGpuHour / 3600)
fee = compute × feeBps / 10_000 // on top, token units, rounded down
charge (A) = compute + fee // what you pay (quote: fee rounded up)
// on release, ComputeEscrow splits A (integer division truncates):
protocolFee = A × feeBps / (10_000 + feeBps) // = fee → fee recipient
commission = (A − protocolFee) × commissionBps / 10_000
provider = A − protocolFee − commission // = compute − commission
customerRefund = maxPayment − A // unused escrow → you
// provider + commission = compute, to the base unitLive prices by GPU class
Per GPU-hour, over GPUs that are online, benchmark-verified and priced right now. Median is per GPU.
Worked example
2 × RTX 4090 at an example rate of $0.46/GPU-hour — not a live price (nothing is listed yet), paid in USDG.
- Runtime (measured)
- 847 s (14:07)
- Billable (unit 60 s)
- 900 s
- GPU-seconds
- 2 × 900 = 1800
- Compute
- ceil(1800 × 460000 / 3600) = $0.23
- Fee (2.5%)
- $0.00575
- Charge A
- $0.23575
- Escrowed (max runtime 30:00)
- $0.4715
- Charge A released
- $0.23575
- Protocol fee → fee recipient
- $0.00575
- Farm commission → farm owner(no farm in this example)
- $0.00
- Host receives(= compute, the host's full rate)
- $0.23
- Unused escrow refunded to you
- $0.23575
Computed on this page with the same computeCharge and escrow split code the coordinator uses to settle real jobs. Amounts are in USDG, where one base unit equals one micro-dollar. With ETH, the USD rate is locked when you create the job.
No hidden fees
- One platform fee, added on top of compute, shown in the quote and snapshotted onchain when you fund. It goes to the protocol fee recipient; the host still receives its full rate.
- Billing covers your container's run time only — not queue time, image pulls or result upload.
- Failed compute isn't charged: a failed job is refunded in full through the escrow.
- No subscription, no token, no minimum spend. Gas for your own transactions is the only other cost.
- Unused escrow (max cost minus the final charge) is credited back to you at release; claim it from the RewardDistributor any time.
Payment assets
Escrow on Robinhood Chain. No arbitrary ERC-20s.