nuzaTHE HONEST GPU EXCHANGE← to the exchange

Renting a GPU on nuza

Real GPUs, rented by the second, paid through a per-rental escrow on Solana mainnet-beta. Deposits and settlements are real USDC; every one is a public transaction you can check.

Quickstart

  1. Install Phantom or Solflare — or just sign in with email/Google on the exchange and an embedded wallet is created for you.
  2. Connect, then fund the wallet with USDC (Solana) for the deposit and ~0.01 SOL for transaction fees. You only ever deposit rate × runtime — and the unused part refunds at stop.
  3. Pick an offer on the board — the order ticket opens. Choose GPU count, runtime, and image.
  4. Paste your SSH public key into the ticket (no key? 30 seconds), hit Deploy, and approve the escrow deposit in your wallet. Your box is usually SSH-ready in under a minute.
  5. Connect with the command the ticket reveals:
    ssh root@HOST -p PORT
    ssh tries your default key automatically — non-default path? add -i ~/.ssh/yourkey.

Stop rental when you're done — you're only ever billed for metered seconds, and the unused deposit refunds to your wallet on-chain. The ticket links the deposit, the escrow vault, and the settlement so you can verify every cent on the explorer.

Funding your wallet

Deposits are USDC on the Solana network, plus ~0.01 SOL for transaction fees. To fund:

  1. Copy your address from the account menu (click your address, top-right).
  2. On Coinbase, Kraken, or Binance: withdraw USDC and select the Solana network — not ERC-20/Base. USDC sent on another network will not arrive in this wallet.
  3. Send ~0.01 SOL the same way (it pays the network fees on your deposit and refund).

Deposits typically confirm in seconds. You only ever escrow rate × runtime, and the unused part refunds automatically at stop.

SSH keys in 30 seconds

In any terminal (macOS, Linux, or Windows PowerShell):

ssh-keygen -t ed25519

Accept the defaults, then paste the contents of ~/.ssh/id_ed25519.pub — one line starting with ssh-ed25519 AAAA… — into the ticket. The private key never leaves your machine; the container accepts only your public key.

Jupyter template

The PyTorch + Jupyter image runs JupyterLab on the box. On a live rental the ticket shows Open Jupyter ↗ — one click, opens in your browser through the nuza app tunnel with the server token already applied. No SSH, no port juggling.

Tunnel offline or prefer SSH? The classic way still works:

ssh -L 8888:localhost:8888 root@HOST -p PORT

then open http://localhost:8888 — the token is printed by jupyter server list on the box.

ComfyUI template

The ComfyUI · SD 1.5 baked image boots with ComfyUI already running and a Stable Diffusion 1.5 checkpoint on disk — zero downloads before your first image. It listens on localhost:8188 inside the box only (ComfyUI has no login of its own, so nuza never exposes it to the internet). Connect with the ticket's tunnel line:

ssh -L 8188:localhost:8188 root@HOST -p PORT

then open http://localhost:8188 and hit Queue Prompt. On first connect ssh shows a host-key fingerprint - your ticket displays the exact same string; match it and type yes. Models you download land in /workspace/comfy/models — on your disk quota, picked up automatically.

Where the money sits

Every rental gets its own escrow account on Solana. Deploy deposits rate × runtime into that vault — nuza never holds your funds. As the box runs, usage is metered; at stop, the on-chain program pays the host for metered seconds and refunds the rest to you in one conservation-checked transaction (host + fee + refund == deposit, enforced by the program). Runtime running out? ＋ extend in My Rentals tops the same escrow up.

Program: C6mbkJ3H…NnAaCo ↗ on mainnet-beta — verifiable without a wallet, along with every settlement and the live pricing feed. If your wallet shows different balances than the header chip, your wallet app is set to a different network — the chip reads mainnet-beta.

API

The exchange UI is just a client — everything runs over plain HTTP, so bots and scripts trade the same market. Reads are public; writes authenticate with a Sign-In-With-Solana session cookie (POST /api/auth/nonce → sign → POST /api/auth/verify).

  1. GET /api/board — every live offer with spot pricing, measured specs, reliability, contract cap. GET /api/board/stream is the same board as an SSE live feed.
  2. GET /api/quote?model=rtx6000pro&region=us-east&count=1&seconds=86400&mode=spot — price a contract without committing: exact per-second rate and escrow deposit, no reservation.
  3. POST /api/rentals — reserve + quote for signing (the returned numbers match /api/quote); then deposit on-chain and POST /api/rentals/:id/funded. Manage with GET /api/rentals[/:id], POST /api/rentals/:id/stop, POST /api/rentals/:id/topup.
  4. Hosts: GET /api/host/earnings, POST /api/host/price (payout-wallet session), GET /api/host/kit. Market: GET /api/index, GET /api/stats, and stable public feeds: GET /api/v1/pricing (per-model, for price aggregators) and GET /api/v1/settlements (recent settlements with tx links — rendered live at /tape). Human-readable per-GPU pricing: H100 · A100 · RTX 6000 Pro · 4090 · 5090.

