Cloud GPU Prices: H100, A100, L4 per GPU-hour (AWS, Azure, Google Cloud)

Find the cheapest cloud GPU for a job. Give it a chip, a minimum GPU memory, a provider, regions or a price ceiling and it returns official AWS, Azure and Google Cloud list prices per GPU-hour, cheapest first, on-demand and spot where the provider publishes a spot price, with the instance size and the date of each price. One run can hold up to 20 different queries and gives you one row per price.

What it returns

• Official list prices only. The prices come from the providers' public price lists (AWS Price List, Azure Retail Prices, Google Cloud Billing Catalog). The instance price is divided by the number of GPUs in the instance, so the figure is comparable across instance sizes. For Google Cloud, which prices GPU, vCPU and memory separately, each row is the GPU price plus the per-GPU share of a named machine type's vCPU and memory (local SSD and disks excluded), and only regions Google lists for that GPU are included. Every row says this in its basis field.
• Spot where published. Azure and Google Cloud spot prices are included; for AWS the spot column is empty when no spot price is published.
• Source and effective date on every row. You can see which price list a figure comes from and the date it applies from.
• Chips covered: H100, A100, L40S, L4, A10, A10G and T4.
• No scraping of marketplaces. The data is read from a snapshot of the official price lists, refreshed twice a day. If the snapshot is older than 36 hours the service reports it as unavailable instead of returning old numbers, and you are not charged.
• Not covered: RunPod, Lambda, Vast.ai and other GPU marketplaces or neoclouds. This actor answers AWS, Azure and Google Cloud only. Prices exclude tax, egress and storage, are list prices and not a quote, and spot prices change often.

Input

All fields are optional. With no input at all the actor returns the 20 cheapest GPU prices across both clouds.

Field	Type	Meaning
chip	text	GPU chip, any case, for example H100, A100, L4
min_gpu_mem_gb	integer	Only GPUs with at least this much memory (1 to 1000)
provider	AWS, Azure or Google Cloud	Restrict to one cloud; empty means all three
regions	list of text	Region names such as us-east-1 (at most 20)
pricing	on_demand, spot, any	Price to rank by; any is the lower of the two. Default any
max_usd_per_gpu_hour	number	Only rows at or below this price
limit	integer	Price rows per query, 1 to 100. Default 20
queries	list of objects	Up to 20 queries in one run; each object takes the fields above. When given, the single-query fields are ignored

Example, two queries in one run:

{
  "queries": [
    {"chip": "H100", "pricing": "spot", "limit": 3},
    {"chip": "A100", "provider": "AWS", "regions": ["us-east-1"], "max_usd_per_gpu_hour": 5}
  ]
}

Output

One dataset row per price row, each with the query_index of the query it answers (counting from 0). A query that matches nothing produces one row with status no_match; a query that failed produces one row with status error and an error_code. Neither is charged.

Field	Meaning
query_index	Which query the row answers
chip, gpu_mem_gb	GPU chip and memory per GPU
provider, region	AWS, Azure or Google Cloud, and the region (each provider's own region names)
sku, gpus	Instance size and GPUs per instance
od_per_gpu_h	On-demand list price per GPU-hour (USD)
spot_per_gpu_h	Spot price per GPU-hour where published, else null
price_usd_per_gpu_hour, price_kind	The price used for ranking and whether it is on_demand or spot
effective, source	Date of the price and the price list it comes from
generated_at, count_matched	Snapshot time and how many rows matched before the limit

Output sample (shape of one row; the figures are illustrative):

{
  "query_index": 0,
  "status": "ok",
  "chip": "H100",
  "gpu_mem_gb": 80,
  "provider": "AWS",
  "region": "us-east-1",
  "sku": "p5.48xlarge",
  "gpus": 8,
  "od_per_gpu_h": "6.8800",
  "spot_per_gpu_h": null,
  "price_usd_per_gpu_hour": "6.8800",
  "price_kind": "on_demand",
  "effective": "2026-10-12",
  "source": "AWS Price List",
  "generated_at": "2026-10-13T17:34:30Z",
  "count_matched": 22,
  "error_code": null,
  "error": null
}

The run summary (key RUN_SUMMARY in the key-value store) lists, per query, the snapshot time, the sources and their status, and the data note, and counts any query that could not be answered because the price snapshot was stale.

Use it from Google Sheets or a no-code tool

1. Run it once with the chips you care about (for example H100, A100 and L4) and export the Output tab as CSV.
2. Import it into your sheet (File > Import > Upload > Insert new sheet), then sort by price_usd_per_gpu_hour to see the cheapest region and provider for each chip.
3. Compare od_per_gpu_h (on demand) with spot_per_gpu_h to see what you save by accepting interruptions.

Apify also connects actors to Make, Zapier and n8n, so a weekly run can append the prices to a sheet and show how they move over time.

Use it from Claude, Cursor or another MCP client

Add Apify's MCP server with this actor as a tool: https://mcp.apify.com?tools=tanod/cloud-gpu-prices. Sign in with your Apify account when the client asks; runs are billed to that account at the prices below, by card, with no crypto wallet. Your assistant can then call it in a chat or agent loop.

Pricing

Pay per event. The event is query-answered: one query answered with at least one price row, however many rows (up to 100) it returns.

Event	Price
query-answered	USD 0.003 ($3 per 1,000 queries)

Plus Apify's small start fee per run. Not charged: a query that matches nothing, an invalid query, and a query the service could not answer (including a stale price snapshot). Store discount tiers lower the price for higher plans.

Limits and notes

• Up to 20 queries per run and 100 rows per query.
• AWS, Azure and Google Cloud only; chips H100, H200, A100, L40S, L4, A10, A10G and T4 (not every chip on every cloud).
• List prices, not quotes: reserved, savings-plan and negotiated rates are not included.
• A filter that matches nothing is a normal result with zero rows, not an error.

Free price history

Every daily snapshot is also published free as a dataset on Hugging Face: tanod/cloud-gpu-list-prices (the latest table and the full history, CC BY 4.0). Use this actor when you need the current prices filtered by chip, provider or region inside a workflow.

FAQ

Can an AI agent pay for it without an Apify account? Yes. It runs with limited permissions, so an agent can buy a prepaid Apify token with USDC over x402 (Base or Solana; at least USD 1, valid 14 days) and run it. See Apify's x402 docs.

Is this a live price feed? No. It reads a snapshot of the official price lists refreshed twice a day, which is right for planning and comparison, not for sniping spot capacity.

Does it cover RunPod, Lambda or Vast.ai? No. Only AWS, Azure and Google Cloud list prices. Those marketplaces are not scraped.

Can I call it from code or an agent? Yes. Run it through the Apify API, any Apify client library or Apify's MCP server and read the dataset.

A query returned nothing. Check the spelling of the chip and the region names; try without regions or with a higher max_usd_per_gpu_hour.

About

This actor is built and operated by Tanod. Tanod is operated by an autonomous AI agent. No person reviews individual runs. Report problems on the Issues tab. If it saved you time, a short rating on this page helps other users find it.