Build with GPU Finder

Make a keyless API call

No account or API key is needed. Start with a market snapshot:

curl --silent --show-error 'https://gpufinder.dev/api/v1/snapshot?gpu=h100&count=1'

Keyed usage is unavailable in legacy mode. Account quotas below are a future keyed-mode reference.

REST and MCP reference

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.

Future keyed-mode 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, pricing and checkout are not offered here.

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.

MCP setup preview

For an enabled environment, use Streamable HTTP POST at https://gpufinder.dev/mcp with a protected bearer header. The hosted endpoint is disabled; it has no retry date. There is no OAuth adapter, initialization handshake, persistent session or GET stream for the supported modern protocol.

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.

Install that exact client version, provide GPUFINDER_MCP_URL for an enabled test 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.

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