GPU Finder for developers
GPU prices.
Meet your AI agent.
Compare cloud GPU prices, recent stock observations and availability history from your AI assistant, or use the REST API.
Connect your AI agent
Give Claude, Cursor or any MCP client live GPU prices, stock and price history. Server: https://gpufinder.dev/mcp. ChatGPT and Codex: https://gpufinder.dev/mcp/openai.
Step 1: Get a free API key
Sign in with your email (no password: we send a link that also creates your account) and create a key. It is shown once, so copy it now. Free accounts get 60 data calls a month, shared with REST.
Get a free keyStep 2: Connect your agent
Using Claude on the web, desktop or mobile? Add GPU Finder from the Claude directory and sign in with your GPU Finder email. No key to paste.
Add to ClaudePick your client and replace
YOUR_API_KEYwith your key.Terminal
claude mcp add --transport http --scope user gpufinder https://gpufinder.dev/mcp --header "Authorization: Bearer YOUR_API_KEY"~/.cursor/mcp.json
{ "mcpServers": { "gpufinder": { "url": "https://gpufinder.dev/mcp", "headers": { "Authorization": "Bearer YOUR_API_KEY" } } } }.vscode/mcp.json
{ "inputs": [ { "type": "promptString", "id": "gpufinder-api-key", "description": "GPU Finder API key", "password": true } ], "servers": { "gpufinder": { "type": "http", "url": "https://gpufinder.dev/mcp", "headers": { "Authorization": "Bearer ${input:gpufinder-api-key}" } } } }claude_desktop_config.json
{ "mcpServers": { "gpufinder": { "command": "npx", "args": ["-y", "gpufinder", "mcp"], "env": { "GPUFINDER_API_KEY": "YOUR_API_KEY" } } } }~/.codex/config.toml
[mcp_servers.gpufinder] url = "https://gpufinder.dev/mcp/openai" bearer_token_env_var = "GPUFINDER_API_KEY"Terminal
gemini mcp add --scope user --transport http --header "Authorization: Bearer YOUR_API_KEY" gpufinder https://gpufinder.dev/mcpYour client's mcp_config.json
{ "mcpServers": { "gpufinder": { "command": "npx", "args": ["-y", "gpufinder", "mcp"], "env": { "GPUFINDER_API_KEY": "YOUR_API_KEY" } } } }Check it withclaude mcp list. Drop--scope userto add it to the current project only.Use.cursor/mcp.jsoninstead to add it to one project. Keep files that contain the key out of git.VS Code asks for the key on first start and stores it masked, so this file is safe to commit. See Microsoft's MCP configuration reference.Open Settings → Developer → Edit Config, paste, then restart Claude. Uses the open-source gpufinder npm package (source), a small stdio proxy to the hosted endpoint. Requires Node.js 20 or newer.Then set the key in your shell:export GPUFINDER_API_KEY=YOUR_API_KEY. The key never sits in the file.Drop--scope userto add it to the current project only.For ChatGPT and Codex, use https://gpufinder.dev/mcp/openai. Other OAuth clients use https://gpufinder.dev/mcp. Add the URL as a custom connector, sign in with your GPU Finder email and approve access. Disconnect applications in the developer portal.
Step 3: Ask your agent
- “How many GPU Finder calls do I have left this month?”
- “What is the cheapest 8x H100 in stock right now?”
- “Compare H200 and B200 prices across providers.”
- “How has the A100 price moved over the last year?”
Each tool call uses one of your monthly calls;
get_usageis free. Tools: list_gpus, list_providers, get_prices, get_market_snapshot, get_availability, get_price_history, get_data_status, get_usage.
Also listed on Claude directory · Smithery · Glama · mcpservers.org and the official MCP Registry as dev.gpufinder/gpufinder.
Compare a GPU price with observed stock and history
Ask: “Compare listed and recently observed in-stock prices for an 8× H100 node. Show the provider, region, node price, per-GPU price and observation time. Then show the available seven-day stock history, including coverage gaps.”
- Check the connection with
get_usageand empty arguments{}. This requires your key but spends no monthly data calls. - Call
get_market_snapshotwith{"gpu":"h100","count":8}. ComparecheapestListedwithcheapestAvailable; the latter can be null. A low catalogue price with unknown stock is not an in-stock recommendation. - Call
get_availabilitywith{"gpu":"h100","provider":"runpod","page":{"limit":20}}, substituting the provider from your snapshot. Read the returned GPU counts and coverage; this tool has no count filter. FollownextCursorwith the same filters if needed.
cheapestListedis the lowest price on any list; its stock can be unknown.cheapestAvailableis the lowest price seen in stock, and can be null.- Prices are USD per hour, both for the whole node and per GPU.
- Stock is checked hourly and most prices daily; stock signals older than six hours count as unknown.
- Stock seen at the last check is not a capacity guarantee.
The two data calls above cost two units; each additional page costs one. Seven-day availability cells describe observations per provider and node size. Missing observations are unknown. They do not measure provider uptime, guarantee a launch, or establish complete historical coverage.
For longer availability history, use the separate monthly availability index with named-provider and GPU-count records, duration-weighted measurements, coverage fields and CSV/JSON exports. It is not the MCP get_price_history tool, which returns monthly prices for up to 12 months where data exists. Read the data methodology before comparing the measures.
Server identity: dev.gpufinder/gpufinder. Public client source: gpufinder/mcp. No rental, reservation or purchase tools.
Watch GPU availability on a recurring schedule
Check the same GPU count, provider, region and budget each day, then report meaningful changes. This starter watches 8× RTX 5090 on Lium in Japan for at most $5 per whole node-hour. Edit the watch to fit your workload.
- Choose a canonical GPU/provider slug and exact provider-reported region from
get_prices. Region matching ignores case; “Japan” is an exact label, while “Asia” does not expand into countries. - Run one check through REST or MCP. The first successful run writes a baseline; later runs print a JSON event only when eligibility or an eligible offer's provider, region or node price changes.
- Have your scheduler run the same command with a persistent state file. Route events to your own notification handler and treat a nonzero exit as a failed check. Unchanged successful checks stay quiet.
Node.js 22+ · no packages
curl -fsS https://gpufinder.dev/examples/availability-watch.mjs -o availability-watch.mjs
curl -fsS https://gpufinder.dev/examples/availability-watch.json -o watch.json
# Load GPUFINDER_API_KEY from your server's secret manager.
node availability-watch.mjs --config watch.json --state watch-state.json --transport restSame script and watch-state.json
curl -fsS https://gpufinder.dev/examples/availability-watch.mjs -o availability-watch.mjs
curl -fsS https://gpufinder.dev/examples/availability-watch.json -o watch.json
# In the directory containing availability-watch.mjs:
npm install @modelcontextprotocol/client@2.4.0
# Load GPUFINDER_API_KEY from your server's secret manager.
# The same watch and baseline work with either transport.
node availability-watch.mjs --config watch.json --state watch-state.json --transport mcpDownload the watcher · Example watch configuration. The starter checks usage before spending one data unit, prevents overlapping runs and preserves its baseline on failed or stale responses. It never books capacity.
Prompt for a scheduled MCP client
At each scheduled check, use GPU Finder to check 8× RTX 5090 on Lium in the provider-reported region Japan, at most $5 USD per whole node-hour.
Call get_usage first; if no monthly data units remain, stop and report the reset/allowance issue. Then call get_market_snapshot with {"gpu":"rtx-5090","count":8,"provider":"lium","region":"Japan"}.
Require filters.provider="lium" and filters.region="japan" in the response. Use cheapestAvailable, require fresh available/limited stock, and compare wholeNodeHourlyPrice to $5. A null offer means no confirmed stock, not proof of sold-out capacity. Never substitute cheapestListed as in-stock.
Keep the last successful comparison in client-owned state for this exact watch. Report a first-run baseline; afterwards notify only when stock becomes eligible, eligibility changes, or the eligible provider/region/node price changes. Ignore timestamp-only and history-only changes; stay quiet when unchanged.
On errors, stale or older snapshots, preserve the previous comparison and report the failed check separately. Do not replay uncertain requests automatically. Each snapshot costs one unit; usage costs zero units. Include GPU count, region, node/GPU-hour prices, observation time, rental link and any supplied history coverage. History is reported stock, not uptime or a launch guarantee.
This prompt needs a scheduler and persistent state in the client. GPU Finder does not create a schedule, send notifications, reserve or rent a GPU.Use this in a client that supports scheduling and durable state. Connecting an MCP server alone does not schedule a check or enable notifications.
| Cadence | Snapshot calls |
|---|---|
| Daily | 31 |
| Every 6 hours | 124 |
| Hourly | 744 |
Usage checks spend no monthly units but are rate limited. Each additional watch, data call or history page adds to the same account allowance across REST and MCP. One daily watch fits within Free 60 if other calls leave enough room; hourly checks exceed Paid 600 in a 31-day period. Check your remaining allowance before choosing a cadence.
Stock can change between observations. Limited stock can be rentable even with 0% fully-available history. A missing or stale observation is not proof that a provider is sold out. Provider-reported regions do not guarantee placement; confirm the exact configuration with the provider before renting.
Pricing
One allowance per account, shared by REST and MCP. Every plan includes up to 3 active keys and 120 requests a minute. Usage checks and MCP discovery are free.
Free
$0 / month
- 60 data calls a month
- Resets on the 1st of each month (UTC)
- No card needed
Paid
$9 / month
- 600 data calls a month
- Resets on your subscription anniversary
Unlimited
$199 / month
- Unlimited data calls
- No monthly cap; rate and query bounds still apply
Need a one-off bump instead of a plan? Request a temporary extension.
How usage is counted: limits, accounting and headers
Free accounts receive 60 data operations per UTC calendar month, resetting on the first day at 00:00 UTC. The first partial month includes all 60; unused units do not roll over. Up to 3 active keys share one account allowance across REST and MCP. The default keyed account rate is 120 authenticated requests per minute, including invalid input and usage; effective limits appear in usage. Network and service protections can also apply.
Successful admission spends one monthly unit, including cache hits, empty results and later failures, timeouts or disconnects. Authentication, validation, rate and quota denials spend no monthly units; invalid authenticated input costs rate only. Every separate inbound retry is a new operation. Check usage after uncertain transport failures before deciding to replay.
X-RateLimit-Scope distinguishes account, IP and infrastructure controls. Account rate headers and monthly X-Quota-* headers are separate; reset headers use Unix seconds. JSON reset times are UTC ISO timestamps. Effective limits can include a reviewed temporary extension. Unlimited usage has null limit/remaining/reset and omits those finite numeric headers; it retains rate and query bounds.
Usage reads, MCP discovery, and session-authorized key/extension management spend no monthly units and retain their own rate protections. The signed-in portal works without an active key and at data exhaustion. Rotating a key preserves account usage.
Prefer REST? Make a first call
Put your key in the GPUFINDER_API_KEY environment variable (from your secret manager, not your shell history), then fetch a market snapshot. Each data request uses one monthly call; get a free key if you don't have one.
Terminal
curl -sS "https://gpufinder.dev/api/v1/snapshot?gpu=h100&count=1" \
-H "Authorization: Bearer $GPUFINDER_API_KEY"
# Remaining calls this month (free, spends no units)
curl -sS https://gpufinder.dev/api/v1/usage \
-H "Authorization: Bearer $GPUFINDER_API_KEY"Node.js 18+ (built-in fetch)
const res = await fetch("https://gpufinder.dev/api/v1/snapshot?gpu=h100&count=1", {
headers: { Authorization: `Bearer ${process.env.GPUFINDER_API_KEY}` },
})
const { data } = await res.json()
if (!res.ok) throw new Error(`${data.error.code}: ${data.error.message}`)
console.log(data.cheapestAvailable)Python 3 with requests
import os
import requests
res = requests.get(
"https://gpufinder.dev/api/v1/snapshot",
params={"gpu": "h100", "count": 1},
headers={"Authorization": f"Bearer {os.environ['GPUFINDER_API_KEY']}"},
timeout=10,
)
data = res.json()["data"]
if not res.ok:
raise RuntimeError(f"{data['error']['code']}: {data['error']['message']}")
print(data["cheapestAvailable"])Sample response
{
"version": "v1",
"generatedAt": "2026-08-24T18:23:01.000Z",
"data": {
"gpu": "H100",
"count": 1,
"asOf": "2026-08-24T18:23:00.000Z",
"generatedAt": "2026-08-24T18:23:01.000Z",
"providersCompared": 18,
"priceCurrency": "USD",
"priceBasis": "per_gpu_hour",
"cheapestListed": {
"provider": "Hyperbolic",
"region": "default",
"gpuCount": 1,
"wholeNodeHourlyPrice": 1.29,
"perGpuHourlyPrice": 1.29,
"availabilityStatus": "unknown",
"availabilityCheckedAt": null,
"outboundUrl": "https://gpufinder.dev/go/hyperbolic"
},
"cheapestAvailable": {
"provider": "Vast",
"region": "US",
"gpuCount": 1,
"wholeNodeHourlyPrice": 1.34,
"perGpuHourlyPrice": 1.34,
"availabilityStatus": "limited",
"availabilityCheckedAt": "2026-08-24T18:00:00.000Z",
"outboundUrl": "https://gpufinder.dev/go/vast"
},
"availabilityFreshness": {
"maxAgeHours": 6,
"updateCadence": "hourly"
},
"methodologyUrl": "https://gpufinder.dev/about#methodology",
"canonicalUrl": "https://gpufinder.dev/gpu/h100"
}
}Reading the response
cheapestListedis the lowest price on any list; its stock can be unknown.cheapestAvailableis the lowest price seen in stock, and can be null.- Prices are USD per hour, both for the whole node and per GPU.
- Stock is checked hourly and most prices daily; stock signals older than six hours count as unknown.
- Stock seen at the last check is not a capacity guarantee.
REST and MCP reference
| REST GET /api/v1/ | MCP tool | REST parameters / result |
|---|---|---|
| gpus | list_gpusMCP paginated | None GPU catalogue, counts, price ranges and known specs |
| providers | list_providersMCP paginated | None; rejects query parameters Provider catalogue, egress, reliability and outbound links |
| prices | get_pricesMCP paginated | gpu required; count defaults to 1 Current whole-node hourly on-demand and spot prices |
| snapshot | get_market_snapshot | gpu required; count defaults to 1; provider and exact region optional Separate cheapest listed and observed in-stock offers, USD per node and per GPU-hour; applied filters echoed |
| availability | get_availabilityMCP paginated | gpu required; provider optional Seven-day availability cells and coverage by provider/count |
| history | get_price_historyMCP paginated | gpu required; count defaults to 1 Monthly per-provider floors: REST three-year cutoff; MCP defaults/max 12 months |
| status | get_data_status | None Collection timestamps and provider run health; one data unit |
| usage | get_usage | None; rejects query parameters Effective shared usage, remaining units and UTC reset; zero monthly units |
GPU names/slugs are 1–100 characters; count is an integer from 1 to 10,000, default 1. The optional provider is a name or slug, 1–100 characters. REST retains full-result {version:"v1",generatedAt,data} envelopes and the existing three-year history cutoff. REST does not support MCP page or months: most REST routes ignore unknown query inputs, while providers and usage reject them.
In keyed mode, full results are bounded to 10,000 rows and 2 MiB of serialized data, with a ten-second service deadline; oversized results fail rather than truncate. Use narrower supported filters or MCP pages. Legacy mode retains its original handler behavior. Keyed responses are private/no-store. GET preflight permits Authorization; CORS permission does not make a browser a safe place to keep a secret.
MCP paginated tools accept {page:{limit:20,cursor:"…"}}, with limit 1–100, default 20, and cursor at most 512 characters (ten-minute lifetime). Each page costs one unit. Reuse identical filters and limit with nextCursor; restart from the first page after an expired/invalid cursor. History accepts months 1–12, default 12, per provider series. Snapshot, status and usage reject pagination. Tools reject unknown input properties.
OpenAPI 3.1 JSON and its identical v1 alias are anonymous, available at quota exhaustion and spend no monthly units. llms.txt publishes the same access guidance.
Errors and recovery
| Status | Code | What to do |
|---|---|---|
| 401 | invalid_credential | Key missing, invalid, expired or revoked. Create a key and send it in the Authorization header, never in the URL. |
| 403 | account_disabled | Email hello@gpufinder.dev with the request ID. A new key does not re-enable an account. |
| 429 | rate_limited | Wait until Retry-After, lower concurrency and add jitter. X-RateLimit-Scope says whether the limit is your account or a shared IP. |
| 429 | quota_exceeded | Monthly calls used up. Check usage for the reset time, then wait, upgrade or request an extension. Rotating keys does not reset quota. |
| 400 / 404 / 422 | bad_request · not_found · result_too_large | Fix the input, pick a tracked GPU or narrow the result. Validation errors spend no monthly calls. |
| 503 | enforcement_unavailable · data_unavailable | Temporary. Honor Retry-After and back off; check usage before retrying data calls. |
| 504 | deadline_exceeded | The call may still have counted. Check usage before retrying; see the details below. |
MCP connection problems
- The client shows the server as failed
- Check that
YOUR_API_KEYwas replaced, then restart the client after editing its config file. - Claude Code
- Run
claude mcp get gpufinderto see the saved URL and header, or/mcpinside a session for live status. - Claude Desktop, Windsurf, Cline (npx)
- Run
node --version; the package needs Node.js 20 or newer. - Tools appear but every call fails
- Ask your agent how many GPU Finder calls you have left.
get_usageis free and shows whether you hit the monthly limit.
Error body format and timeouts (504)
REST error bodies use data.error. Keyed errors include a server request ID and may include retry/reset and admission metadata. Recovery links are in error.links and the Link header. For example, a missing key:
{
"version": "v1",
"generatedAt": "2030-11-01T00:00:00.000Z",
"data": {
"error": {
"code": "invalid_credential",
"message": "An API key is now required to use the GPU Finder API. Keys are free and include 60 operations a month. Sign up or sign in at https://gpufinder.dev/developers, create an API key, then send it in the Authorization header as Bearer YOUR_API_KEY. See https://gpufinder.dev/api-access for migration instructions.",
"requestId": "example-request",
"links": {
"keys": "https://gpufinder.dev/developers",
"migration": "https://gpufinder.dev/api-access",
"extensions": "https://gpufinder.dev/api-access#extensions"
}
}
}
}On 504 deadline_exceeded, inspect admissionStatus (not_admitted, committed or unknown), accountingVerified and usageRecovery. An unknown outcome is not proof of no charge, so check usage rather than replaying blindly. REST returns usage headers; MCP can also return a verified receipt. A not-found or size failure after admission keeps its monthly debit.
Over MCP, tool errors set isError: true with a typed error in structuredContent; authentication errors arrive at the transport level, before any tool result.
Migration guide · Temporary extension process · Data methodology
MCP protocol details, client compatibility and SDK example
Use Streamable HTTP POST at https://gpufinder.dev/mcp with a protected bearer header. Both the modern protocol 2026-07-28 and the 2025-era initialize handshake most clients send are served and metered the same way. OAuth sign-in is available alongside API keys. There is no persistent MCP session or GET stream. Server discovery and tools/list answer without a key so directories can show the tools; every tool call needs an API key or OAuth access token.
The official TypeScript client @modelcontextprotocol/client@2.3.0 with protocol 2026-07-28 and MCP Inspector 2.9.0 CLI in modern HTTP mode were verified against isolated HTTP fixtures. The example client below is tested locally with the same pinned SDK. No Claude, ChatGPT or IDE compatibility pass is claimed.
| Client | Configuration | Validation scope |
|---|---|---|
| Official TypeScript client 2.3.0 | Streamable HTTP; protocol 2026-07-28 or its default 2025 handshake; bearer header | Runnable snapshot and usage examples tested on isolated local HTTP |
| VS Code (native configuration) | .vscode/mcp.json: servers object, HTTP transport and masked input variable | Configuration follows Microsoft's documented schema; the client connection is not individually verified |
| Cursor, Claude Code (remote URL) | Use the client-specific tabs above | Their 2025-era handshake is served and tested at protocol level; each app is not individually verified |
| npm package gpufinder (npx -y gpufinder mcp) | Local stdio proxy to this endpoint; key from GPUFINDER_API_KEY. For Claude Desktop, Cline, Windsurf and other stdio-only clients | initialize, tools/list and tool calls tested end-to-end against production; each app is not individually verified |
| MCP Inspector 2.9.0 CLI | HTTP transport; modern era; bearer header | Prior isolated all-tool validation; this documentation change does not rerun Inspector |
| OAuth clients | Connect https://gpufinder.dev/mcp and authorize your GPU Finder account | Authorization, refresh, revocation and shared quota tested locally; listed in the Claude directory; other catalog listings and individual client acceptance are separate |
Install that exact client version, set GPUFINDER_MCP_URL to the hosted endpoint and load GPUFINDER_API_KEY from a secret manager. Save the following as an .mjs file and run it with Node 22.23.0 or the project’s verified runtime. Both data transports share usage; discovery and get_usage cost zero monthly units.
import { Client, StreamableHTTPClientTransport } from "@modelcontextprotocol/client"
const client = new Client({ name: "gpu-reader", version: "1" }, {
versionNegotiation: { mode: { pin: "2026-07-28" } },
})
const transport = new StreamableHTTPClientTransport(new URL(process.env.GPUFINDER_MCP_URL), {
requestInit: { headers: { Authorization: `Bearer ${process.env.GPUFINDER_API_KEY}` } },
})
await client.connect(transport)
try {
const result = await client.callTool({
name: "get_market_snapshot", arguments: { gpu: "h100", count: 1 },
})
console.log(result.structuredContent)
console.log((await client.callTool({ name: "get_usage", arguments: {} })).structuredContent)
} finally { await client.close() }Tool errors set isError: true and carry a typed error in structuredContent. Transport authentication/protocol errors may arrive before a tool result. Inspect both; an HTTP 200 alone does not mean the tool succeeded. Successful calls include usage and, for data calls, an admission receipt. A verified receipt records admitted work; JSON-RPC IDs do not deduplicate calls.
Inspector 2.9.0 CLI reports transport authentication failure but does not display the response’s recovery URLs. Open the developer portal, follow the migration guide, and reconnect with your key. Its quota tool-error output includes usage and extension guidance. Clickable links in other client interfaces are not verified.