PCPartPicker APIpcpartpicker.com ↗
Access PCPartPicker data via API: search parts, get specs, compare prices from multiple merchants, and browse all component categories.
What is the PCPartPicker API?
This API gives developers structured access to PCPartPicker's component catalog across 4 endpoints. Use get_part_details to retrieve full specifications, multi-merchant pricing, and compatibility links for any part by its PCPartPicker URL. Use search_parts to query across all categories, or get_motherboards for paginated browsing with optional keyword filtering. Responses include fields like specs, prices, buy_link, and compatibility_links.
curl -X GET 'https://api.parse.bot/scraper/87f06a9b-7688-4c9e-a5c7-c607744b9f24/get_motherboards?page=1&search=B650' \ -H 'X-API-Key: $PARSE_API_KEY'
Typed, relational, agent-ready
A generated client with real types, enums, and the links between objects — the structure a flat JSON response can't carry. Autocompletes in your editor and reads cleanly to coding agents.
- Fully typed · autocompletes
- Objects link to objects
- Typed errors & pagination
Typed Python client. Set up the SDK in your uv project, then pull this API’s typed client:
uv add parse-sdk uv run parse init uv run parse add --marketplace pcpartpicker-com-api
uv run parse add --marketplace pulls a pinned snapshot of this canonical API — it won’t change underneath you. To customize it, subscribe and swap to your own copy.
"""Walkthrough: PCPartPicker SDK — search parts, browse motherboards, get details."""
from parse_apis.pcpartpicker_api import PCPartPicker, PartNotFound
client = PCPartPicker()
# Browse all available part categories
for cat in client.categories.list(limit=5):
print(cat.name, cat.slug)
# Search for a specific component across all categories
result = client.searchresults.search(query="rtx 4090", limit=1).first()
if result:
print(result.name, result.category, result.url)
# Browse motherboards with a filter
for mobo in client.motherboards.list(search="B650", limit=3):
print(mobo.name, mobo.price, mobo.specs)
# Get full details for a part using its URL
if result:
try:
part = client.parts.get(url=result.url)
print(part.name, part.specs)
for p in part.prices:
print(p.merchant, p.price)
except PartNotFound as exc:
print(f"Part not found: {exc}")
print("exercised: categories.list / searchresults.search / motherboards.list / parts.get")
Get a paginated list of motherboards with specs and prices. Returns up to ~30 products per page from the full motherboard catalog. Supports text filtering via the search parameter. Paginate by incrementing page; each page returns a slice of the total count.
| Param | Type | Description |
|---|---|---|
| page | integer | Page number for pagination. |
| search | string | Filter results by search term within motherboards (e.g. 'MSI', 'B650'). |
{
"type": "object",
"fields": {
"page": "integer, current page number",
"count": "integer, total number of matching motherboards",
"products": "array of motherboard objects each containing name, url, price, and specs"
},
"sample": {
"data": {
"page": 1,
"count": 156,
"products": [
{
"url": "https://pcpartpicker.com/product/Pz2WGX/asus-tuf-gaming-b650-plus-wifi-atx-am5-motherboard-tuf-gaming-b650-plus-wifi",
"name": "Asus TUF GAMING B650-PLUS WIFI",
"price": "$161.80",
"specs": {
"Color": "Black",
"Memory Max": "128 GB",
"Form Factor": "ATX",
"Memory Slots": "4",
"Socket / CPU": "AM5"
}
}
]
},
"status": "success"
}
}About the PCPartPicker API
What the API Covers
The PCPartPicker API surfaces PC component data across four endpoints. get_all_part_categories returns the full list of part types (with name and slug fields), giving you a stable map of what's browsable. search_parts accepts a free-text query and returns up to 10 results across all categories, with each result carrying a name, url, and category field you can pass directly into other endpoints.
Part Details and Pricing
get_part_details is the most data-dense endpoint. Supply a full PCPartPicker product URL and you get back a specs object with all listed specifications (socket type, memory slots, form factor, etc.), a prices array where each entry includes merchant, price, and buy_link, and a compatibility_links array pointing to related component categories. This makes it practical to compare retailer prices for a single part in one call.
Motherboard Browsing
get_motherboards returns a paginated list of motherboards — up to approximately 30 per page — with a page parameter for navigating deeper into the catalog and a search parameter to filter by keyword (for example, 'B650' or 'MSI'). Each product object includes name, url, price, and a specs field. The count field in the response reflects the total number of matching results, which is useful for calculating total pages.
Data Shape Notes
All product URLs returned by search or list endpoints follow the https://pcpartpicker.com/product/... pattern and are directly usable as the url input to get_part_details. The specs object keys vary by part type — a motherboard will expose different spec keys than a GPU or PSU — so treat it as a flexible map rather than a fixed schema.
The PCPartPicker API is a managed, monitored endpoint for pcpartpicker.com — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when pcpartpicker.com changes and a check fails, the API is automatically queued for repair and re-verified. It is built to keep working as the site underneath it changes.
This isn't an official pcpartpicker.com API — it's an independent, maintained REST wrapper over public data. Where the source has no official API (or only a limited one), Parse gives you a stable contract over a source that never promised one, and keeps it current. Need a new endpoint or field? You can revise it yourself in plain English and the agent rebuilds it against the live site in minutes — contributing the change back to the shared API is free.
Will this API break when the source site changes?+
Is this an official API from the source site?+
Can I fix or extend this API myself if I need a new endpoint or field?+
What happens if I call an endpoint that has an issue?+
- Build a PC configurator that looks up compatible parts using
compatibility_linksreturned byget_part_details. - Track price changes for specific components by polling
get_part_detailsand monitoring thepricesarray over time. - Aggregate multi-merchant pricing for a parts list to surface the cheapest
buy_linkper component. - Filter the motherboard catalog by chipset (e.g.
search='X670') usingget_motherboardsto narrow upgrade options. - Populate a parts database by iterating
get_all_part_categoriesslugs and queryingsearch_partsfor each. - Build a comparison tool that shows spec-by-spec differences between two parts using the
specsobjects fromget_part_details.
| Tier | Price | Credits/month | Rate limit |
|---|---|---|---|
| Free | $0/mo | 100 | 5 req/min |
| Hobby | $30/mo | 1,000 | 20 req/min |
| Developer | $100/mo | 5,000 | 100 req/min |
One credit = one API call regardless of which marketplace API you call. Exceeding the rate limit returns a 429 response. Authenticate with the X-API-Key header.
Does PCPartPicker have an official developer API?+
What does `get_part_details` return beyond basic specs?+
specs object (which maps specification names to values), the endpoint returns a prices array — each entry includes merchant, price, and buy_link — and a compatibility_links array listing related part categories with their URLs. This lets you see all current retail listings for a part in a single response.Does `search_parts` let you filter by category or only search across all categories?+
search_parts searches across all categories and returns up to 10 results per query; there is no category filter parameter on that endpoint. get_motherboards does support a search parameter scoped to motherboards. You can fork this API on Parse and revise it to add category-scoped search endpoints for other part types.Does the API expose user-submitted part lists or build guides?+
How deep does the `get_motherboards` pagination go, and how do I know the total page count?+
count field reflecting total matching results for the current query, so you can calculate the number of pages by dividing count by 30. Pass the page integer parameter to advance through the catalog.