There is a price gap hiding in plain sight in the AI economy. A renter who needs an RTX 4090 for an overnight training run can pay a big cloud provider’s list price — or rent the same silicon, by the hour, from an anonymous host on a peer-to-peer marketplace at roughly half the cost. The renter saves money. The host earns it. If you own the right card and your electricity is cheap, you are the spread.

This is hardware-backed arbitrage: buy GPU-hours at used-hardware prices plus your local power rate, sell them into a market priced against big-cloud list rates. It needs capital (a used card is a four-figure purchase), it needs honesty about occupancy, and it can be modeled precisely before you spend a dollar. Below: the verified numbers on both sides of the gap, the failure modes that eat margins, and a tested Python spread desk that pulls live marketplace prices and tells you whether the trade is on or dead — today, with your electricity rate.

The two sides of the spread

The retail side (what renters pay big clouds): Runpod lists on-demand RTX 4090 instances from $0.34/hr on its own GPU page. The AmCompute price index, which tracks provider pricing pages directly, shows RTX 4090 on-demand list prices across seven providers ranging $0.33/hr (SaladCloud) to $0.89/hr (Runpod’s own list on the index), updated October 2026. Stepping up the stack, entry-tier A100 40GB cloud instances have historically listed around $1.35/hr — and if that figure matters to your decision, verify it on the provider’s current calculator before you commit, because datacenter list prices move quarterly.

The marketplace side (what renters pay individual hosts): we queried the public Vast.ai search API — no key, no login — for verified, rentable single-GPU offers on November 3–4, 2026. The medians:

GPULive verified offersMedian $/hrCheapest $/hr
RTX 409046$0.469$0.362
RTX 309031$0.254$0.148
RTX 509047$0.937$0.476
A100 PCIE6$0.756$0.403

Note the tail: verified H100 SXM offers showed a median near $4.47/hr with an ask as low as $2.27 — the AWS list price for an H100 node runs to five figures per month. That is the same pattern repeating at every tier of the market: someone, somewhere, is selling compute at 40–70% below the rack rate. Not because the hardware is fake — verified offers carry Vast’s benchmark-validated badge — but because the seller’s cost basis is a used card on a shelf, not a colocation contract with an SLA attached.

Why the gap exists (and why it persists)

Big clouds bundle: guaranteed uptime, enterprise networking, compliance paperwork, and a sales team. That bundle costs money, so an H100-hour through a hyperscaler is priced for CFOs. A host on Vast.ai, by contrast, is a person whose card would otherwise be idle. Their marginal cost is electricity — roughly $0.10/kWh in Indonesia (ASEAN survey, 2026) versus an average 18+ cents/kWh residential in the US (EIA-based estimates, 2026). Same GPU-hour, radically different cost basis. As long as both markets exist, the spread exists.

It persists because arbitrage here is not frictionless. You cannot buy a card today and profit tomorrow; you must survive setup costs, host reputation mechanics, and the fact that your rental income stops the instant your machine hiccups. That friction is exactly why the margin survives — and exactly what the desk below is built to quantify before you commit hardware.

The economics: what a hosted card actually nets

Hosting income is a function of four honest numbers:

  1. Rate you can list at. Anchor to marketplace median for your card, not the lucky outlier.
  2. Occupancy. The fraction of hours a renter is actually paying. Community discussion and host reports put realistic sustained occupancy anywhere from ~30% to 70%+ depending on card, price, and reputation. A used RTX 3090 at median pricing is a commodity listing; assume commodity occupancy (~60%) until your listing proves otherwise.
  3. Electricity burn. A 3090 rig pulls roughly 350W at load for the card plus ~100W for CPU/RAM/fans, 24/7 — rented or not.
  4. Platform cut. Vast.ai’s commission is not published as a single number; third-party analyses place it anywhere from ~3% to ~15% depending on program tier and era. Model 13% and treat anything better as upside.

Run the math at 62% occupancy, 450W total draw, $0.096/kWh, 13% cut: a median-priced RTX 3090 listing nets roughly $65/month; the same assumptions on an RTX 5090 listing (which commands 3.7x the median rate) net roughly $337/month, with hardware cost obviously much higher. Payback on a $1,650 one-card rig (used 3090 at ~$1,199 tracked used price as of November 2026, plus ~$450 PSU/frame/board share) lands around two years at conservative occupancy — or under a year if you already own the card, since the setup cost is then near zero and every net dollar is found money.

