# PC Build Compatibility Checker: Will These Parts Fit? (`anoopibrampur/pc-build-compatibility-checker`) Actor

Checks a PC build before you buy: CPU socket, RAM type and slots, PSU wattage and GPU power cables, GPU length and cooler height against the case, board and PSU form factor. Pass, fail or uncertain for each rule, citing maker spec pages. No guessing.

- **URL**: https://apify.com/anoopibrampur/pc-build-compatibility-checker.md
- **Developed by:** [Anoop Ibrampur](https://apify.com/anoopibrampur) (community)
- **Categories:** E-commerce, Developer tools
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 build checkeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## PC Build Compatibility Checker: will these parts fit?

**Check a PC build before you buy it.** Fill in the parts (CPU, motherboard, RAM, graphics card, power supply, case, cooler). The Actor runs up to **12 compatibility rules** and returns **pass**, **fail** or **uncertain** for each one, with the numbers it compared and the **maker spec pages** behind them.

### What you get

- One row per build: **pass**, **fail**, **partial** or **uncertain**, and for each of up to 12 rules the numbers compared and the maker page behind them.
- Sample row (the default input): `{"rule_id": "fit.cooler_height", "verdict": "fail", "reason": "cooler height 155 mm exceeds case clearance 145 mm", "sources": ["thermalright.com ...", "fractal-design.com ..."], "build_verdict": "fail"}`
- Price: **$0.005 per build checked** (plus Apify's $0.00005 run start).

It never guesses. A spec nobody knows makes that rule **uncertain**, not a pass. A build with parts missing never gets a plain PASS: its verdict is **partial**, and the summary says which rules could run and which parts were not given, for example `PASS for the 1 rule(s) that could run; not given: memory, gpu, psu, case, cooler`. A part we cannot read, an unknown key or a bad number makes the build **uncertain** and names it.

Built for **AI shopping agents**. Our own, [Tech Bazaar](https://github.com/vs-githjk/cal-hacks-2026), uses it to veto a part that will not fit before any money moves. It is just as useful to PC builders, resellers and anyone quoting a build.

### What it checks

| Rule | Compares | Fails when |
|---|---|---|
| `fit.cpu_socket` | CPU socket vs board socket (and LGA1151 chipset generation) | sockets differ |
| `fit.ram_type` | RAM generation vs board | DDR4 kit on a DDR5 board, or the reverse |
| `fit.ram_form` | DIMM vs SO-DIMM | laptop memory on a desktop board |
| `fit.ram_slots` | modules vs slots | 4 sticks, 2 slots |
| `fit.psu_wattage` | estimated load + 25% headroom, and the GPU maker's recommended PSU | the PSU is too small |
| `fit.gpu_connectors` | GPU power cables vs PSU (16-pin 12V-2x6 or 8-pin) | not enough cables |
| `fit.gpu_length` | card length vs case GPU clearance | card is longer than the case allows |
| `fit.cooler_height` | air cooler height vs case clearance (or AIO radiator vs mounts) | cooler too tall |
| `fit.cooler_socket` | cooler's supported sockets vs CPU | socket not listed |
| `fit.form_factor` | board size vs case | an ATX board in a mini-ITX case |
| `fit.psu_form_factor` | PSU size vs case | an ATX PSU in an SFX-only case |
| `fit.storage` | NVMe needs an M.2 slot, SATA needs a port | no slot or port (runs once per drive you list) |

A rule runs when both of its parts are in the build, so a build with no drives runs 11.

### Real example (the default input)

Open the Actor and press **Start**: the form is filled with a Ryzen 7 9700X build with an MSI RTX 5070 Ti Gaming Trio OC, a Thermalright Peerless Assassin 120 SE and a Fractal Design North case. It returns:

**`FAIL: cooler height 155 mm exceeds case clearance 145 mm (11 checks: 10 pass, 1 fail, 0 uncertain)`**

The cooler height comes from thermalright.com and the case clearance from fractal-design.com. The card's 338 mm length (msi.com) fits the North's 355 mm, and the 750 W PSU meets MSI's 750 W recommendation. The build has no drive listed, so the 12th rule (storage) does not run.

### How to use it

1. **Your parts:** type each part's name. For parts we hold maker data on (below), the name alone fills in the specs.
2. **Specs you know:** pick or type what you know (socket, RAM generation, PSU wattage, case clearance). Leave a field empty when you are not sure; that rule then says uncertain instead of guessing.
3. Press **Start**. Each rule is one row in the results table, and the run's status line gives the verdict.

To check many builds in one run, or to give specs the form does not have (drives, AIO radiators, chipset), use **Advanced**: a JSON build or a batch of builds.

### Input

From the API, send the form's fields:

```json
{
  "cpu": "AMD Ryzen 7 9700X", "cpuSocket": "AM5", "cpuVendor": "AMD", "cpuTdpW": 65,
  "motherboard": "Asus PRIME B650-PLUS WIFI", "boardSocket": "AM5", "boardFormFactor": "ATX", "boardMemorySlots": 4,
  "memory": "32GB (2x16GB) DDR5-6000", "memoryType": "DDR5", "memoryForm": "DIMM", "memoryModules": 2,
  "gpu": "MSI GeForce RTX 5070 Ti 16G GAMING TRIO OC",
  "psu": "Corsair RM750e", "psuWattage": 750, "psuFormFactor": "ATX", "psu16pin": 1, "psu8pin": 3,
  "case": "Fractal Design North", "caseMaxGpuLengthMm": 355, "caseBoardSizes": ["ATX", "Micro ATX", "Mini ITX"], "casePsuSizes": ["ATX"],
  "cooler": "Thermalright Peerless Assassin 120 SE"
}
```

Or give the same build as JSON parts in `parts` (it overrides the form for any part it names), or many builds in `builds` as a list of `{id, parts}`:

```json
{"parts": {"gpu": {"name": "MSI GeForce RTX 5070 Ti 16G GAMING TRIO OC"}, "case": {"name": "NZXT H5 Flow", "max_gpu_length_mm": 365}}}
```

**JSON spec fields by part:**

- **cpu:** `socket`, `vendor` (AMD or Intel), `tdp_w` or `max_power_w`, `microarchitecture`
- **motherboard:** `socket`, `form_factor`, `memory_type`, `memory_form`, `memory_slots`, `memory_max_speed_mhz`, `chipset_series`, `m2_slots`, `sata_ports`
- **memory:** `type` (DDR4, DDR5), `form` (DIMM, SO-DIMM), `modules`, `speed_mhz`
- **gpu:** `chipset` (read from the name if left out), `length_mm`, `board_power_w`, `rec_psu_w`
- **psu:** `wattage`, `form_factor`, `pcie_16pin`, `pcie_8pin`
- **case:** `max_gpu_length_mm`, `max_cooler_height_mm`, `motherboard_form_factors`, `psu_form_factors`, `radiator_mounts_mm`, `type`
- **cooler:** `height_mm`, `sockets`, or `type: "aio"` with `radiator_mm`
- **storage** (a list): `interface` (for example "M.2 PCIe 4.0 X4" or "SATA 6.0 Gb/s")

A part can also be given as just its name (`"cooler": "Noctua NH-D15"`): it is looked up by that exact name, and with no maker data its rules come back uncertain. A drive must be an object (`{"interface": "M.2 PCIe 4.0 X4"}`); a plain string drive is named as unreadable. Sizes must be finite numbers above 0 (NaN, infinity and 0 count as unknown and are named). Counts (cables, slots, ports, modules) must be whole numbers, never negative; a negative or fractional count, or an implausible figure like a 1 W TDP, is named and treated as unknown. Form factors are read in any case (`atx`, `Micro ATX`) and lists may be comma strings (`"AM5, AM4"`). A cooler's `type: "aio"` and a case's `type` are used exactly as given. Your own numbers always win over our maker data. Sockets and memory types are read in any case (`am5` is `AM5`), numbers may be strings (`"300"`), and a size of 0 counts as unknown.

### Output

One dataset row per rule:

```json
{"build_id": "build-1", "build_verdict": "fail", "rule_id": "fit.cooler_height", "verdict": "fail",
 "reason": "cooler height 155 mm exceeds case clearance 145 mm",
 "parts": ["Thermalright Peerless Assassin 120 SE", "Fractal Design North"],
 "sources": ["fractal-design.com: GPU 355 (300 with 360 front radiator), cooler 145, ATX PSU", "thermalright.com: 155 mm; AM4, AM5, 115X, 1200, 1700, 1851"],
 "origin": "MIRROR (dated maker data, Oct 24 2026)"}
```

Each row also carries `complete` and `missing_parts`, and `build_verdict` is `partial` when every rule that ran passed but parts were missing. `origin` says whether a row's numbers came from our dated maker data, from chipset estimates only, or only from your input. A figure for a sibling model is cited with that caveat, and GPU board power and cable needs taken from NVIDIA or AMD chipset reference figures are cited as estimates. The key-value store's `OUTPUT` record holds every build with its verdict, `complete`, `rules_run`, `missing_parts`, the specs we filled in and their sources.

### Maker data we hold (dated Oct 24 2026)

- **Graphics cards:** RTX 5070 Ti models from MSI (Gaming Trio, Ventus 3X, Vanguard), Gigabyte (Gaming OC, Windforce), ASUS (Prime, ProArt, TUF) and PNY, with length and recommended PSU. The brand must be in the name (a Zotac "Prime" is not an ASUS Prime). Chipset power tables cover 30 cards: GeForce RTX 30, 40 and 50 series, and Radeon RX 7000 and RX 9070.
- **Coolers:** Thermalright Peerless Assassin 120 SE, Noctua NH-D15, NH-U12S, NH-L12S, DeepCool AK400, be quiet! Dark Rock Pro 5.
- **Cases:** Fractal Design North, Cooler Master MasterBox NR200P (we use its 153 mm glass-panel cooler clearance, the lower of its two figures), NZXT H5 Flow.
- **Boards:** Asus PRIME B650-PLUS WIFI, PRIME Z270-A, MSI B550 GAMING GEN3, PRO Z790-A WIFI, PRO Z890-A WIFI, PRO B760M-A DDR4 II.

For any other part, give its specs; the rules work the same.

### Pricing

**$0.005 per build checked** (pay per event), and Apify platform usage is included.

| You check | You pay |
|---|---|
| 1 build | $0.005 |
| 100 builds | $0.50 |
| 1,000 builds | $5.00 |
| A build with nothing to compare (no pair of parts) | free |

Each run also has Apify's run start event of $0.00005. A build is charged only when at least one rule ran, and it is charged before its results are delivered. When your spending limit is reached the run stops and the summary says how many builds were not run. A restarted run never charges a build twice.

### Agents can pay per call (experimental)

An AI agent with a stablecoin wallet and **no Apify account** can pay for this Actor itself, through [Apify's Agent General Interface](https://agi.apify.com/AGENTS.md):

1. The agent asks for a prepaid token: `GET https://agi.apify.com/protocols/x402/prepaid-tokens?amount=1&currency=usd` answers **HTTP 402** with a payment challenge. x402 takes USDC on Base, or USDC or USDT on Solana. MPP (`/protocols/mpp/...`) takes USDC.e or pathUSD on Tempo, or USDC or USDT on Solana.
2. The agent's wallet pays it (for example `npx awal x402 pay ...`, `mppx ...` or `pay.sh`), and Apify returns a token with a hard spend cap: at least $1, it expires after 14 days, and unused balance is not refunded.
3. The agent runs this Actor with `Authorization: Bearer <token>`, and each build is metered against that balance. This works because the Actor uses limited permissions.

**What we have verified (Oct 24 2026):** unpaid requests to agi.apify.com answered **HTTP 402** for a prepaid token (x402 and MPP) and for a proxied run of this Actor ($1.00 USDC on Base). That is *reached, not paid*. This section will say LIVE only after a real paid run.

### Use it from an AI agent or your code

**AI agents (MCP):** `https://mcp.apify.com?tools=anoopibrampur/pc-build-compatibility-checker` adds it as a tool in any MCP client.

**API (one call, results in the response):**

```bash
curl -X POST "https://api.apify.com/v2/acts/anoopibrampur~pc-build-compatibility-checker/run-sync-get-dataset-items" \
  -H "Authorization: Bearer YOUR_APIFY_TOKEN" -H "Content-Type: application/json" \
  -d '{"gpu": "MSI GeForce RTX 5070 Ti 16G GAMING TRIO OC", "case": "NZXT H5 Flow", "caseMaxGpuLengthMm": 365}'
```

### Our other Actor

- [**Listing Claim Checker: Price, Stock, Condition**](https://apify.com/anoopibrampur/tech-bazaar-claim-check) checks what a seller says (price, stock, condition, warranty, returns) against the live product page, before you buy the parts this Actor said will fit.

### FAQ

**Why "uncertain" instead of a best guess?** A wrong "fits" costs a return. If a spec is missing, we say so and name it in the reason, so you know exactly what to look up.

**Does it browse store pages?** No. It works from your specs and our dated maker data, so it is fast and never blocked.

**What does "est. load" mean in the PSU rule?** CPU power plus GPU board power plus 75 W for the rest of the system, then 25% headroom, rounded up to 10 W. The GPU maker's recommendation is used when it is higher.

### Source

[github.com/vs-githjk/cal-hacks-2026](https://github.com/vs-githjk/cal-hacks-2026), `data/fit_checker/`. Labels: maker data is MIRROR (a dated read of maker pages). **Building from git alone fails:** run `./bundle.sh` first, which copies the fit checker and its data into `src/data/` (that copy is not committed, so there is one source of truth).

# Actor input Schema

## `cpu` (type: `string`):

Name of the processor, for example AMD Ryzen 7 9700X.

## `motherboard` (type: `string`):

Name of the motherboard. Exact names we hold maker data for fill in their RAM type and form.

## `memory` (type: `string`):

Name of the RAM kit.

## `gpu` (type: `string`):

Name of the graphics card. For RTX 5070 Ti models we hold, the maker's length and recommended PSU are filled in.

## `psu` (type: `string`):

Name of the power supply.

## `case` (type: `string`):

Name of the case. Exact names we hold maker data for fill in their cooler clearance.

## `cooler` (type: `string`):

Name of the CPU cooler. Exact names we hold maker data for fill in their height and sockets.

## `cpuSocket` (type: `string`):

Leave empty if unknown; that check then comes back uncertain.

## `cpuVendor` (type: `string`):

Used to estimate CPU power for the PSU check.

## `cpuTdpW` (type: `integer`):

The CPU's rated TDP in watts, for the PSU check.

## `boardSocket` (type: `string`):

The board's CPU socket.

## `boardFormFactor` (type: `string`):

The board's form factor.

## `boardMemorySlots` (type: `integer`):

Number of RAM slots on the board.

## `memoryType` (type: `string`):

DDR4 or DDR5.

## `memoryForm` (type: `string`):

Desktop DIMM or laptop SO-DIMM.

## `memoryModules` (type: `integer`):

Number of RAM modules in the kit.

## `gpuLengthMm` (type: `integer`):

Only needed when we do not hold the card's maker length.

## `psuWattage` (type: `integer`):

The PSU's rated wattage.

## `psuFormFactor` (type: `string`):

ATX, SFX or SFX-L.

## `psu16pin` (type: `integer`):

Native 16-pin GPU power cables on the PSU.

## `psu8pin` (type: `integer`):

8-pin PCIe GPU power cables on the PSU.

## `caseMaxGpuLengthMm` (type: `integer`):

Longest graphics card the case takes.

## `caseMaxCoolerHeightMm` (type: `integer`):

Tallest CPU air cooler the case takes. Only needed when we do not hold the case.

## `caseBoardSizes` (type: `array`):

Board form factors the case takes, one per line.

## `casePsuSizes` (type: `array`):

PSU form factors the case takes, one per line.

## `coolerHeightMm` (type: `integer`):

Only needed when we do not hold the cooler's maker height.

## `parts` (type: `object`):

Optional. The same build as an object of parts ({cpu: {name, socket, ...}, ...}; field names in the README). Overrides the form fields for any part it names.

## `builds` (type: `array`):

Optional. A list of {id, parts} objects, each checked as its own build.

## Actor input object example

```json
{
  "cpu": "AMD Ryzen 7 9700X",
  "motherboard": "Asus PRIME B650-PLUS WIFI",
  "memory": "32GB (2x16GB) DDR5-6000",
  "gpu": "MSI GeForce RTX 5070 Ti 16G GAMING TRIO OC",
  "psu": "Corsair RM750e",
  "case": "Fractal Design North",
  "cooler": "Thermalright Peerless Assassin 120 SE",
  "cpuSocket": "AM5",
  "cpuVendor": "AMD",
  "cpuTdpW": 65,
  "boardSocket": "AM5",
  "boardFormFactor": "ATX",
  "boardMemorySlots": 4,
  "memoryType": "DDR5",
  "memoryForm": "DIMM",
  "memoryModules": 2,
  "psuWattage": 750,
  "psuFormFactor": "ATX",
  "psu16pin": 1,
  "psu8pin": 3,
  "caseMaxGpuLengthMm": 355,
  "caseBoardSizes": [
    "ATX",
    "Micro ATX",
    "Mini ITX"
  ],
  "casePsuSizes": [
    "ATX"
  ]
}
```

# Actor output Schema

## `checks` (type: `string`):

One row per rule per build: pass, fail or uncertain, the reason and the maker pages it used

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "cpu": "AMD Ryzen 7 9700X",
    "motherboard": "Asus PRIME B650-PLUS WIFI",
    "memory": "32GB (2x16GB) DDR5-6000",
    "gpu": "MSI GeForce RTX 5070 Ti 16G GAMING TRIO OC",
    "psu": "Corsair RM750e",
    "case": "Fractal Design North",
    "cooler": "Thermalright Peerless Assassin 120 SE",
    "cpuSocket": "AM5",
    "cpuVendor": "AMD",
    "cpuTdpW": 65,
    "boardSocket": "AM5",
    "boardFormFactor": "ATX",
    "boardMemorySlots": 4,
    "memoryType": "DDR5",
    "memoryForm": "DIMM",
    "memoryModules": 2,
    "psuWattage": 750,
    "psuFormFactor": "ATX",
    "psu16pin": 1,
    "psu8pin": 3,
    "caseMaxGpuLengthMm": 355,
    "caseBoardSizes": [
        "ATX",
        "Micro ATX",
        "Mini ITX"
    ],
    "casePsuSizes": [
        "ATX"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("anoopibrampur/pc-build-compatibility-checker").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "cpu": "AMD Ryzen 7 9700X",
    "motherboard": "Asus PRIME B650-PLUS WIFI",
    "memory": "32GB (2x16GB) DDR5-6000",
    "gpu": "MSI GeForce RTX 5070 Ti 16G GAMING TRIO OC",
    "psu": "Corsair RM750e",
    "case": "Fractal Design North",
    "cooler": "Thermalright Peerless Assassin 120 SE",
    "cpuSocket": "AM5",
    "cpuVendor": "AMD",
    "cpuTdpW": 65,
    "boardSocket": "AM5",
    "boardFormFactor": "ATX",
    "boardMemorySlots": 4,
    "memoryType": "DDR5",
    "memoryForm": "DIMM",
    "memoryModules": 2,
    "psuWattage": 750,
    "psuFormFactor": "ATX",
    "psu16pin": 1,
    "psu8pin": 3,
    "caseMaxGpuLengthMm": 355,
    "caseBoardSizes": [
        "ATX",
        "Micro ATX",
        "Mini ITX",
    ],
    "casePsuSizes": ["ATX"],
}

# Run the Actor and wait for it to finish
run = client.actor("anoopibrampur/pc-build-compatibility-checker").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "cpu": "AMD Ryzen 7 9700X",
  "motherboard": "Asus PRIME B650-PLUS WIFI",
  "memory": "32GB (2x16GB) DDR5-6000",
  "gpu": "MSI GeForce RTX 5070 Ti 16G GAMING TRIO OC",
  "psu": "Corsair RM750e",
  "case": "Fractal Design North",
  "cooler": "Thermalright Peerless Assassin 120 SE",
  "cpuSocket": "AM5",
  "cpuVendor": "AMD",
  "cpuTdpW": 65,
  "boardSocket": "AM5",
  "boardFormFactor": "ATX",
  "boardMemorySlots": 4,
  "memoryType": "DDR5",
  "memoryForm": "DIMM",
  "memoryModules": 2,
  "psuWattage": 750,
  "psuFormFactor": "ATX",
  "psu16pin": 1,
  "psu8pin": 3,
  "caseMaxGpuLengthMm": 355,
  "caseBoardSizes": [
    "ATX",
    "Micro ATX",
    "Mini ITX"
  ],
  "casePsuSizes": [
    "ATX"
  ]
}' |
apify call anoopibrampur/pc-build-compatibility-checker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,anoopibrampur/pc-build-compatibility-checker"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/djo1yhWs81xud1DkO/builds/9o05OTnavc1iL4kJb/openapi.json