GPU Finder

Live cloud GPU prices, hourly stock checks and 12-month price history across 30+ providers (hyperscalers, neoclouds, marketplaces). Remote over Streamable HTTP at https://gpufinder.dev/mcp; read-only tools; free API key.

View on gpufinder.dev

Hosted MCP Server

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

Installs into Claude Code, Codex, Cursor and more

Documentation

MCP setup

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

  1. 1. Add GPU Finder to your client

    Claude Code Run this in a terminal. 
    claude mcp add --transport http gpufinder https://gpufinder.dev/mcp --header "Authorization: Bearer YOUR_API_KEY"
    Claude Desktop, Cline, Windsurf (npx) Add to claude_desktop_config.json or your client's mcpServers file. Uses the open-source gpufinder npm package (source), a small stdio proxy to the hosted endpoint. Requires Node.js 20 or newer. 
    {
  "mcpServers": {
    "gpufinder": {
      "command": "npx",
      "args": ["-y", "gpufinder", "mcp"],
      "env": { "GPUFINDER_API_KEY": "YOUR_API_KEY" }
    }
  }
}
    Cursor Merge into .cursor/mcp.json. 
    {
  "mcpServers": {
    "gpufinder": {
      "url": "https://gpufinder.dev/mcp",
      "headers": { "Authorization": "Bearer YOUR_API_KEY" }
    }
  }
}
    VS Code Save as .vscode/mcp.json. VS Code prompts for the key and masks it. See Microsoft's MCP configuration reference. 
    {
  "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}" }
    }
  }
}
    Also listed on Smithery · Glama · and the official MCP Registry as dev.gpufinder/gpufinder.

  2. 2. Replace YOUR_API_KEY with a free key

    Sign in to the developer portal with your email and create a key. Free accounts get 60 data operations a month, shared with REST. Keep the key private and out of committed project files.

  3. 3. Ask your agent

    • “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?” Tools: list_gpus, list_providers, get_prices, get_market_snapshot, get_availability, get_price_history, get_data_status, get_usage and get_usage. Advanced MCP details: protocol, compatibility, 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.

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 separate client-specific examples belowTheir 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-only clients / other versionsNo OAuth adapterUnsupported 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.

Developer portal

Sign in with your email to create API keys, watch usage and manage your plan. There is no password: we email you a sign-in link, and the same link creates your account.

Sign in to the developer portal

Prefer REST? Get a key and make a first call

  1. Open the developer portal, enter your email and request a sign-in link. Open the verification page from that email and select Continue. Links expire after ten minutes; request a fresh link if needed.
  2. Under API keys, choose a label and optional expiry, then create a key. Copy it into your server’s secret manager before hiding it. The full secret is shown once and cannot be retrieved later.
  3. Supply the key as the environment variable GPUFINDER_API_KEY from your secret manager, then run this snapshot request. It is one data operation in keyed mode.
# Supply GPUFINDER_API_KEY from your secret manager; do not paste it into history.
export GPUFINDER_BASE_URL="https://gpufinder.dev"
curl --silent --show-error --config - <<EOF
url = "${GPUFINDER_BASE_URL}/api/v1/snapshot?gpu=h100&count=1"
header = "Authorization: Bearer ${GPUFINDER_API_KEY}"
EOF

The snapshot separates cheapestListed from cheapestAvailable. A listed winner can have unknown stock; the in-stock winner can be null. Prices are USD: most price rows describe a whole node per hour; snapshot gives both whole-node and per-GPU-hour prices. Collected stock is not a capacity guarantee. Signals older than six hours become unknown; stock is polled hourly and most prices daily.

To inspect usage, replace the curl URL with ${GPUFINDER_BASE_URL}/api/v1/usage, keeping the bearer header. Read data.monthly and data.rate. Usage remains available at monthly exhaustion in keyed mode.

REST and MCP reference

REST GET /api/v1/MCP toolREST parameters / result
gpuslist_gpus MCP paginatedNone GPU catalogue, counts, price ranges and known specs
providerslist_providers MCP paginatedNone; rejects query parameters Provider catalogue, egress, reliability and outbound links
pricesget_prices MCP paginatedgpu required; count defaults to 1 Current whole-node hourly on-demand and spot prices
snapshotget_market_snapshotgpu required; count defaults to 1 Separate cheapest listed and observed in-stock offers, USD per node and per GPU-hour
availabilityget_availability MCP paginatedgpu required; provider optional Seven-day availability cells and coverage by provider/count
historyget_price_history MCP paginatedgpu required; count defaults to 1 Monthly per-provider floors: REST three-year cutoff; MCP defaults/max 12 months
statusget_data_statusNone Collection timestamps and provider run health; one data unit
usageget_usageNone; 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.

Shared keyed limits and accounting

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.

Paid plans: Paid is USD 9 a month for 600 data operations; Unlimited is USD 199 a month with no monthly cap (rate and query bounds still apply). Buy or change a plan in the developer portal at https://gpufinder.dev/developers/billing; Free needs no purchase.

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.

Errors and recovery

  • 401 invalid_credential: missing key: verify your email and create a key; invalid, expired or revoked key: replace it in your protected header configuration. Do not put it in a URL.
  • 403 account_disabled: contact hello@gpufinder.dev with the request ID. A different key does not re-enable an account.
  • 429 rate_limited: pause until Retry-After/reset, reduce concurrency and add jitter. Check X-RateLimit-Scope; other accounts on your network may share an IP limit.
  • 429 quota_exceeded: inspect usage and its reset time (Free: UTC calendar month; paid allowance: subscription anniversary); wait or request an extension. Rotating keys does not replenish quota. Do not repeatedly retry exhausted data requests.
  • 503 enforcement_unavailable / data_unavailable: temporary unavailability. Honor Retry-After when supplied and use bounded backoff; first check accounting and usage before retrying data. Deliberately disabled MCP omits Retry-After.
  • 504 deadline_exceeded: work may have been admitted. Inspect admissionStatus (not_admitted, committed or unknown), accountingVerified and usageRecovery. An unknown outcome is not proof of no charge; inspect usage rather than replay blindly. REST returns usage headers, while MCP can also return a verified receipt. Disconnects can prevent any receipt from reaching you.
  • 400 bad_request / 404 not_found / 422 result_too_large: correct input, choose a tracked GPU or narrow the result. Validation spends rate only; a not-found or size failure after admission keeps its monthly debit.

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. Original legacy errors can omit that metadata. For example, a missing key at enforcement:

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

Migration guide · Temporary extension process · Data methodology