The first three items above, in that order, are the complete programmatic rent → SSH → stop → settle flow — ask in the Discord if you want a working reference script.

For machines — rent over HTTP 402

An agent with a Solana wallet can rent a GPU here with one paid HTTP call — no account, no session, no sign-in. nuza speaks x402 v2 (USDC on Solana; the facilitator fronts the network fee, so the wallet needs only USDC):

  1. POST /api/x402/rent with {sshPubkey, model?, region?, count?, seconds?} — the 402 challenge's amount IS the exact escrow deposit for that spec (rate × runtime, priced live). Retry with payment and the response carries rentalId + a bearer accessToken. You are charged only if the reservation succeeds.
  2. GET /api/x402/rentals/:id (Authorization: Bearer …) — poll until active; the response then carries SSH host, port, and the per-rental host key to pin.
  3. POST /api/x402/rentals/:id/stop — stop anytime; metered seconds settle on-chain and the unused deposit returns to the wallet that paid.

Try the rail for $0.001 first: GET /api/x402/quote is the same live quote behind the same paywall. Stated plainly: for x402 rentals the on-chain renter is the exchange treasury, so the settlement split (host + fee + refund == deposit) is program-enforced as always, and the refund leg back to your wallet is a treasury-signed transfer you can verify by signature — forwarded, not program-enforced. Every settlement is public on /tape. This door is independently indexed on x402scan ↗ — a third-party listing, not our claim.

Host your GPUs

Supply side is one Python agent on your rig: it enrolls with a wallet-ownership proof, heartbeats for work, provisions an isolated Docker container per rental (fair CPU/RAM slice, dropped capabilities, renter's key only), and gets paid per metered second straight to your wallet at settlement. Your offer appears on the board automatically — you set the price and the max contract length.

Requirements: Linux with an NVIDIA GPU + driver, Docker with nvidia-container-toolkit, a reachable public IP (or a forwarded port range), and an enroll code from us — enrollment is gated while the beta fleet is curated, so ask in the nuza Discord and we'll issue one.

  1. Download the host kit (the agent, installer, and container templates) and unpack it on the rig: tar xzf nuza-host-kit.tar.gz
  2. Forward a TCP port range on your router to the rig (e.g. 49000-49010 — one port per concurrent rental). The agent only allocates inside this range, and the backend never bills for a container it can't reach.
  3. Run the installer (installs a systemd service, builds the rental image, verifies GPU passthrough):
    sudo NUZA_API_URL=https://nuza.io NUZA_PAYOUT_WALLET=<your pubkey> NUZA_HOST_KEYPAIR=/root/host-id.json NUZA_ENROLL_SECRET=<enroll code> NUZA_SSH_PORT_START=49000 NUZA_SSH_PORT_END=49010 NUZA_PRICE_PER_HR=0.65 NUZA_MAX_RENTAL_HOURS=168 bash agent/install-agent.sh
  4. That's it — your GPUs go live on the board within a heartbeat (~5s). Watch journalctl -u nuza-agent -f, or your rig's live console at nuza.io/host.

Running next to Vast? Two things: add NUZA_DOCKER_RUNTIME=nvidia-plain to the installer line — Vast's docker shim breaks --gpus and the default check will misdiagnose it as a missing toolkit. And know that the agent tracks its own rentals per GPU: if Vast rents the machine, pause your nuza listing (or price above your Vast floor) so two renters never share the same silicon. Use a port range distinct from Vast's. Why list here at all? The pitch, with the payout math →

Payouts & price. Set NUZA_PAYOUT_WALLET to any wallet — your browser wallet works, and its private key never touches the rig (the local keypair only proves the rig's identity, and only it can change where payouts go). Connect that wallet on the exchange to get the Earnings panel: live rentals with earnings accruing, settled payouts, and your spot price — editable right there, live on the board in seconds. Pin NUZA_PRICE_PER_HR on the rig instead if you want the agent to own the price (it wins over the panel). Set your max contract length with NUZA_MAX_RENTAL_HOURS.

Payouts settle on-chain per rental via the escrow program — see where the money sits.

Questions

The fastest way to reach us — an enroll code, a stuck rental, anything — is the nuza Discord.

tape · open books · host · docs · gpu pricing · machine marketsx402