ComputePrices API

Cloud GPU and LLM inference pricing, catalog, daily trends, and weekly movers — all under /api/v1/* as stable JSON.

Quickstart

Every endpoint needs an API key. One takes about 30 seconds: sign in with any email at computeprices.com/account/api-keys (magic link, no password), create a key, then:

curl -H "Authorization: Bearer cp_live_..." \
  https://computeprices.com/api/v1/gpu-prices

Your first key is a 14-day trial: latest prices, the full catalog, weekly movers, and a 30-day window on trends and raw price history. After the trial the key stops working unless you subscribe to Pro — $299/month or $2,499/year prepaid, for a 90-day window and the right to show our figures in your product, or to Builder — $79/month, for internal use with the trial's 30-day window. The archive back to December 2024 is a one-time backfill.

Three things if you're running an agent or automated tool:

• Send a descriptive User-Agent header.
• Respect Retry-After on 429 responses.
• Read meta.upgrade_hint — it names the next-tier features, not just throughput.

A raw markdown copy of this page is at /docs/api.md — curl it directly. The full machine-readable schema lives at /api/v1/openapi.json (OpenAPI 3.1) — feed it to your client generator, agent framework, or MCP server. For broader site discovery, see llms.txt.

Tiers

What you get at each tier:

On every tier, trial included: latest GPU and LLM prices, filters (provider, gpu/model, pricing_type), the GPU / LLM / provider catalog, and weekly movers. Coming to every tier in v1.1 (the next release): provider comparison, cheapest-per-model aggregates, raw LLM price history, and CSV / NDJSON export; in v1.2: LLM benchmarks (throughput, TTFT).

roadmap = planned, no date. Full history = every observation we hold, daily from April 2025 and sparser back to December 2024.

Plans differ on history depth and usage rights, not throughput. Pricing data refreshes hourly at most, so a real integration makes tens of calls a day; the request limit is a fair-use ceiling, the same on every self-serve plan. A trial and Builder see 30 days of history and Pro, monthly or annual, a rolling 90 days. The archive behind that window is sold once, as a backfill.

Trial

Every self-serve key starts a 14-day trial — live prices, the full catalog and 30 days of history, no card, nothing to cancel. On day 15 the key stops validating; subscribe to Pro or Builder and it comes back at the paid tier, with no expiry. The trial belongs to the account, not the key: revoking and re-creating a key does not restart it. If you're using the data for research or a personal project and Pro doesn't fit, email api@computeprices.com and say what you're doing.

Pro

Pro is a flat subscription — $299/month, or $2,499/year prepaid (the same plan, two months free):

• Daily price trends (/trends/gpu/{slug}, /trends/llm/{slug}) and raw GPU price history (/gpu-prices/history) with a rolling 90-day window.
• The v1.1 endpoints as they ship: provider comparison, cheapest-per-model aggregates, LLM raw price history, CSV/NDJSON export.
• Up to 3 active API keys (trials get 1) — useful for per-environment keys or zero-downtime rotation.
• The right to show our figures in a product or on a public page, with a "market data via ComputePrices" credit linking to computeprices.com. Trials are for evaluation only.

Upgrade self-serve from the API keys dashboard — all keys on your account move to the paid tier immediately, and new keys you create inherit it.

Cancelling is self-serve from the same page: Manage billing opens the Stripe customer portal, where you can cancel, change your card, or download invoices. Cancelling stops the renewal; your keys keep working until the paid period ends and stop after that.

Builder

Builder is $79/month for using the data inside your own organization — research, analysis, internal dashboards and reports:

• Everything a trial key gets, with no expiry: latest prices, the full catalog, weekly movers, and a 30-day window on trends and raw GPU price history.
• Up to 3 active API keys.
• Internal use only. Showing our figures in a product or on a public page needs Pro; redistribution, index construction and use as a financial reference need Enterprise.

Subscribe from the API keys dashboard. Moving between Builder and Pro is done from Manage billing; your keys follow the new plan as soon as the change goes through.

Full-history backfill

Pro's window rolls: it always covers the last 90 days. The archive behind it is sold once, for $7,499: every GPU price observation we hold (daily from April 2025, sparser back to December 2024) and every LLM price observation (from January 2026), up to the end of the purchase date. You get them as NDJSON or CSV files — GPU rows in the same format as /gpu-prices/history, LLM rows in the matching per-1M-token shape, both with the normalization audit trail — plus a manifest with row counts and a SHA-256 per file, for internal use. From then on, your own polling of the 90-day window keeps your copy current, so there is nothing to renew. Publishing the archive or building an index on it needs Enterprise terms. A one-week sample file is available on request, so you can check the format and coverage before buying. Email api@computeprices.com to buy one.

Enterprise

Raw per-scrape observations, redistribution and index-construction rights, and provider data-health metrics (v1.2), with service terms agreed per contract. One-time historical extracts for a single GPU are also available. Samples scoped to the datasets you're evaluating are available on request. Not self-serve — email api@computeprices.com to talk it through.

Authentication

Every request needs a Bearer token:

curl -H "Authorization: Bearer cp_live_..." \
  https://computeprices.com/api/v1/gpu-prices

Requests without a key get a 401 with a pointer to signup. (The only exception is /api/v1/openapi.json — the schema itself is open so agents and client generators can discover the API.)

Getting a key

Sign in with any email at computeprices.com/account/api-keys — a magic link, no password. Create a key, copy it (it's shown only once), and you're done: it works for 14 days, with a 30-day history window. Trials get 1 active key (Pro raises it to 3). Upgrade to Pro from the same dashboard; for Enterprise, email api@computeprices.com.

Endpoints

All endpoints return { data, meta }. meta always includes version, generated_at, tier, attributions (credit owed to openly licensed sources whose rows the API serves; see Data sources and licences), and (when rate-limiting is in play) rate_limit and upgrade_hint.

The examples below omit the required -H "Authorization: Bearer cp_live_..." header for brevity.

Pricing

GET /api/v1/gpu-prices · all tiers

Latest GPU prices across every tracked provider. One row per (provider, GPU, pricing_type, node size).

Query parameters:

Example:

curl "https://computeprices.com/api/v1/gpu-prices?gpu=h100&pricing_type=on_demand"

Each row carries an available field — the provider's own stock signal at collection time. true means rentable, false means listed but out of capacity, and null means the provider publishes no stock signal at all (most catalog-priced providers). Filter on it before treating the cheapest row as the one to buy.

Response:

{
  "data": [
    {
      "provider": "Lambda",
      "provider_slug": "lambda",
      "provider_url": "https://lambdalabs.com",
      "gpu": "H100 80GB",
      "gpu_slug": "h100",
      "vram_gb": 80,
      "architecture": "Hopper",
      "gpu_count": 1,
      "max_gpus_per_node": 8,
      "price_per_hour_usd": 2.49,
      "total_hourly_usd": 2.49,
      "pricing_type": "on_demand",
      "commitment_months": null,
      "available": true,
      "currency": "USD",
      "exchange_rate_to_usd": 1,
      "source_url": "https://lambdalabs.com/pricing",
      "last_updated": "2026-04-20T10:15:30Z"
    }
  ],
  "meta": {
    "count": 1,
    "generated_at": "2026-04-20T12:00:00Z",
    "version": "v1",
    "tier": "pro",
    "rate_limit": { "limit": 3000, "remaining": 2943, "reset": 1714827060, "window_seconds": 86400 },
    "upgrade_hint": "The full price history back to December 2024 is a one-time $7,499 backfill...",
    "attributions": [
      {
        "source": "Aquanode GPU Price Index",
        "provider_slug": "aquanode",
        "source_url": "https://www.aquanode.io/gpu-index",
        "licence": "CC BY 4.0",
        "licence_url": "https://creativecommons.org/licenses/by/4.0/",
        "changes": "Lowest per-GPU rate per model, matched to our GPU catalog and stored as one-GPU on-demand USD rows."
      }
    ]
  }
}

GET /api/v1/llm-prices · all tiers

Latest LLM inference prices. Per-1M-token input/output pricing, modalities, knowledge cutoff.

Query parameters:

Example:

curl "https://computeprices.com/api/v1/llm-prices?model=claude-3-5-sonnet"

Catalog

GET /api/v1/gpus · all tiers

List of every GPU model we track, with specs (VRAM, architecture, TFLOPs, memory bandwidth).

curl https://computeprices.com/api/v1/gpus

GET /api/v1/gpus/{slug} · all tiers

Single GPU model with full specs.

curl https://computeprices.com/api/v1/gpus/h100

GET /api/v1/llm-models · all tiers

List of tracked LLM models with creator, context window, modalities, and knowledge cutoff.

curl https://computeprices.com/api/v1/llm-models

GET /api/v1/llm-models/{slug} · all tiers

Single LLM model detail.

curl https://computeprices.com/api/v1/llm-models/claude-3-5-sonnet

GET /api/v1/providers · all tiers

List of tracked cloud and inference-API providers (archived providers excluded).

curl https://computeprices.com/api/v1/providers

GET /api/v1/providers/{slug} · all tiers

Single provider detail.

curl https://computeprices.com/api/v1/providers/lambda

Trends & movers

Available on every plan; the trends window depth is what varies — 30 days on the trial and Builder, 90 on Pro, the full history on Enterprise. meta.tier_cap_days in every trend response tells you your cap.

GET /api/v1/trends/gpu/{slug} · all tiers

Daily average on-demand price for a GPU across providers (spot and reserved rows are excluded). days is capped by plan (trial and Builder 30, Pro 90, Enterprise the full history).

Query parameters:

Example:

curl "https://computeprices.com/api/v1/trends/gpu/h100?days=90"

GET /api/v1/trends/llm/{slug} · all tiers

Daily average standard input/output token price for an LLM across providers (batch rows are excluded).

Query parameters:

Example:

curl "https://computeprices.com/api/v1/trends/llm/claude-3-5-sonnet?days=30"

GET /api/v1/movers · all tiers

Biggest week-over-week price changes (up or down) for a (provider, GPU/LLM) pair.

Each mover compares like against like: GPU movers are keyed on (provider, GPU, variant, region, pricing_type, GPU count, commitment term) and LLM movers on (provider, model, pricing_type), so a spot rate is never diffed against an on-demand one, nor a batch rate against standard. Every row carries the pricing_type it applies to — check it before presenting a change as a headline price move.

Query parameters:

Example:

curl "https://computeprices.com/api/v1/movers?scope=gpu&limit=10"

Raw price history

Raw price observations as collected — one row per collection run, not a daily aggregate — including the normalization audit trail: original_price (the value as published by the provider) and normalization_method (how it was converted to a per-GPU hourly USD price). The window depth is capped by plan: 30 days on the trial and Builder, 90 on Pro, the full history on Enterprise; older observations are sold as a backfill.

GET /api/v1/gpu-prices/history · all tiers

Rows are ordered oldest first and paginated. When a page is full, meta.next_cursor carries an opaque cursor — pass it back as cursor to fetch the next page; it is null on the last page.

Query parameters:

Example:

curl "https://computeprices.com/api/v1/gpu-prices/history?gpu=h100&days=90"

Corrections

Price history is an audit trail. When a published price turns out to be wrong — an instance total stored as a per-GPU rate, a row filed under the wrong GPU — the row is corrected and the change is logged: the row as it was published, the row it became, when, and why. See Corrections in the methodology.

GET /api/v1/corrections · all tiers

A feed of every correction in publication order. Each entry carries a seq (its position) and the row before and after the change. Read it with a cursor:

1. Start with after=0, or with a cursor you kept from earlier.
2. Keep requesting with after=<meta.cursor> while meta.has_more is true.
3. When has_more is false, you have everything published so far. Keep the last meta.cursor and poll from it later. It never moves backwards, and an empty page returns the same cursor you sent.

Positions are assigned in the order corrections became visible, not the order they started, so a reader never skips an entry that committed late. A very large correction is published over several requests.

Match price_id against the id of an observation from /gpu-prices/history to reconcile a stored copy. Each entry also says:

• provenance: how the entry was recorded.
  • trigger: captured as it happened (every change since 12 October 2026).
  • reconstructed: an earlier correction, rebuilt per row where the value before it is known exactly.
  • pre_log_summary: an earlier correction recorded once, with what it changed and why but no row values; the rows were deleted before the log existed.
• changed_at_basis: how changed_at is known.
  • captured: the time of the change.
  • migration_file_timestamp: when an earlier correction was written; it ran in production some time later, and that moment was not recorded.
• before / after: the row with the provider and GPU or model slugs it had at the time of the change, so a later rename or merge doesn't rewrite it.
• before_withheld / after_withheld: true when that side's row exists but is null here. Either the observation is older than your plan's history window (meta.history_start; see Tiers), matching what /gpu-prices/history would serve you, or its provider hadn't passed review at the time, so that row was never public.

A correction is published when the row was public on either side of the change. A row moved from an approved provider to one still pending review is listed with before shown and after withheld, so you learn the public row was withdrawn. Changes that only ever touched a pending provider's prices are not published.

Query parameters:

Example:

curl -H "Authorization: Bearer cp_live_..." \
  "https://computeprices.com/api/v1/corrections?after=0"

Pro — coming in v1.1

• GET /api/v1/compare — side-by-side provider comparison with price differences and shared-GPU coverage.
• GET /api/v1/cheapest — cheapest provider per LLM model for input and output tokens.
• GET /api/v1/llm-prices/history — raw LLM price history, mirroring the GPU history endpoint.

Enterprise — coming in v1.2

• GET /api/v1/llm-benchmarks — LLM throughput, time-to-first-token, p95 latency from Artificial Analysis.
• GET /api/v1/providers/{slug}/health — per-provider data-collection health, staleness, and price confidence metrics.

Daily releases

The release API freezes the GPU and LLM prices published in one daily dataset. Publication is best-effort with no SLA: the publisher is scheduled for 07:15 UTC, after the daily collectors, with hourly retries through 23:15 UTC, and every manifest records that target as scheduled_publish_at. A retry returns the same release; it never refreshes its contents. Authorized manual publication captures its actual cutoff, including an early run. There is no historical backfill: no release is created for a date that was missed.

release_date is UTC. cutoff_at is the observation timestamp watermark used by the builder; published_at records publication. Observations and public catalog identities are frozen in one database transaction. Later price corrections, provider archival, catalog renames and removals never alter a release. A release contains exactly the current prices the site and /api/v1/gpu-prices / /api/v1/llm-prices serve at the cutoff: the latest offering from each provider's last two UTC collection dates within 30 days, reviewed providers only. GPU variants, regions, node sizes and commitment terms remain separate offerings.

Each manifest retains the expected reviewed, unarchived provider channels with public pricing, including channels with no observations. A provider of type both has separate GPU and LLM channels. Each channel has a collection_status: fresh if every selected observation is within 24 hours, stale if its newest selected observation is older than 12 days, missing if nothing was selected, and carried_forward otherwise. Rotating providers are often carried forward by design. Each channel also lists the past 24 hours of collection logs with an issue_count (failed runs, unmatched models, skipped sources, or matched rows that were never inserted). These describe what was checked, not proof that every upstream offering was discovered.

Historical access follows the existing tier windows: free 7 days, trial and Builder 30 days, Pro 90 days, Enterprise the full retained archive. The same gate applies to direct release IDs and exports. Releases are available on all tiers under the existing licence; benchmark and derived-distribution rights require their own agreement.

GET /api/v1/releases

Returns summaries newest first; meta.next_before pages older dates. Missing dates indicate publication did not occur.

GET /api/v1/releases/{id}

Returns the immutable manifest, checksum, versions and export URLs. {id} can be a UUID or latest. A missing or out-of-window release returns 404. Check the returned release date: latest can be yesterday's release after a publication failure.

curl -H "Authorization: Bearer cp_live_..." \
  "https://computeprices.com/api/v1/releases/latest"

GET /api/v1/releases/{id}/observations

Returns the frozen observations, ordered by global position. Pin the UUID returned by the manifest when fetching multiple pages. There are no table filters; each row identifies source_table (prices or llm_prices) and observation_id. GPU rows carry gpu_id, gpu_name, gpu_slug and the GPU price fields (price_per_hour, gpu_count, pricing_type, commitment_months, variant, region, available, vcpu_count, ram_gb); LLM rows carry model_id, model_name, model_slug and price_per_1m_input, price_per_1m_output, price_per_1m_cached_input, pricing_type. Both carry the provider identity, currency, exchange_rate_to_usd, original_price, normalization_method and source_url.

To find later corrections to an observation, match source_table + observation_id against a correction's table + price_id. The release itself never changes.

Pagination follows the same convention as /api/v1/corrections: keep requesting with after=<meta.cursor> while meta.has_more is true. An empty page returns the cursor you sent. NDJSON pages carry the same values as X-Cursor and X-Has-More headers. All pages carry X-Release-Id and X-Release-Checksum-Sha256; the checksum covers the entire release, not the current page.

To verify the SHA-256, concatenate every NDJSON page in order and hash the resulting UTF-8 bytes. Each row is the stored PostgreSQL JSONB text plus one LF, ordered by source_table in C collation, then observation UUID. Preserve the exact response bytes. Parsing and reserializing JSON changes formatting and will not reproduce the checksum. The empty dataset hashes empty bytes. JSON mode adds position to each row.

curl -H "Authorization: Bearer cp_live_..." \
  "https://computeprices.com/api/v1/releases/RELEASE_UUID/observations?format=ndjson"

GET /api/v1/release-notes

Every change to collection, normalization or selection that alters what a release contains, newest first: id, added (UTC date), kind (correction, coverage or policy), providers (slugs; empty means every provider), tables (prices, llm_prices) and summary. A policy entry also carries effective, at least 30 days after added; nothing it describes appears in a release before that date. Corrections and coverage changes take effect from the first collection after added. See Release notes in the methodology. Row-level changes to prices already published are in /api/v1/corrections.

curl -H "Authorization: Bearer cp_live_..." \
  "https://computeprices.com/api/v1/release-notes"

The schema and normalization version labels are recorded at publication; deliberate changes to the release shape, offering selection or normalization policy bump those labels.

Rate limits

Every response carries X-RateLimit-Limit, X-RateLimit-Remaining, and X-RateLimit-Reset (Unix epoch seconds). 429 Too Many Requests additionally sets Retry-After in seconds.

Limits are a fair-use ceiling keyed by API key, not a plan feature. Trial, Builder and Pro keys share a daily sliding window of 3,000 requests — far above what a polling integration needs — so a once-a-day batch job can burst its whole quota in one run and a request made now frees its slot 24 hours later.

A note on how we read usage: pricing data changes at most hourly, so no honest integration needs to sit at its ceiling around the clock. Sustained near-ceiling usage — especially from accounts we can't identify — is treated as an abuse signal and may be throttled or blocked rather than granted a higher limit. If you genuinely need more throughput, talk to us.

Errors

Standard HTTP status codes. Error bodies share a small envelope.

401 Unauthorized

Missing, malformed, or invalid/revoked/expired key — an expired trial key lands here too. A missing key gets a signup_url in the body and a Link: <...>; rel="help" header pointing at signup:

{
  "error": "Authentication required",
  "hint": "All /api/v1 endpoints require an API key. A key takes 30 seconds and starts a 14-day trial: https://computeprices.com/account/api-keys",
  "signup_url": "https://computeprices.com/account/api-keys"
}

An expired key (a trial that ran out, or a subscription that ended) gets code: "key_expired" and a Link: <...>; rel="payment" header. Subscribing reactivates the same key, so nothing in your code has to change:

{
  "error": "API key expired.",
  "code": "key_expired",
  "expired_at": "2026-10-15T00:00:00.000Z",
  "hint": "This key's access ended on 2026-10-15. Subscribe to Builder or Pro at https://computeprices.com/account/api-keys and this key starts working again, no code change needed.",
  "upgrade_url": "https://computeprices.com/account/api-keys"
}

404 Not Found

Unknown slug or resource.

429 Too Many Requests

Over your tier's rate budget. Wait Retry-After seconds.

500 Internal Server Error

Upstream failure. Try again; if persistent, ping us.

Terms of use

Short version: use the API to build things, don't use it to become us or to relicense our dataset.

The API and the dataset are provided by Lancekey Advising LLC, which operates ComputePrices. It is the party to these terms and to any data licence.

Permitted — using the API to power your own applications, dashboards, agents, internal tooling, and research. A trial and Builder are for internal use only. On Pro you may also show our figures in your product or on a public page, with a "market data via ComputePrices" credit linking to computeprices.com.

Prohibited, on every self-serve tier:

• Reselling or redistributing the raw feed. You may not resell, sublicense, or bulk-republish the dataset (or a substantial portion of it) as a data product, whether as an API, a file dump, or a mirror. That includes delivering the data itself to your own clients or customers as files, feeds, or exports; showing figures inside your product is display, handing over the data is redistribution.
• Building an index or financial reference on it. You may not construct a price index or benchmark from the data, or use the data (or anything derived from it) to price, settle, or reference a financial instrument or contract. Both need an index licence, agreed under Enterprise terms.
• Building a direct competitor. You may not use the API to build or operate a cloud GPU or LLM pricing comparison service that competes with ComputePrices.
• Circumventing limits or tier gates. No key sharing, multi-account key farming, IP rotation, or systematically archiving responses to reconstruct the historical dataset from a tier that doesn't include it.

Openly licensed rows keep their own licence: rows from a source listed in meta.attributions (today the Aquanode GPU Price Index, CC BY 4.0) are not restricted by these terms, and reusing them means keeping that source's credit.

Keys and IPs violating these terms may be throttled, suspended, or revoked without notice. Want to license the raw feed or do something these terms don't cover? Email api@computeprices.com — we're easy to talk to.

Versioning & stability

All endpoints live under /api/v1/* and guarantee additive, non-breaking changes at this version. Breaking changes will ship under a new version prefix and the old version will stay available for at least 6 months.

Fields added to response bodies are non-breaking. Fields are never renamed or removed at the same version. meta.version is always "v1".

Roadmap

Near-term (explicit target):

• v1.1: provider comparison, cheapest-per-model, historical prices with date ranges, CSV & NDJSON export.
• v1.2: LLM benchmarks (throughput, TTFT, p95), per-provider scrape-health and data-confidence metrics.

No-date items:

• Webhooks on price change.
• Per-key scopes (restrict a key to specific endpoints).

Next steps

• Start with /api/v1/providers to see what's tracked.
• Grab the OpenAPI 3.1 schema for client generation: /api/v1/openapi.json.
• Grab raw markdown for your agent: /docs/api.md (text/markdown).
• Read how the numbers are produced — sources, normalization, validation, freshness: /docs/methodology (raw: /docs/methodology.md).
• Site-wide resource map: llms.txt.
• Get a key (or upgrade to Pro): computeprices.com/account/api-keys.
• Feedback or enterprise inquiries: api@computeprices.com.