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

New to Apify? Create an account (affiliate link).

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 plus Akash marketplace bids with the GPUs free right now, 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.
• Akash marketplace rows. Set provider to Akash (or leave it empty with pricing any) to get, per chip and interface, the median, lowest and highest bid in USD per GPU-hour and the GPUs free and in total, with the time they were read (read_at). These are what Akash providers currently ask, basis is marketplace_bid, and price_kind is marketplace_bid: they are not list prices and not executed trades. Akash is read from its public API and kept for about 30 minutes; if that read fails, the three clouds are still answered and the Akash rows are simply missing.
• No scraping. The cloud prices are 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 neoclouds or marketplaces besides Akash. Prices exclude tax, egress and storage, are list prices (or Akash bids) and not a quote, and spot prices and bids change often.

Input

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

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, Google Cloud or Akash	Restrict to one provider; empty means all four
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, Google Cloud or Akash, and the region (each provider's own region names; Akash rows say marketplace)
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, spot or marketplace_bid (Akash median)
basis	instance_share for cloud list prices, marketplace_bid for Akash
median_usd_per_gpu_hour, min_usd_per_gpu_hour, max_usd_per_gpu_hour	Akash rows only: the median, lowest and highest bid per GPU-hour (USD)
gpus_available, gpus_total, read_at	Akash rows only: GPUs free, GPUs in total, and when they were read (UTC)
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, Google Cloud and Akash; 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? Mostly no. The cloud prices come from a snapshot of the official price lists refreshed twice a day, which is right for planning and comparison. Akash bids and free GPUs are read from Akash about every 30 minutes; they move by the minute, so check again before you rent.

Does it cover Akash? Yes: Akash marketplace bids per GPU-hour, with GPUs free and in total, next to the three clouds' list prices.

Does it cover RunPod, Lambda or Vast.ai? No. AWS, Azure, Google Cloud and Akash only.

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.