How GPU Economy collects prices

Every number on this site was read from a page or API the provider publishes, by an automated parser that runs every hour. No price is estimated, averaged in from third parties or filled in by hand; a price listed in another currency is shown as listed, beside its USD figure at a dated official rate; and one figure is modelled, not read - cost per million tokens - and says so (below). This page explains what that means in practice.

These rules change, and a citation outlives the rule it was computed under, so every file carries methodology_version and each change is dated in the methodology changelog.

One unit: US dollars per GPU per hour

Providers quote in different shapes — per GPU, per 8-GPU node, per second, per instance with a bundled CPU. We store the quote exactly as listed, together with how many GPUs it covers, and the database derives the per-GPU-hour rate. Where a rate was divided, the page shows the original quote and the divisor next to it (for example, $49.24/node ÷ 8), so the normalization is auditable rather than silent. Per-second serverless rates are multiplied by 3,600.

Why every figure is one GPU, not one node

A price list mixes shapes: one card, a machine of two, four or eight, a card billed by the second. A median taken over those shapes as listed would put an eight-card node beside a single card and call both “an H100”, and the figure would move with the mix of machine sizes rather than with what a GPU costs. So every figure here is per GPU per hour, and three rules decide what one GPU-hour is:

• A node price is divided by its card count. The listed price and the count are both kept, and every table shows them beside the result.
• An instance price stays an instance price. Where a provider bundles CPU, memory and disk into the rate, the figure is tagged instance; where the GPU is billed alone, GPU only (price scope). Nothing is added to or taken from either.
• A marketplace floor is kept apart. It is the median of the five cheapest verified offers, a real ask that moves with supply, tagged floor and left out of every median and of the index.

An example from this build: Bitdeer AI lists 2 * H100 SXM with 2 H100 SXM cards at $4.72 an hour, read October 23, 2026, 21:40 UTC. $4.72 ÷ 2 = $2.36 per GPU-hour, the figure in the H100 SXM table and in the index. Anyone can repeat the division from the page the link opens.

What a figure covers: price scope

Providers sell different things under “per GPU-hour”. Every row carries a scope, shown as a tag next to the price wherever it is not a plain instance:

• instance (no tag) — a runnable VM, pod or node: the GPU together with the CPU and memory it ships with. Most providers, including the hyperscalers.
• GPU only — the GPU line item alone; CPU, memory and storage are billed separately, so a runnable machine costs more. Cudo Compute, Google Cloud, Modal.
• floor — the median of the five cheapest verified offers on a marketplace at scrape time (always one real ask, never an average), not a rate card; it moves with supply. Withheld entirely when the offers behind it cannot carry a floor: fewer than three, or a median more than three times the cheapest ask beside it. Vast.ai.
• from — a provider’s advertised “from $X” rate rather than a configured instance. GMI Cloud.

The median printed for a card — on its page, in the cards table, on /spread, /buy-vs-rent and the GPU comparisons — is the median rate card: each provider once, at its cheapest on-demand rate proper, with community capacity and marketplace floors left out, so a provider that lists many regions or tiers still has one vote. A median needs two providers: a card on one provider’s rate card shows that rate card, named, with the cheapest marketplace floor on its own line, and no break-even or median comparison. GPU-only and “from” rates stay in and carry their tag, so you can discount a figure that is not like-for-like. The Price Index excludes marketplace floors and withholds any week with fewer than 8 contributing providers. Where a page says cheapest on-demand or which provider is cheaper, it counts on-demand rates proper: community capacity (RunPod Community Cloud, on third-party hosts) and marketplace floors are listed as on-demand by their sources, but they can be reclaimed or move with supply, so they are shown beside and never decide a comparison or enter the median rate card. The scope is also a field in prices.json.

