Skip to content
GPU Finder

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.

Get a free API keyConnect your agent60 free calls a month · no card · email sign-in

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.

  1. 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 key
  2. Step 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 Claude

    Pick your client and replace YOUR_API_KEY with your key.

    Terminal

    claude mcp add --transport http --scope user gpufinder https://gpufinder.dev/mcp --header "Authorization: Bearer YOUR_API_KEY"
    Check it with claude mcp list. Drop --scope user to 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.

  3. 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_usage is 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.”

  1. Check the connection with get_usage and empty arguments {}. This requires your key but spends no monthly data calls.
  2. Call get_market_snapshot with {"gpu":"h100","count":8}. Compare cheapestListed with cheapestAvailable; the latter can be null. A low catalogue price with unknown stock is not an in-stock recommendation.
  3. Call get_availability with {"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. Follow nextCursor with the same filters if needed.
  • cheapestListed is the lowest price on any list; its stock can be unknown. cheapestAvailable is 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.

  1. 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.
  2. 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.
  3. 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 rest

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

One watch: data calls over 31 days
CadenceSnapshot calls
Daily31
Every 6 hours124
Hourly744

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
    Get a free key
  • Paid

    $9 / month

    • 600 data calls a month
    • Resets on your subscription anniversary
    Upgrade in the portal
  • Unlimited

    $199 / month

    • Unlimited data calls
    • No monthly cap; rate and query bounds still apply
    Upgrade in the portal

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"
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

  • cheapestListed is the lowest price on any list; its stock can be unknown. cheapestAvailable is 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

Seven data operations and zero-unit usage
REST GET /api/v1/MCP toolREST parameters / result
gpuslist_gpusMCP paginated

None

GPU catalogue, counts, price ranges and known specs

providerslist_providersMCP paginated

None; rejects query parameters

Provider catalogue, egress, reliability and outbound links

pricesget_pricesMCP paginated

gpu required; count defaults to 1

Current whole-node hourly on-demand and spot prices

snapshotget_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

availabilityget_availabilityMCP paginated

gpu required; provider optional

Seven-day availability cells and coverage by provider/count

historyget_price_historyMCP paginated

gpu required; count defaults to 1

Monthly per-provider floors: REST three-year cutoff; MCP defaults/max 12 months

statusget_data_status

None

Collection timestamps and provider run health; one data unit

usageget_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

Error codes and how to recover
StatusCodeWhat to do
401invalid_credentialKey missing, invalid, expired or revoked. Create a key and send it in the Authorization header, never in the URL.
403account_disabledEmail hello@gpufinder.dev with the request ID. A new key does not re-enable an account.
429rate_limitedWait until Retry-After, lower concurrency and add jitter. X-RateLimit-Scope says whether the limit is your account or a shared IP.
429quota_exceededMonthly calls used up. Check usage for the reset time, then wait, upgrade or request an extension. Rotating keys does not reset quota.
400 / 404 / 422bad_request · not_found · result_too_largeFix the input, pick a tracked GPU or narrow the result. Validation errors spend no monthly calls.
503enforcement_unavailable · data_unavailableTemporary. Honor Retry-After and back off; check usage before retrying data calls.
504deadline_exceededThe 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_KEY was replaced, then restart the client after editing its config file.
Claude Code
Run claude mcp get gpufinder to see the saved URL and header, or /mcp inside 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_usage is 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.

Verified MCP versions and limitations
ClientConfigurationValidation scope
Official TypeScript client 2.3.0Streamable HTTP; protocol 2026-07-28 or its default 2025 handshake; bearer headerRunnable snapshot and usage examples tested on isolated local HTTP
VS Code (native configuration).vscode/mcp.json: servers object, HTTP transport and masked input variableConfiguration follows Microsoft's documented schema; the client connection is not individually verified
Cursor, Claude Code (remote URL)Use the client-specific tabs aboveTheir 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 clientsinitialize, tools/list and tool calls tested end-to-end against production; each app is not individually verified
MCP Inspector 2.9.0 CLIHTTP transport; modern era; bearer headerPrior isolated all-tool validation; this documentation change does not rerun Inspector
OAuth clientsConnect https://gpufinder.dev/mcp and authorize your GPU Finder accountAuthorization, 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.