gpus APIgpus.io ↗
Access normalized GPU cloud rental pricing across 25+ providers via the gpus.io API. Filter by GPU model, provider, and region to compare per-hour costs.
What is the gpus API?
The gpus.io API exposes a single endpoint, get_gpu_pricing, that returns live GPU cloud rental pricing across more than 25 providers, normalized into comparable configuration objects. Each record includes the GPU model, provider name, per-GPU-hour price in USD, GPU count, tenor, and regional availability. Filters for gpu_model, provider, and region let you narrow results without post-processing the full dataset.
curl -X GET 'https://api.parse.bot/scraper/1a5a5d32-f4fe-4ea3-9e94-d7bdbf5a905f/get_gpu_pricing?provider=lambda®ion=us&gpu_model=H100' \ -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 gpus-io-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: GPUs.io SDK — compare cloud GPU pricing across providers."""
from parse_apis.gpus_io_api import GpusIo, ParseError
client = GpusIo()
# Fetch the full pricing snapshot to see when data was last refreshed.
try:
pricing = client.pricing.get()
except ParseError as e:
print(f"Upstream extraction failed: {e.code}")
raise
print(f"Last updated: {pricing.last_updated} | Total configs: {pricing.total}")
# Browse H100 configurations across all providers, capped at 10 items.
for cfg in client.configurations.list(gpu_model="H100", limit=10):
print(f"{cfg.gpu_model} x{cfg.gpu_count} @ ${cfg.price_per_hour}/hr "
f"— {cfg.provider} ({cfg.availability})")
# Drill into a single provider's cheapest offering.
cheapest = client.configurations.list(provider="lambda", limit=1).first()
if cheapest is not None:
print(f"\nLambda highlight: {cheapest.gpu_model}, "
f"{cheapest.vcpu} vCPUs, {cheapest.ram_gb} GB RAM, "
f"regions={cheapest.regions}")
# Filter by region for localized results.
for cfg in client.configurations.list(region="us", limit=5):
print(f"[US] {cfg.provider} {cfg.gpu_model} — ${cfg.price_per_hour}/hr")
print("\nexercised: pricing.get / configurations.list (gpu_model / provider / region filters)")
Returns all GPU cloud rental pricing configurations from gpus.io. Each record represents one rentable GPU configuration from a specific provider with exact per-GPU-hour pricing in USD. Supports optional filters for GPU model name, provider name, and region code. Without filters, returns all configurations (2000+). A single upstream request fetches the full dataset; no pagination is needed.
| Param | Type | Description |
|---|---|---|
| region | string | ISO 3166-1 alpha-2 country code filter (e.g. 'us', 'ca', 'de'). Omitting returns all regions. |
| provider | string | Case-insensitive substring filter for provider name or ID (e.g. 'lambda', 'vast', 'hyperstack'). Omitting returns all providers. |
| gpu_model | string | Case-insensitive substring filter for GPU model name or slug (e.g. 'H100', 'A100', 'RTX 4090'). Omitting returns all GPU models. |
{
"type": "object",
"fields": {
"total": "integer count of configurations returned",
"last_updated": "ISO 8601 timestamp of last pricing data update",
"configurations": "array of GPU rental configuration objects, each containing gpu_model, provider, price_per_hour, gpu_count, tenor, regions, availability, is_from_price, vcpu, ram_gb"
},
"sample": {
"data": {
"total": 68,
"last_updated": "2026-08-08T20:02:10.582Z",
"configurations": [
{
"vcpu": 26,
"tenor": "on_demand",
"ram_gb": 200,
"regions": [
"us"
],
"provider": "Lambda",
"gpu_count": 1,
"gpu_model": "NVIDIA H100",
"availability": "available",
"is_from_price": true,
"price_per_hour": 3.29
}
]
},
"status": "success"
}
}About the gpus API
What the API Returns
The get_gpu_pricing endpoint returns a configurations array where each object represents one rentable GPU configuration from a specific cloud provider. Fields include gpu_model (e.g. H100, A100, RTX 4090), provider, price_per_hour in USD, gpu_count, tenor (commitment length), regions, and availability status. The total field gives the count of matched configurations, and last_updated carries an ISO 8601 timestamp indicating when the pricing data was last refreshed.
Filtering
All three filter parameters are optional. gpu_model accepts a case-insensitive substring, so passing H100 matches any configuration whose GPU name contains that string. provider works the same way — passing lambda or vast will match the relevant provider records. region accepts an ISO 3166-1 alpha-2 code such as us, de, or ca. You can combine all three filters in a single request; omitting any filter means that dimension is unfiltered and all matching records are returned.
Coverage and Freshness
The dataset spans 25+ GPU cloud providers, covering a wide range of GPU hardware tiers from consumer-class cards like the RTX 4090 to data-center GPUs like the H100 and A100. Pricing is normalized so that price_per_hour represents a consistent per-GPU-hour USD figure regardless of the source provider's native pricing format. The last_updated timestamp in each response indicates how recently the underlying pricing data was refreshed, which is useful when building cost-comparison tools that need to surface data age to end users.
The gpus API is a managed, monitored endpoint for gpus.io — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when gpus.io 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 gpus.io 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 price comparison dashboard that ranks providers by
price_per_hourfor a specificgpu_model - Alert users when pricing for a given provider and GPU model drops below a threshold by polling
get_gpu_pricing - Filter by
regionto find the lowest-cost H100 rental available in a specific country - Aggregate
configurationsdata to compute average and median per-hour costs across all providers for a given GPU - Track
availabilitychanges over time to identify which providers consistently have GPU stock - Power a Slackbot that answers 'cheapest A100 right now' by querying
get_gpu_pricingwithgpu_model=A100 - Compare
tenoroptions across providers to surface spot vs. reserved pricing differences for the same GPU model
| 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 gpus.io have an official developer API?+
What does each configuration object in the response actually contain?+
configurations array includes gpu_model, provider, price_per_hour (USD, per GPU), gpu_count, tenor (the commitment or rental period type), regions (where the configuration is available), and an availability indicator. The top-level response also includes total (integer count of matched records) and last_updated (ISO 8601 timestamp).How current is the pricing data?+
last_updated ISO 8601 timestamp that reflects when the dataset was last refreshed. Because cloud provider pricing changes frequently, you should check this field before relying on a cached response for time-sensitive cost comparisons.Does the API return historical pricing trends or only current prices?+
get_gpu_pricing response. You can fork this API on Parse and revise it to store and expose historical records if trending data is required.Can I filter by GPU memory size or specific hardware specs beyond the model name?+
gpu_model, provider, and region. Filtering by VRAM, CUDA cores, or other hardware attributes is not directly supported. You can fork this API on Parse and revise it to add spec-level filtering if your use case requires it.