# Compatibility > Which cases a card fits, which cards fit a case, and which AI models a card can run, with the exact rules behind each answer. URL: https://gpuninja.com/docs/api/compatibility Last updated: 2026-10-05 ## Four documents Compatibility is precomputed for every pair, in both directions, and published as four kinds of document: | Path | `kind` | Subject | Items | | ------------------------------- | --------------- | --------- | --------------------------------------------- | | `/api/v1/boards/{slug}/fits` | `board-fits` | `board` | every case, as `chassis`, `fit`, `psu` | | `/api/v1/chassis/{slug}/fits` | `chassis-fits` | `chassis` | every graphics card, as `board`, `fit`, `psu` | | `/api/v1/boards/{slug}/can-run` | `board-can-run` | `board` | each model that fits in the card's VRAM | | `/api/v1/models/{slug}/runs-on` | `model-runs-on` | `model` | each card with enough VRAM for the model | Every board and chassis has a fits document, every board a can-run document and every model a runs-on document, discontinued records included. Each detail document links its own in `data.compatibility`: `fits` and `canRun` on a board, `fits` on a chassis, `runsOn` on a model. On each of them, `links.self` is the compatibility URL, while `links.page` and `links.text` point at the subject's web page and `.txt`, where the same answers are shown. `asOf` is the latest time any value in the document was retrieved or verified: the subject's own values, those of every entity in the items, and those of every entity named in an item's benchmark `results`. It is `null` when none of them has a recorded time. ## Fit ```bash curl -s https://gpuninja.com/api/v1/boards/asus-rog-strix-4090/fits ``` ```json { "apiVersion": "v1", "kind": "board-fits", "asOf": "2026-10-04T06:12:00Z", "board": { "slug": "asus-rog-strix-4090", "name": "ASUS ROG Strix GeForce RTX 4090 OC", "lengthMm": 357.6, "slotWidth": 3.5 }, "rule": { "checkMarginMm": 10 }, "counts": { "fits": 0, "check": 0, "doesNotFit": 1 }, "items": [ { "chassis": { "slug": "fractal-north", "name": "Fractal Design North", "maxGpuLengthMm": 355, "maxGpuSlots": 3 }, "fit": { "verdict": "does-not-fit", "basis": "dimensions", "reasons": [ { "code": "length-exceeds", "boardLengthMm": 357.6, "clearanceMm": 355, "marginMm": -2.6 }, { "code": "slots-exceed", "boardSlotWidth": 3.5, "maxSlots": 3 } ] }, "psu": { "includedW": null, "recommendedW": 1000, "sufficient": null } } ], "links": { "self": "https://gpuninja.com/api/v1/boards/asus-rog-strix-4090/fits", "page": "https://gpuninja.com/boards/asus-rog-strix-4090", "text": "https://gpuninja.com/boards/asus-rog-strix-4090.txt" } } ``` (Abridged: the `board` and `chassis` objects are full summaries in the real response.) ### Verdicts `fit.verdict` is one of three values: | Verdict | Meaning | | -------------- | -------------------------------------------------------------------------------------------------------------------------------- | | `fits` | The card is shorter than the case's clearance by more than 10 mm, and its slot width is within the case's slot count | | `check` | Nothing rules the card out, but it fits by 10 mm or less, or one of the four measurements isn't recorded. Measure before you buy | | `does-not-fit` | The card is longer than the clearance, or wider than the slot count | ### The rule When no override exists, `basis` is `"dimensions"` and the verdict comes from two comparisons: 1. Length. The margin is the case's `maxGpuLengthMm` minus the card's `lengthMm`, compared exactly in tenths of a millimetre. - Either value unknown: `length-unknown`, which counts as check. - Margin below 0: `length-exceeds`, does-not-fit. - Margin from 0 to 10.0 mm inclusive: `length-tight`, check. This is the 10 mm rule, published as `rule.checkMarginMm`. - Margin above 10.0 mm: `length-clear`, fits. 2. Slots. The card's `slotWidth` against the case's `maxGpuSlots`, compared exactly in hundredths of a slot, so a 3.04-slot card does not fit a 3-slot case and a 3.00-slot card does. - Either value unknown: `slots-unknown`, check. - Card wider than the slot count: `slots-exceed`, does-not-fit. - Otherwise: `slots-ok`, fits. The verdict is the worse of the two, where `does-not-fit` is worse than `check`, which is worse than `fits`. `reasons` holds both, length first. Length reasons carry `boardLengthMm`, `clearanceMm` and `marginMm` (negative when the card is too long); slot reasons carry `boardSlotWidth` and `maxSlots`. The `-unknown` reasons carry only their `code`. At the boundaries: a margin of exactly 10.0 mm is `check` and 10.1 mm is `fits`; a margin of exactly 0.0 mm is `check` and −0.1 mm is `does-not-fit`. `marginMm` is always a whole number of tenths, written with at most one decimal place (`7.4`, never `7.400000000000034`). ### Overrides Dimensions occasionally give the wrong answer, for instance when a card fits only with the front fans removed. A maintainer can then record an override, which always carries a note. With an override, `basis` is `"override"`, the verdict is `fits` or `does-not-fit` as recorded, and `reasons` holds a single reason: ```json { "verdict": "fits", "basis": "override", "reasons": [ { "code": "override", "fits": true, "note": "Verified with front fans removed; see manufacturer FAQ." } ] } ``` ### PSU advisory Each item has a `psu` object: the case's `includedW` (the wattage of a bundled power supply, if any), the card's `recommendedW`, and `sufficient`, which is `includedW >= recommendedW` when both are known and `null` otherwise. The advisory never changes the fit verdict. ### Counts and ordering `counts` gives the number of items with each verdict (`fits`, `check`, `doesNotFit`). Items are ordered `fits` first, then `check`, then `does-not-fit`, and by the other entity's slug within each verdict. A board's fit against a case is always identical in the board's document and in the case's document. ## Can-run and runs-on ```bash curl -s https://gpuninja.com/api/v1/boards/asus-rog-strix-4090/can-run curl -s https://gpuninja.com/api/v1/models/llama-3-1-8b-q4/runs-on ``` ```json { "apiVersion": "v1", "kind": "board-can-run", "asOf": "2026-10-04T06:12:00Z", "board": { "slug": "asus-rog-strix-4090", "vramGb": 24 }, "determinable": true, "items": [ { "model": { "slug": "llama-3-1-8b-q4", "name": "Llama 3.1 8B Q4_K_M", "minVramGb": 6 }, "headroomGb": 18, "results": [] } ], "links": { "self": "https://gpuninja.com/api/v1/boards/asus-rog-strix-4090/can-run", "page": "https://gpuninja.com/boards/asus-rog-strix-4090", "text": "https://gpuninja.com/boards/asus-rog-strix-4090.txt" } } ``` (Abridged: the `board` and `model` objects are full summaries in the real response.) The rule compares the card's `vramGb` with the model's `minVramGb`, to a hundredth of a gigabyte: - A card can run a model when its VRAM is at least the model's minimum. Equality counts: a 24 GB card runs a model that needs 24 GB, with `headroomGb: 0`, but not one that needs 24.01 GB. `headroomGb` is the difference, a whole number of hundredths, so it is never negative. - Only pairs that can run appear as items. A card with too little VRAM is simply absent. - If either value is unknown, the pair can't be decided and is left out. When the subject's own value is unknown, `determinable` is `false` and `items` is empty; otherwise it is `true`. - `results` lists the benchmark results for that model whose subject is that card or the card's chip (`subject.kind` tells you which). `can-run` items are ordered by the model's `minVramGb`, largest first, then model slug. `runs-on` items are ordered by `headroomGb`, smallest first, then board slug, so the tightest fits come first. Can-run is a VRAM check only. It says the model's weights fit; how fast it runs is what the benchmark results are for. ## Discontinued hardware Fit and can-run are recomputed on every build for discontinued boards and chassis too, so a discontinued card is checked against cases and models added after it was frozen, by the same rules. Its summary in these documents shows `status: "discontinued"`, `inStock: false` and `lowestPriceUsd: null`.