# RockAuto Catalog Price & Fitment Lookup (`dataspryva/rockauto-catalog-price-and-fitment-lookup`) Actor

Search the RockAuto auto-parts catalog by keyword, part number, or vehicle fitment, returning manufacturer, part number, category, price, core charge and fitment notes for each listing.

- **URL**: https://apify.com/dataspryva/rockauto-catalog-price-and-fitment-lookup.md
- **Developed by:** [Dataspryva](https://apify.com/dataspryva) (community)
- **Categories:** E-commerce, Automation, Developer tools
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.49 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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?

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

## RockAuto Catalog Price & Fitment Lookup

RockAuto lists thousands of aftermarket parts from competing brands, but the catalog is built around a year → make → model → engine → part-type walk and a 50-result keyword box. This actor reads those public pages without a RockAuto account and returns one clean row per part: brand, part number, description, price, core charge, quality grade, availability, fitment notes and links.

### Lookup modes

| Mode | What it does | Best for |
| --- | --- | --- |
| `search` | Runs one or more keyword or part-number searches on RockAuto's part search. | Quick price checks, brand sweeps, known part numbers. |
| `catalog` | Resolves a vehicle (year, make, model, engine) plus a part term to the exact catalog page and reads every listing on it. | Full fitment-aware price lists — catalog pages are not limited to 50 rows. |
| `partNumber` | Looks up a part number's interchange equivalents and returns every brand RockAuto lists with live prices. | Cross-referencing an OEM or aftermarket number. |
| `urls` | Scrapes pasted part-search, catalog, category, engine or more-info URLs. Category and engine URLs are expanded into their part-type pages. | Reproducible runs from links you already have. |

### What you get per part

| Field | Description |
| --- | --- |
| `manufacturer` | Brand shown on the listing (e.g. BOSCH, DURAGO, MOTORCRAFT). |
| `partNumber` | Manufacturer part number. |
| `description` | Short listing description (e.g. `Semi-Metallic`, `Ceramic`). |
| `category` | RockAuto category or part type (e.g. `Brake Pad`, `Oil Filter`). |
| `partGroup` | Catalog group the part belongs to (e.g. `Brake & Wheel Hub`). |
| `partType` | Catalog part-type label (e.g. `Alternator / Generator`). |
| `priceUSD` | Current listing price in US dollars. |
| `coreChargeUSD` | Refundable core charge, when the listing shows one. |
| `totalUSD` | Price plus core charge. |
| `packSize` | Units in the listing (`4` for a four-pack); `1` when RockAuto doesn't state a pack. |
| `grade` | RockAuto quality group: Economy, Daily Driver, Premium, Heavy Duty and similar. |
| `availability` | `In Stock` or `Out of Stock` when RockAuto states it. |
| `fitmentNotes` | The position / trim / option note printed under the part. |
| `notes` | Same fitment note, kept for compatibility with existing integrations. |
| `markets` | Markets the part fits (`US`, `CA`, `MX`). |
| `imageUrl` | Product image shown on the listing. |
| `priceOptions` | Quantity-break prices when RockAuto shows them. |
| `moreInfoUrl` | Link to the part's RockAuto detail page. |
| `vehicle` | For catalog runs: `make`, `year`, `model`, `engine`, `carCode`. |
| `details` | With `enrichWithPartDetails`: `specs`, `features`, `images`, `warranty`, `oemNumbers`, `alternateNumbers`. |
| `fitment` | With `includeFitment`: list of `make`, `model`, `yearRange`, `yearStart`, `yearEnd`. |
| `sourceUrl` | The page the row was read from. |
| `inputQuery` | The query, part number or URL that produced the row. |
| `scrapedAt` | ISO-8601 capture timestamp. |

Fields RockAuto doesn't show for a listing are omitted, never emitted as `null` or an empty string.

### Input

| Field | Type | Default | Description |
| --- | --- | --- | --- |
| `mode` | Select | – | `search`, `catalog`, `partNumber` or `urls`; inferred from the other fields when omitted. |
| `queries` | String list | – | Search terms or the part term to open in catalog mode. |
| `partNumbers` | String list | – | Part numbers for `partNumber` mode. |
| `vehicleMake` | String | – | Catalog mode make. |
| `vehicleModel` | String | – | Catalog mode model. |
| `vehicleYear` | Integer | – | Catalog mode year. |
| `vehicleEngine` | String | – | Catalog mode engine; the first match is used when omitted. |
| `manufacturerFilter` | String | – | Keep only matching brands (also applied at RockAuto in search mode). |
| `categoryFilter` | String | – | Keep only matching category, part type, part group or description. |
| `gradeFilter` | Select | Any | Keep only one quality grade. |
| `minPrice` / `maxPrice` | Number | – | Price window in USD. Records without a price are kept. |
| `inStockOnly` | Boolean | `false` | Drop listings RockAuto marks out of stock. |
| `maxResults` | Integer | 50 | Hard cap after deduplication and filtering (1–500). |
| `enrichWithPartDetails` | Boolean | `false` | Add specs, warranty, OEM numbers, features and images from the detail page. |
| `includeFitment` | Boolean | `false` | Add the buyer's-guide fitment table for each emitted part. |
| `startUrls` | String list | – | RockAuto part-search, catalog, category, engine or more-info URLs. |
| `customProxyUrls` | String list | – | Optional premium proxy URLs tried before the built-in fallback. |

### Examples

#### Compare brake-pad brands under $80

```json
{
  "mode": "search",
  "queries": ["brake pads"],
  "manufacturerFilter": "BOSCH",
  "maxPrice": 80,
  "maxResults": 100
}
```

#### Every brake pad listed for a 2020 Toyota Camry 2.5L

```json
{
  "mode": "catalog",
  "vehicleMake": "Toyota",
  "vehicleModel": "Camry",
  "vehicleYear": 2020,
  "vehicleEngine": "2.5L L4",
  "queries": ["brake pad"],
  "maxResults": 200
}
```

#### Interchange lookup with fitment

```json
{
  "mode": "partNumber",
  "partNumbers": ["PH2808"],
  "includeFitment": true
}
```

#### Expand a category URL

```json
{
  "mode": "urls",
  "startUrls": [
    "https://www.rockauto.com/en/catalog/toyota,2020,camry,2.5l+l4,3445372,brake+%26+wheel+hub"
  ],
  "maxResults": 100
}
```

### How it runs

- No RockAuto login, cookies or API key.
- Direct HTTP first; when RockAuto serves its security-code page, the request is retried through Apify residential proxy with a fresh session. The actor chooses this automatically.
- Search results are deduplicated by manufacturer + part number across all inputs.
- Keyword search returns RockAuto's own 50-row page. Use `catalog` mode (or split by manufacturer/part type) when you need every listing for a vehicle.
- `enrichWithPartDetails` and `includeFitment` each add one request per emitted part; leave them off for the cheapest daily runs.

### FAQ

**Does this need a RockAuto account?**
No. It reads the same public catalog and part pages shown to any visitor.

**Why does a keyword search stop at 50 rows?**
That is RockAuto's limit for its part-search page. Catalog pages are not capped the same way, so `catalog` mode is the right choice for a complete vehicle part list.

**Why is `priceUSD` sometimes missing?**
A few discontinued or special-order listings show no price; the field is omitted instead of being reported as zero.

**Are prices USD?**
Yes — the actor reads RockAuto's US catalog, which prices in US dollars.

**What happens if nothing matches?**
The run completes and writes one diagnostic record describing what was attempted, so an empty dataset never happens silently.

**Is this affiliated with RockAuto?**
No. This is an independent tool and is not affiliated with, endorsed by, or sponsored by RockAuto.

# Actor input Schema

## `mode` (type: `string`):

How to look up parts. `search` runs a keyword or part-number search; `catalog` walks a vehicle (year/make/model/engine) to a part type; `partNumber` finds interchange equivalents; `urls` scrapes pasted RockAuto URLs. When omitted, the actor infers the mode from the fields you filled in.

## `queries` (type: `array`):

One or more search terms. In `search` mode use part numbers, brands, or categories (e.g. `BREMBO P28004`, `oil filter`, `brake pads`). In `catalog` mode use the part type to open for the chosen vehicle (e.g. `brake pad`, `alternator`, `cabin air filter`).

## `partNumbers` (type: `array`):

Part numbers for `partNumber` mode (e.g. `PH2808`, `51334`). RockAuto returns matching parts from every brand, with live prices and a fitment buyer's guide.

## `vehicleMake` (type: `string`):

Catalog mode: vehicle make, e.g. `Toyota`, `Ford`, `Honda`.

## `vehicleModel` (type: `string`):

Catalog mode: vehicle model, e.g. `Camry`, `F-150`, `Civic`.

## `vehicleYear` (type: `integer`):

Catalog mode: model year, e.g. `2020`.

## `vehicleEngine` (type: `string`):

Catalog mode: engine, e.g. `2.5L L4`, `5.7L V8 Hemi`. Optional — the first matching engine is used when omitted.

## `manufacturerFilter` (type: `string`):

Only keep records whose manufacturer matches this text (case-insensitive). In `search` mode it is also sent to RockAuto so the 50-result page is filtered at the source.

## `categoryFilter` (type: `string`):

Only keep records whose category, part type, part group or description matches this text (case-insensitive), e.g. `Brake Pad`, `Oil Filter`.

## `gradeFilter` (type: `string`):

Only keep records in this RockAuto quality group. Applies to catalog and URL modes, which carry RockAuto's grade labels. Leave empty for all grades.

## `minPrice` (type: `number`):

Drop records priced below this amount. Records without a parsed price are kept.

## `maxPrice` (type: `number`):

Drop records priced above this amount. Records without a parsed price are kept.

## `inStockOnly` (type: `boolean`):

Drop records RockAuto explicitly marks out of stock.

## `maxResults` (type: `integer`):

Hard cap on parts emitted across all inputs, after deduplication and filtering.

## `enrichWithPartDetails` (type: `boolean`):

Also fetch each part's more-info page for specifications, warranty, OEM / interchange numbers, features and product images. Adds one request per emitted part.

## `includeFitment` (type: `boolean`):

Also fetch each part's buyer's-guide fitment table (make, model, year range). Adds one request per emitted part.

## `startUrls` (type: `array`):

Paste RockAuto part-search, catalog or more-info URLs. A part-type URL returns that page; a category or engine URL is expanded into its part-type pages until `maxResults` is reached; a more-info URL returns that part's detail record.

## `customProxyUrls` (type: `array`):

Optional premium proxy URLs in `http://user:pass@host:port` form to try before Apify's residential pool. Not needed for normal use.

## Actor input object example

```json
{
  "mode": "search",
  "queries": [
    "brake pads"
  ],
  "gradeFilter": "",
  "inStockOnly": false,
  "maxResults": 3,
  "enrichWithPartDetails": false,
  "includeFitment": false
}
```

# Actor output Schema

## `parts` (type: `string`):

Dataset containing all scraped RockAuto part listings.

# 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 = {
    "mode": "search",
    "queries": [
        "brake pads"
    ],
    "inStockOnly": false,
    "maxResults": 3,
    "enrichWithPartDetails": false,
    "includeFitment": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("dataspryva/rockauto-catalog-price-and-fitment-lookup").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 = {
    "mode": "search",
    "queries": ["brake pads"],
    "inStockOnly": False,
    "maxResults": 3,
    "enrichWithPartDetails": False,
    "includeFitment": False,
}

# Run the Actor and wait for it to finish
run = client.actor("dataspryva/rockauto-catalog-price-and-fitment-lookup").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 '{
  "mode": "search",
  "queries": [
    "brake pads"
  ],
  "inStockOnly": false,
  "maxResults": 3,
  "enrichWithPartDetails": false,
  "includeFitment": false
}' |
apify call dataspryva/rockauto-catalog-price-and-fitment-lookup --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,dataspryva/rockauto-catalog-price-and-fitment-lookup"
        }
    }
}
```

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/eAUyz0HuYdTaYIVFq/builds/2nIFLyG2W6wiB9ffW/openapi.json
