How Boogie works

Boogie is a marketplace for GPU hours. Hosts publish machines, you rent them by the hour, and the price you see is the price you pay. This page covers the whole path, from picking a card to getting a shell on it.

Overview

Renting GPU capacity usually means a sales call, a quota request, or a queue. Boogie removes all three. Every machine in the catalog is live capacity across a dozen datacenters, listed with the price it costs at this moment and the time it takes to boot.

Renting a GPU

1. Pick a machineThe catalog lists GPU model, VRAM, vCPU, RAM, disk, region and how long the machine takes to boot. Every listing is datacenter capacity, not a spare card in somebody's flat.
2. Choose how longRentals are measured in hours. One hour is the smallest unit, and you can add more time later without restarting the machine.
3. Add a keyA machine will not start until an SSH key is bound to your wallet. You can make one in the browser on the profile page, no terminal needed. See Access and data.
4. PayConnect a wallet and settle the order. See Paying for a rental for what is accepted.
5. Get accessThe machine is ordered from the datacenter and boots, which takes about eight to twelve minutes. The catalog shows the expected time for each listing, and your hours do not start until it is up.

Machines arrive with the NVIDIA driver, Docker with GPU passthrough configured, and a browser workspace running PyTorch. You get root through sudo, so anything else you need is one command away.

How pricing works

Every listing shows one number: dollars per hour, for the whole machine as configured. A host with four cards in one box publishes each slice separately, so a 2x RTX 5090 listing is priced as a pair, not per card.

Prices move. A card that costs $0.45 an hour this morning may cost $0.51 tonight, because supply and demand on the network move too. The figure attached to your order is fixed when you pay.

Paying for a rental

Orders settle on Solana in USDC, and are booked in dollars. What you hand over does not have to be dollars. Phantom, Solflare and Backpack all work, and a little SOL on the same address covers the network fee.

Paying with tokenized stocks

If you hold tokenized equity on Solana, you can spend it directly. NVDAx, SPYx, QQQx and TSLAx are accepted. The stock is swapped to USDC through Jupiter in the same transaction that books your order, so nobody holds an equity position between the quote and the container.

• The wallet shows a ceiling, not a fixed amount. The swap sells a little more stock than the price needs, the exact rental amount goes to Boogie, and the change stays in your wallet as USDC.
• The band is 2% above the quoted amount. If the swap would deliver less than the rental costs, the whole transaction fails and nothing leaves your wallet.
• Quotes hold for five minutes. After that, reprice.

Paying with USDC

USDC is the settlement currency, so paying in it skips the swap entirely and settles for the exact amount shown.

What the order looks like on chain

Every payment carries a short memo with the machine, the hours and a check value we sign. That memo is the order. There is no account and no database row behind it: the history of the Boogie treasury on Solana is the full ledger of rentals and refunds, and anyone can read it.

Access and data

There are two ways in, and both open the same machine.

The workspace

Every machine boots a notebook in your browser with PyTorch installed and every GPU already visible. One button in your rental opens it, and a starter notebook is waiting there that lists your cards and measures how fast they are. Nothing to install, no terminal.

SSH

You connect as boogie, with sudo. Not as root: the provider keeps that account for maintenance, and taking it away breaks the machine.

ssh boogie@<host>

If your key was made in the browser it lands in a file of its own, so point ssh at it:

ssh -i ~/.ssh/boogie_ed25519 boogie@<host>

Keys

Your public key is bound to your wallet by a signature, which costs nothing and takes one click. That binding is what tells us whose key to install, so a machine never starts before it exists. Nobody can attach a key to a wallet they do not control, and the private half never leaves your computer, including when the browser generates it for you.

Credentials never go onchain. An order records which machine it bought and for how long; the connection details live in your dashboard and nowhere else.

Time, extending and shutdown

The clock starts when the machine is up, not when you pay. Boot takes minutes and somebody has to pay for them, and that somebody is us, not you.

While a rental runs you can add time from the same card: one hour, six, or twenty four. The extra hours attach to the machine you are already on, so nothing restarts and nothing is lost. You pay for an extension the same way you paid for the rental, and the cheapest asset you hold that covers it is used automatically.

When the time runs out the machine is shut down and released back to the datacenter, without waiting for you to remember. There is no forgotten instance quietly billing you, in either direction.

You can also end a rental early. Stop and refund in the rental card shuts the machine down and sends back the hours you did not use, priced from the same clock that started when the machine came up. The refund goes to the wallet that paid, in USDC on Solana. We do not keep the difference, even though the boot is already paid for on our side.

Renting from code

Everything the website does is a public HTTP call plus a signature from your wallet. There is no account to create and no API key to request: what proves you are you is the same wallet that pays. An agent, a script or another interface can rent a machine exactly the way the page does.

The base is https://app.boogiecompute.com. Cross-origin requests are allowed, so this works from a browser as well as from a server.

One call, if you do not care which machine

Describe the job instead of picking a row. The server filters the same live catalog and prices the best match in one request, so nothing is taken between your choice and your payment.

q = requests.post(f"{API}/api/rent", json={
    "hours": 6,
    "gpu": "A6000",          # optional: model fragment
    "minVramGb": 40,         # optional
    "maxUsdPerHour": 1.5,    # optional
    "country": "US",         # optional
    "template": 1,           # ComfyUI, see /api/templates
    "prefer": "cheapest",    # or fastest, or biggest
    "payer": str(kp.pubkey()),
}).json()

q["machine"]   # what it picked
q["matched"]   # how many machines fit those requirements
q["usd"]       # what it costs