That last line is the real entry point: the trade is violently better for people with idle hardware. A gaming rig that runs 20 hours a week has an asset on the desk earning nothing for the other 148 hours. Listing it converts dead capital into yield with zero marginal capex.

The risks that eat the margin

Interruption and reputation. The economics assume your machine is up, but renters rent by the hour and abandon flaky listings within days — their failures cost them pennies, yours cost you the listing. A machine that reboots, drops connectivity, or fails Vast’s verification checks gets bad reviews and stops being rented — occupancy is the whole business, and reputation is how you keep it. Verified host status exists precisely because renters pay a premium for reliability; the premium is worth $0.05–$0.15/hr on comparable listings.

Hardware wear at 100% duty cycle. A card running folding loads 24/7 ages like a taxi, not a weekend car. Fan bearings, thermal paste, and VRAM thermals all degrade. Budget for a fan replacement and a repaste per year of heavy hosting — tens of dollars, but it comes out of yield.

Price decay. GPU rental rates trend down as newer generations ship. A 3090 that lists at $0.25/hr today will list lower after the next generation saturates the marketplace. Your payback model should assume the rate you start with is the best rate you’ll see.

Buyer-side exposure (the grey-area angle). The flip side of this market is renting cheap verified compute and reselling the output — batch inference, fine-tuning jobs, image generation sold at per-image rates that price against big-cloud costs. Renting verified marketplace GPUs at $0.25–0.47/hr to run workloads you’d otherwise run at $1.00+/hr cloud list is the same spread, captured from the demand side, with zero hardware capex and no reputation to build. Most marketplaces’ terms treat compute resale businesses as ordinary commercial use; check the AUP of whichever platform you rent from before building a product on it — the risk is contractual, not legal.

Security. Renters get root-level access to a machine you own. Vast’s sandboxing isolates containers, but treat the host machine as hostile territory: no personal files, no browser sessions, no wallet keys anywhere near the rig. If you wouldn’t run it on a sketchy public PC, don’t have it on the host.

The spread desk: tested code

The script below is a decision tool, not a toy. It queries the live Vast.ai API for verified offers per card, compares medians against verified retail list prices, computes net monthly income and payback from your numbers, and prints a deploy/no-deploy call. It ran clean on this machine on November 3, 2026, against the live API — real output below the code, no mocks needed since the API is public.

#!/usr/bin/env python3
"""GPU Rental Spread Desk.

Pulls live rentable offers from the public Vast.ai search API (no key needed),
compares them against verified retail GPU-cloud list prices, and computes:
  1. the spread you can capture hosting your own card on the marketplace,
  2. net monthly profit after electricity + platform commission,
  3. payback time on the hardware.

Tested 2026-11-03 against the live Vast.ai API.
Only stdlib. Python 3.8+.
"""
import json
import statistics
import sys
import time
import urllib.parse
import urllib.request

VAST_API = "https://console.vast.ai/api/v0/bundles/"

# Verified retail list prices ($/GPU-hour, on-demand, provider pricing pages /
# amcompute index, Oct-Nov 2026). These are what renters pay big-cloud.
RETAIL_REFERENCE = {
    "RTX 4090": 0.34,   # runpod.io on-demand list price
    "RTX 3090": 0.53,   # typical provider list (HPC AI $0.48, Sesterce $0.44-0.55 band)
    "RTX 5090": 0.99,   # low-end neocloud list
    "A100 PCIE": 1.35,  # entry A100 40GB cloud list
}

# Your rig economics - EDIT THESE
ELECTRICITY_KWH = 0.096   # $/kWh - Indonesia residential avg (ASEAN survey, 2026)
CARD_WATTS = 350          # GPU load draw (3090 ~350W)
RIG_OVERHEAD_WATTS = 100  # CPU/RAM/fans/per-card share of idle rig
UPTIME = 0.62             # fraction of hours the card is actually rented (be honest)
PLATFORM_CUT = 0.13       # marketplace commission budget: 3%-15% band, use mid
CARD_USED_COST = 1200     # $ - used RTX 3090, Nov 2026 tracked price
RIG_COST_PER_CARD = 450   # $ - PSU/plate/board/ram share (one-off)


