lantern-works/gpu-cloud-prices

Lantern Works GPU Rental Price History

A daily history of per-GPU-hour rental prices from tracked cloud GPU providers (H100, H200, A100, L40S, RTX 4090/5090, RTX A6000, B200 and others), 29 vendors with a ranked price in the latest snapshot. This covers tracked providers only, not the whole market.

Snapshot range: 2026-10-27 to 2026-11-11 (14 daily snapshots). The files hold 224 price series, 446 change points and 159 price changes. No snapshots for 2026-11-07 and 2026-11-08 because the price refresh was down; those days are missing rather than estimated.

Load it

With datasets (three configs: points, changes and daily):

from datasets import load_dataset
daily = load_dataset("lantern-works/gpu-cloud-prices", "daily", split="train").to_pandas()
points = load_dataset("lantern-works/gpu-cloud-prices", "points", split="train").to_pandas()
changes = load_dataset("lantern-works/gpu-cloud-prices", "changes", split="train").to_pandas()

daily is the easiest place to start: one row per price series per snapshot day, already expanded from the change points. Days with no snapshot have no rows, so they are not filled in. For example, the cheapest tracked on-demand H100 on each snapshot day:

od = daily[(daily.gpu_family == "H100") & (daily.pricing_type == "on-demand") & (daily.status == "ranked")]
print(od.loc[od.groupby("date").hourly_usd.idxmin(), ["date", "vendor", "gpu_model", "tier", "hourly_usd"]])

To browse it without code, try the GPU Cloud Prices Explorer Space: pick a GPU and see the cheapest tracked price per snapshot day and the latest prices by vendor.

With pandas only:

import json, urllib.request, pandas as pd
base = "https://huggingface.co/datasets/lantern-works/gpu-cloud-prices/resolve/main/"
points = pd.read_csv(base + "gpu_price_points.csv")
changes = pd.read_csv(base + "gpu_price_changes.csv")
daily = pd.read_csv(base + "gpu_daily.csv")
snapshot_days = [s[:10] for s in json.load(urllib.request.urlopen(base + "history.json"))["snapshot_ids"]]

hourly_usd is always USD per GPU-hour, so it is the column to compare across vendors and billing units.

Example: cheapest tracked H100 on each snapshot day

gpu_price_points.csv stores change points, so a series' price on a day is its latest point on or before that day. This uses only the snapshot days that exist, so the missing days are not filled in.

def as_of(day):
    # each series' latest change point on or before `day`, ranked rows only
    s = points[points.date <= day].sort_values("date").groupby("key").tail(1)
    return s[s.status == "ranked"]

rows = []
for day in snapshot_days:
    h100 = as_of(day)
    h100 = h100[h100.gpu.str.startswith("H100")]
    # to drop interruptible capacity: h100 = h100[~h100.tier.str.contains("spot|interruptible", case=False)]
    best = h100.loc[h100.hourly_usd.idxmin()]
    rows.append({"day": day, "vendor": best.vendor, "gpu": best.gpu, "tier": best.tier, "usd_per_gpu_hour": best.hourly_usd})
print(pd.DataFrame(rows).to_string(index=False))

Swap the gpu filter for "A100", "L40S", "RTX 4090" and so on. gpu keeps vendor variants apart (for example H100, H100 SXM, H100 PCIe, H100 NVL), which is why the example matches on the prefix.

Column dictionary

gpu_price_points.csv (one row per change point):

column	meaning
key	Series id: vendor|gpu|tier|vram_gb|gpu_count
vendor	Provider name as tracked
gpu	GPU model as the vendor lists it (variants such as SXM and PCIe kept separate)
tier	The vendor's offering for this price: on-demand, spot or interruptible, reserved or committed term, marketplace, serverless, or a named instance type
vram_gb	Memory per GPU in GB (blank where the vendor does not state it)
gpu_count	GPUs in the priced unit (for example 8 for an 8-GPU instance)
billing_unit	Unit the vendor bills in: hourly, monthly or per-second
first_seen	First snapshot date the series appeared
date	Snapshot date this price or status took effect
hourly_usd	Normalised price in USD per GPU-hour, before tax, storage and egress
price_usd	Price as read from the vendor page in its billing unit. Depending on the vendor it is per GPU or for the whole unit, so use hourly_usd to compare
status	ranked, held (published but not ranked: stale or too thin a marketplace) or removed (no longer tracked)
verified_at	UTC time the source was last read successfully for this point

gpu_price_changes.csv (one row per price change between consecutive snapshots):

column	meaning
date	Snapshot date the new price was seen
vendor, gpu, tier, vram_gb, key	Same as above
from_hourly_usd, to_hourly_usd	USD per GPU-hour before and after
change_pct	(to - from) / from * 100, rounded to one decimal
status	Series status after the change
source_url	The vendor's own pricing page