Every rate carries a risk tag. It answers one question - can the capacity be taken back while a job runs - and it is read off the market the rate is sold on, never off the provider: high for spot and community capacity (RunPod Community Cloud, marketplace floors), which can be reclaimed mid-run; medium for serverless, shared capacity billed by the second with no instance to hold, and for a shared GPU - a card other tenants use too, such as packet.ai’s Dynamic plan, which is never reclaimed but is not yours alone and, like community capacity, counts in no median and no “cheapest” (since September 27, 2026); low for on-demand and for every reserved term, where the capacity stays yours while it runs. What it does not measure: how reliable a provider is, whether a card is in stock, or the financial side of a commitment - a reserved rate is low risk to your run and still billed for hours the GPU sits idle, which is why a commitment's discount is shown against the same provider's on-demand rate rather than on its own. The tag is also a field, risk, in prices.json and prices.csv. It exists so that the cheapest line in a table, which is usually spot or community capacity, is not read as the price of a GPU you can plan a week-long run on.

Beside the median, from four rate cards, the site prints the middle half: the 25th and 75th percentile of the same rate cards, interpolated between neighbouring rates as Postgres percentile_cont does, so the 50th percentile is the median itself. The cheapest and the dearest rate are one quote each and can vanish or be a promotion overnight; the middle half does not move like that, and answers whether a quoted rate is high. It describes the observed rates; it is not a modelled figure. It is on /spread, on each card page, in gpus.json and, for the index quotes, in price-index.json.

Three price types, never mixed

• On-demand — the listed pay-as-you-go rate. The Price Index and every median on the site use on-demand rates only.
• Spot — interruptible or preemptible capacity, as published by the provider. Marketplace auction bids are not recorded.
• Reserved — a published committed-use rate. Contact-sales and quote-only tiers carry no number and are left out.

Providers partition prices differently

The “region” column holds whatever the provider itself uses to split prices: a geography, a data center, or a tier such as RunPod's Secure and Community Cloud. Those are never averaged together. For marketplaces (Vast.ai) we record a trimmed floor — the median of the five cheapest verified, rentable, single-GPU offers, so one machine renting out does not move the figure — and label it as such. Multi-GPU machines on the same marketplace are a separate row, labelled “Multi-GPU machines”: a share of a 2-, 4- or 8-GPU machine is not a machine you can rent alone, so it never enters the single-GPU floor. That row shows the machine’s own price and its GPU count, and its per-GPU figure is that price divided by the count, from the machine whose per-GPU ask is the median of the five cheapest.

A floor is only a floor while the offers behind it are a market, so we publish one only when the window can carry it: at least three verified offers, and a median no more than three times the cheapest ask in the same window. Below that we publish nothing for that GPU rather than a number you could not find on the marketplace an hour later — with two offers the median is simply the dearer of the two, and with one it is a single machine. On 11 September 2026 a thinned-out book put an RTX 5090 on this site at $53.34 per GPU-hour for five hours; the guards date from the day after. When a read has no defensible floor for a GPU we already published, the row stays with its last floor and the time it was read, marked thin market and left out of every figure; the next read with a floor makes it live again. A GPU missing from Vast.ai here was never published: we had no defensible floor, which is not the same as an empty marketplace.

What is deliberately not on the site

• Silent currency conversion. A price listed in another currency (EUR since September 8, 2026; any currency since September 28, 2026) shows the listed figure next to the USD one, with the official reference rate and its date: the ECB’s daily rate, or the Bank of Russia’s for RUB and VND, which the ECB does not publish. Both numbers can be checked. Price changes are detected on the listed figure, never on the exchange rate, and non-USD listings do not enter the Price Index.
• Estimates of a price, including for GPUs a provider sells only on request.
• Prices scraped from a page that could not be parsed reliably. A parser that finds nothing fails loudly instead of writing zeros.

The one modelled figure

Cost per million output tokens is the only figure we do not read from a page: a listed rate divided by a throughput NVIDIA published for that card, carried with the run that produced it - model, framework, precision, sequence lengths, concurrency and date - and a link to NVIDIA's page. Cards are not comparable on it, because NVIDIA runs each card in its own configuration; read it as a floor, never as a bill. It is published in /token-cost.json and through the MCP server; card pages showed it from the rule's writing until October 10, 2026.

