Datasets:

fastgpu
/

cloud-gpu-prices

license: cc-by-4.0
pretty_name: Cloud GPU Rental Prices (FastGPU)
language:
  - en
tags:
  - gpu
  - gpu-pricing
  - cloud-gpu
  - gpu-rental
  - cloud-computing
  - pricing
  - market-data
  - time-series
  - finops
  - h100
  - h200
  - b200
  - a100
  - rtx-4090
  - mi300x
task_categories:
  - time-series-forecasting
size_categories:
  - 10K<n<100K
configs:
  - config_name: current
    data_files: gpu-prices-current.csv
    default: true
  - config_name: daily
    data_files: gpu-prices-daily.csv
  - config_name: fixings
    data_files: gpu-price-fixings.csv

Cloud GPU Rental Prices (FastGPU)

What it costs to rent a GPU in the cloud, per GPU per hour, across marketplaces, neoclouds and hyperscalers. Mirrored here once a day from fastgpu.co/dataset, where the same files are served live and every price links to the provider it came from. Browse the prices themselves at fastgpu.co.

A free, openly licensed dataset of GPU cloud rental prices across the whole market: marketplaces, neoclouds, and hyperscalers. It contains a normalized snapshot of every current live offer (provider, GPU model, VRAM, offer type, region, per-GPU-hour price, availability) plus a daily price time-series with each day's floor, average, and high price per GPU, and a frozen daily fixing per GPU (floor, on-demand median, spot floor and hyperscaler median, never revised). Sourced from live provider feeds and refreshed daily, it is the reference dataset for tracking cloud GPU cost over time, benchmarking providers, and FinOps and AI-infrastructure research. Published by FastGPU under CC BY 4.0.

Snapshot of 2026-10-08 07:22 UTC: 396 offers (396 with a price) from 29 providers across 40 GPU models. Files generated 2026-10-08 07:30 UTC.

Files

Subset	File	Rows	Days	One row is
`current`	gpu-prices-current.csv	396		One live offer: provider, GPU model, offer type, region, price per GPU-hour, the GPUs you must rent for that price, stock, and a link to rent it.
`daily`	gpu-prices-daily.csv	22,700	2026-08-09 to 2026-10-08	One provider's price for one GPU, offer type and region on one UTC day: that day's lowest, average and highest observed price.
`fixings`	gpu-price-fixings.csv	160	2026-10-05 to 2026-10-08	One GPU model on one day at 07:00 UTC: the market floor, the on-demand median, the spot floor and the hyperscaler median, frozen and never revised.

The daily file is a rolling window of the last 60 days. The fixings file keeps every fixing since the first one: a fixing is frozen at 07:00 UTC and never revised, and a day whose run was missed stays missing.

Load it

from datasets import load_dataset

current = load_dataset("fastgpu/cloud-gpu-prices", "current", split="train")
daily = load_dataset("fastgpu/cloud-gpu-prices", "daily", split="train")
fixings = load_dataset("fastgpu/cloud-gpu-prices", "fixings", split="train")

import pandas as pd

df = pd.read_csv("hf://datasets/fastgpu/cloud-gpu-prices/gpu-prices-current.csv")
cheapest = df[df.gpu_model == "H100 SXM"].sort_values("price_usd_hr").head(10)

Prices are per GPU per hour in US dollars. min_gpu_count says how many GPUs you must rent to pay that rate (8 means the price is only sold as a whole 8-GPU machine), and providers that bill CPU, memory or storage on top of the GPU are named in the column notes below, so compare like with like.

Columns

`current` (gpu-prices-current.csv)

Column	Type	Description
`provider`	string	Provider slug, e.g. runpod, vast, lambdalabs.
`provider_label`	string	Human-readable provider name.
`gpu_model`	string	Canonical GPU model, e.g. H100 SXM, RTX 4090.
`gpu_slug`	string	URL slug for the model on fastgpu.co/gpus/{slug}.
`vram_gb`	integer	GPU memory in GB (blank if not exposed).
`offer_type`	string	on-demand, community, spot, reserved, or serverless.
`region`	string	Data-center region (blank when global/unspecified).
`price_usd_hr`	number	Per-GPU price in USD/hour (blank if listed but unpriced). Each price is the provider's own per-GPU rate. Most providers include the machine's CPU and memory in it (storage is often billed separately); Modal, Cudo Compute, TensorDock, Daytona price the GPU alone and bill CPU and memory on top.
`min_gpu_count`	integer	GPUs in the instance this per-GPU price is quoted for: to pay this rate you rent at least this many GPUs (1 = a single GPU; 8 = a whole 8-GPU machine such as a hyperscaler VM). The price stays per GPU-hour.
`available_count`	integer	Instances currently available (blank if not exposed).
`interconnect`	string	nvlink or infiniband when known (blank otherwise).
`source_url`	string	Deep link to the provider's rental page for this offer.
`fetched_at`	datetime	ISO 8601 timestamp when this offer was last observed.

`daily` (gpu-prices-daily.csv)

Column	Type	Description
`day`	date	UTC calendar day (YYYY-MM-DD).
`provider`	string	Provider slug.
`gpu_model`	string	Canonical GPU model.
`offer_type`	string	on-demand, community, spot, reserved, or serverless.
`region`	string	Data-center region (blank when global/unspecified).
`min_price_usd_hr`	number	Lowest per-GPU USD/hour observed that day.
`avg_price_usd_hr`	number	Average per-GPU USD/hour observed that day.
`max_price_usd_hr`	number	Highest per-GPU USD/hour observed that day.
`observations`	integer	Number of price observations backing the day.

