nuzaCOMPUTE, SETTLED.

DocumentationGuides and API

Real GPUs, rented by the second. Humans use USDG escrow on Robinhood; agents use x402 USDC on Solana. Deposits and settlements are real; every one is a public transaction you can check.

Quickstart

1. Connect with email, Google, or an EVM wallet. Rabby is recommended because it supports custom EVM networks; an installed Rabby appears through wallet discovery. Nuza adds and pins Robinhood Chain(chain ID 4663) before any payment. Phantom is kept on Nuza's Solana surfaces because it cannot add Robinhood Chain. If Privy has more than one wallet connected, open the account menu and choose Pay with; that exact address is used for balances, authentication, escrow, and refunds.
2. Fund that address with USDG on Robinhood Chain for the deposit and a little ETHfor gas. You deposit rate × runtime; unused USDG refunds at stop.
3. Pick an offer on the board — the order ticket opens with browser-ready PyTorch + Jupyter selected. Choose runtime and change the software only when your workload needs something else.
4. Hit Deploy and approve the escrow deposit. Jupyter needs no SSH key; add your SSH public key only when you want terminal access or choose an SSH-only image (no key? 30 seconds).
5. When the rental turns active, click Open Jupyter. For SSH images, 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 rentalwhen 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 use canonical USDG on Robinhood Chain; ETH pays gas.

1. Copy your 0x… address from the account menu.
2. Move USDG and ETH onto Robinhood Chain with the official bridging routes ↗. Confirm the destination is Robinhood Chain · 4663.
3. Canonical USDG is 0x5fc5360D0400a0Fd4f2af552ADD042D716F1d168 ↗. Ignore lookalike tokens.

Nuza requests an exact allowance, not an unlimited approval. Deposits typically confirm in seconds; unused USDG refunds automatically at stop.

SSH keys in 30 seconds

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

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:

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 insidethe box only (ComfyUI has no login of its own, so nuza never exposes it to the internet). Connect with the ticket's tunnel line:

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 a renter-scoped record in the Nuza escrow contract on Robinhood Chain. Deploy deposits rate × runtime in USDG — the contract has no administrator withdrawal path. As the box runs, usage is metered; at stop, the contract pays the host for metered seconds and refunds the rest to you in one conservation-checked transaction (host + fee + refund == deposit, enforced on-chain). Runtime running out? ＋ extend in My Rentals tops the same escrow up.

Contract: 0x406244…de3f32 ↗ on Robinhood Chain · 4663 — 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 — Nuza pins 4663 before signing.

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 wallet-signed 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 — create a five-minute soft quote for signing without reserving a GPU (the returned numbers match /api/quote); then deposit on-chain and POST /api/rentals/:id/funded to atomically claim available capacity. Manage with GET /api/rentals[/:id], POST /api/rentals/:id/stop, and top up through a pre-send GET /api/rentals/:id/topup followed by landed-transactionPOST /api/rentals/:id/topup. New funding fails closed when the active worker cannot attest the exact live escrow; a valid transaction that already landed is still recorded and refunded if it cannot be serviced.
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.

For a customer-ready programmatic path, use the guarded Nuza client below. The raw API remains available for integrations that need to own every transition.

For machines — payment API

x402 is live on Solana mainnet in USDC. The fastest path is the versioned Nuza client: it quotes first, enforces your maximum, opens the private GPU, returns bounded command output, requests stop in finally, and polls settlement. No account, ports, or SSH choreography are required.

The second command uses an owner-only payer at ~/.nuza/payer.json or ~/.config/solana/id.json. Create a dedicated local payer with npx -y -p https://nuza.io/cli.tgz nuza wallet --create, or pass --payer /absolute/path/id.json. Fund its public address with Solana USDC and a small amount of SOL. Never paste private key material into a command, website, chat, or environment variable.

For persistent work, use open --name NAME, command --name NAME, status --name NAME, and stop --name NAME. Add --json for machine-readable output.

The raw protocol underneath the client is:

1. POST /api/x402/rent without payment — returns the exact rental deposit as a 402 challenge after validating the request and live capacity. Free inventory feeds remain at /api/quote and /api/v1/pricing.
2. POST /api/x402/rent with { sshPubkey, model, region, count, seconds } — the 402 amount is the exact rental deposit. Pay and retry to receive a rental ID and bearer capability.
3. Poll /api/x402/rentals/:id. When active, queue one bounded command through /api/x402/rentals/:id/run with an idempotency key and poll its returned status URL. Raw SSH remains available for interactive work.
4. Stop through /api/x402/rentals/:id/stop as soon as work is complete. The escrow split is enforced on-chain; unused USDC is forwarded back to the paying wallet.

The Coinbase/CDP hosted facilitator does not currently list Robinhood Chain. Nuza therefore uses supported Solana USDC for x402 and native USDG escrow for the Robinhood browser flow. Every completed rental appears on /tape with its actual network.

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, 100 GB quota-backed workspace by default, read-only root filesystem, private host/LAN egress, 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, iptables, and a reachable public IP (or a forwarded port range). The verified host console issues a wallet-bound enrollment code that works once and expires after 15 minutes.

1. Open the host command center. Sign in with email or Google to create an embedded payout wallet, or connect an EVM wallet you already control.
2. If the rig is behind a router, forward the installer's fixed TCP range 49000-49010to it. Nuza automatically chooses a free port inside that range for each rental, and the backend never bills for a container it can't reach. A directly reachable server needs no router step.
3. Set the price and optional contract limit, then run the installer on the rig. The agent derives the coarse market region from its public-IP geography (with a machine-timezone fallback) and detects its public address; neither belongs in browser setup. After dependency, image, and CUDA checks finish, the terminal asks for a fresh one-time code from the command center. Paste it at the hidden prompt; it never enters the install command, process arguments, or shell history.
4. The installer downloads the current host kit, verifies Docker + CUDA, builds the selected templates, creates the rig identity, and starts the agent and tunnel services.
5. Your GPUs go live on the board after the first heartbeat. 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-plainto 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 ownrentals 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.The command center puts the connected wallet's public address intoNUZA_PAYOUT_EVM; its private key never touches the rig. The local enrollment key proves the rig's identity, and only that rig can update its payout destination. The same command center shows live accruals, settled payouts, hardware readiness, and your spot price. A dashboard price remains live; restarting a rig with NUZA_PRICE_PER_HR pinned deliberately reapplies that configured price.

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

Questions

The fastest way to reach us for a stuck enrollment or rental is the nuza Discord.