Reading a rate table

• Listed rates, not availability. We read published price lists: a listed rate can be sold out, waitlisted or absent from the region you need.
• Per single GPU-hour. A node price is divided by its GPU count. A provider's name opens the page its rate was read from; hovering it shows the provider's own name for what was priced.
• The percentage under a rate compares it with the Price Index (or, for other cards, the median rate card). A spot rate is cheaper because it can be taken back, not because the provider is cheaper.
• Risk is read off the market, not the provider. Spot and community capacity can be reclaimed mid-run; serverless is shared capacity billed by the second; a shared GPU is a card other tenants use too; on-demand and committed capacity stays yours while it runs. Community capacity and shared GPUs never count as on-demand: they are out of every median and every "cheapest".
• 7d appears when a listed figure differs from the same quote seven days earlier.
• API marks a rate read from the provider's API, and links the endpoint where the figure stands.
• Every rate on a card page is also data, with the day each figure was first listed and the provider type: /gpu/{card}/prices.json, for example /gpu/h100-sxm/prices.json.

Freshness and history

Prices are re-read every hour and stored append-only, so every figure has a capture time and the history is never rewritten. The changelog lists every change between consecutive reads; the Price Index is a weekly series on top of the same data. Each page states when its data was last updated.

When a source goes quiet

A parser that stops finding a price does not delete it: the row keeps the time it was last read successfully, and on its own that looks exactly like a price that has not changed. So every quote carries a status, measured against the newest scrape in the data. A quote read within the last 48 hours is live. After 48 hours without a successful read it is marked unconfirmed beside its price, with the date and time it was last confirmed; after 7 days it is stopped. A quote that is not live stays visible — a price that was real is still evidence — but it is never presented as current: it leaves every figure the site computes, including the Price Index, medians, cheapest rates, spreads, break-even months and comparisons. The status and the time of the last successful read are fields in prices.json, its CSV and its slices. A marketplace floor the parser read and withheld as too thin (see above) is not a quiet source: from that read on it is marked thin market, keeps its last floor with the time that floor was read, and leaves every figure in the same way until a floor is published again. A quote whose provider’s own page for that card answers “not found” in a read is not confirmed by that read: since October 9, 2026 it is marked unconfirmed from that read on, instead of staying live for the rest of the 48 hours, and is live again the moment the page prints a figure. The Price Index is computed in the database at each scrape and keeps its own 48-hour rule for such a quote. Each provider’s state is in the source table at the end of this page.

How old a listed figure is. The other half of the same question: a price can be current because it was read an hour ago and still be a number its provider set months back. Every live rate carries the date its figure was first seen at that value — our own hourly reads only — and as of October 23, 2026, 335 of the 995 live rates have carried the same figure for 30 days or more; the middle one has stood 24 days, and the oldest change we have watched happen was on September 21, 2026. That age is the provider’s, not ours: we re-read every one of these rates every hour, and a source that stops answering is marked above instead of ageing quietly. For 729 of them the figure has not moved since our first read of it, so the real age may be longer than we can prove — those say “unchanged since first read” beside the price, and the two cases are separate fields in prices.json (listed_since, listed_since_first_read).

How long a price has held

Next to the time a live price was read, every table says since when the provider has listed that exact figure: unchanged since the date of its last change. The comparison is made on the listed figure in the listed currency and the number of GPUs it covers, so an exchange-rate move on a listing in another currency is not a price change. It is computed from our own hourly reads only; the reconstructed SkyPilot history never feeds it. Where a price has not changed since we first read it, the label says unchanged since first read: the provider may have listed it for much longer, and we do not claim a date we did not see. A price that is no longer being confirmed shows when it was last confirmed instead. Both dates are fields in prices.json (listed_since, listed_since_first_read).

Change over seven days