`fixings` (gpu-price-fixings.csv)

Column	Type	Description
`fixing_date`	date	UTC day of the fixing (YYYY-MM-DD). One row per GPU model per day; a day whose run was missed has no rows and is never backfilled.
`gpu_model`	string	Canonical GPU model, e.g. H100 SXM (the form factor is part of the name).
`gpu_slug`	string	URL slug for the model on fastgpu.co/gpus/{slug}.
`floor_usd_hr`	number	Cheapest posted on-demand price per GPU-hour outside the hyperscalers at the fixing snapshot, in-stock offers first. Blank when no such offer existed.
`floor_provider`	string	Slug of the provider that set the floor.
`floor_provider_label`	string	That provider's name.
`floor_offer_type`	string	on-demand, or community (a marketplace's shared-host tier, rented the same way).
`floor_min_gpu_count`	integer	GPUs in the instance the floor price is sold as (1 = a single GPU). The price stays per GPU-hour.
`floor_billed_separately`	string	What the floor's provider bills on top of its per-GPU rate (CPU, memory, storage). Blank when the rate includes CPU and memory.
`floor_availability`	string	Availability of the floor offer: in-stock, low, out or unknown. out means every eligible offer was sold out, so the floor is the cheapest sold-out price.
`on_demand_median_usd_hr`	number	Median of each provider's lowest on-demand price per GPU-hour, over the same providers the floor is drawn from (hyperscalers excluded). For an even count, the mean of the two middle prices.
`on_demand_providers`	integer	Providers behind the floor and the on-demand median.
`spot_floor_usd_hr`	number	Cheapest interruptible (spot) price per GPU-hour on any provider, hyperscalers included.
`spot_floor_provider`	string	Slug of the provider that set the spot floor.
`spot_floor_provider_label`	string	That provider's name.
`spot_floor_min_gpu_count`	integer	GPUs in the instance the spot floor is sold as (hyperscaler spot is often a whole multi-GPU machine).
`spot_floor_billed_separately`	string	What the spot floor's provider bills on top of its per-GPU rate. Blank when the rate includes CPU and memory.
`spot_floor_availability`	string	Availability of the spot floor offer: in-stock, low, out or unknown.
`spot_providers`	integer	Providers behind the spot floor.
`hyperscaler_median_usd_hr`	number	Median of each hyperscaler's lowest on-demand price per GPU-hour (AWS, Azure, Google Cloud, Oracle Cloud).
`hyperscaler_providers`	integer	Hyperscalers behind that median.
`on_demand_offers`	integer	Eligible on-demand offers outside the hyperscalers, sold-out ones included.
`stock_known_offers`	integer	Of those, the offers whose availability the provider exposes: the denominator of the in-stock share.
`in_stock_offers`	integer	Of those, the offers in stock (low stock counts as in stock): the numerator of the in-stock share.
`carried_providers`	integer	Contributing providers whose price was not observed within 30 minutes of the snapshot and was carried from an earlier observation (0 on a clean run).
`degraded_providers`	string	Providers the feed flagged as degraded at the snapshot, comma separated (blank on a clean day).
`snapshot_at`	datetime	ISO 8601 time the snapshot behind the fixing was observed.
`method_version`	string	Version of the published method the row was computed under (fastgpu.co/methodology/fixings).

How the data is collected

Each provider is read from its own API, price feed or published rate card. Sources, collection method and terms per provider: data provenance.
How offers are normalized, compared and ranked: methodology. How a daily fixing is taken: fixings method.
Known errors are corrected in the published files and listed with their dates: corrections.
Dated list-price changes: price-change log. Monthly figures: State of GPU prices report.

Updates and live access

This repository is updated once a day, after the 07:00 UTC fixing, by one commit that replaces all three files. For prices that move during the day, filters and the workload-to-GPU matcher, use the free REST API and MCP server. A longer history and raw observations are part of the paid plans.

License and citation

Creative Commons Attribution 4.0 International (CC BY 4.0). Use it in products, research or reporting, commercially too; credit FastGPU with a link:

Data: FastGPU GPU cloud pricing dataset (https://fastgpu.co/dataset), CC BY 4.0.

Archived, versioned copies have a permanent DOI on Zenodo: 10.5281/zenodo.22842387 (it always resolves to the latest version).

@misc{fastgpu_gpu_cloud_pricing,
  author    = {{FastGPU}},
  title     = {GPU Cloud Pricing Dataset},
  year      = {2026},
  publisher = {Zenodo},
  doi       = {10.5281/zenodo.22842387},
  url       = {https://fastgpu.co/dataset}
}

Providers in this snapshot

AWS, Azure, Baseten, CloudRift, CoreWeave, Crusoe, Daytona, DeepInfra, fal.ai, GMI Cloud, Google Cloud, Hyperstack, Jarvis Labs, Lambda, Modal, Nebius, Oracle Cloud, Paperspace, QuantaCloud, Replicate, RunPod, TensorDock, TensorWave, Thunder Compute, Together AI, Vast.ai, Verda, Voltage Park, Vultr