# Cars.com Scraper - Vehicle Listings, Prices & Dealers (`cryptosignals/cars-com-scraper`) Actor

Scrape Cars.com vehicle listings with price, mileage, dealer info, and vehicle details (VIN, colors, engine, MPG). Filter by make/model, year, price, mileage, and listing type. Pay Per Event pricing.

- **URL**: https://apify.com/cryptosignals/cars-com-scraper.md
- **Developed by:** [Web Data Labs](https://apify.com/cryptosignals) (community)
- **Categories:** E-commerce
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-usage

## 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

## Cars.com Scraper — Vehicle Listings, Prices & Dealers

Get structured vehicle listing data from Cars.com — make, model, year, price, mileage, VIN, dealer name, location, rating, and phone — without writing a single line of scraping code. Filter by keyword, location, price range, year range, mileage, and listing type (new, used, certified).

### Who is this for?

- **Auto dealers and marketplaces** monitoring competitor inventory and pricing
- **Market researchers** tracking used-car price trends across regions
- **Lead-gen and affiliate businesses** building local-dealer databases
- **Data scientists** training pricing or recommendation models
- **Resellers and arbitrageurs** spotting underpriced listings

### Pricing — Pay Per Event (PPE)

This actor charges **$0.01 per listing scraped**. You only pay for results that land in your dataset — failed pages cost nothing. No platform-rental fees, no hourly billing.

> Apify Free plan users are capped at **5 listings per run**. Upgrade to a paid Apify plan for full access (up to 1,000 listings per run).

### Input

| Field | Type | Required | Description |
|---|---|---|---|
| `query` | string | Yes | Keyword search — e.g. `Toyota Camry`, `Tesla Model 3`, `truck` |
| `location` | string | Yes | City + state (`Chicago, IL`) or 5-digit ZIP (`60601`) |
| `maxResults` | number | No | Max listings to scrape, 1–1000. Default `50` |
| `minPrice` | number | No | Minimum list price ($) |
| `maxPrice` | number | No | Maximum list price ($) |
| `minYear` | number | No | Minimum model year |
| `maxYear` | number | No | Maximum model year |
| `maxMileage` | number | No | Maximum odometer reading (miles) |
| `listingType` | string | No | `all` (default), `new`, `used`, or `certified` |

### Output

Each item in the dataset has the following structure:

| Field | Type | Description |
|---|---|---|
| `listingId` | string | Cars.com internal listing identifier |
| `url` | string | Direct link to the vehicle detail page |
| `title` | string | Year + Make + Model + Trim |
| `make` | string | Vehicle make (e.g. `Toyota`) |
| `model` | string | Vehicle model (e.g. `Camry`) |
| `year` | number | Model year |
| `trim` | string | Trim level (e.g. `LE`, `XSE V6`) |
| `mileage` | number | Odometer reading in miles (null for new) |
| `price` | number | Listed price in USD |
| `priceText` | string | Formatted price (e.g. `$28,495`) |
| `dealerName` | string | Selling dealership name |
| `dealerCity` | string | Dealer city |
| `dealerState` | string | Dealer state (2-letter) |
| `dealerZip` | string | Dealer ZIP code |
| `dealerRating` | number | Dealer rating (0–5), nullable |
| `ratingCount` | number | Number of dealer reviews, nullable |
| `dealerPhone` | string | Dealer phone, when available |
| `exteriorColor` | string | Exterior color |
| `interiorColor` | string | Interior color |
| `transmission` | string | Transmission type |
| `drivetrain` | string | Drivetrain (FWD/AWD/4WD/RWD) |
| `engineDescription` | string | Engine description |
| `fuelType` | string | Fuel type (Gasoline / Hybrid / Electric / Diesel) |
| `mpgCity` | number | EPA city MPG, nullable |
| `mpgHighway` | number | EPA highway MPG, nullable |
| `vin` | string | Vehicle Identification Number |
| `stockNumber` | string | Dealer stock number |
| `listingType` | string | `new`, `used`, or `certified` |
| `imageUrl` | string | Primary listing image URL |
| `scrapedAt` | string | ISO timestamp |

### Example output

```json
{
  "listingId": "812345678",
  "url": "https://www.cars.com/vehicledetail/812345678/",
  "title": "2022 Toyota Camry XSE",
  "make": "Toyota",
  "model": "Camry",
  "year": 2022,
  "trim": "XSE",
  "mileage": 18250,
  "price": 27995,
  "priceText": "$27,995",
  "dealerName": "Chicago Toyota",
  "dealerCity": "Chicago",
  "dealerState": "IL",
  "dealerZip": "60601",
  "dealerRating": 4.6,
  "ratingCount": 1284,
  "dealerPhone": "(312) 555-0142",
  "exteriorColor": "Midnight Black",
  "interiorColor": "Black",
  "transmission": "8-Speed Automatic",
  "drivetrain": "FWD",
  "engineDescription": "2.5L I4",
  "fuelType": "Gasoline",
  "mpgCity": 28,
  "mpgHighway": 39,
  "vin": "4T1G11AK6NU000000",
  "stockNumber": "T22-1234",
  "listingType": "used",
  "imageUrl": "https://platform.cstatic-images.com/...",
  "scrapedAt": "2026-04-30T12:00:00.000Z"
}
````

### Example call

```js
const run = await client.actor('cryptosignals/cars-com-scraper').call({
    query: 'Toyota Camry',
    location: 'Chicago, IL',
    maxResults: 50,
    minPrice: 15000,
    maxPrice: 30000,
    minYear: 2020,
    listingType: 'used'
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

### Common use cases

- **Competitive pricing intel**: pull all `Honda Civic` listings within 50 miles of a metro and benchmark against your own inventory.
- **Lead lists**: build a regional dealer directory with phone, location, and review scores.
- **Trend analysis**: track price-per-mile averages across model years and states.
- **Inventory monitoring**: schedule daily runs and diff datasets to detect new arrivals and price drops.

### Notes

- Cars.com listings can change at any time. Run the actor when you need fresh data.
- Some optional fields (color, MPG, phone) may be empty when Cars.com doesn't expose them on the search results page.
- This actor uses US residential proxies for reliability — no setup required from your side.

Built and maintained on Apify. Questions or feature requests? Open an issue on the actor's source repo or message the maintainer via Apify.

# Actor input Schema

## `query` (type: `string`):

Search term, e.g. 'Toyota Camry' or 'Honda Civic'.

## `location` (type: `string`):

US city/state or ZIP code (e.g. 'Chicago, IL' or '60601').

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

Maximum number of vehicle listings to extract.

## `minPrice` (type: `integer`):

Lower bound on listing price.

## `maxPrice` (type: `integer`):

Upper bound on listing price.

## `minYear` (type: `integer`):

Earliest model year.

## `maxYear` (type: `integer`):

Latest model year.

## `maxMileage` (type: `integer`):

Upper bound on odometer (miles).

## `listingType` (type: `string`):

Vehicle stock type.

## Actor input object example

```json
{
  "query": "Honda Civic",
  "location": "Chicago, IL",
  "maxResults": 50,
  "listingType": "all"
}
```

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("cryptosignals/cars-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("cryptosignals/cars-com-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 '{}' |
apify call cryptosignals/cars-com-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=cryptosignals/cars-com-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Cars.com Scraper - Vehicle Listings, Prices & Dealers",
        "description": "Scrape Cars.com vehicle listings with price, mileage, dealer info, and vehicle details (VIN, colors, engine, MPG). Filter by make/model, year, price, mileage, and listing type. Pay Per Event pricing.",
        "version": "0.1",
        "x-build-id": "251PUG1wSAhg6ksEP"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/cryptosignals~cars-com-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-cryptosignals-cars-com-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/cryptosignals~cars-com-scraper/runs": {
            "post": {
                "operationId": "runs-sync-cryptosignals-cars-com-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/cryptosignals~cars-com-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-cryptosignals-cars-com-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",
                "required": [
                    "query",
                    "location"
                ],
                "properties": {
                    "query": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Search term, e.g. 'Toyota Camry' or 'Honda Civic'."
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "US city/state or ZIP code (e.g. 'Chicago, IL' or '60601')."
                    },
                    "maxResults": {
                        "title": "Maximum results",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of vehicle listings to extract.",
                        "default": 50
                    },
                    "minPrice": {
                        "title": "Minimum price (USD)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Lower bound on listing price."
                    },
                    "maxPrice": {
                        "title": "Maximum price (USD)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Upper bound on listing price."
                    },
                    "minYear": {
                        "title": "Minimum year",
                        "minimum": 1900,
                        "type": "integer",
                        "description": "Earliest model year."
                    },
                    "maxYear": {
                        "title": "Maximum year",
                        "minimum": 1900,
                        "type": "integer",
                        "description": "Latest model year."
                    },
                    "maxMileage": {
                        "title": "Max mileage",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Upper bound on odometer (miles)."
                    },
                    "listingType": {
                        "title": "Listing type",
                        "enum": [
                            "all",
                            "new",
                            "used",
                            "certified"
                        ],
                        "type": "string",
                        "description": "Vehicle stock type.",
                        "default": "all"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