Every live quote also carries its change over seven days: the listed figure now against the same quote’s figure seven days before the newest scrape, taken from its last read at or before that moment and within the 48 hours before it. Like the price age it compares the listed figure per GPU in the listed currency and uses our own hourly reads only. A card’s change is like-for-like: the geometric mean of its rate cards’ own changes, so a provider arriving or leaving does not move it. A marketplace floor is compared only with reads taken since its current estimator began on 8 September 2026, so a change of method is never printed as a change of price. Our own series began on 6 September 2026, so the first values appear on 13 and 14 September; a change over 30 days follows once 30 days of reads exist. The fields are listed_7d_ago, read_7d_ago_at and change_7d_pct in prices.json.

How the index series was made

The series starts with the week of September 7, 2026, the first week published. Every weekly value is computed from reads made in that same week - the newest read of each provider and region, counted only if it was confirmed within 48 hours of the week's last scrape - and published with its receipt, the list of those quotes. No value was entered by hand, reconstructed after the fact or carried over from an earlier week. Closed months are published as they were first published and never recomputed.

price-index-history.csv is a separate series under its own name, rebuilt after the fact from a public price catalog, whose repository is named at https://gpueconomy.com/methodology#second-hand-history, for the weeks before September 2026. It is second-hand, and it is never merged into or back-filled with this one. The same two sentences travel in price-index.json as history_provenance.

Second-hand history: the SkyPilot catalog

Our own scrape began in September 2026. To show what H100 rates did before that, the index page carries a separately named series rebuilt from skypilot-org/skypilot-catalog, a public price catalog committed by bots every few hours since 2022. For each ISO week we take the catalog’s state at the end of the week and record, per provider and GPU, the cheapest per-GPU on-demand instance, with a permalink to the exact commit. That makes every historical number verifiable in the catalog — but it is second-hand: we vouch that the catalog published it on that date, not that the provider’s page did. The series is stored and published apart from our own, under its own name, with its own coverage guard (at least 4 providers), and the two are never merged or back-filled into each other.

Price Index panel rules

The Cloud GPU Price Index is the weekly median of one number per provider and region. The panel is not chosen by hand; a quote is in if it meets every rule:

• Product: NVIDIA H100 SXM, on-demand. Spot and reserved rates never enter.
• Listed rate: a price published on the provider’s pricing page or API, listed in USD, with a source link. Marketplace floors and listings in any other currency are excluded (a converted figure would move with the exchange rate); “from” and GPU-only quotes are included and tagged.
• Markets: the index selects on price type and scope, not on market, so community-cloud and serverless list prices enter it (today RunPod Community Cloud and Modal): each is a fixed hourly rate published for one H100, not a marketplace floor. The card median printed on card pages leaves community capacity and shared GPUs out, because it ranks rate cards you can hold; the index measures listed prices. The difference is small - without the one community quote each published week would read about $0.025 higher - and it is stated, not changed (September 27, 2026). The same sentence is markets_included in price-index.json.
• Weighting: one quote per provider and region — the newest listed rate of each pair in the week. A provider that lists several regions enters the median once per region. The index page and price-index.json (weighting_check) print the same quotes recomputed as the median of each provider’s own median, with the most quotes any one provider gave and a concentration index (HHI): a check on what the rule costs, not a second index. A quote count counts rate cards, not GPUs available to book.
• Entry: a provider joins the week its listing is first read. There is no waiting period; the coverage guard below protects the series instead.
• Exit: a quote counts in a week only if its latest read that week is within 48 hours of the week’s last scrape. A provider leaves the week its listing is no longer found, and a source that goes quiet leaves the running week within two days. Earlier weeks are never recomputed.
• Coverage guard: a week is published only when at least 8 providers contributed. Weeks below that are withheld, not backfilled later, and nothing is carried forward in their place. A withheld week prints why wherever its value would have been — on the index page, on the home page and in price-index.json (current.status, withheld_reason, withheld[]): too few providers list the card, or enough do but some have not been confirmed within 48 hours, named with the time each was last read.
• Base-100 index: next to the dollar median, a chain-linked index built to move only on price changes — each week’s link is the geometric mean of week-over-week ratios over the (provider, region) pairs quoted in both weeks, base week = 100 (2026-09-07 for our series, 2025-01-06 for the reconstructed one). Joining or leaving providers contribute no ratio. Cite the median for a level, the index for a change.
• Vintage: the running week is provisional — it is recomputed on every hourly scrape as quotes join the panel and rate cards move. It becomes final when the week closes on Monday, and a final point is never recomputed. Every row of the series carries its vintage, on the page and in the JSON and CSV. One addition was made to closed weeks, on September 19, 2026: each published week now also carries the middle half of its quotes (25th and 75th percentile), computed from the receipt that week already published. That describes the same quotes; no published median changed, and the band can be recomputed from each receipt.
• Receipts: every published week lists the quotes that entered it, one CSV per ISO week with each quote’s source and read time, and the command that turns the file back into the published value: reproduce the index.
• Revisions: a published weekly value changes only if the underlying scrape is corrected, and such a change is noted on the index page.

