GPU Finder

npx add-mcp 'https://gpufinder.dev/mcp'

Connect your AI agent

Give Claude, Cursor or any MCP client live GPU prices, stock and price history. Server: https://gpufinder.dev/mcp.

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. Connect your agent

   Pick your client and replace YOUR_API_KEY with your key. Claude CodeCursorVS CodeClaude DesktopCodex CLIGemini CLIWindsurf, Cline, other Copy 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. Clients that only support OAuth sign-in, such as ChatGPT connectors, are not supported yet.

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 Smithery · Glama · mcpservers.org and the official MCP Registry as dev.gpufinder/gpufinder.

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

REST GET /api/v1/	MCP tool	REST parameters / result
gpus	list_gpus MCP paginated	None GPU catalogue, counts, price ranges and known specs
providers	list_providers MCP paginated	None; rejects query parameters Provider catalogue, egress, reliability and outbound links
prices	get_prices MCP 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 Separate cheapest listed and observed in-stock offers, USD per node and per GPU-hour
availability	get_availability MCP paginated	gpu required; provider optional Seven-day availability cells and coverage by provider/count
history	get_price_history MCP 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_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. There is no OAuth adapter, persistent session or GET stream. Server discovery and tools/list answer without a key so directories can show the tools; every tool call needs one.

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; OAuth-only clients are unsupported.

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-only clients / other versions	No OAuth adapter	Unsupported or unverified; no compatibility promise

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.