Guides & Tutorials7 min read

A Free GPU Price API: Live Rental Prices as JSON, No Key

One public URL returns every GPU you can rent on ParalonCloud right now, with the price per hour for the machine and per GPU, on-demand or spot, in stock or not, refreshed every 30 seconds. No key, no signup. Here is what is in it, how to read it from curl, Python and JavaScript, and how to go from a price to a running GPU with a price ceiling.

ParalonCloud GPU price API: live rental prices as JSON

What does a GPU cost right now? On ParalonCloud the answer is one public URL:

https://paraloncloud.com/pricing-api/offers

No key, no signup, no rate card in a PDF. It returns every machine shape you can rent on the network at this moment, at the price you would pay this minute, and it is rebuilt every 30 seconds. Price comparison sites already read it. You can put it in a script, a dashboard, a Discord bot or an AI agent that has to pick a GPU.

These are our own prices, the marketplace's: GPUs from independent owners and data centers, each one verified by our agent before it rents, billed per minute. It is not a cross-provider comparison. If you build one of those, this is the feed to add us with.

Read it in one line

curl -s https://paraloncloud.com/pricing-api/offers | jq '.offers[] | select(.in_stock) | {gpu, gpus, spot, price_per_hour_usd, url}'

Each line of offers is a machine shape: a GPU model, how many of it the machine has, and whether it is on-demand or spot. "1 x RTX 4090" and "2 x RTX 4090" are separate lines, because you rent a machine, and a machine with two cards costs what two cards cost. Here is what the RTX 4090 lines looked like when we wrote this:

{
  "gpu": "RTX 4090",
  "name": "NVIDIA GeForce RTX 4090",
  "gpus": 1,
  "vram_gb": 24,
  "price_per_gpu_hour_usd": 0.4,
  "price_per_hour_usd": 0.4,
  "in_stock": true,
  "spot": true,
  "url": "https://paraloncloud.com/rent/browse?gpu=RTX+4090&gpus=1&kind=spot",
  "info_url": "https://paraloncloud.com/pricing/rtx-4090"
}

The same card on demand was $0.50 an hour, and a two-card RTX 4090 machine $0.94 (out of stock at that minute). Prices move: owners set their own, and the feed shows the cheapest free machine of each shape.

What every field means

FieldMeaning
gpu / nameShort and full GPU name.
gpusCards in the machine.
vram_gbMemory per card, not per machine.
price_per_hour_usdWhat the whole machine costs per hour, billed per minute.
price_per_gpu_hour_usdThe same, divided by the cards: the number to compare across providers.
in_stocktrue when a machine of this shape is free this minute. When false, the price is the list price of its cards.
spottrue for a spot machine: cheaper, but its owner can take it back with two minutes' notice. Spot and on-demand are always separate lines, so an on-demand line never shows a spot price.
urlWhere a click should go. In stock: the rent page filtered to this exact shape. Out of stock: the GPU's page.
info_urlThe GPU's page: specs, price and a Rent button.

The header says the rest once: currency (USD), billing ("per minute, no minimum, no contract"), and updated_at, the moment these prices were read. The response carries Cache-Control: max-age=30, so polling faster than every 30 seconds gets you the same answer.

The feed also lists our inference models under models, priced per million tokens (input_per_million_usd, output_per_million_usd, context_length), for anyone comparing LLM API prices.

Find the cheapest GPU that fits, in Python

import requests

feed = requests.get("https://paraloncloud.com/pricing-api/offers", timeout=10).json()

# On-demand machines free right now with at least 24 GB per card, cheapest first
fits = [o for o in feed["offers"]
        if o["in_stock"] and not o["spot"] and o["vram_gb"] >= 24]
fits.sort(key=lambda o: o["price_per_gpu_hour_usd"])

for o in fits[:5]:
    print(f'{o["gpus"]} x {o["gpu"]:<12} ${o["price_per_hour_usd"]:.2f}/h  {o["url"]}')

Swap vram_gb >= 24 for what your job needs: 16 GB runs most 7B to 8B models in 4 bit, 24 GB a 13B or Flux, 48 GB and up a 70B quantised. Drop not o["spot"] when the job can survive a restart.

Or in JavaScript, in the browser