def fetch_vast_offers(gpu_name: str) -> list:
    """Return list of dph_total for rentable+verified single-GPU offers."""
    q = json.dumps({
        "rentable": {"eq": True},
        "verified": {"eq": True},
        "gpu_name": {"eq": gpu_name},
        "num_gpus": {"eq": 1},
    })
    url = VAST_API + "?q=" + urllib.parse.quote(q)
    req = urllib.request.Request(url, headers={"User-Agent": "spread-desk/1.0"})
    last = None
    for attempt in range(4):
        try:
            with urllib.request.urlopen(req, timeout=30) as r:
                data = json.load(r)
        except Exception as ex:
            last = f"HTTP error: {ex}"
            time.sleep(8 * (attempt + 1))
            continue
        if isinstance(data, dict) and "offers" in data:
            # NOTE: filtered gpu_name queries omit the "success" key entirely,
            # so presence of "offers" is the real success signal.
            return [o["dph_total"] for o in data["offers"] if o.get("dph_total")]
        last = f"unexpected response keys: {list(data)[:5] if isinstance(data, dict) else type(data)}"
        time.sleep(8 * (attempt + 1))
    raise RuntimeError(f"Vast API failed after retries ({last})")


def model_row(gpu: str) -> dict:
    prices = fetch_vast_offers(gpu)
    if len(prices) < 5:
        raise RuntimeError(f"{gpu}: only {len(prices)} live offers - thin market, skip")
    med = statistics.median(prices)
    retail = RETAIL_REFERENCE[gpu]
    return {"gpu": gpu, "n": len(prices), "min": min(prices),
            "median": med, "retail": retail, "spread": retail - med}


def economics(row: dict, uptime: float = None) -> dict:
    u = UPTIME if uptime is None else uptime
    kw = (CARD_WATTS + RIG_OVERHEAD_WATTS) / 1000.0
    burn = kw * ELECTRICITY_KWH                      # $/hr rig burn
    rev_h = row["median"] * u                        # $/hr expected revenue
    net_h = rev_h * (1 - PLATFORM_CUT) - burn        # $/hr net
    capex = CARD_USED_COST + RIG_COST_PER_CARD
    return {
        "burn_hr": burn, "rev_mo": rev_h * 730, "elec_mo": burn * 730,
        "net_mo": net_h * 730, "capex": capex,
        "payback_mo": capex / (net_h * 730) if net_h > 0 else None,
    }


def main() -> int:
    print("=" * 78)
    print(f"{'GPU':<12}{'offers':>7}{'min $/h':>9}{'med $/h':>9}"
          f"{'retail':>8}{'spread':>9}{'net $/mo':>10}{'payback':>10}")
    print("=" * 78)
    rows, any_positive = [], False
    for gpu in RETAIL_REFERENCE:
        time.sleep(3)  # be polite to the public API
        try:
            r = model_row(gpu)
        except Exception as e:  # network/API failure must not crash the desk
            print(f"{gpu:<12}  ERROR: {e}")
            continue
        e = economics(r)
        rows.append((r, e))
        pb = f"{e['payback_mo']:.1f} mo" if e["payback_mo"] else "never"
        flag = " <-" if e["net_mo"] > 0 else ""
        if e["net_mo"] > 0:
            any_positive = True
        print(f"{r['gpu']:<12}{r['n']:>7}{r['min']:>9.3f}{r['median']:>9.3f}"
              f"{r['retail']:>8.2f}{r['spread']:>9.3f}{e['net_mo']:>10.0f}{pb:>10}{flag}")

    print("-" * 78)
    print(f"Assumptions: uptime {UPTIME:.0%}, platform cut {PLATFORM_CUT:.0%}, "
          f"power {(CARD_WATTS+RIG_OVERHEAD_WATTS)}W @ ${ELECTRICITY_KWH}/kWh, "
          f"capex ${CARD_USED_COST + RIG_COST_PER_CARD}")
    print("Sensitivity (RTX 3090 net $/mo by occupancy):")
    r3090 = next((r for r, _ in rows if r["gpu"] == "RTX 3090"), None)
    if r3090:
        for u in (0.40, 0.60, 0.80):
            e = economics(r3090, uptime=u)
            pb = f"{e['payback_mo']:.0f}" if e["payback_mo"] else "-"
            print(f"  {u:.0%} occupied -> ${e['net_mo']:.0f}/mo, payback {pb} months")
    if not rows:
        print("No market data - check network/API.")
        return 1
    print(f"\nDecision: {'DEPLOY desk' if any_positive else 'NO trade today - spreads dead'}")
    return 0


if __name__ == "__main__":
    sys.exit(main())

