ComputePrices APIcomputeprices.com ↗
Access GPU cloud rental pricing from 65+ providers and 50+ GPU models via the ComputePrices.com API. Filter by GPU model and pricing type.
What is the ComputePrices API?
The ComputePrices.com API exposes a single endpoint, get_gpu_prices, that returns roughly 900–1000 GPU cloud rental records spanning 65+ providers and 50+ GPU models. Each record includes the GPU model, per-hour price, GPU count, region, availability, and pricing type. Optional filters for gpu_model and pricing_type let you narrow results without post-processing the full dataset.
curl -X GET 'https://api.parse.bot/scraper/fdc965ca-77e7-4099-b2d7-5b9f9719864c/get_gpu_prices?gpu_model=h100&pricing_type=on_demand' \ -H 'X-API-Key: $PARSE_API_KEY'
Typed, relational, agent-ready
A generated client with real types, enums, and the links between objects — the structure a flat JSON response can't carry. Autocompletes in your editor and reads cleanly to coding agents.
- Fully typed · autocompletes
- Objects link to objects
- Typed errors & pagination
Typed Python client. Set up the SDK in your uv project, then pull this API’s typed client:
uv add parse-sdk uv run parse init uv run parse add --marketplace computeprices-com-api
uv run parse add --marketplace pulls a pinned snapshot of this canonical API — it won’t change underneath you. To customize it, subscribe and swap to your own copy.
"""Walkthrough: ComputePrices GPU Pricing API — browse and filter cloud GPU prices."""
from parse_apis.computeprices_com_api import ComputePrices, PricingType, ParseError
client = ComputePrices()
# List all on-demand GPU prices, capped at 10 results.
for price in client.gpu_prices.list(pricing_type=PricingType.ON_DEMAND, limit=10):
print(f"{price.provider:20s} {price.gpu_model:12s} x{price.gpu_count} ${price.price_per_hour:.2f}/hr {price.vram_gb}GB VRAM")
# Filter to a specific GPU model slug.
h100 = client.gpu_prices.list(gpu_model="h100", limit=5).first()
if h100 is not None:
print(f"\nCheapest H100 listing: {h100.provider} @ ${h100.price_per_hour}/hr ({h100.tenor})")
# Spot pricing overview with error handling.
try:
for spot in client.gpu_prices.list(pricing_type=PricingType.SPOT, limit=5):
print(f"[spot] {spot.gpu_model} — {spot.provider} ${spot.price_per_hour:.2f}/hr")
except ParseError as e:
print(f"Extraction failed ({e.code}): {e}")
print("\nexercised: gpu_prices.list (on_demand / by model / spot)")
Returns all GPU cloud rental pricing records from ComputePrices.com. Each record represents a specific (provider, GPU model, GPU count, pricing type) combination with its per-GPU hourly price. Approximately 900-1000 records are returned covering 65+ providers and 50+ GPU models. Optionally filter by pricing type or GPU model slug. One network round-trip.
| Param | Type | Description |
|---|---|---|
| gpu_model | string | Filter by GPU model slug (e.g. 'h100', 'a100sxm', 'l40s'). Slugs are returned in the gpu_slug field of each record. Omitting returns all GPU models. |
| pricing_type | string | Filter by pricing model. Omitting returns all pricing types. |
{
"type": "object",
"fields": {
"total": "integer count of records returned",
"prices": "array of GPU pricing records, each containing gpu_model, price_per_hour, gpu_count, tenor, region, availability, is_from_price, provider, provider_slug, gpu_slug, vram_gb, currency"
},
"sample": {
"data": {
"total": 985,
"prices": [
{
"tenor": "on-demand",
"region": null,
"vram_gb": 80,
"currency": "USD",
"gpu_slug": "h100",
"provider": "Deep Infra",
"gpu_count": 1,
"gpu_model": "H100 SXM",
"availability": null,
"is_from_price": false,
"provider_slug": "deep-infra",
"price_per_hour": 2.2
},
{
"tenor": "spot",
"region": null,
"vram_gb": 80,
"currency": "USD",
"gpu_slug": "h100",
"provider": "Verda",
"gpu_count": 8,
"gpu_model": "H100 SXM",
"availability": null,
"is_from_price": false,
"provider_slug": "verda",
"price_per_hour": 1.625
}
]
},
"status": "success"
}
}About the ComputePrices API
What get_gpu_prices Returns
The get_gpu_prices endpoint returns a prices array alongside a total integer count. Each element in the array represents a distinct (provider, GPU model, GPU count, pricing type) combination. Fields include gpu_model, price_per_hour, gpu_count, tenor, region, availability, is_from_price, and the gpu_slug identifier used for filtering. Coverage spans on-demand, spot, and reserved pricing models across major and independent cloud providers.
Filtering the Dataset
Two optional query parameters narrow the response. gpu_model accepts a GPU slug string — for example, h100, a100sxm, or l40s — which correspond to values returned in the gpu_slug field of each record. pricing_type filters by pricing model (on-demand, spot, reserved, etc.). Omitting both parameters returns the full dataset of ~900–1000 records. Since slugs are sourced from the response itself, a common pattern is to fetch the full dataset once, collect gpu_slug values, then issue filtered requests for specific models.
Data Shape and Coverage
The is_from_price boolean flag indicates whether the listed price_per_hour is a minimum/starting price rather than a fixed rate — useful when comparing spot or auction-style offerings. The tenor field captures the rental commitment period (hourly, monthly, etc.), and region identifies the data-center geography. With 65+ tracked providers, the dataset includes both hyperscalers and smaller GPU-cloud operators that may not appear in typical cloud-comparison tools.
Source and Freshness
ComputePrices.com does not publish a documented public developer API. Pricing data reflects the listings tracked on the ComputePrices.com marketplace at the time of the request. Prices in the GPU cloud market can shift frequently, so applications that depend on current rates should poll regularly rather than cache results for extended periods.
The ComputePrices API is a managed, monitored endpoint for computeprices.com — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when computeprices.com changes and a check fails, the API is automatically queued for repair and re-verified. It is built to keep working as the site underneath it changes.
This isn't an official computeprices.com API — it's an independent, maintained REST wrapper over public data. Where the source has no official API (or only a limited one), Parse gives you a stable contract over a source that never promised one, and keeps it current. Need a new endpoint or field? You can revise it yourself in plain English and the agent rebuilds it against the live site in minutes — contributing the change back to the shared API is free.
Will this API break when the source site changes?+
Is this an official API from the source site?+
Can I fix or extend this API myself if I need a new endpoint or field?+
What happens if I call an endpoint that has an issue?+
- Build a GPU cost-comparison dashboard filtered by
gpu_modelto surface the cheapest provider for a specific chip. - Monitor spot-pricing volatility for H100 or A100 instances by polling
get_gpu_pricesand trackingprice_per_hourchanges over time. - Alert ML teams when
availabilitychanges for a specific GPU model and region combination. - Estimate infrastructure budgets by querying
tenorandprice_per_hourfor reserved versus on-demand pricing types. - Aggregate provider coverage gaps by counting which
gpu_slugvalues appear for fewer than a threshold number of providers. - Feed a procurement tool that recommends the lowest-cost region for a given
gpu_countrequirement. - Track entry of new providers into the GPU rental market by watching for new values in the provider field over time.
| Tier | Price | Credits/month | Rate limit |
|---|---|---|---|
| Free | $0/mo | 200 | 5 req/min |
| Hobby | $30/mo | 1,000 | 20 req/min |
| Developer | $100/mo | 5,000 | 100 req/min |
| Team | $300/mo | 20,000 | 300 req/min |
| Company | $1,000/mo | 100,000 | 500 req/min |
Each endpoint has a fixed posted price per successful call — most fall between 1 and 10 credits — shown on this API's page before you run it. Exceeding the rate limit returns a 429 response. Authenticate with the X-API-Key header.
Does ComputePrices.com have an official developer API?+
How do I find the correct slug to use with the `gpu_model` filter?+
gpu_slug field — for example, h100, a100sxm, or l40s. Use those returned values as inputs to the gpu_model parameter in subsequent filtered requests.What does the `is_from_price` field mean and when should I use it?+
is_from_price is true, the price_per_hour value is a minimum or starting price rather than a fixed rate. This is common for spot or auction-priced offerings. Applications doing price comparisons should treat these records as lower-bound estimates rather than guaranteed rates.Does the API return historical pricing data or price change trends?+
Are there endpoints for filtering by provider name or by region?+
get_gpu_prices endpoint supports filtering by gpu_model and pricing_type only. Provider and region are returned as response fields, so client-side filtering is possible. You can fork this API on Parse and revise it to add a dedicated provider or region filter parameter.