# Cars.com Scraper \[$1.5💰] VIN, Price, Dealer & History 🚗 (`ahmed_jasarevic/cars-com-scraper`) Actor

Extract used, new & CPO listings from Cars.com for $1.5/1,000 results. Price, VIN, mileage, trim, dealer contact, deal rating, CARFAX/AutoCheck links & full photo gallery. Fast Cheerio-based extraction — search by make, model, ZIP, price & mileage.

- **URL**: https://apify.com/ahmed\_jasarevic/cars-com-scraper.md
- **Developed by:** [Ahmed Jasarevic](https://apify.com/ahmed_jasarevic) (community)
- **Categories:** E-commerce, Automation, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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, VIN & Dealer Data 🚗

💰 **From $1.5 per 1,000 results** — price, VIN, mileage, trim, dealer contact info, deal rating, and CARFAX/AutoCheck availability, extracted as clean structured JSON.

**Scrape used, new, and certified pre-owned car listings from [Cars.com](https://www.cars.com)** — built on the Apify platform with API access, scheduling, proxy rotation, and monitoring included. Searches by make, model, ZIP code, year, price, and mileage, then extracts every listing on the results pages.

***

### Why use this actor?

- 💸 **Fast & affordable** — from $1.5 per 1,000 results, powered by a lightweight CheerioCrawler (plain HTTP, no browser).
- 🔍 **Deep data on every listing** — year/make/model/trim, VIN, MSRP, mileage, body style, fuel type, colors, engine, transmission, and drivetrain.
- 📞 **Dealer intelligence** — dealer name, phone, address, distance, and deal rating on every record.
- 📸 **Rich media** — full photo gallery and feature list when detail scraping is enabled.
- 🕓 **Listing dynamics** — days on market, price drops, and listing date, so you can track how inventory moves over time.
- 📋 **Vehicle history links** — CARFAX and AutoCheck availability and report URLs where offered.
- 🔒 **Safe to run** — traffic routes through a rotating US proxy; schedule daily/weekly runs directly from Apify Console.

***

### Use cases

#### Market analysis

**Analysts and investors tracking used-car pricing, inventory, and days-on-market across regions.**
Input: make/model + ZIP + filters · Output: price, mileage, days on market, deal rating · Use: build regional pricing dashboards and inventory trend reports.

#### Dealer intelligence

**Dealers monitoring competitors' stock, pricing strategy, and deal ratings.**
Input: ZIP or make/model search around a competitor's location · Output: full listing set with pricing and deal ratings · Use: benchmark your pricing against nearby competitors.

#### Price-tracking SaaS

**Builders feeding a recurring schedule to detect price drops and new listings.**
Input: scheduled daily/weekly runs · Output: structured JSON with `priceDrop` and `listedAt` · Use: power price-alert tools or inventory-change notifications.

#### Arbitrage & deal-hunting

**Buyers and resellers finding underpriced vehicles by deal rating and price-vs-MSRP gap.**
Input: filtered search by price/mileage/year · Output: `dealRating`, `price`, `msrp` · Use: surface "Great Deal" listings automatically across regions.

#### CRM enrichment

**Sales and finance teams appending VIN, photos, and dealer contact data to existing records.**
Input: VIN-matched or targeted search · Output: full vehicle + dealer record · Use: enrich CRM entries without manual lookup.

***

### How to use

1. Open the actor in [Apify Console](https://console.apify.com) and click **Try for free** / **Start**.
2. Fill in the input form — at minimum a **ZIP code** (or a make/model). Set filters like max price, max mileage, year range, and stock type.
3. Click **Start**. Watch the live run log, then open the **Dataset** tab to browse results.
4. Download the dataset as **JSON, CSV, Excel, or HTML**, or pull it via the Apify API into your own pipeline.

**Example input:**

```json
{
  "make": "Honda",
  "model": "Civic",
  "zip": "78701",
  "maximumDistance": 50,
  "stockType": "used",
  "yearMin": 2019,
  "priceMax": 25000,
  "maxItems": 100,
  "includeDetails": true
}
```

***

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `startUrls` | array | — | Optional custom cars.com search-results URLs to start from |
| `make` | string | — | Vehicle make, e.g. `Honda` |
| `model` | string | — | Vehicle model, e.g. `Civic` (used together with make) |
| `keyword` | string | — | Free-text keyword search |
| `zip` | string | — | Search center ZIP code |
| `maximumDistance` | integer | `50` | Search radius in miles |
| `yearMin` / `yearMax` | integer | — | Model year range |
| `priceMin` / `priceMax` | integer | — | List price range in USD |
| `mileageMax` | integer | — | Maximum odometer reading |
| `stockType` | string | `used` | `used`, `new`, `cpo` or `all` |
| `sort` | string | `listed_at_desc` | Sort order (newest, price, mileage, distance, year…) |
| `maxItems` | integer | `100` | Max listings to scrape (free users capped at 10) |
| `includeDetails` | boolean | `true` | Fetch detail pages for richer data (falls back to search data on failure) |
| `proxyConfiguration` | object | US proxy group | Apify proxy settings |

***

### Output

Each dataset item is one vehicle listing:

```json
{
  "listingId": "1234567890",
  "url": "https://www.cars.com/vehicledetail/1234567890/",
  "title": "Used 2019 Honda Civic EX",
  "year": 2019,
  "make": "Honda",
  "model": "Civic",
  "trim": "EX",
  "vin": "1HGCV1F34LA012345",
  "price": 18999,
  "msrp": 22000,
  "mileage": 45000,
  "bodyStyle": "Sedan",
  "fuelType": "Gasoline",
  "stockType": "used",
  "cpo": false,
  "exteriorColor": "Modern Steel Metallic",
  "interiorColor": "Black",
  "engine": "1.5L I4 16V GDI DOHC Turbo",
  "transmission": "CVT",
  "drivetrain": "FWD",
  "dealerName": "Honda of Austin",
  "dealerPhone": "(512) 555-0100",
  "dealerAddress": "123 Main St",
  "dealerCity": "Austin",
  "dealerState": "TX",
  "dealerZip": "78701",
  "distanceMiles": 5,
  "daysOnMarket": 12,
  "listedAt": "2026-08-01T10:00:00Z",
  "priceDrop": null,
  "dealRating": { "label": "Great Deal", "variant": "great-deal", "description": "Below market" },
  "carfaxAvailable": true,
  "autocheckAvailable": false,
  "carfaxUrl": "https://www.carfax.com/vehiclehistory/abc",
  "autocheckUrl": null,
  "images": ["https://images.cstatic-images.com/1.jpg"],
  "imageCount": 3,
  "primaryImage": "https://images.cstatic-images.com/thumb.jpg",
  "features": ["Blind Spot Monitor", "Apple CarPlay", "Backup Camera"],
  "updatedAt": "2026-08-19 10:00:00",
  "isShippable": false,
  "shipPrice": null,
  "scrapedAt": "2026-08-20T10:00:00.000Z"
}
```

You can download the dataset as **JSON, HTML, CSV, or Excel**.

#### Data table

| Field | Description |
|---|---|
| `listingId`, `url` | Listing identifier and detail-page URL |
| `title`, `year`, `make`, `model`, `trim` | Vehicle identity |
| `vin` | Vehicle identification number |
| `price`, `msrp` | List price and original MSRP |
| `mileage` | Odometer reading |
| `bodyStyle`, `fuelType`, `stockType`, `cpo` | Vehicle attributes |
| `exteriorColor`, `interiorColor`, `engine`, `transmission`, `drivetrain` | Specs (enriched from detail page) |
| `dealerName`, `dealerPhone`, `dealerAddress`, `dealerCity`, `dealerState`, `dealerZip` | Selling dealer info |
| `distanceMiles` | Distance from search ZIP |
| `daysOnMarket`, `listedAt`, `priceDrop`, `dealRating` | Listing dynamics |
| `carfaxAvailable`, `autocheckAvailable`, `carfaxUrl`, `autocheckUrl` | Vehicle history report availability |
| `images`, `imageCount`, `primaryImage`, `features` | Media and options |

***

### Integration examples

#### JavaScript / Node.js

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

const client = new ApifyClient({ token: 'YOUR_TOKEN' });

const run = await client.actor('ahmed_jasarevic/cars-com-scraper').call({
  make: 'Honda',
  model: 'Civic',
  zip: '78701',
  maxItems: 100,
  includeDetails: true,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items[0]);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_TOKEN')

run = client.actor('ahmed_jasarevic/cars-com-scraper').call(run_input={
    'make': 'Toyota',
    'model': 'Camry',
    'zip': '90001',
    'maxItems': 200,
    'includeDetails': True,
})

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

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/ahmed_jasarevic~cars-com-scraper/runs?token=YOUR_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"make":"Honda","model":"Civic","zip":"78701","maxItems":100,"includeDetails":true}'
```

#### Automation workflows (n8n / Zapier / Make)

1. **Trigger**: schedule or webhook
2. **HTTP Request**: call the actor API
3. **Process**: parse the JSON results, filter by `priceDrop` or `dealRating`
4. **Action**: save to a sheet/DB, send price-drop alerts, or feed into a CRM

***

### Pricing / cost estimation

How much does it cost to scrape Cars.com? At **$1.5 per 1,000 results**, the actor uses a lightweight **CheerioCrawler** (plain HTTP, no browser), so runs stay cheap. A 100-listing run typically finishes in a few minutes and costs a fraction of a compute unit. Free Apify users get a **10-item preview**; paid users can scrape up to **5,000 listings per run**. Proxy traffic is included in your Apify plan.

***

### Tips and advanced options

- **Use a ZIP code** — Cars.com results are distance-based; without one you get nationwide results.
- **Set `maxItems`** to bound run time and cost.
- **Disable `includeDetails`** for a faster, cheaper run when you only need search-page data.
- **Schedule it** in Apify Console (e.g. daily) to track price drops and new inventory over time.
- **Combine filters** (make + model + year range + price cap) to keep result sets small and focused.

***

### FAQ

**How much does it cost?**
$1.5 per 1,000 results. Free users get a 10-item preview to test before scaling up.

**Do I need a proxy?**
Included by default via a rotating US proxy group. Very large runs may benefit from the residential proxy group if Cars.com rate-limits your requests.

**What's the difference with `includeDetails` on vs off?**
Off: fast, cheap search-page data (price, mileage, dealer basics). On: additionally visits each detail page for full photo gallery, dealer phone/address, vehicle-history links, and features — slower and uses more proxy bandwidth. Falls back to search-page data if a detail page fails.

**Can I scrape new, used, and CPO listings?**
Yes — set `stockType` to `used`, `new`, `cpo`, or `all`.

**How many listings can I scrape per run?**
Free users: 10-item preview. Paid users: up to 5,000 listings per run.

**What output formats are supported?**
JSON, CSV, Excel, and HTML — all exportable directly from the Apify dataset.

**Is scraping Cars.com legal?**
Scraping public data for personal or analytical use is generally acceptable, but you are responsible for complying with Cars.com's Terms of Service and applicable laws. This actor is not affiliated with or endorsed by Cars.com.

***

### Known limitations

- Cars.com rate-limits and blocks some clients on detail pages; the actor gracefully falls back to search-page data when a detail page fails.
- Very large runs may need the residential proxy group.

***

### Support

Report issues or request features on the **Issues** tab of this actor. Need a custom scraper? Contact the author for tailored solutions.

# Actor input Schema

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

Optional custom cars.com search-results URLs to start from. If empty, the actor builds a search URL from the filters below.

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

Vehicle make, e.g. Honda, Toyota, Tesla.

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

Vehicle model, e.g. Civic, Camry, Model Y. Only used together with Make.

## `keyword` (type: `string`):

Free-text keyword search (e.g. a model name without a make).

## `zip` (type: `string`):

Search center ZIP code.

## `maximumDistance` (type: `integer`):

Search radius around the ZIP code.

## `yearMin` (type: `integer`):

Oldest model year to include.

## `yearMax` (type: `integer`):

Newest model year to include.

## `priceMin` (type: `integer`):

Lowest list price to include.

## `priceMax` (type: `integer`):

Highest list price to include.

## `mileageMax` (type: `integer`):

Highest odometer reading to include.

## `stockType` (type: `string`):

Type of inventory to search.

## `sort` (type: `string`):

How to sort the results.

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

Maximum number of listings to scrape. Free users are capped at 10.

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

Proxy settings. Defaults to the account's US proxy group.

## Actor input object example

```json
{
  "maximumDistance": 50,
  "stockType": "used",
  "sort": "listed_at_desc",
  "maxItems": 100,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "BUYPROXIES94952"
    ]
  }
}
```

# Actor output Schema

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

No description

# 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 = {
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "BUYPROXIES94952"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("ahmed_jasarevic/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 = { "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["BUYPROXIES94952"],
    } }

# Run the Actor and wait for it to finish
run = client.actor("ahmed_jasarevic/cars-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 '{
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "BUYPROXIES94952"
    ]
  }
}' |
apify call ahmed_jasarevic/cars-com-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,ahmed_jasarevic/cars-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/CxOVyoQk2QQQk51HC/builds/dK8A59A0cBZsXlao9/openapi.json