Methodology

Used prices are the median of live listings, not sold prices. Mainland China comes from Xianyu and the US from the eBay Browse API, both through the same pipeline: keyword search, regex title cleaning, then the median, with quartiles and sample count recorded alongside.

Each device has its own cleaning rule: terms that must appear, terms that must not (mining cards, accessories, proxy buying and the like), and a reference price. Outliers are dropped with MAD (median absolute deviation), falling back to 1.5x IQR when MAD is zero. A round is not published when fewer than 3 listings survive: an empty cell beats a fake median.

One more guard sits before publishing: when a median moves more than 35% from the last published one on fewer than 8 listings, that round is kept as a snapshot but never enters the history; and when a whole round has fewer than 5 live devices it is discarded and the previous snapshot stands. Collection runs every 6 hours and history is kept in 6-hour slots for 30 days.

weights_gb = params_b × bytes_per_param × 1.05

Weight memory = parameters x bytes per parameter x 1.05. Bytes per parameter by quantization: Q4_K_M 0.57, Q5_K_M 0.69, Q8_0 1.06, FP16 2. The 1.05 factor covers fixed costs such as GGUF metadata and embedding layers that stay unquantized.

kv_gb = 2 × layers × kv_heads × head_dim × context × 2

KV cache = 2 x layers x KV heads x head dim x context x 2 bytes (K and V, in FP16). The generic formula badly overestimates MLA and linear-attention hybrids, so a measured bytes-per-token figure from the model library takes precedence when we have one. Sliding-window attention is not modelled separately, so long-context figures are an upper bound.

fits = weights_gb + kv_gb + 1 ≤ vram_gb

ms_per_token = (active_params_b × bytes_per_param + kv_cache_gb ÷ 2) ÷ (bandwidth_gbs × eff) × 1000 + overhead_ms
tokens_per_sec = 1000 ÷ ms_per_token

It fits when weights + KV cache + 1GB of runtime overhead is at or below usable memory, on a single card with no CPU offload; unified-memory machines are counted at their full memory size, without deducting the macOS GPU wiring limit. Estimated speed follows single-stream llama.cpp: time per token = bytes read ÷ (bandwidth × ecosystem efficiency) + fixed overhead, where bytes read = active parameters × bytes per parameter + half of the KV cache at the given context. Ecosystem efficiency is CUDA 0.7, ROCm 0.5, Metal 0.55, oneAPI 0.45; fixed overhead is 0.8 ms for dense models and 4 ms for MoE. Calibrated against published llama.cpp runs, usually within ±20%; longer contexts run slower.

price_per_gb = used_price ÷ vram_gb

VRAM unit price = median used price / VRAM capacity, in currency per GB. It is the default sort column of the main table.

price_per_bandwidth = used_price ÷ (bandwidth_gbs ÷ 100)

Bandwidth unit price = median used price / (bandwidth / 100), in currency per 100GB/s. Dividing by 100 only puts the number on the same order of magnitude as the VRAM unit price so the columns read side by side.

price_per_tops = used_price ÷ int8_tops_dense

Compute unit price = median used price / dense INT8 throughput, in currency per TOPS; devices with no published INT8 figure leave the column empty. All three unit prices follow the selected price basis and are computed in USD first, which is equivalent to dividing first and converting after.

Prices are stored in their original currency and converted for display at the day rate, with USD as the base. Rates are fetched once a day; when a fetch fails the previous day is reused and the footer says so. This page is using rates from Sep 5, 2026, source open.er-api.com.

GPU specifications come from vendor spec sheets, the TechPowerUp GPU Database and Wikipedia GPU lists, cross-checked; every device carries its source links in the data file. 29 devices are covered.

Model parameters come from the Hugging Face model API and the config.json in each repository, quantized weight sizes from the actual file sizes in the GGUF repositories, and Ollama tags from the official Ollama library: 8 families and 37 versions in total, synced weekly.

Prices run every 6 hours, the model library weekly and exchange rates daily. The updated-at stamp on each page is the last round that actually succeeded; we do not fake refreshes. Spec and formula changes go through Git commits, and any coefficient change is written up here.

Current coefficients: bytes per parameter Q4_K_M 0.57 / Q5_K_M 0.69 / Q8_0 1.06 / FP16 2, weight overhead 1.05, 2 bytes per KV element, 1GB runtime overhead, speed efficiency {eff}.

If a price, spec or formula looks wrong, open an issue or send an email with the page you saw and one source link. Once verified we fix the data file and note it on this page.

Open an issue · Send an email