RockAuto APIrockauto.com ↗
Browse the RockAuto catalog by make, year, model, and engine. List part categories, part types, and full part listings with brand, part number, and price.
What is the RockAuto API?
The RockAuto API exposes 3 endpoints that walk the full vehicle catalog tree and return structured parts data from rockauto.com. Starting with list_vehicle_options, you can resolve any vehicle down to a numeric carcode, then pass that carcode to list_part_types to enumerate categories and part types, and finally call list_parts to retrieve every offered part with brand, part number, quality tier, and price for that vehicle and part type combination.
curl -X GET 'https://api.parse.bot/scraper/d2105fd8-abee-4464-9261-56cea2eac2db/list_vehicle_options?make=Acura&year=2015&model=TLX' \ -H 'X-API-Key: $PARSE_API_KEY'
Walks one level of the vehicle catalog tree in a single page fetch. With no inputs it returns every make in the catalog; with make it returns the model years offered for that make; with make and year it returns the models; with make, year and model it returns the engine variants, each carrying the numeric carcode that identifies that exact vehicle and is the key for list_part_types and list_parts. The result grain is one catalog child node per item; level says which kind of node the items are (make, year, model or engine). Labels are matched case-insensitively by the site. A make, year or model the catalog does not know yields a stale_input (input_not_found) error; a valid selection with no children is an empty items list.
| Param | Type | Description |
|---|---|---|
| make | string | Vehicle make label as listed by the site (e.g. one shape: Acura). Omitted = list all makes. |
| year | string | 4-digit model year; requires make. Omitted = list years for the make. |
| model | string | Model label as returned at the model level; requires make and year. Omitted = list models for the make and year; supplied = list engine variants with their carcode. |
{
"type": "object",
"fields": {
"make": "echo of the make input, null when omitted",
"year": "echo of the year input, null when omitted",
"count": "number of items",
"items": "array of catalog nodes; each has label, and at the engine level also engine and carcode (numeric string vehicle key)",
"level": "which node kind the items are: make | year | model | engine",
"model": "echo of the model input, null when omitted"
},
"sample": {
"data": {
"make": "Acura",
"year": "2015",
"count": 2,
"items": [
{
"label": "2.4L L4",
"engine": "2.4L L4",
"carcode": "3309767"
},
{
"label": "3.5L V6",
"engine": "3.5L V6",
"carcode": "3309768"
}
],
"level": "engine",
"model": "TLX"
},
"status": "success"
}
}About the RockAuto API
Navigating the Vehicle Catalog
list_vehicle_options walks the RockAuto catalog tree one level at a time. Called with no parameters it returns all vehicle makes. Add a make to get available model years, add year to list models, and add model to list engine variants. Engine-level items carry a carcode — a numeric string that acts as the vehicle key for all subsequent calls — along with an engine label. The level field in every response tells you which node kind the items array contains: make, year, model, or engine.
Listing Part Categories and Types
list_part_types takes a carcode and optionally a category label. Without category it returns the top-level groupings (such as "Brake & Wheel Hub") at level: category. Pass one of those category labels back as the category parameter and the endpoint returns the individual part types inside it, each with a part_type label and a numeric part_type_id. The vehicle object in every response echoes make, year, model, engine, and carcode so responses are self-describing.
Retrieving Parts for a Vehicle and Part Type
list_parts accepts a carcode and part_type_id and returns every part the site lists for that combination — no pagination, the full set in one response. Each entry in parts includes manufacturer, part_number, part_key, nullable description and notes fields, a quality_group tier indicator, and price. The top-level currency field gives the ISO code the prices are denominated in. The part_type and category fields confirm what you queried.
The RockAuto API is a managed, monitored endpoint for rockauto.com — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when rockauto.com changes and a check fails, the API is automatically queued for repair and re-verified. It is built to keep working as the site underneath it changes.
This isn't an official rockauto.com API — it's an independent, maintained REST wrapper over public data. Where the source has no official API (or only a limited one), Parse gives you a stable contract over a source that never promised one, and keeps it current. Need a new endpoint or field? You can revise it yourself in plain English and the agent rebuilds it against the live site in minutes — contributing the change back to the shared API is free.
Will this API break when the source site changes?+
Is this an official API from the source site?+
Can I fix or extend this API myself if I need a new endpoint or field?+
What happens if I call an endpoint that has an issue?+
- Build a VIN-to-parts lookup tool using carcode resolution from list_vehicle_options
- Compare part prices across quality tiers (quality_group) for a specific vehicle and part type
- Populate a repair estimator with real part prices from list_parts for a given make/year/model/engine
- Audit part catalog coverage across multiple vehicle makes and model years
- Extract brand and part number data for cross-referencing with other supplier catalogs
- Monitor price changes on specific part types for a fleet of vehicles identified by carcode
- Generate a structured parts taxonomy from list_part_types category and part_type_id data
| Tier | Price | Credits/month | Rate limit |
|---|---|---|---|
| Free | $0/mo | 200 | 5 req/min |
| Hobby | $30/mo | 1,000 | 20 req/min |
| Developer | $100/mo | 5,000 | 100 req/min |
| Team | $300/mo | 20,000 | 300 req/min |
| Company | $1,000/mo | 100,000 | 500 req/min |
Each endpoint has a fixed posted price per successful call — most fall between 1 and 10 credits — shown on this API's page before you run it. Exceeding the rate limit returns a 429 response. Authenticate with the X-API-Key header.