Entry and exit log, generated from the price history (34 providers in the current panel):

What the index does not measure

• Negotiated, committed-use and enterprise contract rates. Most large H100 deployments are priced this way, and none of it is public.
• What a marketplace actually clears at. Auction bids and the floor of the moment are not rate cards.
• Reserved and spot discounts, except where a provider publishes them as a rate — and even then they are shown, not indexed.
• Availability. A listed price does not mean capacity is free to rent right now.
• The cost of a runnable machine on GPU-only quotes, where CPU, memory and storage are billed separately.

Read the index as “what a public H100 rate card says this week”, not as the market-clearing price of H100 capacity.

Why another H100 index prints a different number. Three differences account for most of the gap between two H100 indices for the same week, and none of them makes either figure wrong. First, a posted rate against a transacted price: this index is the median of public on-demand rate cards, each linked to the page it was read from, while a transaction-based index such as Ornn’s OCPI (its methodology) is computed from executed rental prices that an outside reader cannot check one by one. Second, the panel: whether AWS, Azure, Google Cloud and Oracle are counted changes an H100 median on its own, and the index page prints the hyperscaler and specialist-cloud medians side by side. Third, the statistic: a median, as here, against a trimmed, interquartile or volume-weighted mean, which weigh the same quotes differently. Compare two indices by their method before comparing their numbers; this site does not print another index’s figures next to its own.

Indices that settle futures. Two other GPU rental indices are becoming reference prices for exchange-traded contracts. CME Group announced on August 11, 2026 that two cash-settled contracts, Silicon Data H100 Rental Index Futures and Silicon Data B200 Rental Index Futures, are to be listed on NYMEX from October 5, 2026, pending regulatory review, settled against Silicon Data’s hourly rental indices (CME Group’s release). Intercontinental Exchange announced on May 19, 2026 cash-settled GPU compute futures referenced to Ornn’s OCPI, subject to regulatory approval and with no listing date given as of September 19, 2026 (ICE’s release). That makes the difference a difference of subject, not only of method: a settlement index measures the price a contract pays out on; this index measures what providers publicly ask, each rate linked to the page that lists it. This site issues no contract on it (who publishes this). Since October 1, 2026 the index has a specification written for that reading. Settling an instrument on it is free under CC BY 4.0; a settlement licence adds the terms a contract needs and the free series does not bind us to (/data).

Retail prices

Purchase prices come from a server reseller’s own price list (ASA Computers) and from Google Shopping, which carries both stores selling on their own pages and sellers on marketplaces (eBay, Walmart and Newegg marketplace sellers, Alibaba, StockX). Every listing is linked, and every price says what kind of price it is: a store price (a seller’s own price on its own page), a marketplace listing (a seller’s asking price on someone else’s marketplace) or a completed sale (none tracked yet). An asking price is not a sale price, and a store price is not a marketplace ask, so a median is computed inside one kind and never across. A card gets a 30-day median only when three or more sellers carry it; the purchase price a card leads with is the store median where stores carry it, else the marketplace median, each named, and the other kind is printed beside it. Below three sellers the page shows the listings. A listing that disappears from its source drops out after 30 days. Accessory listings and implausible prices are filtered out.

