---
sidebar_position: 9
title: Pricing Pages and Price Feed
description: The public GPU price surfaces on lium.io — the /pricing hub, one page per GPU model at /gpu/<slug>, the per-model JSON feed at /pricing.json, and the markdown twin every one of them serves to agents. No account, no key.
---

> ## Documentation Index
> Fetch the complete documentation index at: https://docs.lium.io/llms.txt
> Use this file to discover all available pages before exploring further.

# Pricing Pages and Price Feed

What a GPU costs on Lium is public. Three surfaces on `lium.io` answer "what does an H200 cost right now" without an account, an API key or a `lium ls`:

| Surface | URL | For |
|---------|-----|-----|
| Pricing hub — every GPU model, grouped by class, with the live price range and how many pods are rentable | [`https://lium.io/pricing`](https://lium.io/pricing) | people, search engines, agents (markdown twin) |
| One page per GPU model | `https://lium.io/gpu/<slug>` — e.g. [`/gpu/h100`](https://lium.io/gpu/h100), [`/gpu/b200`](https://lium.io/gpu/b200), [`/gpu/h200`](https://lium.io/gpu/h200) | the same, per model |
| Per-model price feed, JSON | [`https://lium.io/pricing.json`](https://lium.io/pricing.json) | aggregators, comparison sites, agents |

The hub, the generated model pages and the feed render from the same model list, and each URL is cached for an hour, so the number an aggregator shows from `pricing.json` and the number on the page it links to differ by at most one CDN revalidation. The per-node rows behind those numbers are the [Public Nodes Feed](./public-nodes-feed.md).

## `/pricing.json`

```bash
curl -sSL https://lium.io/pricing.json
```

```json
{
  "generated_at": "2026-09-07T09:32:29.120Z",
  "unit": "USD per GPU-hour",
  "nodes_url": "https://lium.io/api/public/v1/nodes",
  "count": 91,
  "models": [
    {
      "model": "NVIDIA H100 80GB HBM3",
      "gpu_model": "H100 80GB HBM3",
      "name": "H100 80GB HBM3",
      "slug": "h100-80gb-hbm3",
      "url": "https://lium.io/gpu/h100",
      "gpu_class": "datacenter",
      "reference_price_usd_per_gpu_hour": 1.49,
      "min_price_usd_per_gpu_hour": 1.2,
      "max_price_usd_per_gpu_hour": 2.75,
      "available_nodes": 20,
      "available_gpus": 56,
      "vram_gb": 80,
      "architecture": "hopper",
      "browse_url": "https://lium.io/?gpu=NVIDIA%20H100%2080GB%20HBM3",
      "updated_at": "2026-09-07T09:32:29.120Z"
    }
  ]
}
```

| Field | Meaning |
|-------|---------|
| `generated_at` | When the prices were read (ISO 8601). The feed is cached at the CDN for an hour (`s-maxage=3600`, with `stale-while-revalidate=86400`, so a copy just past the hour can still be served while the CDN refreshes it); this is the age of the numbers, not of the HTTP response. |
| `unit` | Always `USD per GPU-hour`. Every price in the file is per GPU, per hour. |
| `nodes_url` | The [Public Nodes Feed](./public-nodes-feed.md) — one row per node with the same prices, if you want rows instead of models. |
| `count` | Number of entries in `models`. |
| `models[].model` | Full machine name (`NVIDIA H100 80GB HBM3`). |
| `models[].gpu_model` | The same string the nodes feed uses in its `gpu_model` field — the join key between the two feeds. |
| `models[].name` | Display name. |
| `models[].slug` | URL slug of the model. |
| `models[].url` | The page for this model. Models covered by a landing page point at it — both H100 form factors resolve to `/gpu/h100`. |
| `models[].gpu_class` | `datacenter`, `professional` or `consumer`. The nodes feed's `tier` means Secure/Spot, so the class has its own name here. |
| `models[].reference_price_usd_per_gpu_hour` | Lium's reference price for the model — the `machine_prices` entry of the public `GET https://lium.io/api/v1/shared-config`. Present for every model, including ones with no pod available. |
| `models[].min_price_usd_per_gpu_hour`, `max_price_usd_per_gpu_hour` | Cheapest and dearest live ask across the pods rentable right now. With one pod they are equal; with none they both fall back to the reference price, which the pages show as a single figure. |
| `models[].available_nodes`, `available_gpus` | Rentable nodes and GPUs at `generated_at`. `0` when nothing is available — the model stays in the file with its reference price. |
| `models[].vram_gb`, `architecture` | Per-GPU memory (`null` when the model is not in the spec table) and architecture family (`null` when the shared config has no entry for it). |
| `models[].browse_url` | Browse Pods on lium.io filtered to this model — the rent-now link. |
| `models[].updated_at` | Same instant as `generated_at`. |

The feed is a contract: fields are only ever added, never renamed or removed. Ingest it on a schedule (prices move as providers reprice and pods come and go); the rows behind each model are in the nodes feed, with location, per-node price and a deploy link.

## `/pricing` and `/gpu/<slug>`

The hub lists every model in `pricing.json` grouped by `gpu_class`, with its price range and availability, and links each row to its model page; the markdown twin links each row to Browse Pods filtered on it instead. A generated model page shows the same numbers for one model, its specs, how many pods are rentable now with a link to browse them, and related models.

`<slug>` is `models[].slug` from the feed. Two landing pages are hand-written — [`/gpu/h100`](https://lium.io/gpu/h100) (covers `H100 80GB HBM3` and `H100 PCIe`) and [`/gpu/b200`](https://lium.io/gpu/b200) — every other model gets a generated pricing page at its slug. A slug the landing page covers redirects to it (`/gpu/h100-pcie` → `/gpu/h100`, HTTP 308); an unknown slug is a 404. [`https://lium.io/sitemap.xml`](https://lium.io/sitemap.xml) lists the landing pages plus the current indexing batch of model pages, not all of them.

## Markdown for agents

`/`, `/pricing` and every `/gpu/<slug>` page have a markdown twin. Ask for it with the `Accept` header — rank `text/markdown` above `text/html` and you get the same prices as a markdown table, no HTML to parse:

```bash
curl -sSL -H 'Accept: text/markdown' https://lium.io/pricing
curl -sSL -H 'Accept: text/markdown' https://lium.io/gpu/h200
```

```text
# Lium — GPU rental marketplace

...

## Prices right now

### Data center

| GPU | $ / GPU / hour | Rentable now |
| --- | --- | --- |
| [B200](https://lium.io/?gpu=NVIDIA%20B200) | $5.50 – $6.53 | 5 pods · 19 GPUs |
| [H200](https://lium.io/?gpu=NVIDIA%20H200) | $2.75 – $4.23 | 10 pods · 29 GPUs |
```

Negotiation follows RFC 9110: a tie, a bare `*/*` or no `Accept` header returns HTML, the canonical representation; a header that rules out both (`Accept: application/json`) gets `406 Not Acceptable` with a markdown body that lists the URLs that do answer. Responses carry `Vary: Accept`, so a shared cache never hands an agent the HTML it stored for a browser. The redirects and 404s are the same in both representations: `/gpu/h100-pcie` answers 308 to `/gpu/h100` whichever you ask for.

The docs site does the same for every page here — see [AI Agents](./agents.md#stable-agent-facing-urls) — and `https://lium.io/robots.txt` names `llms.txt`, `pricing.json` and the sitemap for crawlers.

## Related

- [Public Nodes Feed](./public-nodes-feed.md) — per-node rows: price, location, GPU count, deploy link
- [Executor availability WebSocket](./executor-availability-websocket.md) — push updates when nodes appear or are rented
- [AI Agents](./agents.md) — every no-key surface an agent can read, and how to go from no account to a pod