The feed sends Access-Control-Allow-Origin: *, so a static page can read it directly:

const { offers, updated_at } = await (await fetch("https://paraloncloud.com/pricing-api/offers")).json();
const cheapest = offers
  .filter(o => o.in_stock && o.gpu === "RTX 4090")
  .sort((a, b) => a.price_per_gpu_hour_usd - b.price_per_gpu_hour_usd)[0];

console.log(cheapest ? `RTX 4090 from $${cheapest.price_per_gpu_hour_usd}/h` : "No RTX 4090 free right now", updated_at);

From a price to a running GPU, without paying more than you read

A price list is half the job. The other half is renting what you found, from the same code, and being sure the price did not change in between. That is what the Rental API is for: GET /api/v1/gpus lists the actual machines (by node_id, with country, CUDA compute capability and which apps they can start), and POST /api/v1/rentals starts one.

Send the price you read as max_price_per_hour. If the owner raised it in the seconds between your read and your request, the API answers 409 price_changed with the new price, and nothing is started or charged:

import os, requests

API = "https://paraloncloud.com/api/v1"
H = {"Authorization": f"Bearer {os.environ['PARALON_API_KEY']}"}

gpus = requests.get(f"{API}/gpus", headers=H, timeout=10).json()["gpus"]
rtx4090 = [g for g in gpus
           if not g["spot"] and any("RTX 4090" in c["model"] for c in g["gpus"])]
node = min(rtx4090, key=lambda g: g["price_per_hour"])

r = requests.post(f"{API}/rentals", headers=H, timeout=30, json={
    "node_id": node["node_id"],
    "type": "jupyter",
    "hours": 2,                                  # stops itself after two hours
    "max_price_per_hour": node["price_per_hour"],
})
if r.status_code == 409 and r.json().get("error") == "price_changed":
    print("Price went up to", r.json()["price_per_hour"], "- not renting")
else:
    print(r.json())   # rental_id; poll GET /rentals/{id} for the JupyterLab URL

The rental then bills at that price for its whole life, whatever the owner does next. The key needs the rental scope; you make one in API keys. The full flow (polling for the URL, SSH instead of Jupyter, starting with ComfyUI or Open WebUI installed) is in Manage rentals.

For AI agents. An agent that compares and rents GPUs needs exactly these two steps: a price it can trust, and a rent call that cannot overspend. Our MCP server gives Claude, Cursor and other MCP clients list_gpus and create_rental directly; the REST calls above work from any agent framework.

Using the feed on your site

Use it as much as you like: it is free, needs no key, and a request costs us almost nothing because every answer comes from the same 30-second snapshot. The feed says so itself in terms. What we ask is in attribution: link each offer to its url. That link already points where your visitor wants to go: the machines of that shape that are free right now, or the GPU's page when none is.

If you run a price comparison site and need a field we do not have, or a different format, tell us. Spot and on-demand became separate lines because a price data site asked for it.

What the feed never says

How many machines there are, or how many are rented. in_stock tells you whether you can rent a shape this minute, which is what a buyer needs; the size of the network is ours to keep. Machines kept private for one customer, and machines with mixed GPU models, are not listed.

FAQ

Is the GPU price API free? Yes. No key, no signup, no daily cap. The answer changes every 30 seconds, so polling more often than that returns the same prices.

How fresh are the prices? At most 30 seconds old; updated_at says exactly when they were read. The price you pay is set when the rental starts, and max_price_per_hour makes sure it is never above what you read.

Is it the price per GPU or per machine? Both: price_per_hour_usd is the machine, price_per_gpu_hour_usd is per card. Compare providers on the per-GPU figure.

Does it include other providers' prices? No, only what you can rent on ParalonCloud. Aggregators combine feeds like this one from many providers.

What is the difference between spot and on-demand here? A spot machine is cheaper, and its owner can take it back with two minutes' notice; an on-demand one is yours until you stop it. They are always separate lines.

Is there a price API for LLM inference too? Yes, the same response lists our models under models, with the price per million input and output tokens.

On the network

A GPU with JupyterLab on it, in about a minute

Billed for the minutes it runs, on a machine we benchmarked before listing it. Or call open models through an OpenAI-compatible API.

Keep reading

Related articles