# CarParts.com Scraper — Price & Stock Monitor (`crawloop/carparts-com-scraper`) Actor

Watch CarParts.com aftermarket prices and catalog status. Save SKU, brand, part number, price, core, and shipping, then alert on new parts and price or status changes.

- **URL**: https://apify.com/crawloop/carparts-com-scraper.md
- **Developed by:** [Andrej Kiva](https://apify.com/crawloop) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $11.99 / 1,000 parts

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?

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

## CarParts.com Scraper — Price & Stock Monitor

> **Disclaimer:** Unofficial tool — not affiliated with, sponsored by, or endorsed by CarParts.com, Inc. or its affiliates. Data is read from the public product search only. No login. You are responsible for complying with applicable law and the site’s terms. No warranty on accuracy or availability. Provided for informational and research use.

Watch **aftermarket auto parts** prices and catalog status. Each row is one part: SKU, brand, manufacturer part number, price, core charge, shipping, fit label, and OE number when the search publishes it. Turn on monitor mode and an Apify Schedule to save only new parts, price drops, price rises, and catalog-status changes.

**Best for:** parts-counter price checks, brand and SKU watches, and a scheduled alert when a price or catalog status moves.

> **Auto parts suite** — US aftermarket price here, then a EUR catalog price, a used yard price, and the donor car.

| Actor | What it returns |
| :--- | :--- |
| [Row52 Scraper](https://apify.com/crawloop/row52-scraper) | Junkyard donor cars: VIN, yard, row |
| [Pick-n-Pull Scraper](https://apify.com/crawloop/picknpull-scraper) | Self-service yard inventory: VIN, row |
| [PartsHotlines Scraper](https://apify.com/crawloop/partshotlines-scraper) | Used part price, grade, and yard |
| CarParts.com Scraper ◄── you are here | US aftermarket price and catalog status |
| [Oscaro Scraper](https://apify.com/crawloop/oscaro-scraper) | French catalog price in EUR |
| [Car-Part Scraper](https://apify.com/crawloop/car-part-scraper) | Used recycler price, grade, and distance |

### When to use this Actor

- **Price a repair** — Search brake pads, an alternator, or a part number and export the cheapest matches with brand, price, core, and shipping.
- **Fit a vehicle** — Add year, make, and model so the search is limited to that vehicle.
- **Watch a SKU window** — Schedule the same search. The first run stores a baseline. Later runs return only parts that are new or whose price or catalog status changed.
- **Compare with used stock and EUR prices** — After this run, check a Hotlines yard price with [PartsHotlines Scraper](https://apify.com/crawloop/partshotlines-scraper) and recycler asking prices with [Car-Part Scraper](https://apify.com/crawloop/car-part-scraper). For a French EUR price, run [Oscaro Scraper](https://apify.com/crawloop/oscaro-scraper). To find the donor car, run [Row52 Scraper](https://apify.com/crawloop/row52-scraper) or [Pick-n-Pull Scraper](https://apify.com/crawloop/picknpull-scraper).

This Actor reads the public product search. It does not log in, place orders, or read account pages.

### Data pipeline

```
Input                         Flow                         Output
─────────────────────        ─────────────────────        ──────────────────────────
keyword or search URL    ──► public product search   ──► SKU, price, core, shipping
year / make / model      ──► vehicle filters         ──► brand, part number, OE
monitorMode + Schedule   ──► named key-value store   ──► new, price, or status change
```

### Key features

- **Cheapest first** — Each search is sorted by price, low to high, so a scheduled watch stays on the same window.
- **Vehicle filters** — Optional year, make, model, brand, and part type apply to every search in the run.
- **Price and status** — Selling price, regular price, special price, core charge, shipping, pricing status, and SKU status.
- **OE and interchange** — OE number and interchange numbers when the search result publishes them.
- **Monitor** — Baseline on the first run. Later runs charge only new parts, price drops, price rises, and catalog-status changes.
- **No proxy by default** — The public search answers over HTTP. Leave the proxy off unless a run is blocked.

### Input parameters

| Parameter | Type | Default | Description |
| :--- | :--- | :--- | :--- |
| `searchQueries` | Array | `["brake pads"]` | Part name, keyword, or part number. Each entry is its own search. |
| `startUrls` | Array | — | Search URL. The `q` value is the keyword. A category path is used as the keyword. |
| `year` | String | — | Model year, for example `2020`. |
| `make` | String | — | Make, for example `Toyota`. |
| `model` | String | — | Model, for example `Camry`. |
| `brand` | String | — | Brand facet label, for example `Bosch`. |
| `part` | String | — | Part facet label, for example `Brake Pad Set`. |
| `maxItems` | Integer | `50` | Maximum parts to save. In monitor mode this caps alerts. |
| `maxPages` | Integer | `3` | Pages per search. One page is 20 parts. A monitor scans every page. |
| `includeFitment` | Boolean | `false` | Add a fitment count and up to 25 vehicle keys. |
| `monitorMode` | Boolean | `false` | Save only changes after the baseline run. |
| `monitorStoreName` | String | `carparts-com-monitor` | Named store for one watch. |
| `resetMonitorState` | Boolean | `false` | Clear the baseline before this run. |
| `proxyConfiguration` | Object | off | Leave off unless a run is blocked. |

#### Input example — vehicle search

```json
{
  "searchQueries": ["brake pads"],
  "year": "2020",
  "make": "Toyota",
  "model": "Camry",
  "maxItems": 50,
  "maxPages": 3
}
```

#### Input example — scheduled price watch

```json
{
  "searchQueries": ["brake pads"],
  "year": "2020",
  "make": "Toyota",
  "model": "Camry",
  "monitorMode": true,
  "monitorStoreName": "camry-brake-pads",
  "maxItems": 50,
  "maxPages": 3
}
```

Use one `monitorStoreName` per watch. The first run returns the current window and stores every scanned SKU. Later runs return rows with `monitorChange` set to `new`, `price_drop`, `price_rise`, or `status_change`, plus `previousPrice` when the price moved. A run with no changes saves nothing new.

`skuStatus` is the catalog status code (for example `OBS` when the index publishes it). A change in that code or in `pricingStatusId` is a `status_change`. This is the catalog status from search, not a live warehouse quantity.

### Output fields

| Field | Description |
| :--- | :--- |
| `sku` | Catalog SKU. Monitor key. |
| `title` | Part title. |
| `brand` | Brand. |
| `partNumber` | Manufacturer part number. |
| `part` | Part type facet. |
| `location` | Position, such as Front. |
| `price` | Selling price in USD. |
| `regularPrice` | Regular price. |
| `specialPrice` | Special price when one is published. |
| `corePrice` | Core charge when one is published. |
| `shippingPrice` | Shipping amount published with the part. |
| `pricingStatusId` | Catalog pricing status code. |
| `skuStatus` | Catalog SKU status. |
| `productFit` | Fit label. |
| `quantitySold` | How the part is sold. |
| `warranty` | Warranty text when published. |
| `replacesOeNumber` | OE number when published. |
| `interchangePartNumber` | Interchange numbers when published. |
| `url` | Product page URL. |
| `imageUrl` | Image URL. |
| `searchQuery` | Search that returned the part. |
| `year`, `make`, `model` | Vehicle filters for this search, when set. |
| `monitorChange` | `new`, `price_drop`, `price_rise`, or `status_change`. |
| `previousPrice` | Price from the previous monitor run. |
| `scrapedAt` | UTC time of the run. |

#### Output example

```json
{
  "sku": "JSTPSSCP1650",
  "productId": "17128064",
  "title": "Front Brake Pad Set, Ceramic",
  "brand": "JC Whitney",
  "partNumber": "JSTPSSCP1650",
  "part": "Brake Pad Set",
  "location": "Front",
  "price": 23.49,
  "regularPrice": 23.49,
  "specialPrice": null,
  "corePrice": null,
  "shippingPrice": 9.3,
  "currency": "USD",
  "pricingStatusId": 1,
  "skuStatus": "OBS",
  "productFit": "Direct Fit",
  "quantitySold": "2-Wheel Set",
  "warranty": "3-year or 36,000-mile limited warranty",
  "replacesOeNumber": "D10603TA0A",
  "interchangePartNumber": "TXC1650, 500165",
  "url": "https://www.carparts.com/Brake%20Pad%20Set/JC%20Whitney/JSTPSSCP1650",
  "searchQuery": "brake pads",
  "year": "2020",
  "make": "Toyota",
  "model": "Camry",
  "scrapedAt": "2026-10-23T14:00:00+00:00"
}
```

### Use cases

- A shop checks the current aftermarket price for a Camry brake-pad set before quoting a job.
- A reseller schedules a part-number watch and reads only the rows whose price dropped.
- A catalog team exports brand, SKU, OE number, and core charge for one part type.
- A buyer compares the new-part price from this Actor with used recycler prices from the Car-Part Scraper.

### Integration examples

#### Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('crawloop/carparts-com-scraper').call({
  searchQueries: ['brake pads'],
  year: '2020',
  make: 'Toyota',
  model: 'Camry',
  monitorMode: true,
  monitorStoreName: 'camry-brake-pads',
  maxItems: 50,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("crawloop/carparts-com-scraper").call(run_input={
    "searchQueries": ["brake pads"],
    "year": "2020",
    "make": "Toyota",
    "model": "Camry",
    "monitorMode": True,
    "monitorStoreName": "camry-brake-pads",
    "maxItems": 50,
})
items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items)
```

#### cURL

```bash
curl "https://api.apify.com/v2/acts/crawloop~carparts-com-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"searchQueries":["brake pads"],"year":"2020","make":"Toyota","model":"Camry","maxItems":20}'
```

### MCP and AI assistants

Use this Actor from AI tools via [Apify MCP](https://docs.apify.com/platform/integrations/mcp).
Connect your Apify account, then call this Actor by its Store name.

Example prompts:

- "Run CarParts.com Scraper for 2020 Toyota Camry brake pads and return the 20 cheapest rows as JSON."
- "Watch brake pads for a 2020 Camry with monitor mode and summarize any price drops."
- "After CarParts.com Scraper prices 2020 Camry brake pads, run Oscaro Scraper for the EUR price and PartsHotlines Scraper for the used yard price."

### Suite next step

Take the part name, year, and make from this dataset and compare a used yard price with [PartsHotlines Scraper](https://apify.com/crawloop/partshotlines-scraper) or [Car-Part Scraper](https://apify.com/crawloop/car-part-scraper). For the same kind of part on the French catalog, run [Oscaro Scraper](https://apify.com/crawloop/oscaro-scraper). To find the donor car, run [Row52 Scraper](https://apify.com/crawloop/row52-scraper) or [Pick-n-Pull Scraper](https://apify.com/crawloop/picknpull-scraper).

### FAQ

**Does the first monitor run return parts?**\
Yes. The first run with an empty monitor store returns parts up to `maxItems` and stores every scanned SKU. The next run returns only changes.

**What does a zero-row monitor run mean?**\
The search still ran. No scanned part was new, and none of the stored prices or catalog statuses changed.

**Is SKU status a live stock count?**\
No. `skuStatus` and `pricingStatusId` are the codes published in the product search. A change in those codes is reported as `status_change`.

**Can I paste a search URL?**\
Yes. `startUrls` reads the `q` parameter. A category path is used as the keyword. Year, make, model, brand, and part from the input still apply.

# Actor input Schema

## `searchQueries` (type: `array`):

Part name, keyword, or part number. Each entry is its own search. Results are the cheapest matches first.

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

A CarParts.com search URL. The q= value is used as the part search. A category path is used as the keyword.

## `year` (type: `string`):

Optional model year, for example 2020. Applied to every search in this run.

## `make` (type: `string`):

Optional make, for example Toyota. Applied to every search in this run.

## `model` (type: `string`):

Optional model, for example Camry. Applied to every search in this run.

## `brand` (type: `string`):

Optional brand facet, for example Bosch. Use the catalog label.

## `part` (type: `string`):

Optional part facet, for example Brake Pad Set. Use the catalog label.

## `maxItems` (type: `integer`):

Maximum parts to save. In monitor mode this caps alerts, not how many parts are scanned.

## `maxPages` (type: `integer`):

Pages to read for each search. One page is 20 parts, cheapest first. A monitor scans every page, then saves only changes.

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

Add a fitment count and up to 25 vehicle keys (year, make, model, trim). Off by default so monitor rows stay small.

## `monitorMode` (type: `boolean`):

The first run saves a baseline and returns parts up to Max saved parts. Later runs with the same monitor store save and charge only new parts, price changes, and catalog-status changes. Pair with an Apify Schedule.

## `monitorStoreName` (type: `string`):

Named key-value store for prices already seen. Use one name per watch so schedules do not overwrite each other.

## `resetMonitorState` (type: `boolean`):

Clear the saved baseline before this run. The run then saves a new baseline.

## `proxyConfiguration` (type: `object`):

Off by default. The public product search does not need a proxy. Turn a proxy on only if a run is blocked.

## Actor input object example

```json
{
  "searchQueries": [
    "brake pads"
  ],
  "maxItems": 50,
  "maxPages": 3,
  "includeFitment": false,
  "monitorMode": false,
  "monitorStoreName": "carparts-com-monitor",
  "resetMonitorState": false,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `results` (type: `string`):

Default dataset items.

# 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 = {
    "searchQueries": [
        "brake pads"
    ],
    "maxItems": 50,
    "maxPages": 3
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawloop/carparts-com-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 '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "searchQueries": ["brake pads"],
    "maxItems": 50,
    "maxPages": 3,
}

# Run the Actor and wait for it to finish
run = client.actor("crawloop/carparts-com-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 '{
  "searchQueries": [
    "brake pads"
  ],
  "maxItems": 50,
  "maxPages": 3
}' |
apify call crawloop/carparts-com-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,crawloop/carparts-com-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 <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/5RULvq0c8VXC57RK0/builds/3GCi9mnb9phlGSXl3/openapi.json