# GPU Cloud Rate Monitor – Runpod & Lambda Price Changes (`maydit/gpu-cloud-rate-monitor`) Actor

Track official Runpod and Lambda GPU rates, per-GPU and per-instance cost, VRAM and announced effective dates. Save price changes without a login or API key.

- **URL**: https://apify.com/maydit/gpu-cloud-rate-monitor.md
- **Developed by:** [Brandt May](https://apify.com/maydit) (community)
- **Categories:** E-commerce
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.20 / 1,000 saved observations

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

## GPU Cloud Rate Monitor

Turn official Runpod and Lambda rate cards into comparable, source-linked GPU pricing records. Keep the price unit, GPU count, memory allocation and effective date beside each number, then compare subsequent complete observations.

This Actor helps AI agencies prepare compute estimates, infrastructure buyers compare advertised offers, and research teams monitor rate changes. It reads public pricing pages without an account, API key, browser or paid proxy.

**Start with the prefilled input.** It returns the advertised Runpod H100 PCIe Community and Secure rates, usually two records. Each saved rate costs **$0.002**, plus Apify's **$0.00005 Actor Start** event at the default memory setting. Two saved rates therefore produce $0.004 in result events plus the start event; platform usage is separate. Unmatched filters, unchanged observations skipped by `onlyChanges`, and failed source responses do not produce result charges.

### The distinction that matters

An hourly GPU price is not necessarily the hourly cost of an instance. Lambda's 8-GPU group publishes a price **per GPU-hour**; `usdPerInstanceHour` multiplies that price by eight. GPU count, VRAM per GPU, CPU/RAM allocation and storage text remain visible. RAM values keep their source unit—GB and GiB are not silently mixed.

Effective dates matter too. At the initial November 8, 2026 verification, Lambda's instance page advertised rates taking effect **November 16, 2026, at 00:00 UTC**, with current prices available only after login. Those public rows are labeled `announced_future`; the Actor does not retrieve or invent the logged-in price. The actual observed footer and parsed effective time travel with every Lambda row. Undated advertised rates are labeled `advertised_undated`, never “guaranteed current.”

### Three useful inputs

#### Runpod H100 PCIe tiers

```json
{"providers":["runpod"],"gpuModels":["H100 PCIe"],"runpodTiers":["community","secure"],"maxResults":5}
```

#### Lambda H100 instance sizes

```json
{"providers":["lambda"],"gpuModels":["H100"],"lambdaGpuCounts":[1,2,4,8],"maxResults":5}
```

#### A40 compute estimate and saved changes

```json
{"providers":["runpod"],"gpuModels":["A40"],"runpodTiers":["secure"],"computeHours":100,"comparePrevious":true,"snapshotName":"a40-budget-watch","maxResults":5}
```

`gpuModels` contains case-insensitive literal name phrases. It is a filter over the selected public rate cards, not a compatibility or performance search. An empty list selects every parsed model; use a sufficiently large `maxResults` for complete history. Provider values are `runpod` and `lambda`. Runpod tiers and Lambda GPU-count filters apply only to their respective provider. There are at most two pricing-page requests plus robots checks, with a shared 30–120 second deadline.

### Output you can use

| Field | Meaning |
| --- | --- |
| `recordId`, `title` | Stable rate identity: provider, exact GPU name, VRAM, tier and GPU count. |
| `provider`, `gpuName`, `tier` | Source provider, literal advertised model and commercial tier. |
| `gpuCount`, `acceleratorAllocation` | Whole-GPU count priced in this instance; fractional MIG offers are excluded. |
| `usdPerGpuHour` | Advertised price per GPU-hour, normalized to USD. |
| `usdPerInstanceHour` | Per-GPU rate multiplied by the explicit instance GPU count. |
| `vramGbPerGpu` | Published GPU memory in GB. |
| `vcpusPerInstance`, `ramAmount`, `ramUnit`, `storageText` | Published resource configuration, preserving GB/GiB and source storage wording. |
| `resourceBasis` | Runpod configuration card or Lambda instance table; not a capacity promise. |
| `rateTiming`, `rateEffectiveAt`, `rateNote` | Undated, future-announced or effective listed rate, with original source note. |
| `computeHours`, `estimatedComputeUsd` | Optional user hours multiplied by per-instance rate; no taxes, storage, networking or performance adjustment. |
| `comparisonStatus`, `changedFields`, `previous` | New, changed, unchanged or comparison not requested, with prior complete observation. |
| `usdPerGpuHourChange`, `usdPerInstanceHourChange` | Numeric deltas against that previous observation, or null on the first check. |
| `sourceUrl`, `observedAt` | Official source and fetch time. |
| `availability`, `availabilityChecked` | Always null and false. No capacity check is performed. |

Download JSON or CSV from the dataset. `SUMMARY` reports parsed and filtered rate counts, source errors, unprocessed selections, output caps and history status. `RUN_REPORT` is a readable HTML version.

### Repeatable comparisons

Enable `comparePrevious` to save a baseline only after all selected source requests and matching output succeed. Use `onlyChanges` on later runs to save new or changed rates. An unchanged repeat can correctly return zero rows.

History is isolated by provider selection, filters, GPU counts, `maxResults`, compute-hour assumption and `snapshotName`. Source errors, a deadline, a spending cap or an output cap cutting through matching results leave the previous baseline intact. A concurrent writer is detected before committing. Run the same snapshot sequentially. Disappearing offers are not reported as deleted, unavailable or sold out.

### Source coverage and limits

- [Runpod's official pricing page](https://www.runpod.io/pricing): structured on-demand Pod offers with matching configuration cards. Community and Secure tiers remain separate. The Actor cross-checks structured prices against their displayed card attributes. Serverless, clusters, spot prices, fractional MIG partitions and console capacity are excluded. Models without a structured offer are outside this feed.
- [Lambda's official pricing page](https://lambda.com/pricing): the 1/2/4/8-GPU on-demand instance tables. Reserved cluster tables are excluded. Published future rates remain explicitly future; current rates behind login are outside scope. Lambda uses dollar-denominated public cloud rates; the provider also describes its published pricing as [US dollars per hour](https://lambda.ai/blog/lambdas-nvidia-hgx-8xb200-on-stac-ai-lang6).

Neither source promises that the shown configuration can be booked now. Rates can change after collection. The output is not a quote, profit forecast, resale recommendation or claim that different GPUs finish a workload in the same time. Compute estimates exclude sales tax, storage, network charges, negotiated discounts and other provider charges. Runpod configuration resources describe the published card, not every available host.

The Actor honors robots.txt, rejects arbitrary source URLs and stops further source requests on HTTP 401, 403 or 429. It does not use account cookies, private endpoints, paid proxies or access workarounds. A changed table or contradictory price fails visibly rather than emitting a fabricated rate.

### Automations and AI tools

Save this input as a private Apify task and schedule it at a cadence appropriate for your purchasing workflow. Send the dataset to a spreadsheet, warehouse or workflow tool through your own Apify integration. For API or MCP use, supply the same small input and inspect `SUMMARY.incomplete`, `rateTiming` and the source URLs before acting on the results. This Actor reads rate cards; it never rents hardware or sends notifications itself.

For troubleshooting, open an issue on this Actor with the run ID, selected provider and filters. Do not include credentials.

# Actor input Schema

## `providers` (type: `array`):

runpod and/or lambda. Reads only their official public pricing pages.

## `gpuModels` (type: `array`):

Up to 10 case-insensitive literal phrases. A GPU name may contain any phrase. Empty selects every published model within the other filters; increase maxResults for complete comparison history.

## `runpodTiers` (type: `array`):

Applies only to Runpod on-demand Pods. Serverless, clusters and spot are excluded.

## `lambdaGpuCounts` (type: `array`):

Choose explicit instance GPU counts from \[1, 2, 4, 8]. Prices remain per GPU-hour and are multiplied by this count for instance totals. Reserved clusters are excluded.

## `maxUsdPerGpuHour` (type: `number`):

Optional advertised per-GPU price ceiling. Future announced rates can match; inspect rateTiming.

## `computeHours` (type: `number`):

Estimate hours × published per-instance rate. Excludes taxes, storage, egress and performance/capacity guarantees; respects the source effective-date label.

## `maxResults` (type: `integer`):

One billed result per provider/model/VRAM/tier/GPU-count rate. A truncated selection never advances history.

## `comparePrevious` (type: `boolean`):

New, changed and unchanged observations plus prior prices. No removal or capacity inference.

## `onlyChanges` (type: `boolean`):

Enables comparison. Unchanged repeats may correctly save zero rows and incur no result charges.

## `snapshotName` (type: `string`):

1–80 letters, numbers, underscores or hyphens. History is also separated by providers, filters, GPU counts and output cap.

## `maxRunSeconds` (type: `integer`):

Shared deadline. Bounded public requests honor robots.txt and stop on 401/403/429 without a bypass.

## Actor input object example

```json
{
  "providers": [
    "runpod"
  ],
  "gpuModels": [
    "H100 PCIe"
  ],
  "runpodTiers": [
    "community",
    "secure"
  ],
  "lambdaGpuCounts": [
    1
  ],
  "maxResults": 5,
  "comparePrevious": false,
  "onlyChanges": false,
  "snapshotName": "default",
  "maxRunSeconds": 90
}
```

# Actor output Schema

## `dataset` (type: `string`):

No description

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

No description

## `report` (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 = {
    "providers": [
        "runpod"
    ],
    "gpuModels": [
        "H100 PCIe"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("maydit/gpu-cloud-rate-monitor").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 = {
    "providers": ["runpod"],
    "gpuModels": ["H100 PCIe"],
}

# Run the Actor and wait for it to finish
run = client.actor("maydit/gpu-cloud-rate-monitor").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 '{
  "providers": [
    "runpod"
  ],
  "gpuModels": [
    "H100 PCIe"
  ]
}' |
apify call maydit/gpu-cloud-rate-monitor --silent --output-dataset

```

## MCP server setup

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

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/vh8z9TbJm4V0xGOuI/builds/joBfA6DLFKX76gvRZ/openapi.json