# Rockauto Parts Scraper (`mrdoe/rockauto-parts-scraper`) Actor Scrape RockAuto auto parts and car parts by year, make, model, engine, category and part type. Extract part numbers, brands, prices, availability, fitment, categories, images and more from the RockAuto catalog for pricing and market research. - **URL**: https://apify.com/mrdoe/rockauto-parts-scraper.md - **Developed by:** [MrDoe](https://apify.com/mrdoe) (community) - **Categories:** - **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks - **User rating**: No ratings yet ## Pricing from $0.80 / 1,000 results This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events. Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have. Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event ## What's an Apify Actor? Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows. 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. Actors are written with capital "A". ## 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. The best way to integrate Actors is as follows. - **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use). - **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`. - **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`. - **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`. - **Any other language** — the [REST API](https://docs.apify.com/api/v2.md). For usage examples, see the [API](#api) section below. For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt). # README ![Rockauto Parts Scraper hero](https://api.apify.com/v2/key-value-stores/kE36venAoVchGsE6b/records/rockauto-parts-scraper--hero.png) ### What does RockAuto Parts Scraper do? RockAuto Parts Scraper walks the RockAuto catalog the same way a shopper does — **year, make, model, engine, category, part type** — and returns every part it finds as structured data: brand, part number, description, current price, availability, and the vehicle it fits. The quickest way to try it is to open a RockAuto part-type page in your browser, copy the URL into **RockAuto catalog URLs**, and press **Start**. It is built for teams that need an always-current view of RockAuto pricing and fitment without keeping a full copy of the catalog. Data is pulled live from RockAuto on every run, so prices and availability reflect what the site shows at that moment. ### Why use RockAuto Parts Scraper? - **Navigate by vehicle, not guesswork** — give it a make (and optionally year, model, engine, category, part type) and it follows the real RockAuto selection path to the parts. - **Current prices and availability** — every run reads live pages; nothing is served from a stale database unless you explicitly turn caching on. - **Clean, structured output** — one row per part with consistent fields, ready for a spreadsheet, database, or pricing tool. - **Scales sensibly** — target one part type, a whole category, or several vehicles at once, with limits that keep large jobs from running away. - **Repeatable** — schedule it, connect it to Google Sheets or your own systems, and refresh only the vehicles or part types you care about. ### What makes this different? Two things. First, the input follows RockAuto's own **Year → Make → Model → Engine → Category → Part Type** tree, matching your plain-text selections to the on-site options, so you never need internal codes. Second, it is designed for **incremental, on-demand refresh**: an optional cache lets recurring runs re-price only the part-type pages you ask for instead of re-crawling everything, which is what makes covering a large slice of the catalog practical. ### What data can you extract? ![Rockauto Parts Scraper dataset output](https://api.apify.com/v2/key-value-stores/kE36venAoVchGsE6b/records/rockauto-parts-scraper--output.png) ![Rockauto Parts Scraper data fields](https://api.apify.com/v2/key-value-stores/kE36venAoVchGsE6b/records/rockauto-parts-scraper--fields.png) | Field | Description | | ------------------------- | ----------------------------------------------------------------------------------------------- | | `brand` | Manufacturer / brand of the part (e.g. `MOTORCRAFT`, `BOSCH`). | | `partNumber` | The manufacturer part number. | | `description` | Fitment and specification text shown with the listing (position, material, options). | | `price` | Current part price, as a number. | | `corePrice` | Refundable core charge, if any (`0` when there is none). | | `totalPrice` | Price plus core charge. | | `currency` | Always `USD`. | | `availability` | `In stock`, `Out of stock`, or `Unknown` based on the listing's order controls. | | `shipsFromWarehouseCount` | How many warehouses can ship the part. | | `grade` | RockAuto quality tier when shown (`Economy`, `Daily Driver`, `Premium`, `High Performance`, …). | | `note` | Closeout / warranty note attached to the listing, if any. | | `vehicle` | The selected vehicle: `make`, `year`, `model`, `engine`. | | `category` / `partType` | Where the part sits in the catalog. | | `partKey` | Stable RockAuto identifier for the listing (used for de-duplication). | | `partInfoUrl` | Link to the part's information page on RockAuto. | | `catalogUrl` | Link to the part-type page the part came from. | | `imageUrls` | Image URL(s) for the part (when *Include part images* is on). | | `alternatePartNumbers` | Equivalent inventory numbers (only when *Fetch extra part details* is on). | | `installationTips` | RockAuto's install notes for the part type (only when *Fetch extra part details* is on). | | `scrapedAt` | ISO timestamp when the row was collected. | ### How to use RockAuto Parts Scraper ![How Rockauto Parts Scraper works](https://api.apify.com/v2/key-value-stores/kE36venAoVchGsE6b/records/rockauto-parts-scraper--how-it-works.png) 1. Open the Actor in Apify Console. 2. Either paste one or more RockAuto catalog URLs into **RockAuto catalog URLs**, or add entries under **Vehicles** (make required; year, model, engine, category, part type optional). 3. Set **Max parts per selection** and, for broad selections, the part-type limits. 4. Keep **Proxy configuration** enabled (US). 5. Press **Start**. 6. When the run finishes, download the dataset (JSON, CSV, Excel) from the **Storage** tab or pull it through the API. ### Input Parameters | Parameter | Type | Required | Default | Description | | ------------------------- | ---------------- | ------------------------------- | --------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | | `startUrls` | Array of URLs | One of `startUrls` / `vehicles` | Example Ford brake-pad page | RockAuto catalog pages copied from your browser. Any level works — make, model, engine, category, or a full part-type page. The Actor crawls down to the parts from wherever you point it. | | `vehicles` | Array of objects | One of `startUrls` / `vehicles` | – | Select vehicles by name. Each entry: `make` (required), `year`, `model`, `engine`, `category`, `partType`. Leave a field out to collect everything below that level. | | `maxItems` | Integer | No | `20` | Maximum parts returned per Start URL or Vehicle entry. Raise it to get a full part-type list (often 100+). | | `maxPartTypesPerCategory` | Integer | No | `3` | When a selection stops at category level, how many part types to open per category. `0` = all. | | `maxLeafPages` | Integer | No | `5` | Safety cap on part-type listing pages opened per selection. `0` = no cap. | | `includeImages` | Boolean | No | `true` | Collect part image URLs. | | `fetchPartDetails` | Boolean | No | `false` | Also open each part's info page for alternate part numbers and installation tips. Slower. | | `useCache` | Boolean | No | `false` | Reuse recent part lists to speed up recurring runs. See the FAQ. | | `cacheMaxAgeHours` | Integer | No | `24` | How old a cached part list may be before it is refreshed. | | `proxyConfiguration` | Object | Yes | Apify Proxy, US | A US IP is required (see Known Limitations). | ### Output Data Each dataset item is one part. Example: ```json { "brand": "MOTORCRAFT", "partNumber": "BRF1454", "description": "Front; Standard Premium; w/o Sensor Wire", "price": 45.79, "corePrice": 0, "totalPrice": 45.79, "currency": "USD", "availability": "In stock", "shipsFromWarehouseCount": 2, "grade": "Daily Driver", "note": null, "vehicle": { "make": "Ford", "year": 2015, "model": "F-150", "engine": "3.5L V6" }, "category": "Brake & Wheel Hub", "partType": "Brake Pad", "partKey": "12345678", "partInfoUrl": "https://www.rockauto.com/en/moreinfo.php?pk=12345678&cc=3308774&pt=1684", "catalogUrl": "https://www.rockauto.com/en/catalog/ford,2015,f-150,3.5l+v6,3308774,brake+%26+wheel+hub,brake+pad,1684", "imageUrls": ["https://www.rockauto.com/info/000/BRF1454__ra_m.jpg"], "scrapedAt": "2026-09-01T10:48:33.918Z" } ``` ### Usage Examples **One part type by URL** ```json { "startUrls": [ { "url": "https://www.rockauto.com/en/catalog/ford,2015,f-150,3.5l+v6,3308774,brake+%26+wheel+hub,brake+pad,1684" } ], "maxItems": 200 } ``` **Three different vehicles, one part type each** ```json { "vehicles": [ { "make": "Toyota", "year": 2007, "model": "Camry", "engine": "2.4L L4", "category": "Engine", "partType": "Motor Mount" }, { "make": "Honda", "year": 2019, "model": "Civic", "engine": "2.0L L4", "category": "Brake & Wheel Hub", "partType": "Brake Pad" }, { "make": "Ford", "year": 2015, "model": "F-150", "engine": "3.5L V6", "category": "Ignition", "partType": "Spark Plug" } ], "maxItems": 100 } ``` **A whole category for one vehicle, bounded** ```json { "vehicles": [ { "make": "Ford", "year": 2015, "model": "F-150", "engine": "3.5L V6", "category": "Brake & Wheel Hub" } ], "maxPartTypesPerCategory": 10, "maxLeafPages": 10, "maxItems": 500 } ``` ### Tips for Best Results - For the most reliable runs, copy a **part-type URL** straight from RockAuto — it removes any ambiguity in matching names. - Match the **engine** text to how RockAuto writes it (e.g. `3.5L V6`, `2.0L L4 Turbocharged`). - Start with a small `maxItems` to preview the output shape, then raise it. - Use **Vehicles** with only `make`, `year`, `model` filled in to discover the exact engine, category, and part-type names RockAuto uses, then pin them. - For recurring pricing checks on the same parts, turn on **Use cache** and schedule the run. ### Known Limitations - **US IP required.** RockAuto shows a verification page for part-listing requests from non-US IP addresses, so the Actor needs a US proxy. Keep proxy configuration enabled. - **No stock quantities.** RockAuto does not publish unit counts. `availability` reflects whether the listing can be ordered; it is not a live inventory number. - **Name matching depends on RockAuto's wording.** If your `engine`, `category`, or `partType` text doesn't match an on-site option, the run logs which options were available and skips that branch. Using a URL avoids this. - **Broad selections are capped.** Selections above part-type level are bounded by `maxPartTypesPerCategory` and `maxLeafPages` so a single run can't try to crawl an entire make. - **Fitment detail** is limited to what RockAuto shows on the listing (`description`) plus the selected vehicle; deep application tables are not collected. ### Integrations Connect runs to Google Sheets, Make, Zapier, Slack, or your own backend via webhooks and the Apify API. Schedule runs to keep a pricing sheet current. Every run's dataset is available through the API immediately. ### Export Formats JSON, CSV, Excel, and XML — from the **Storage** tab in Console or via the dataset API. ### Frequently Asked Questions #### How many parts can it return? As many as RockAuto lists. `maxItems` caps results per selection; set it high (e.g. `100000`) for no practical limit. A single part-type page often has 100–200 parts. #### Can I scrape by search term instead of a vehicle? No. RockAuto's catalog is organised by vehicle, so this Actor navigates by vehicle. Provide a catalog URL or a vehicle selection. #### Why are some fields `null`? RockAuto doesn't show every field for every listing. `grade`, `note`, `corePrice` details and images vary by part and brand. Missing values are returned as `null` rather than guessed. #### How fresh is the data? Live as of the run, unless **Use cache** is on. With caching enabled, part-type lists newer than **Cache max age (hours)** are reused; older ones are refreshed. The vehicle navigation pages are always re-read so new part types are picked up. #### Does caching hide price changes? Only within the cache window you set. Leave **Use cache** off (the default) for always-current prices, or set a short **Cache max age** for near-current prices on recurring runs. #### How are duplicates handled? Parts are de-duplicated per run using RockAuto's stable listing identifier, so the same part won't appear twice from one selection. #### Can I run it on a schedule? Yes. Use Apify Schedules. Combine with **Use cache** to re-price a fixed set of part types cheaply. #### Will Apify's automated daily test pass? Yes — the default input scrapes a single part-type page and completes well within the time limit. ### Support If a run fails or the output looks wrong, open an issue on the Actor's **Issues** tab in Apify Console with the input you used and the run link. Most breakages are caused by RockAuto layout changes and are quick to patch. ### Legal / Responsible Use You are responsible for ensuring your use of this Actor complies with RockAuto's Terms of Use, applicable laws, and any contractual obligations. This Actor collects product and pricing data, not personal data. Use the output for legitimate purposes such as market research, pricing analysis, and catalog integration. ### Preview ![Rockauto Parts Scraper input options](https://api.apify.com/v2/key-value-stores/kE36venAoVchGsE6b/records/rockauto-parts-scraper--input.png) # Actor input Schema ## `startUrls` (type: `array`): RockAuto catalog pages to scrape, copied straight from your browser address bar. Any level of the vehicle tree works: a make (.../catalog/ford), a model, an engine, a category, or a full part-type page such as https://www.rockauto.com/en/catalog/ford,2015,f-150,3.5l+v6,3308774,brake+%26+wheel+hub,brake+pad,1684. The Actor automatically walks down to the parts from wherever you point it. Leave empty if you use the Vehicles field instead. ## `vehicles` (type: `array`): Select vehicles by name instead of by URL. Each entry is an object with any of: make (required), year, model, engine, category, partType. The Actor follows the normal RockAuto selection path and matches your text to the on-site options. Leave a field out to collect everything below that level (bounded by the limits below). Example: \[{"make":"Toyota","year":2007,"model":"Camry","engine":"2.4L L4","category":"Engine","partType":"Motor Mount"}] ## `maxItems` (type: `integer`): Upper limit on the number of parts returned for each Start URL or Vehicle entry. A single part-type page on RockAuto can list 100+ parts, so raise this if you want the full list. Set high (e.g. 100000) for no practical limit. ## `maxPartTypesPerCategory` (type: `integer`): Only used when a selection stops above the part-type level (e.g. you give a category but no part type). Caps how many part types are opened inside each category. Set to 0 for all of them. ## `maxLeafPages` (type: `integer`): Safety cap on how many part-type listing pages are opened for each Start URL or Vehicle entry, to keep broad selections from running away. Set to 0 to disable the cap. ## `includeImages` (type: `boolean`): Collect the image URL(s) shown next to each part. ## `fetchPartDetails` (type: `boolean`): Open each part's info page for alternate part numbers and installation tips. Slower and uses more requests. Disabled by default. ## `useCache` (type: `boolean`): Reuse previously collected part lists when they are still recent, to speed up recurring runs and avoid repeated requests. Prices and availability from the cache are only as fresh as the cache age below. Disabled by default. ## `cacheMaxAgeHours` (type: `integer`): When Use cache is on, cached part lists older than this are refreshed from RockAuto instead of reused. ## `proxyConfiguration` (type: `object`): RockAuto shows a verification page for part-listing requests that do not come from a US IP address, so a US proxy is required. The default (Apify Proxy, US) works for most runs; switch to residential IPs if you see verification warnings in the log. ## Actor input object example ```json { "startUrls": [ { "url": "https://www.rockauto.com/en/catalog/ford,2015,f-150,3.5l+v6,3308774,brake+%26+wheel+hub,brake+pad,1684" } ], "vehicles": [ { "make": "Honda", "year": 2019, "model": "Civic", "engine": "2.0L L4", "category": "Brake & Wheel Hub", "partType": "Brake Pad" } ], "maxItems": 20, "maxPartTypesPerCategory": 3, "maxLeafPages": 5, "includeImages": true, "fetchPartDetails": false, "useCache": false, "cacheMaxAgeHours": 24, "proxyConfiguration": { "useApifyProxy": true, "apifyProxyCountry": "US" } } ``` # Actor output Schema ## `parts` (type: `string`): No description # 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 '' with your token const client = new ApifyClient({ token: '', }); // Prepare Actor input const input = { "startUrls": [ { "url": "https://www.rockauto.com/en/catalog/ford,2015,f-150,3.5l+v6,3308774,brake+%26+wheel+hub,brake+pad,1684" } ], "vehicles": [ { "make": "Honda", "year": 2019, "model": "Civic", "engine": "2.0L L4", "category": "Brake & Wheel Hub", "partType": "Brake Pad" } ], "proxyConfiguration": { "useApifyProxy": true, "apifyProxyCountry": "US" } }; // Run the Actor and wait for it to finish const run = await client.actor("mrdoe/rockauto-parts-scraper").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 '' with your token. client = ApifyClient("") # Prepare the Actor input run_input = { "startUrls": [{ "url": "https://www.rockauto.com/en/catalog/ford,2015,f-150,3.5l+v6,3308774,brake+%26+wheel+hub,brake+pad,1684" }], "vehicles": [{ "make": "Honda", "year": 2019, "model": "Civic", "engine": "2.0L L4", "category": "Brake & Wheel Hub", "partType": "Brake Pad", }], "proxyConfiguration": { "useApifyProxy": True, "apifyProxyCountry": "US", }, } # Run the Actor and wait for it to finish run = client.actor("mrdoe/rockauto-parts-scraper").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 '{ "startUrls": [ { "url": "https://www.rockauto.com/en/catalog/ford,2015,f-150,3.5l+v6,3308774,brake+%26+wheel+hub,brake+pad,1684" } ], "vehicles": [ { "make": "Honda", "year": 2019, "model": "Civic", "engine": "2.0L L4", "category": "Brake & Wheel Hub", "partType": "Brake Pad" } ], "proxyConfiguration": { "useApifyProxy": true, "apifyProxyCountry": "US" } }' | apify call mrdoe/rockauto-parts-scraper --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "type": "http", "url": "https://mcp.apify.com/?tools=fetch-actor-details,mrdoe/rockauto-parts-scraper" } } } ``` 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 ` 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/0VbvXy2WnhGFV60Um/builds/QEOu1eNdPL744NelB/openapi.json