Marketplace API

A free, public, unauthenticated endpoint that returns live GPU rental pricing and availability across nine cloud providers.

Aquanode is a platform for renting GPUs across multiple cloud providers and moving your environment between them. Its marketplace aggregates live GPU offers — price, availability, region, and specs — from every provider it integrates with. That aggregated feed is exposed as one free, public, unauthenticated API endpoint.

Endpoint

GET https://server.aquanode.io/api/v1/marketplace

No account and no API key

This endpoint requires no authentication, no API key, and no signup. It returns a plain HTTP 200 with a JSON body. It returns no rate-limit headers, which is not a guarantee that no rate limiting applies — be reasonable about polling frequency.

Not browser-callable

The endpoint does not send an Access-Control-Allow-Origin header, so a cross-origin browser fetch() from a web page will be blocked by CORS. Call it from a server, a CLI, a script, or any other non-browser HTTP client instead.

Example request

curl -s https://server.aquanode.io/api/v1/marketplace | jq

Example response

The real response currently lists offers across nine providers — akash, datacrunch, hotaisle, hyperstack, massecompute, runpod, simplepod, vastai, and vultr — and the number of offers and providers changes as capacity comes and goes. Below is a trimmed excerpt with three real offers kept as-is:

{
  "success": true,
  "data": [
    {
      "address": "secure|NVIDIA B200|1",
      "type": "instant",
      "location_id": "EU-RO-1",
      "cloud_type": "secure",
      "available": 1,
      "gpuCount": 1,
      "gpuShortName": "B200",
      "availableCpu": 2,
      "availableMemory": { "value": 8, "unit": "GB" },
      "availableStorage": { "value": 100, "unit": "GB" },
      "interface": "",
      "gpuVendor": "B200",
      "gpuVendorFamily": "nvidia",
      "gpuArchitecture": "Blackwell",
      "gpuMemory": "180GB",
      "isPersistent": false,
      "price": 6.79,
      "region": "EU-RO-1",
      "provider": "runpod",
      "providerId": "secure|NVIDIA B200|1",
      "storagePerGpu": 100,
      "cpuCoresPerGpu": 2,
      "ramPerGpu": 8,
      "providerName": "runpod"
    },
    {
      "address": "akash1hgulk6aekakqzc0v6wukrd3dy9n90f5gkl4ezk/p4",
      "type": "spot",
      "location_id": "akash1hgulk6aekakqzc0v6wukrd3dy9n90f5gkl4ezk",
      "cloud_type": null,
      "available": 2,
      "gpuCount": 2,
      "gpuShortName": "P4",
      "availableCpu": 437,
      "availableMemory": { "value": 5868, "unit": "GB" },
      "availableStorage": { "value": 4807, "unit": "GB" },
      "interface": "PCIe",
      "gpuVendor": "p4",
      "gpuVendorFamily": null,
      "gpuArchitecture": null,
      "gpuMemory": "8Gi",
      "isPersistent": false,
      "price": 0.0315,
      "region": "LIS",
      "provider": "akash",
      "providerId": "akash1hgulk6aekakqzc0v6wukrd3dy9n90f5gkl4ezk/p4",
      "storagePerGpu": 2403.5,
      "cpuCoresPerGpu": 218.5,
      "ramPerGpu": 2934,
      "providerName": "akash"
    }
  ],
  "message": "Marketplace data retrieved successfully",
  "timestamp": "2026-08-28T19:18:46.464Z"
}

Response envelope

Field	Type	Description
`success`	boolean	Whether the request succeeded. Always `true` on a 200.
`data`	array	The list of offers. See below.
`message`	string	A short human-readable status message.
`timestamp`	string	ISO 8601 time the response was generated.

Offer object fields

Every element of data is one rentable offer from one provider. Not every field is populated by every provider — several are null or an empty string for providers that don't report that detail. Read price carefully; its unit depends on the provider (explained below the table).