gpu_daily.csv (config daily, one row per series per snapshot day; only days with a snapshot appear):

column	meaning
date	Snapshot day
vendor, tier, vram_gb, gpu_count, billing_unit, key	Same as above
gpu_model	GPU model as the vendor lists it (same as gpu above)
gpu_family	gpu_model with SXM, PCIe, NVL and NVLink suffixes dropped, for grouping (for example H100)
hourly_usd, price_usd	The series' price in effect that day (its latest change point on or before the day)
pricing_type	Coarse bucket of tier: on-demand, spot/interruptible, marketplace, serverless, reserved/term or other
interruptible	true when pricing_type is spot/interruptible
status	ranked or held that day (removed series are left out)

After a missing day, the next change row compares against the last snapshot that exists, so it can span more than one day.

Query the live data with an MCP agent

Lantern Works runs a free, read-only MCP server (no API key) over the same live feed this dataset is built from.

Hosted endpoint (nothing to install, 13 tools):

claude mcp add --transport http lantern-works-deals "https://lantern-works-mcp.lantern-works.workers.dev/mcp?ref=hf"

For Claude Desktop, Cursor or VS Code, add https://lantern-works-mcp.lantern-works.workers.dev/mcp?ref=hf as an HTTP MCP server. The hosted endpoint adds four opt-in price-watch tools (create_watch_key, watch_price, list_watches, delete_watch) to the 9 package tools.

Stdio (local, 9 tools, PyPI lantern-works-deals-mcp 0.6.3):

claude mcp add lantern-works-deals -- uvx lantern-works-deals-mcp

or in an MCP client config:

{"mcpServers": {"lantern-works-deals": {"command": "uvx", "args": ["lantern-works-deals-mcp"]}}}

Package tools: compare_gpu_prices, get_price_changes, estimate_job_cost, rebuild_quote, optimize_stack, optimize_agent_stack (estimates a monthly stack cost from a plain-text agent description), search_deals, compare_deals, get_deal.

Example prompt:

Find the cheapest tracked H100 rental, estimate a 100-hour run on it, and tell me whether that rate changed since yesterday. Show the vendor source and check time for each price.

Files

• gpu_price_points.csv: one row per change point, the first snapshot date at each price or status for a series. See the column dictionary above.
• gpu_price_changes.csv: price changes between consecutive snapshots.
• gpu_daily.csv: one row per series per snapshot day (see below).
• history.json: the raw upstream file, including snapshot_ids (the days that have a snapshot).

Live feeds

• Current prices: https://thelanternworks.com/api/v1/gpu-prices.json?ref=hf
• Changes since yesterday: https://thelanternworks.com/api/v1/gpu-price-changes.json?ref=hf
• Upstream history: https://thelanternworks.com/api/v1/gpu-prices/history.json?ref=hf

In a notebook:

import json, urllib.request
feed = json.load(urllib.request.urlopen("https://thelanternworks.com/api/v1/gpu-prices.json?ref=hf"))
h100 = sorted((r for r in feed["rates"] if r["canonical_model"] == "H100"), key=lambda r: r["hourly_equiv_usd"])

Sources and method

• Each rate comes from the vendor's own pricing page or API (source_url). A scheduled job re-reads each source (robots.txt respected) and updates a price only where it parsed one. Days the job did not run have no snapshot. A rate not re-verified for 7 days is held and not ranked.
• Prices are list prices before tax, storage and egress. Check the vendor page before you pay.
• Some vendor links on the Lantern Works site and in MCP results may be referral links. They are labelled, and they do not affect which prices are listed or how they are ranked. source_url in these files is always the vendor's own pricing page.

Update cadence

Upstream is scheduled to refresh once a day at about 10:23 UTC; days it misses are left as gaps. This dataset copy is a snapshot and can lag the live feed until it is re-published.

License

The price data is licensed CC BY 4.0 (https://creativecommons.org/licenses/by/4.0/). Credit: Lantern Works (https://thelanternworks.com/?ref=hf). Prices are factual quotes from the vendors' public pages. The MCP server code is MIT.

How to cite

Credit "Lantern Works GPU Rental Price History" with a link, as CC BY 4.0 requires. For papers:

@misc{lanternworks_gpu_prices,
  title  = {Lantern Works GPU Rental Price History},
  author = {{Lantern Works}},
  year   = {2026},
  note   = {Snapshots 2026-10-27 to 2026-11-11, CC BY 4.0},
  url    = {https://huggingface.co/datasets/lantern-works/gpu-cloud-prices}
}

More from Lantern Works

• Site with live GPU price pages and comparisons: https://thelanternworks.com/?ref=hf
• Receipts, dated test summaries of the Lantern Works MCP server: https://thelanternworks.com/receipts/?ref=hf
• Install guide: https://thelanternworks.com/install/?ref=hf