Methodology

Prices are medians of current asking prices, not completed sales. Xianyu and eBay track used listings; Amazon tracks new primary offers on Amazon.co.jp for delivery within Japan, at displayed JPY prices excluding shipping. Each source is kept separate. We match the GPU model and VRAM, remove unrelated products and record the median, quartiles and sample count. Offers without a known price, seller or available stock are excluded. Amazon samples are distinct product ASINs; used-market samples are deduplicated by seller.

Each device has its own matching rules that exclude unrelated listings such as mining cards, accessories and proxy-purchase offers, and outlier prices are removed. When fewer than 3 valid listings remain, no price is published for that round and the cell stays empty.

A consistency check runs before publication: a result based on few listings that moves sharply from the last published price is not added to the price history, and when a whole round looks abnormal the previous valid prices are kept. Prices update every 6 hours and the history covers the last 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: IQ1_M 0.24, Q2_K_XL 0.38, Q3_K_XL 0.49, 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 unquantized embedding layers.

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 noticeably 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 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 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 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 recorded in their original currency and converted for display at the daily rate, with USD as the base. Rates are updated daily; when the day's rate is unavailable the most recent valid rate is used and the footer says so. This page is using rates from Sep 10, 2026, source open.er-api.com.

GPU specifications come from vendor spec sheets, cross-checked against the TechPowerUp GPU Database and Wikipedia GPU lists, and every figure is traceable to its source. 45 devices are currently covered.

Model parameters come from the public configuration of each official Hugging Face repository, quantized weight sizes use actual GGUF file sizes, and Ollama tags come from the official library. The catalog currently contains 9 families and 43 versions; new models are added regularly after verification.

Prices update every 6 hours, exchange rates daily, and new models are published regularly after review. The timestamp shown on a page is the time of the last successful update. Changes to specifications and formulas are recorded on this page.

Current coefficients: bytes per parameter IQ1_M 0.24 / Q2_K_XL 0.38 / Q3_K_XL 0.49 / 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 CUDA 0.7 / ROCm 0.5 / Metal 0.55 / oneAPI 0.45.

If a price, spec or formula looks wrong, send us an email with the page in question and a source link. Once verified, we will correct it promptly and note the change on this page.

Send an email