Field	Type	Description
`address`	string	Provider-internal offer identifier. Format varies by provider (e.g. a RunPod tier/model/index tuple, an Akash address/model pair, or a bare Vast.ai listing id). Identical to `providerId`.
`type`	string	One of `instant`, `on-demand`, `spot`, `docker`, observed across the current sample. Meaning varies by provider (e.g. Akash's decentralized listings come back as `spot`).
`location_id`	string	Provider-specific location/region code. Can be an empty string when the provider gives no location.
`cloud_type`	string \| null	`"secure"` or `"community"` for RunPod (its Secure Cloud vs. Community Cloud tiers); `null` for every other provider.
`available`	number	Count of matching units currently available at this offer.
`gpuCount`	number	Number of GPUs bundled into this one offer.
`gpuShortName`	string	Compact GPU model name, e.g. `"B200"`, `"RTX4090"`.
`availableCpu`	number	Available vCPU cores.
`availableMemory`	`{ value, unit }`	System RAM, e.g. `{ "value": 8, "unit": "GB" }`.
`availableStorage`	`{ value, unit }`	Disk, e.g. `{ "value": 100, "unit": "GB" }`. Equals `storagePerGpu * gpuCount`.
`interface`	string	GPU form factor / bus, e.g. `"SXM5"`, `"PCIe 4.0 x16"`. Often an empty string when the provider doesn't report it.
`gpuVendor`	string	Despite the name, this holds the provider's own GPU model/variant string, not a manufacturer — e.g. `"B200"`, `"B200-SXM"`, `"RTX 4090"`, or a lowercase `"p4"` for Akash. Format is inconsistent across providers; use `gpuShortName` for a normalized model name.
`gpuVendorFamily`	string \| null	The actual manufacturer family, e.g. `"nvidia"`. `null` for providers that don't report it (observed for Akash).
`gpuArchitecture`	string \| null	GPU architecture, e.g. `"Blackwell"`, `"Ampere"`. `null` when the provider doesn't report it (observed for Akash).
`gpuMemory`	string	GPU VRAM as a free-text string, e.g. `"180GB"` or, for Akash, Kubernetes-style `"8Gi"`. Can be an empty string.
`isPersistent`	boolean	Whether storage persists across restarts. Observed as `false` on every offer in the current feed; treat this field as provider-reported and not independently verified beyond that.
`price`	number	USD per hour. For every provider except Akash, this is the price for the whole offer (all `gpuCount` GPUs combined) — divide by `gpuCount` for a per-GPU-hour figure. For Akash, `price` is already a flat per-GPU rate. See below.
`region`	string	Human-readable region. Can be `"unknown"` when `location_id` is empty.
`provider`	string	Provider slug: one of `akash`, `datacrunch`, `hotaisle`, `hyperstack`, `massecompute`, `runpod`, `simplepod`, `vastai`, `vultr`.
`providerId`	string	Identical to `address` in every offer observed.
`storagePerGpu`	number	GB of storage per GPU in this offer.
`cpuCoresPerGpu`	number	vCPU cores per GPU in this offer.
`ramPerGpu`	number	GB of system RAM per GPU in this offer.
`providerName`	string	Identical to `provider` in every offer observed.

price is a total, not a per-GPU rate, for 8 of the 9 providers

price is USD per hour for the whole offer, not per GPU, for every provider except Akash. A 4-GPU offer's price already covers all 4 GPUs; to get the per-GPU-hour cost, divide price by gpuCount. Akash is the one exception: its price is already a flat per-GPU rate, so do not divide it.

What Aquanode is

Aquanode rents GPUs across this same set of providers and lets you move a running environment between them — pause on one provider, resume on another, without rebuilding it by hand. This marketplace endpoint is the same live pricing feed the Aquanode Marketplace and the aq CLI use to pick where to rent from.

For the full private API (deployments, setups, endpoints — all of which require an account and an API key), see the API Reference.