# Cloud GPU Prices: H100, A100, L4 per GPU-hour (AWS, Azure, GCP) (`tanod/cloud-gpu-prices`) Actor

Cheapest cloud GPUs (H100, H200, A100, L40S, L4, T4 and more) by chip, memory, region and price ceiling: official AWS, Azure and Google Cloud list prices per GPU-hour, on-demand and spot, with instance type and date. No scraping. USD 0.003 per answered query, less on higher Apify plans.

- **URL**: https://apify.com/tanod/cloud-gpu-prices.md
- **Developed by:** [Tanod Labs](https://apify.com/tanod) (community)
- **Categories:** Developer tools, AI, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.50 / 1,000 query answereds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## 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:

```json
{
  "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):

```json
{
  "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](https://huggingface.co/datasets/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](https://docs.apify.com/integrations/x402).

**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.

# Actor input Schema

## `chip` (type: `string`):

GPU chip, any case, for example H100, A100, L40S, L4, A10, A10G or T4. Leave empty for all chips.

## `min_gpu_mem_gb` (type: `integer`):

Only GPUs with at least this much memory, for example 80.

## `provider` (type: `string`):

Restrict to one cloud. Empty means all three.

## `regions` (type: `array`):

Region names, for example us-east-1 or eastus (at most 20). Empty means all regions.

## `pricing` (type: `string`):

on_demand, spot, or any (the lower of the two). Rows are returned cheapest first.

## `max_usd_per_gpu_hour` (type: `number`):

Only rows whose ranked price is at or below this.

## `limit` (type: `integer`):

How many price rows to return per query, 1 to 100.

## `queries` (type: `array`):

Up to 20 query objects, each with any of the fields above (chip, min_gpu_mem_gb, provider, regions, pricing, max_usd_per_gpu_hour, limit). When given, the single-query fields above are ignored. Each query is one charged event if it returns rows.

## Actor input object example

```json
{
  "pricing": "any",
  "limit": 20,
  "queries": [
    {
      "chip": "H100",
      "pricing": "spot",
      "limit": 5
    },
    {
      "chip": "A100",
      "provider": "AWS",
      "limit": 5
    }
  ]
}
```

# Actor output Schema

## `results` (type: `string`):

No description

## `summary` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "queries": [
        {
            "chip": "H100",
            "pricing": "spot",
            "limit": 5
        },
        {
            "chip": "A100",
            "provider": "AWS",
            "limit": 5
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("tanod/cloud-gpu-prices").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "queries": [
        {
            "chip": "H100",
            "pricing": "spot",
            "limit": 5,
        },
        {
            "chip": "A100",
            "provider": "AWS",
            "limit": 5,
        },
    ] }

# Run the Actor and wait for it to finish
run = client.actor("tanod/cloud-gpu-prices").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "queries": [
    {
      "chip": "H100",
      "pricing": "spot",
      "limit": 5
    },
    {
      "chip": "A100",
      "provider": "AWS",
      "limit": 5
    }
  ]
}' |
apify call tanod/cloud-gpu-prices --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,tanod/cloud-gpu-prices"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/CtbdvfVp1xAd620Wb/builds/fKOxHRi9h7DuIn94V/openapi.json