Manufacturer list price

On consumer cards the site shows NVIDIA’s published starting price and the retail median as a share of it. That figure is reference data, not a scraped price: NVIDIA renders it with JavaScript, so it is read by opening the product page in a browser, stored with the URL and the date of that check, and re-checked by hand — it does not change hourly. Datacenter and workstation parts (H100, H200, B200, RTX PRO 6000) carry no published price at all, so no “% of list price” is shown for them; a figure with no verifiable denominator is exactly what this site does not publish.

What a page is made of

This site serves no JavaScript. Every price in every table is in the HTML our server sends, as a plain <table>, so a reader, a screen reader and a crawler that does not run scripts all get the same figures, with the same source link and read time. The only <script> elements on a page are JSON-LD — structured data, not code — and the check we run on every deploy (scripts/site-check.sh) fails if any other appears. The page controls (card, market, hours) are form inputs styled with CSS; the default state is written in the HTML as text. Changes: September 26, 2026 — first stated here; the rule has held since the first page was published.

Link policy

What a link on this site is, written down before any link earns money, so that it can be held against us later.

• First hand only. Every rental rate on this site is read from the company that bills for the GPU-hour — its own pricing page or its own API — never from an aggregator, a comparison site or a republished rate card. A marketplace is first hand too: the host sets the price and the marketplace bills for it, so its floor is read from the marketplace itself (and labelled as a floor, not a rate card). Serverless and community capacity are the provider's own published rate for hardware it bills for. The one exception is stated where it appears: retail purchase prices come from resellers' own listings and from Google Shopping, which is a search over stores, and every retail figure names the store it came from. If a provider's price can only be found on somebody else's site, we do not list it — it goes to what is not listed, and why.
• Source links are direct. Every price links to the page or API it was read from, stored exactly as the source serves it. Seven providers publish prices through an API (AWS, Azure, Cudo, Google Cloud, Oracle, RunPod, Vast.ai): those rows link the provider’s price page and say “read from the provider’s API”, with the endpoint where it can be opened without a key of your own. RunPod’s GraphQL endpoint answers only a POST, so its rows link the published schema of that endpoint instead, and beside it the exact request, printed in the source table below (since 2026-09-28: the schema carries no figure). Google’s Cloud Billing Catalog cannot be opened without a key, so its rows point at Google’s page, where the same rate is published for a reader. A figure read from an API is often more exact than the page beside it, which may round it or default to another region. We add no tracking or affiliate parameters to those links and never route them through a redirect of ours.
• The Deploy button is counted; the price link is not. Since September 19, 2026 the “Deploy ↗” button beside a rate goes through /go/ on this site, which records that it was clicked — the time, which quote, and the page of ours it was on; no IP address, no user agent; since September 25, 2026 also the reader’s one-day visitor code, described below; only a click made on one of our pages counts, so agents, crawlers and scrapers that fetch the link directly are not counted — and redirects at once to the provider. Since October 1, 2026, where we have a referral link with the provider, the button goes to that referral link; otherwise to the same page the price links to. The destination is fixed at build time from our own data and cannot be changed by the link. The price figure itself still links straight to its source, as above. On /reserved the same button reads “Reserve”.
• Where referral links are. Where we have joined a provider’s referral programme, its referral link is the destination of that provider’s Deploy and Reserve buttons (since October 1, 2026) - where the code is only a query on the provider’s own site (RunPod), on the quote’s pricing page rather than the home page - and appears as its own element on that provider’s page, under the rates, saying that the buttons go through it; in the data file providers.json it is its own referral_url field. Source links on prices are never referral links. The answers of the MCP server link GPU Economy pages only (since September 29, 2026): each price’s page is our page, where the price stands beside its direct source link and a referral link, if any, is labelled. No answer carries a referral link. As of October 23, 2026, 5 providers have a referral link, each labelled on its provider page.
• Logos are the providers’ own and say nothing about us. Since October 8, 2026 a provider’s small icon stands beside its name: the square mark its own home page names for itself (its app or touch icon), read once and kept as a file on this site, so no page of ours loads anything from a provider. Logos and names are the trademarks of their owners; showing one means only that we list that provider’s published prices, not a partnership, a sponsorship or an endorsement, and every listed provider whose home page names a usable icon has one, paying or not. A provider without an icon has no mark at all - none is drawn for it.
• Money never changes a table. A referral arrangement never changes which prices a table shows, which providers it includes, or their order. Price tables are sorted by price; other lists by the rule stated beside them.
• A request for quotes is routed by price. A reserved-quote request from /reserved goes to up to three providers that list a committed rate for the card, the cheapest listed first (since October 1, 2026). A provider may pay a fee if a request becomes a contract; it cannot pay to receive requests, and a fee changes no price, table order or index membership.
• Nothing in the index is for sale. Neither inclusion in the Price Index nor a position in any table can be bought; the panel follows the rules above and nothing else.
• Changes are dated. Any change to this policy is recorded below with its date, and the old wording stays readable here.

