RockAuto Parts Scraper: 10 Data Fields, Up to 2,500 Free Results/Month

Each scraped part record carries 10 output fields including manufacturer, part number, category, price, core charge, and Info-page URL. These fields populate directly from RockAuto's public US catalog without requiring any login or API key. The price per 1,000 results is $2.00 on Apify's free plan, which includes $5.00 of monthly usage without a credit card. This tool is built specifically for auto-parts retail developers and parts inventory managers who need bulk pricing data, and it is not for anyone who needs contact details for parts distributors as those records are not in the catalogue.

Try it before you read further. Apify's free plan includes $5.00 of usage every month with no credit card, enough for up to 2,500 results at $0.002 each before platform usage. Open RockAuto Parts Scraper on Apify and run the prefilled example.

How reliable is RockAuto Parts Scraper in production?

Across the last 30 days of public runs on the Apify platform, RockAuto Parts Scraper recorded 70 runs with the following outcomes.

Plan for this structural rate by implementing automatic retries and monitoring within your scheduler. Do not expect user-aborted runs to be solved by programmatic retries, as these reflect manual cancellations.

What does it cost to run RockAuto Parts Scraper?

Each result costs $0.002 on Apify's free plan, which is $2.00 per 1,000 results. Starting a run is charged separately at $0.005 per GB of Actor memory. Apify also bills the platform usage each run consumes, at the rates of your Apify plan, on top of these charges.

Worked example: collecting 10,000 results costs $20.00 in result charges before run-start fees and platform usage. With 11.4% of runs failing or timing out in the last 30 days, budget for re-running a portion of those batches rather than assuming every run completes.

The primary cost driver for a run is the total size of your queries array combined with your maxResults limit, as these controls determine how many items are written to your dataset. The cheapest way to evaluate whether the output fields meet your requirements is to use the prefilled keyword with maxResults capped at 50, limiting your initial result cost to $0.10.

How do you run RockAuto Parts Scraper from the API?

The schema marks 1 of its 13 controls as required: queries. The payload below uses the schema's own prefilled values, so it runs as written once you substitute your API token.

Call the synchronous endpoint to start a run and receive dataset items in one request:

curl -X POST "https://api.apify.com/v2/acts/crawlerbros~rockauto-parts-scraper/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"queries":["brake pads"],"maxResults":50,"enrichWithPartDetails":false,"startUrls":[]}'

The same run from Python, using the official client:

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

run_input = {
  "queries": [
    "brake pads"
  ],
  "maxResults": 50,
  "enrichWithPartDetails": False,
  "startUrls": []
}

run = client.actor("crawlerbros~rockauto-parts-scraper").call(run_input=run_input)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

And from Node.js:

import { ApifyClient } from 'apify-client'

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' })

const input = {
  "queries": [
    "brake pads"
  ],
  "maxResults": 50,
  "enrichWithPartDetails": false,
  "startUrls": []
}

const run = await client.actor('crawlerbros~rockauto-parts-scraper').call(input)
const { items } = await client.dataset(run.defaultDatasetId).listItems()
console.log(items)

The synchronous endpoint holds the connection open until the run finishes, which is convenient for small batches and wrong for large ones. For anything long running, start the run asynchronously and poll, or attach a webhook, so a dropped connection does not cost you the results.

Which RockAuto Parts Scraper inputs matter, and which can you skip?

The queries input is the only required field and accepts part numbers, brand names, or broad categories. Leaving customProxyUrls blank on your first run is recommended, as the automatic Apify residential proxy fallback handles standard CAPTCHA blocks.