Actual output from the test run on November 3, 2026 (exit code 0, live API data):

==============================================================================
GPU          offers  min $/h  med $/h  retail   spread  net $/mo   payback
==============================================================================
RTX 4090         46    0.362    0.469    0.34   -0.129       153   10.8 mo <-
RTX 3090         31    0.148    0.254    0.53    0.276        68   24.1 mo <-
RTX 5090         47    0.476    0.937    0.99    0.053       337    4.9 mo <-
A100 PCIE         6    0.403    0.756    1.35    0.594       266    6.2 mo <-
------------------------------------------------------------------------------
Assumptions: uptime 62%, platform cut 13%, power 450W @ $0.096/kWh, capex $1650
Sensitivity (RTX 3090 net $/mo by occupancy):
  40% occupied -> $33/mo, payback 50 months
  60% occupied -> $65/mo, payback 25 months
  80% occupied -> $97/mo, payback 17 months

Decision: DEPLOY desk

Read the table like a trader, not a fanboy. Two things jump out. First, the RTX 4090 row: the marketplace median ($0.469) is above the cheapest retail list price ($0.34) — that spread is negative against the best retail anchor, and the desk flags it honestly. A 4090 host is competing with Runpod’s own list price, which caps what renters will pay. (Hosting one still nets cash at these assumptions — $153/month — because the median renter is not shopping purely on the single cheapest list price. But the edge is thinner than the 3090’s.) Second, the payback column for rows above the RTX 3090 assumes the 3090’s $1,650 capex baseline — an RTX 5090 costs far more used, so ignore that column for rows where the card name doesn’t match the configured CARD_USED_COST. The net/month figures are capex-independent and valid per-card.

Scaling: from one card to a rack

The desk’s assumptions module is where the strategy lives. Multi-card rigs amortize the overhead — one host machine, one 1600W PSU (a standard mining-rig component, still commodity-priced on eBay), can serve 2–4 consumer cards, pushing per-card overhead watts down and per-card net up. The arithmetic the desk doesn’t do for you: mining-era infrastructure is liquid. Open-air frames, server PSUs, and riser boards built for 2017’s Ethereum rush are cheap on eBay exactly because nobody needs them for mining anymore — and they’re purpose-built for the exact duty cycle GPU hosting demands.

The demand-side scaling is faster still. If you rent five verified 5090-class GPUs at ~$0.94/hr for a batch-inference workload and sell its output per-image at rates anchored to $1.00+/hr cloud pricing, you’ve built the same spread with zero capex and can scale it up or down by the hour. The host-side play is a bond (capex, slow payback, hardware risk); the rent-side play is an option (no capex, immediate margin, contractual-risk only). Aggressive money does both: rent-side for cash flow today, host-side for yield on capital once the desk proves occupancy on your listing.

How to actually start

  1. Run the desk first. Set ELECTRICITY_KWH to your real rate and your target card. If the deploy line says dead, believe it.
  2. Check your hardware honestly. 24GB VRAM (3090/4090-tier) is the rental sweet spot — big enough for serious LLM fine-tuning, cheap enough to be commodity-priced. Cards below 16GB struggle to find renters.
  3. Trial-list before you build. If you own a candidate card, list it on Vast.ai at median pricing for two weeks. Your actual occupancy number replaces the 62% assumption, and the desk reruns with reality.
  4. Host-side hardening. Dedicated machine or dual-boot, nothing personal on the disk, and complete Vast’s verification flow — verified listings command the premium that makes the spread real.
  5. Rent-side immediately if capital is tight. The same API powers the rent side: query the cheapest verified offers for your workload’s VRAM needs, and price your output against retail anchors. The desk’s RETAIL_REFERENCE table is literally your pricing sheet.

The meta-lesson generalizes: wherever a marketplace prices by the hour and a cloud prices by the list, someone is monetizing the difference. The GPU version is unusually measurable — the APIs are public, the math is a four-variable model, and you can know before you spend whether the trade pays. That is more than can be said for most “passive income” on the internet.

Numbers verified November 3–4, 2026: marketplace medians from live Vast.ai API queries (exit-0 test run); retail anchors from Runpod’s RTX 4090 page and the AmCompute October 2026 index; used 3090 pricing from BestValueGPU’s tracked history; electricity rates from ASEAN and US EIA-based 2026 estimates; platform-cut band from third-party marketplace analyses. Rates move — rerun the desk before any commitment.