Changes: September 11, 2026 — policy published; no referral links in use. September 19, 2026 — the Deploy button goes through a counting redirect of ours (/go/); source links on prices stay direct. The earlier wording, “never route them through a redirect of ours”, still holds for source links, which is what it described. September 25, 2026 — a counted Deploy click also carries the one-day visitor code of What we count about readers; the earlier wording said “nothing about the reader”. September 28, 2026 — the first referral link: Massed Compute, on its provider page, labelled, next to its direct links. Its self-serve programme pays in Massed Compute account credits. No price link and no Deploy button changed. The same day, referral links were added as a separate referral_url field to providers.json; and in the MCP server’s answers a provider we have a referral link for is linked by that link alone, marked as a referral link (the earlier wording, “never in place of it”, still holds for every page and file of the site). September 29, 2026 — the MCP server’s answers no longer mark that link or carry a note about it. Later the same day — the MCP server’s answers carry no referral link and no source link at all, only the GPU Economy page for each price, where the source link and any labelled referral link are; the September 28 exception is withdrawn. October 1, 2026 — the Deploy button (and Reserve on /reserved) goes to the provider’s referral link where we have one, without a mark on the button; the earlier wording read “it is not a referral link and adds nothing to the provider’s URL” and “a referral link appears as its own element … never in place of it”. Price source links are unchanged.

What we count about readers

Since September 25, 2026 this site counts its readers with PostHog (EU cloud), from our server, not from your browser. Changes: September 25, 2026 — first published with a one-day visitor code and no cookie; the same day, two first-party cookies set by the server (below); September 26, 2026 — a page view also carries your browser’s first language (below). September 29, 2026 — a Deploy click stored in our own database also records whether the browser returned our visitor cookie (yes or no, not the code), and only clicks with it are counted. October 1, 2026 — the reserved-quote form sends a view of its own (below). October 11, 2026 — a third cookie, ge_last, and a page-leave event with the time spent on a page (below). Everything collected, both forms and the MCP server included, is gathered in the privacy policy.