• queries (array): One or more search terms. Each runs as a separate RockAuto search; results are merged and deduped by part number across queries. Use part numbers, brand names, or category keywords (e.g. BREMBO P28004, oil filter, brake pads).
• maxResults (integer): Hard cap on parts emitted across all queries (after dedup + filtering). Default: 50.
• enrichWithPartDetails (boolean): When true, fetch the part's RockAuto detail page (moreinfo URL) for each result and add a details block (extra specs, fitment notes, image URLs). Adds ~1 extra HTTP request per part - slower but richer. Default: false.
• startUrls (array): Paste full RockAuto partsearch URLs (e.g. https://www.rockauto.com/en/partsearch/?partnum=brake+pads). Each URL's partnum becomes a query. Default: [].
• manufacturerFilter (string): Optional: only emit records whose manufacturer matches this substring (case-insensitive). E.g. BOSCH.
• categoryFilter (string): Optional: only emit records whose category matches this substring (case-insensitive). E.g. Brake Pad, Oil Filter.
• maxPrice (number): Optional: drop records with price above this amount. Records without a parsed price are kept.
• minPrice (number): Optional: drop records with price below this amount. Records without a parsed price are kept.
• vehicleMake (string): Vehicle-mode: filter queries to a specific make (e.g. Toyota, Ford, Honda). Used to narrow keyword search to vehicle-specific parts.
• vehicleModel (string): Vehicle-mode: filter to a specific model (e.g. Camry, F-150, Civic).
• vehicleYear (integer): Vehicle-mode: model year (e.g. 2020).
• vehicleEngine (string): Vehicle-mode: engine spec (e.g. 2.5L L4, 5.7L V8 Hemi).

The other 1 controls, with their defaults, are listed in the input schema on RockAuto Parts Scraper on Apify.

What does RockAuto Parts Scraper return?

Returned records provide clean brand, price, and part number variables that are ideal for inventory matching and competitor pricing spreadsheets. They do not contain any live local warehouse inventory quantities, delivery times, or localized shipping fee schedules.

• manufacturer (e.g. BETTER BRAKE PARTS)
• partNumber (e.g. 5473K)
• category (e.g. Brake Pad Retaining Clip / Spring)
• priceUSD (e.g. 2.15)
• totalUSD (e.g. 2.15)
• packSize (e.g. 1)
• moreInfoUrl (e.g. https://www.rockauto.com/en/moreinfo.php?pk=1...)
• notes (e.g. For 2018-2020 Toyota Camry, Front, OEM 5473K)
• inputQuery (e.g. brake pads)
• scrapedAt (e.g. 2024-12-16T14:23:11+00:00)

These are the documented fields. Optional ones can be empty on a given record, so measure how often each field your deliverable depends on is populated across a real sample before automating the handoff.

How do you build the workflow end to end?

Open RockAuto Parts Scraper and work through these in order. Each step ends with something to check, so a bad configuration surfaces on a small run rather than a scheduled one.

1. Run once with queries set to a single target keyword like brake pads and maxResults set to 10 to inspect the returned records.
2. Verify that the fields priceUSD, totalUSD, and moreInfoUrl are populated correctly in your initial test dataset before scaling up your run.
3. If you require deeper specifications, set enrichWithPartDetails to true, execute a run, and check that the nested details block contains the specs dict.
4. Add a target string to manufacturerFilter such as BOSCH, run the Actor, and verify that all returned records have that exact manufacturer value.
5. Configure the vehicle-mode inputs vehicleMake, vehicleModel, and vehicleYear to narrow your results to fit specific models and check the inputQuery field in the returned dataset to see which query fallback variant succeeded.
6. Paste a direct RockAuto link containing a part number into startUrls and run the Actor to confirm it processes the URL and extracts the listing details correctly.

How do you apply it? Three worked playbooks

These are RockAuto Parts Scraper's own documented use cases, each worked through as an operating pattern rather than a description.

Use case 1: Price comparison

Outcome: Pull every brake-pad listing for a query and compare across brands.

Configure: queries: ["brake pads"], maxResults: 100

Working method: Execute the run with your general search query. Retrieve the dataset, group the items by manufacturer, and compare priceUSD and coreChargeUSD values side by side in your analysis environment.

Deliverable: A spreadsheet showing part prices, brands, and direct product URLs side-by-side for comparison.

Stop condition: The dataset contains only the rockauto_scraper_error record.

Use case 2: Brand sourcing

Outcome: Find every part by a specific manufacturer (e.g. BREMBO, MOTORCRAFT).

Configure: queries: ["oil filter"], manufacturerFilter: "MOTORCRAFT", maxResults: 100

Working method: Set the search query to a general part type and restrict the results using manufacturerFilter. Once complete, inspect the manufacturer field across all output records to verify zero false positives.

Deliverable: A structured list of manufacturer-specific part numbers, categories, and prices.

Stop condition: Any returned item features a manufacturer that does not match the filtered keyword.

Use case 3: Inventory enrichment

Outcome: Feed your retail / repair-shop tool with RockAuto's catalogue (price, brand, category) for cross-reference.

Configure: queries: ["spark plug"], enrichWithPartDetails: true, maxResults: 50

Working method: Run the query with detail enrichment enabled. Ensure each record has the details block parsed with images and technical specs, then map these fields to your catalog database schema.

Deliverable: A JSON export containing parts listings enriched with fitment notes, images, and spec sheets.

Stop condition: The details field is completely absent from records when enrichWithPartDetails is set to true.

What breaks, and how do you design around it?

• Over the last 30 days, 10.0% of public runs failed and 1.4% timed out. Build retries and alerting around those rates rather than assuming every run completes.

To bypass the 50-item display limit per search query on the source website, you must split high-volume requests into multiple smaller queries like spark plug Bosch and spark plug Denso. If your target single-token keywords consistently trigger CAPTCHAs, use vehicle-mode inputs to make your queries more specific.

When should you not use RockAuto Parts Scraper?

Do not use this Actor if you need to fetch vehicle auctions, scrap yards, or used salvage data. Instead, use the Row52 Junkyard & Salvage Yard Parts Scraper for physical yard tracking, or use the eBay Motors Vehicle & Parts Scraper to find consumer listings for vehicles and used components. If you are scraping heavy industrial machinery, the EquipmentTrader Scraper is the correct tool. If your project requires accessing international regional catalogs with non-USD pricing, this USD-only US catalogue scraper will not work.

What should you check before trusting the output?

• Check that priceUSD is a valid positive number for listings where pricing is visible, as missing price data on non-discontinued items suggests a layout change.
• Ensure that each emitted record contains a valid, non-null manufacturer and partNumber combination.
• Verify that moreInfoUrl begins with the correct RockAuto domain protocol and path.
• Check that totalUSD equals priceUSD plus coreChargeUSD when a core charge is present.
• Set up an execution alert if a run returns zero records and only emits the diagnostic error record with type rockauto_scraper_error.

None of this proves a record is correct. It gives a scheduled RockAuto Parts Scraper run defined points where it should stop instead of quietly passing bad data downstream.

Frequently asked questions

What happens if a query returns no matches on the site?

When zero parts match your query, the Actor emits a single diagnostic sentinel record containing the structure {type: "rockauto_scraper_error", reason: "no_results"} to ensure your output dataset is successfully created, and the run finishes with a successful status code.

How are blocked or CAPTCHA-challenged requests handled?

The Actor falls back to Apify residential proxy automatically when RockAuto shows a CAPTCHA. You can also specify premium proxy details inside the optional customProxyUrls field to override the fallback pool entirely.

How does vehicle-mode work to query specific models?

When you specify vehicleMake, vehicleModel, vehicleYear, or vehicleEngine, the Actor appends these parameters to each query and attempts the most specific combination. If the site challenges the request, the Actor automatically falls back to progressively shorter query strings.

Why are some prices missing from the database results?

RockAuto omits prices on its website for certain out-of-stock, special-order, or discontinued parts.

What does this Actor cost to run on the free tier?

The Actor costs $0.002 per result written to the dataset, which translates to $2.00 per 1,000 results. Each run also carries a separate run-start charge of $0.005 per GB of Actor memory, which applies whether results are written or not, and Apify bills platform usage on top.

Where to go next

When you are ready to run it, open RockAuto Parts Scraper on Apify; the free plan covers up to 2,500 results a month.

Start with the RockAuto Parts Scraper Actor page for the current input schema, pricing tier, and run history.

If you are comparing approaches rather than committing to one Actor, these category pages list every option we publish:

• Product and price scrapers covers 344 Actors in this family.

Other Actors we maintain for related data:

• eBay Motors Vehicle & Parts Scraper: Scrape eBay Motors listings for cars, trucks, motorcycles, boats, RVs, ATVs, and parts.
• Row52 Junkyard & Salvage Yard Parts Scraper: Find which self-service junkyard (Pick-n-Pull) has a matching donor vehicle in stock.
• CORE Open Research Scraper: Search millions of open-access research papers from CORE - the world's largest aggregator of open access research.
• Arbeitnow Job Listings Scraper: Scrape job listings from Arbeitnow - a global job board with remote, part-time, and full-time opportunities.
• EquipmentTrader Scraper: Scrape heavy equipment listings from EquipmentTrader.com - search by category, make, keyword, state, price and condition, or fetch full listing detail by URL.
• ASOS Scraper: Scrape ASOS (Europe's largest online fashion marketplace) with search by keyword, browse by category, fetch by product ID or URL, or check live stock and pricing.
• Barnstormers Aircraft Classifieds Scraper: Scrape aircraft and aircraft-parts classified listings from barnstormers.com - search by keyword/make/model, browse by real site category, view recent listings, or pull all ads from one seller.
• Wholesale Marine Scraper: Scrape Wholesale Marine (wholesalemarine.com) - boat parts, propellers, covers, electronics, trailer parts, and outdoor gear.

Resources

• Actor documentation, input schema, and pricing: verified against the published Actor on 2026-09-24.

• Actor last updated by its maintainers on 2026-04-30.

• Run outcome figures cover the 30 day public window ending 2026-09-24.

• RockAuto Parts Scraper on Apify