There is a machine-readable description of every call at /api/openapi.json, so tools and agents can read the interface instead of this page.

Picking a machine yourself

The catalog is the same list the site shows. Prices are per hour for the whole machine as configured, and bootSec tells you how long it takes to come up.

import requests

API = "https://app.boogiecompute.com"

listings = requests.get(f"{API}/api/catalog").json()["listings"]
single = [m for m in listings if m["gpuCount"] == 1]
machine = min(single, key=lambda m: m["usdPerHour"])

print(machine["gpu"], machine["region"], machine["usdPerHour"])
# A6000 Des Moines, US 0.72

Binding a key

The signed message contains the key fingerprint and your address, so a signature cannot be reused for another key or another wallet. Compute the fingerprint locally, it is the SHA-256 of the decoded key body. The examples use solders and solana from PyPI.

import base64, hashlib
from solders.keypair import Keypair

kp = Keypair.from_base58_string(open("wallet.txt").read().strip())
address = str(kp.pubkey())

pub = open("~/.ssh/id_ed25519.pub").read().strip()
fp = base64.b64encode(
    hashlib.sha256(base64.b64decode(pub.split()[1])).digest()
).decode().rstrip("=")

message = "\n".join([
    "Boogie", "",
    "Bind this SSH key to your wallet.", "",
    f"Key: SHA256:{fp}",
    f"Wallet: {address}",
])
sig = str(kp.sign_message(message.encode()))   # base58

requests.post(f"{API}/api/keys", json={
    "publicKey": pub, "address": address, "signature": sig,
})

Getting a price

Send the machine id and the hours. Without payer you get a preview with live numbers for every accepted asset. Add payer and pay (USDC, NVDAx, SPYx, QQQx or TSLAx) and the response carries the transaction that pays for it, ready to sign.

q = requests.post(f"{API}/api/quote", json={
    "machineId": machine["id"], "hours": 6,
    "payer": address, "pay": "USDC",
}).json()

q["usd"]          # 5.0
q["options"]      # how much NVDAx, SPYx, QQQx or TSLAx that costs right now
q["tx"]           # base64 versioned transaction, unsigned
q["expiresAt"]    # five minutes from now

Paying

Sign the transaction with the payer key and send it to any Solana RPC. Then report the signature, and the machine starts without waiting for the next sweep. If the network has not shown the transaction yet, the call answers 404 and you try again a few seconds later.

from solders.transaction import VersionedTransaction
from solana.rpc.api import Client

rpc = Client("https://api.mainnet-beta.solana.com")
raw = VersionedTransaction.from_bytes(base64.b64decode(q["tx"]))
signed = VersionedTransaction(raw.message, [kp])
signature = str(rpc.send_raw_transaction(bytes(signed)).value)

r = requests.post(f"{API}/api/provision", json={"signature": signature})
order_id = r.json()["order"]   # ten hex characters, e.g. "3f9a01c2be"

Waiting for the machine

One call waits for you. It holds the connection open until the machine answers and returns the way in, so there is no polling loop to write. If it runs out of time before the machine is up, it says so and you call it again.

while True:
    r = requests.get(f"{API}/api/wait",
                     params={"id": order_id, "address": address},
                     timeout=90).json()
    if r.get("access"):
        print(r["access"]["command"])     # ssh boogie@1.2.3.4
        print(r["workspace"]["url"])      # the workspace, key included
        break

If you would rather poll your orders yourself, that works too. Boot takes minutes, and the hours you paid for do not start until it is up.

while True:
    orders = requests.get(f"{API}/api/orders", params={"address": address}).json()
    order = next(o for o in orders["orders"] if o["id"] == order_id)
    if order["access"]:
        print(order["access"]["command"])   # ssh boogie@1.2.3.4
        break
    time.sleep(30)

When the work is done, either let the rental run out or end it early and take the rest back:

message = "\n".join([
    "Boogie", "",
    f"Stop rental #{order_id} and refund the unused time.",
    f"Wallet: {address}",
])
sig = str(kp.sign_message(message.encode()))

requests.post(f"{API}/api/stop", json={
    "orderId": order_id, "address": address, "signature": sig,
}).json()
# {"order": "3f9a01c2be", "stopped": true, "refundedUsd": 2.49, "tx": "5h3K..."}

Hosting a node

If you have GPUs sitting idle, you can list them and earn on every hour they run. You set the price and the schedule, Boogie brings the demand and handles billing.

Host onboarding is currently a waitlist while we finish the agent that runs on host machines. Join it from the Host a GPU page and we will get in touch in order.

Limits and refunds

• A machine can go busy. Supply is live, so a card can be rented by someone else between the moment you see it and the moment you pay. Checkout refuses the order and reloads the list rather than taking money for a machine that is gone.
• If the datacenter never delivers the machine, the order is cancelled and refunded in USDC without you asking. We give the provider half an hour, which is well past the longest normal boot, and refund after that.
• If an order settles and cannot be filled for any other reason, it is refunded the same way. Refunds are in dollars, not in the stock you paid with, because the equity leg was already sold at payment time.
• If a machine dies mid-rental, the unused hours come back on their own. We only shut machines down when their time is up, so a machine that disappears early is a failure on the provider side, and the refund is sent without you asking for it.
• A rental with no key waits rather than burning. If no SSH key is bound to your wallet, no machine is started and nothing is spent. Bind a key and it starts. If a day passes without one, the order is refunded.
• Rentals are not backups. Storage on a rented machine disappears when the rental ends. Move anything you want to keep before then.

Something missing here? Tell us on X and we will add it.