• No script; two cookies, set by our server. Pages carry no JavaScript. When our server (a Cloudflare Pages Function) sends a page to a browser, it sets two first-party cookies and reports the page view to PostHog after the page is on its way. ge_vid is a visitor code kept for 13 months, so a return visit is counted as the same reader; ge_sid is a session code that lasts 30 minutes from the last page you opened. Both are readable only by this site’s server (HttpOnly), are sent only over HTTPS, and carry nothing but the code. They are set on pages only — not in our widgets framed on other sites, and never for crawlers or agents. Removing them in your browser starts you as a new reader.
• Time on a page (since October 11, 2026). A third cookie, ge_last, holds the address of the last page you opened here and the time you opened it, for the same 30 minutes as the session. When you open the next page, our server reports the previous one as left, with the time between the two. The last page of a visit, and a visit of one page, has no such report: without a script, nothing tells the server when a tab is closed.
• How the visitor code is made. The first time, it is computed from the day (UTC), your IP address and your browser’s user agent with a secret key held only by the server (HMAC-SHA256); after that it is read from the cookie. A browser that refuses cookies is counted by that day code alone, which changes every day. Your IP address and user agent are used to compute the code and are not sent or stored. PostHog builds no profile of you and is told not to locate you; the country is the two-letter guess Cloudflare attaches to every request.
• What a view carries: the page address without its query string, the site you came from (its domain only), any utm_ tags in the link, whether you arrived from an AI assistant’s answer, the country, and your browser’s first language — its two-letter code only, such as de, never the region or the rest of the list — which tells us whether a page in another language would be read. A Deploy click adds which quote it was; the “Add your GPU cloud” form adds only that a submission was stored and from which page — never the email or the link you sent; the “Get reserved quotes” form (since October 1, 2026) only the card and the term — never the email, company, region or notes.
• Not counted: crawlers, AI agents fetching a page for an answer, and scripts. Those are read, without any code, from Cloudflare’s own logs.

Who publishes this, and what it does not do

Before a price is worth citing, the question to put to whoever published it is who benefits from the number being what it is. Written down here, dated, while the answer still costs us nothing.

• We do not sell the thing we price. GPU Economy sells, resells and hosts no GPU capacity and is party to no contract a reader signs with a provider. Since October 1, 2026 it passes reserved-quote requests from /reserved to providers at the reader’s request, and a provider may pay it a fee if one becomes a contract: that is the one commission it can earn, disclosed on the form, and requests go to the providers with the cheapest listed rates for the card, never to the ones that pay.
• Nothing of ours settles on the index. We issue, price and settle no contract, option, swap or other instrument against the Price Index or any other figure on this site, and hold no position in any market this site measures.
• No provider on the panel is ours. No provider in the Price Index, or in any table here, is owned or operated by the publisher or shares ownership with it. If that ever changes, that provider’s own row is marked where its price appears — in the table, not only on this page.
• A referral link would not change this. Joining a provider’s referral programme (see the link policy above) does not put the publisher in the market: it moves no price, no table and no index membership. Each statement above is written to stay true on the day the first referral link appears, so that none of them has to be quietly withdrawn.
• Which listed providers can pay us. As of October 23, 2026, 5 of the 105 listed providers have a referral link of ours: GMI Cloud, Massed Compute, RunPod, Thunder Compute and Vast.ai. A sign-up through that link can earn us a reward under the provider’s own programme, and their Deploy and Reserve buttons go through it (since October 1, 2026). The other 100 have none. Their prices, places in tables and index membership follow the same rules as everyone else’s.
• Changes are dated. Any change to this section is recorded below with its date, and the old wording stays readable here.

Changes: September 15, 2026 — section published; the publisher sells no capacity, issues nothing settled on the index, and owns no provider on the panel. October 1, 2026 — the first point, which read “GPU Economy sells, resells and hosts no GPU capacity, brokers none, and takes no commission on anything a reader rents from a provider listed here”, now allows a provider’s fee on a reserved-quote request that becomes a contract, and says how requests are routed. October 3, 2026 — the providers with a referral link of ours are named here, read from the data at each build; before, only their number stood in the link policy above.

Using the data

The Price Index is published under CC BY 4.0, with JSON and CSV downloads; prices.json carries every current quote with its source URL. Attribute as “GPU Economy” and link the page you used.

Sources, as of October 23, 2026

99 of 105 listed providers are scraped, covering 79 GPU models; 97 of them confirmed their prices in a read within the last 48 hours of the data.

Data updated: October 23, 2026