# RockAuto Scraper (`solidcode/rockauto-scraper`) Actor \[💰 $4 / 1K] Extract auto parts from RockAuto.com — brand, part number, price, core charge, stock, fitment notes, and warehouse. Look up parts by vehicle (year/make/model) or by catalog URL. - **URL**: https://apify.com/solidcode/rockauto-scraper.md - **Developed by:** [SolidCode](https://apify.com/solidcode) (community) - **Categories:** E-commerce, Automation, Developer tools - **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks - **User rating**: No ratings yet ## Pricing from $4.00 / 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/platform/actors/running/actors-in-store#pay-per-event ## What's an Apify Actor? Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases. 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. In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md): ```bash npm install apify-client ``` In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md): ```bash pip install apify-client ``` In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md): ````bash # MacOS / Linux curl -fsSL https://apify.com/install-cli.sh | bash # Windows irm https://apify.com/install-cli.ps1 | iex ```bash In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md). If your project is in a different language, use 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 Scraper Pull auto-parts listings from RockAuto.com at scale — brand, manufacturer part number, retail price, the refundable core charge, per-warehouse stock, fitment notes, and full vehicle context on every row. Look up parts by year, make, and model, or paste any RockAuto catalog URL. Built for parts resellers, repair shops, and inventory teams who need clean, structured pricing and fitment data without clicking through RockAuto's catalog tree one part type at a time. ### Why This Scraper? - **Refundable core charge captured separately** — every row carries `corePrice` alongside the retail `price`, so you see the true landed cost of remanufactured parts that competitors collapse into a single number. - **One row per warehouse, not per part** — each listing breaks out by fulfilling warehouse with its own `warehouse` location and `warehousePartNumber`, so you know exactly where stock ships from and what to order against. - **Multi-engine union in one run** — flip `includeAllEngines` on and the scraper unions every engine variant for the model (a 2020 Camry resolves to 3 distinct engine codes), so you never miss parts that only fit the 2.5L or the hybrid. - **Two lookup modes** — search by year/make/model or paste any vehicle, category, or part-type catalog URL; pasted URLs apply their own make, model, engine, and category selections automatically. - **Full vehicle fitment on every row** — make, model, year, engine, and RockAuto's internal `carcode` are echoed onto each part so a flat export stays self-describing with no joins. - **Brand + manufacturer part number for cross-referencing** — `brand` (BOSCH, DENSO, ACDelco) plus the exact `partNumber` on every listing, ready to match against your own catalog or a supplier feed. - **Consistent USD pricing** — prices are normalized to USD and the actual currency glyph is read off each price, so a 100,000-row export never mixes EUR and USD by accident. - **Category targeting or full sweep** — limit to a single RockAuto category group like "Brake & Wheel Hub" or "Suspension", or leave it empty to pull every category for the vehicle. - **21 structured fields per listing** — including `condition` (new vs. remanufactured), `inStock`, `footnote`, `fitmentNotes`, the "More Info" URL, and an ISO-8601 `scrapedAt` timestamp on each row. ### Use Cases **Parts Resellers & Price Monitoring** - Track RockAuto pricing across brands and warehouses for repricing decisions - Compare your catalog against RockAuto's retail price plus core charge - Spot in-stock vs. backordered parts before listing them downstream - Build margin models that account for the refundable core deposit **Repair Shops & Mechanics** - Source the right part by exact year/make/model and engine variant - Confirm fitment with per-listing fitment notes and footnotes before ordering - Pull every brand option for a job to quote good/better/best to customers - Identify which warehouse ships fastest for a given part **Inventory & Catalog Building** - Bulk-load brand, part number, and category data into a parts database - Map RockAuto part types to your own SKU taxonomy - Enrich existing SKUs with current pricing and stock status - Build a fitment table keyed on make/model/year/engine/carcode **Market & Competitive Research** - Benchmark aftermarket part pricing by brand and category - Track core-charge ranges across remanufactured part lines - Analyze brand availability across vehicle platforms - Measure price spread between warehouses for the same part **Fleet Maintenance** - Standardize parts sourcing across a multi-vehicle fleet - Pre-price recurring maintenance items (brakes, filters, belts) by model - Maintain an approved-parts list with current pricing and stock ### Getting Started #### Look Up a Vehicle The simplest run — year, make, and model: ```json { "make": "TOYOTA", "model": "CAMRY", "year": 2020, "maxResults": 50 } ```` #### Target One Category, All Engines Pull only brake parts, and include every engine variant for the model: ```json { "make": "FORD", "model": "F-150", "year": 2021, "partCategory": "Brake & Wheel Hub", "includeAllEngines": true, "maxResults": 200 } ``` #### Paste Catalog URLs Paste any RockAuto vehicle, category, or part-type page — selections in the URL are applied automatically: ```json { "startUrls": [ "https://www.rockauto.com/en/catalog/toyota,2020,camry,2.5l+l4,3445372,brake+&+wheel+hub", "https://www.rockauto.com/en/catalog/honda,2019,civic" ], "maxResults": 300 } ``` ### Input Reference #### What to Scrape | Parameter | Type | Default | Description | |-----------|------|---------|-------------| | `startUrls` | string\[] | `[]` | RockAuto catalog URLs — a vehicle page, a category page, or a part-type page. Make, model, engine, and category already selected in the URL are applied automatically. Leave empty to use the vehicle fields instead. | #### Vehicle Lookup These fields apply only when no catalog URL is provided. | Parameter | Type | Default | Description | |-----------|------|---------|-------------| | `make` | string | `"TOYOTA"` | Vehicle manufacturer, e.g. TOYOTA, HONDA, FORD. Not case-sensitive. | | `model` | string | `"CAMRY"` | Model name, e.g. CAMRY, CIVIC, F-150. Not case-sensitive. Leave empty to cover all models for the make. | | `year` | integer | `2020` | Model year, e.g. 2020. Leave empty to cover all years for the model. | | `partCategory` | string | `""` | Limit results to one category group as named on RockAuto, e.g. "Brake & Wheel Hub", "Engine", "Suspension". Leave empty to collect every category. | | `includeAllEngines` | boolean | `false` | Collect parts for every engine variant of the model. When off, only the primary engine variant is used. | #### Options | Parameter | Type | Default | Description | |-----------|------|---------|-------------| | `maxResults` | integer | `100` | Maximum number of parts to return across all URLs and vehicle lookups. Set to `0` for unlimited. Start with 10–50 to test, then increase. | ### Output Each row is one self-contained warehouse part listing: ```json { "brand": "BOSCH", "partNumber": "BC905", "partType": "Disc Brake Pad Set", "partCategory": "Brake & Wheel Hub", "price": 38.79, "corePrice": 0.0, "currency": "USD", "inStock": true, "condition": "QuietCast Premium", "footnote": "Front; Ceramic", "fitmentNotes": "Front; Ceramic", "warehouse": "Wholesaler Closeout", "warehousePartNumber": "BC905", "make": "TOYOTA", "model": "Camry", "year": 2020, "engine": "2.5L L4", "carcode": "3445372", "infoUrl": "https://www.rockauto.com/en/moreinfo.php?pk=8210456&cc=3445372&pt=1684", "url": "https://www.rockauto.com/en/catalog/toyota,2020,camry,2.5l+l4,3445372,brake+&+wheel+hub,1684", "scrapedAt": "2026-06-13T14:30:00+00:00" } ``` #### Part & Pricing | Field | Type | Description | |-------|------|-------------| | `brand` | string | Manufacturer or brand of the part (e.g. BOSCH, DENSO, ACDelco) | | `partNumber` | string | Manufacturer part number | | `partType` | string | Specific part type (e.g. "Disc Brake Pad Set") | | `partCategory` | string | Category group (e.g. "Brake & Wheel Hub") | | `price` | number | Retail price | | `corePrice` | number | Refundable core charge, separate from retail price (`0.0` when none) | | `currency` | string | Currency code (e.g. USD) | | `condition` | string | Quality tier / condition (new, remanufactured, premium line, etc.) | | `footnote` | string | Listing footnote (position, material, application notes) | | `fitmentNotes` | string | Vehicle-fitment notes for this part | #### Warehouse & Stock | Field | Type | Description | |-------|------|-------------| | `inStock` | boolean | Whether the listing is orderable from this warehouse | | `warehouse` | string | Warehouse location or code fulfilling the listing | | `warehousePartNumber` | string | Warehouse's internal part number | #### Vehicle Fitment | Field | Type | Description | |-------|------|-------------| | `make` | string | Vehicle make the part was looked up for | | `model` | string | Vehicle model | | `year` | integer | Vehicle year | | `engine` | string | Engine variant the part fits (e.g. "2.5L L4") | | `carcode` | string | RockAuto internal vehicle code | | `infoUrl` | string | RockAuto "More Info" URL for the part | | `url` | string | Catalog/listing URL the part came from | | `scrapedAt` | string | ISO-8601 timestamp the row was collected | ### Tips for Best Results - **Start small** — set `maxResults` to 10–50 on your first run to confirm the data matches the vehicle and category you expect, then scale up. - **Use `includeAllEngines` for complete coverage** — a single model often has several engine options, each with its own fitting parts. Leave it off when you know the exact engine; turn it on when you need every part that could fit the model. - **Pull the core charge for true cost** — `corePrice` is a refundable deposit that's separate from `price`. Add the two together for the real upfront landed cost of remanufactured parts, and refund the core back into your margin model after the old unit is returned. - **Match category names exactly as RockAuto labels them** — use the site's own wording like "Brake & Wheel Hub" or "Suspension". Leave `partCategory` empty to sweep every category for the vehicle. - **Paste deep URLs to skip the tree** — a part-type URL goes straight to its listings; a category or vehicle URL traverses downward from that point. Mix URLs and vehicle lookups in one run. - **Names aren't case-sensitive** — `make` and `model` match the site's own labels regardless of case, so "toyota" and "TOYOTA" both work. - **One physical part can produce several rows** — the same part stocked at multiple warehouses yields one row per warehouse, each with its own stock and warehouse part number. Group on `partNumber` if you want a single line per part. ### Pricing **From $4.00 per 1,000 results** — undercuts comparable RockAuto extractors while breaking out the core charge and per-warehouse stock that flat-price feeds miss. Bronze, Silver, and Gold subscribers pay progressively less; the table below shows total cost at each discount tier. | Results | No discount | Bronze | Silver | Gold | |---------|-------------|--------|--------|------| | 100 | $0.48 | $0.45 | $0.43 | $0.40 | | 1,000 | $4.80 | $4.50 | $4.30 | $4.00 | | 10,000 | $48.00 | $45.00 | $43.00 | $40.00 | | 100,000 | $480.00 | $450.00 | $430.00 | $400.00 | A "result" is any part-listing row in the output dataset. There are no compute or time-based charges — you pay per result, plus a small fixed per-run start fee. Platform fees depend on your Apify plan. ### Integrations Export data in JSON, CSV, Excel, XML, or RSS. Connect to 1,500+ apps via: - **Zapier** / **Make** / **n8n** — Workflow automation - **Google Sheets** — Direct spreadsheet export - **Slack** / **Email** — Notifications on new results - **Webhooks** — Trigger custom APIs on run completion - **Apify API** — Full programmatic access ### Legal & Ethical Use This actor is designed for legitimate parts sourcing, pricing research, and inventory and catalog building. Users are responsible for complying with applicable laws and RockAuto's Terms of Service. Do not use extracted data for spam, harassment, or any illegal purpose. Make reasonable-rate requests and respect content usage rules for any data you collect. # Actor input Schema ## `startUrls` (type: `array`): Paste RockAuto catalog URLs (a vehicle page, a part-category page, or a part-listing page). Anything already selected in the URL — make, model, engine, category — is applied automatically. Leave empty if you'd rather build a lookup using the vehicle fields below. ## `make` (type: `string`): Vehicle manufacturer, e.g. TOYOTA, HONDA, FORD. Not case-sensitive. Leave empty if you're using Catalog URLs above. ## `model` (type: `string`): Model name, e.g. CAMRY, CIVIC, F-150. Not case-sensitive. Leave empty to cover all models for the make. ## `year` (type: `integer`): Model year, e.g. 2020. Leave empty to cover all years for the model. ## `partCategory` (type: `string`): Limit results to one part-category group as named on RockAuto, e.g. 'Brake & Wheel Hub', 'Engine', 'Suspension'. Leave empty to collect every category for the vehicle. ## `includeAllEngines` (type: `boolean`): A vehicle can have several engine options, each with its own fitting parts. Turn this on to collect parts for every engine variant. When off, only the first engine variant is used. ## `maxResults` (type: `integer`): Maximum number of parts to return across all URLs and vehicle lookups. Set to 0 for unlimited. Tip: start with 10-50 to test, then increase. ## Actor input object example ```json { "startUrls": [], "make": "TOYOTA", "model": "CAMRY", "year": 2020, "includeAllEngines": false, "maxResults": 100 } ``` # Actor output Schema ## `overview` (type: `string`): Table of scraped parts with brand, part number, price, and stock. # 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": [], "make": "TOYOTA", "model": "CAMRY", "year": 2020, "partCategory": "", "includeAllEngines": false, "maxResults": 100 }; // Run the Actor and wait for it to finish const run = await client.actor("solidcode/rockauto-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": [], "make": "TOYOTA", "model": "CAMRY", "year": 2020, "partCategory": "", "includeAllEngines": False, "maxResults": 100, } # Run the Actor and wait for it to finish run = client.actor("solidcode/rockauto-scraper").call(run_input=run_input) # Fetch and print Actor results from the run's dataset (if there are any) print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"]) for item in client.dataset(run["defaultDatasetId"]).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": [], "make": "TOYOTA", "model": "CAMRY", "year": 2020, "partCategory": "", "includeAllEngines": false, "maxResults": 100 }' | apify call solidcode/rockauto-scraper --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "command": "npx", "args": [ "mcp-remote", "https://mcp.apify.com/?tools=solidcode/rockauto-scraper", "--header", "Authorization: Bearer " ] } } } ``` ## OpenAPI specification ```json { "openapi": "3.0.1", "info": { "title": "RockAuto Scraper", "description": "[💰 $4 / 1K] Extract auto parts from RockAuto.com — brand, part number, price, core charge, stock, fitment notes, and warehouse. Look up parts by vehicle (year/make/model) or by catalog URL.", "version": "1.0", "x-build-id": "akSCfXBVo4ryPRhIt" }, "servers": [ { "url": "https://api.apify.com/v2" } ], "paths": { "/acts/solidcode~rockauto-scraper/run-sync-get-dataset-items": { "post": { "operationId": "run-sync-get-dataset-items-solidcode-rockauto-scraper", "x-openai-isConsequential": false, "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.", "tags": [ "Run Actor" ], "requestBody": { "required": true, "content": { "application/json": { "schema": { "$ref": "#/components/schemas/inputSchema" } } } }, "parameters": [ { "name": "token", "in": "query", "required": true, "schema": { "type": "string" }, "description": "Enter your Apify token here" } ], "responses": { "200": { "description": "OK" } } } }, "/acts/solidcode~rockauto-scraper/runs": { "post": { "operationId": "runs-sync-solidcode-rockauto-scraper", "x-openai-isConsequential": false, "summary": "Executes an Actor and returns information about the initiated run in response.", "tags": [ "Run Actor" ], "requestBody": { "required": true, "content": { "application/json": { "schema": { "$ref": "#/components/schemas/inputSchema" } } } }, "parameters": [ { "name": "token", "in": "query", "required": true, "schema": { "type": "string" }, "description": "Enter your Apify token here" } ], "responses": { "200": { "description": "OK", "content": { "application/json": { "schema": { "$ref": "#/components/schemas/runsResponseSchema" } } } } } } }, "/acts/solidcode~rockauto-scraper/run-sync": { "post": { "operationId": "run-sync-solidcode-rockauto-scraper", "x-openai-isConsequential": false, "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.", "tags": [ "Run Actor" ], "requestBody": { "required": true, "content": { "application/json": { "schema": { "$ref": "#/components/schemas/inputSchema" } } } }, "parameters": [ { "name": "token", "in": "query", "required": true, "schema": { "type": "string" }, "description": "Enter your Apify token here" } ], "responses": { "200": { "description": "OK" } } } } }, "components": { "schemas": { "inputSchema": { "type": "object", "properties": { "startUrls": { "title": "Catalog URLs", "type": "array", "description": "Paste RockAuto catalog URLs (a vehicle page, a part-category page, or a part-listing page). Anything already selected in the URL — make, model, engine, category — is applied automatically. Leave empty if you'd rather build a lookup using the vehicle fields below.", "items": { "type": "string" } }, "make": { "title": "Vehicle Make", "type": "string", "description": "Vehicle manufacturer, e.g. TOYOTA, HONDA, FORD. Not case-sensitive. Leave empty if you're using Catalog URLs above." }, "model": { "title": "Vehicle Model", "type": "string", "description": "Model name, e.g. CAMRY, CIVIC, F-150. Not case-sensitive. Leave empty to cover all models for the make." }, "year": { "title": "Vehicle Year", "minimum": 1900, "maximum": 2030, "type": "integer", "description": "Model year, e.g. 2020. Leave empty to cover all years for the model." }, "partCategory": { "title": "Part Category", "type": "string", "description": "Limit results to one part-category group as named on RockAuto, e.g. 'Brake & Wheel Hub', 'Engine', 'Suspension'. Leave empty to collect every category for the vehicle." }, "includeAllEngines": { "title": "Include All Engine Variants", "type": "boolean", "description": "A vehicle can have several engine options, each with its own fitting parts. Turn this on to collect parts for every engine variant. When off, only the first engine variant is used.", "default": false }, "maxResults": { "title": "Max Results", "minimum": 0, "type": "integer", "description": "Maximum number of parts to return across all URLs and vehicle lookups. Set to 0 for unlimited. Tip: start with 10-50 to test, then increase.", "default": 100 } } }, "runsResponseSchema": { "type": "object", "properties": { "data": { "type": "object", "properties": { "id": { "type": "string" }, "actId": { "type": "string" }, "userId": { "type": "string" }, "startedAt": { "type": "string", "format": "date-time", "example": "2025-01-08T00:00:00.000Z" }, "finishedAt": { "type": "string", "format": "date-time", "example": "2025-01-08T00:00:00.000Z" }, "status": { "type": "string", "example": "READY" }, "meta": { "type": "object", "properties": { "origin": { "type": "string", "example": "API" }, "userAgent": { "type": "string" } } }, "stats": { "type": "object", "properties": { "inputBodyLen": { "type": "integer", "example": 2000 }, "rebootCount": { "type": "integer", "example": 0 }, "restartCount": { "type": "integer", "example": 0 }, "resurrectCount": { "type": "integer", "example": 0 }, "computeUnits": { "type": "integer", "example": 0 } } }, "options": { "type": "object", "properties": { "build": { "type": "string", "example": "latest" }, "timeoutSecs": { "type": "integer", "example": 300 }, "memoryMbytes": { "type": "integer", "example": 1024 }, "diskMbytes": { "type": "integer", "example": 2048 } } }, "buildId": { "type": "string" }, "defaultKeyValueStoreId": { "type": "string" }, "defaultDatasetId": { "type": "string" }, "defaultRequestQueueId": { "type": "string" }, "buildNumber": { "type": "string", "example": "1.0.0" }, "containerUrl": { "type": "string" }, "usage": { "type": "object", "properties": { "ACTOR_COMPUTE_UNITS": { "type": "integer", "example": 0 }, "DATASET_READS": { "type": "integer", "example": 0 }, "DATASET_WRITES": { "type": "integer", "example": 0 }, "KEY_VALUE_STORE_READS": { "type": "integer", "example": 0 }, "KEY_VALUE_STORE_WRITES": { "type": "integer", "example": 1 }, "KEY_VALUE_STORE_LISTS": { "type": "integer", "example": 0 }, "REQUEST_QUEUE_READS": { "type": "integer", "example": 0 }, "REQUEST_QUEUE_WRITES": { "type": "integer", "example": 0 }, "DATA_TRANSFER_INTERNAL_GBYTES": { "type": "integer", "example": 0 }, "DATA_TRANSFER_EXTERNAL_GBYTES": { "type": "integer", "example": 0 }, "PROXY_RESIDENTIAL_TRANSFER_GBYTES": { "type": "integer", "example": 0 }, "PROXY_SERPS": { "type": "integer", "example": 0 } } }, "usageTotalUsd": { "type": "number", "example": 0.00005 }, "usageUsd": { "type": "object", "properties": { "ACTOR_COMPUTE_UNITS": { "type": "integer", "example": 0 }, "DATASET_READS": { "type": "integer", "example": 0 }, "DATASET_WRITES": { "type": "integer", "example": 0 }, "KEY_VALUE_STORE_READS": { "type": "integer", "example": 0 }, "KEY_VALUE_STORE_WRITES": { "type": "number", "example": 0.00005 }, "KEY_VALUE_STORE_LISTS": { "type": "integer", "example": 0 }, "REQUEST_QUEUE_READS": { "type": "integer", "example": 0 }, "REQUEST_QUEUE_WRITES": { "type": "integer", "example": 0 }, "DATA_TRANSFER_INTERNAL_GBYTES": { "type": "integer", "example": 0 }, "DATA_TRANSFER_EXTERNAL_GBYTES": { "type": "integer", "example": 0 }, "PROXY_RESIDENTIAL_TRANSFER_GBYTES": { "type": "integer", "example": 0 }, "PROXY_SERPS": { "type": "integer", "example": 0 } } } } } } } } } } ```