# Cars.com Scraper - US Cars, Prices & Dealer Leads (`scrapesage/cars-com-scraper`) Actor

Scrape Cars.com new & used car listings: price, MSRP, price drops, mileage, VIN, year/make/model/trim, specs, features, photos, deal rating & history, plus dealer leads (name, location, type, rating). Filter by make, model, ZIP, price, mileage & year. Price-drop & new-listing monitor.

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

## Pricing

from $4.00 / 1,000 car listings

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 — US New & Used Cars, Prices & Dealer Leads

Scrape **[Cars.com](https://www.cars.com)** — one of the largest US car marketplaces — into clean, structured data. Pull every search result with **year / make / model / trim, asking price, MSRP, price drops, mileage, VIN, body style, drivetrain, fuel type, colours, the selling dealer, and all photos**. Add full **vehicle-detail** records (complete feature list, condition signals, geo, dealer phone) and **dealer leads** with one toggle. Built-in **monitor mode** returns only new listings and price drops between runs.

No API key, no login, no browser automation — fast HTTP straight to the source, with a **0-100 lead score** on every dealer.

### Why this Cars.com scraper?

Most car-listing scrapers give you a name and a price for a handful of cars, then break on the next site update. This actor ships the **full Cars.com record** with everything a pricing model, an inventory feed, or a dealer-prospecting list actually needs:

| Data | Typical car scrapers | This actor |
|---|---|---|
| Year / make / model / trim | ✅ | ✅ |
| Asking price + **MSRP** + **price-drop amount** | partial | ✅ |
| Mileage, **VIN**, stock type (new / used / CPO) | partial | ✅ |
| Body style, drivetrain, fuel, exterior/interior colour | ❌ | ✅ |
| **Full feature list** (opt-in detail) | ❌ | ✅ |
| Condition signals — clean title, no accidents, single owner, open recall, history report | ❌ | ✅ |
| Selling **dealer name, rating, city/state** | partial | ✅ |
| **Dealer leads** (deduped, inventory count, lead score) | ❌ | ✅ |
| All listing **photos** | partial | ✅ |
| **Deal rating** & deal badge | ❌ | ✅ |
| **Monitor mode** — only new listings & price drops | ❌ | ✅ |
| Lead score (0-100) | ❌ | ✅ |

### Who buys Cars.com data?

- **Car dealers & dealer groups** — track competitor pricing, days-on-lot and price drops on the exact year/make/model you stock.
- **Automotive marketplaces, pricing & valuation tools** — feed live asking prices, MSRP and mileage into your model.
- **Dealer-facing SaaS, ad-tech & vendors** — build prospect lists of dealers by market, inventory size and rating.
- **Lenders, insurers & warranty providers** — size markets and reach dealers and shoppers.
- **Wholesalers, flippers & exporters** — surface under-priced cars and recent price drops fast.
- **Researchers & analysts** — used-car price trends, inventory and depreciation by make/model/region.

### How to use

1. [Sign up for Apify](https://console.apify.com/sign-up) — the free plan is enough to try this actor.
2. Open the **Cars.com Scraper**, then either paste **Search URLs** from cars.com or enter **makes / models + a ZIP** and click **Start**.
3. Watch results stream into the dataset table.
4. **Export** as JSON, CSV, Excel, XML, or RSS — or pull results programmatically via the [Apify API](https://docs.apify.com/api/v2).

### Input

The easiest way to run an exact search is to set your filters on cars.com and paste the resulting URL into **Search URLs**. Or build a search from fields:

```json
{
    "makes": ["toyota", "honda"],
    "models": ["rav4"],
    "stockType": "used",
    "zip": "10001",
    "radius": 100,
    "priceMax": 35000,
    "mileageMax": 60000,
    "yearMin": 2019,
    "onlyWithPriceDrop": false,
    "includeCarDetails": false,
    "includeDealerLeads": true,
    "maxResults": 100
}
```

Or by URL:

```json
{
    "searchUrls": [
        "https://www.cars.com/shopping/results/?stock_type=used&makes[]=honda&models[]=honda-accord&zip=10001"
    ],
    "includeCarDetails": true,
    "maxResults": 50
}
```

| Field | What it does |
|---|---|
| `searchUrls` | Paste cars.com search-results URLs — every filter in the URL is respected. |
| `listingUrls` | Scrape specific `/vehicledetail/<id>/` pages as full detail records. |
| `makes`, `models` | Build a search by brand (and optional model) + `zip`. |
| `stockType` | `all`, `used`, `new`, or `cpo` (certified pre-owned). |
| `zip`, `radius` | Search location and distance in miles. |
| `priceMin/Max`, `mileageMax`, `yearMin/Max` | Numeric filters. |
| `sellerType` | `any`, `dealer`, or `private`. |
| `onlyWithPriceDrop` | Keep only cars that recently dropped in price. |
| `sortBy` | Best match, newest listed, price, mileage or year. |
| `includeCarDetails` | Open each vehicle-detail page for full features + condition signals + dealer phone. |
| `includeDealerLeads` | Emit one deduplicated dealer / seller record with a lead score. |
| `monitorMode`, `monitorKey` | Return only new listings & price changes since the last run. |
| `maxResults`, `maxResultsPerSearch` | Result caps. |

### Output

Each vehicle is one record. Example (trimmed):

```json
{
    "recordType": "car",
    "listingId": "fa876696-ffd0-41b2-ad1a-db278660fc1f",
    "title": "2024 Toyota RAV4 XLE",
    "year": 2024,
    "make": "Toyota",
    "model": "RAV4",
    "trim": "XLE",
    "vin": "2T3P1RFV0RW432440",
    "stockType": "Used",
    "price": 31811,
    "priceDropAmount": 1100,
    "mileage": 27550,
    "bodyStyle": "SUV",
    "drivetrain": "All-wheel Drive",
    "fuelType": "Gasoline",
    "exteriorColor": "Ice Cap",
    "dealerName": "The Autobarn Countryside Subaru",
    "dealerRating": 4.6,
    "city": "Countryside",
    "state": "IL",
    "distanceMiles": 724,
    "photoCount": 6,
    "primaryPhoto": "https://platform.cstatic-images.com/.../photo.jpg",
    "listingUrl": "https://www.cars.com/vehicledetail/fa876696-.../"
}
```

With `includeCarDetails` the record adds `features`, `cylinders`, `doors`, `transmission`, `stockNumber`, `cleanTitle`, `noAccidents`, `singleOwner`, `openRecall`, `hasVehicleHistoryReport`, `latitude`/`longitude`, `market` and the dealer `phone`.

A **dealer lead** (`recordType: "dealerLead"`) looks like:

```json
{
    "recordType": "dealerLead",
    "dealerName": "The Autobarn Countryside Subaru",
    "sellerType": "dealer",
    "city": "Countryside",
    "state": "IL",
    "zip": "60525",
    "inventoryCount": 14,
    "avgPrice": 28940,
    "rating": 4.6,
    "leadScore": 88,
    "leadSignals": ["dealer", "high-inventory", "top-rated"]
}
```

#### What to expect (field coverage)

- **Vehicle core** (year, make, model, trim, VIN, price, mileage, body style, drivetrain, fuel, colour, photos): ~100% of listings.
- **Dealer name, rating, city/state**: present on the great majority of dealer listings; private-seller and some sponsored cards may omit name/rating (we never fabricate it).
- **Price drop**: only on listings that actually dropped — an intent signal, not a gap.
- **Features & condition signals**: populated when you turn on `includeCarDetails`.

### Automate & schedule

Run this actor on autopilot and pull results into your own stack:

- **[Apify API](https://docs.apify.com/api/v2)** — start runs, fetch datasets, and manage schedules over REST.
- **[apify-client for JavaScript](https://docs.apify.com/api/client/js/)** and **[apify-client for Python](https://docs.apify.com/api/client/python/)** — official SDKs.
- **[Schedules](https://docs.apify.com/platform/schedules)** — run a saved search daily with **monitor mode** to capture every new listing and price drop as soon as it appears.
- **[Webhooks](https://docs.apify.com/platform/integrations/webhooks)** — trigger downstream actions (CRM import, Slack alert, repricing job) the moment a run finishes.

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

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

const run = await client.actor('scrapesage/cars-com-scraper').call({
    makes: ['toyota'],
    models: ['rav4'],
    stockType: 'used',
    zip: '10001',
    onlyWithPriceDrop: true,
    includeDealerLeads: true,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(`Got ${items.length} cars & dealers`);
```

### Integrate with any app

Connect the dataset to 5,000+ apps — no code required:

- **[Make](https://docs.apify.com/platform/integrations/make)** — multi-step automation scenarios.
- **[Zapier](https://docs.apify.com/platform/integrations/zapier)** — push new listings & dealer leads straight into your CRM.
- **[Slack](https://docs.apify.com/platform/integrations/slack)** — get pinged when a monitored search gets a new car or a price drop.
- **[Google Drive / Sheets](https://docs.apify.com/platform/integrations/drive)** — auto-export every run to a spreadsheet.
- **[Airbyte](https://docs.apify.com/platform/integrations/airbyte)** — pipe results into your data warehouse.
- **[GitHub](https://docs.apify.com/platform/integrations/github)** — trigger runs from commits or releases.

### Use with AI assistants (MCP)

The output is clean, LLM-ready JSON. Call this actor from Claude, ChatGPT, or any agent framework through the **[Apify MCP server](https://docs.apify.com/platform/integrations/mcp)** — ask your assistant to "find every used Toyota RAV4 under $30k within 100 miles of 10001 that just had a price drop, with the dealer and a lead score" and let it run the scraper for you.

### Agent-ready: autonomous payments (x402 & Skyfire)

This actor is **agent-ready** — AI agents can discover it, run it, and **pay for it autonomously**, with no Apify account and no human in the loop. It uses [pay-per-event](https://docs.apify.com/platform/actors/publishing/monetize/pay-per-event) pricing and [limited permissions](https://docs.apify.com/platform/actors/development/permissions), so it qualifies for Apify's agentic-payment standards:

- **[x402](https://docs.apify.com/platform/integrations/x402)** — an open, HTTP-native payment protocol. Agents pay per run in USDC on the Base network directly through the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp) — no account, no API key.
- **[Skyfire](https://docs.apify.com/platform/integrations/skyfire)** — agent-to-service payments for fully autonomous AI-agent workflows.

Building an AI agent, MCP tool, or autonomous data pipeline? This scraper is ready to plug in and pay as it goes.

### More scrapers from scrapesage

Build a complete **automotive & marketplace data stack**:

- **[AutoScout24 Scraper](https://apify.com/scrapesage/autoscout24-scraper)** — Europe's largest car marketplace: listings, specs, prices & dealer leads across 8 countries.
- **[AutoTrader.ca Scraper](https://apify.com/scrapesage/autotrader-ca-scraper)** — Canada's #1 car marketplace with prices, specs & dealer leads.
- **[SGCarMart Scraper](https://apify.com/scrapesage/sgcarmart-used-car-scraper)** — Singapore used cars, prices, specs & seller contacts.
- **[US Auto Dealer Scraper](https://apify.com/scrapesage/us-auto-dealer-scraper)** — licensed auto dealers & repair shops from official state DMV registries.
- **[FMCSA Trucking Scraper](https://apify.com/scrapesage/fmcsa-trucking-scraper)** — US motor carriers & freight brokers with authority, insurance & contacts.
- **[eBay Scraper](https://apify.com/scrapesage/ebay-scraper)** — listings, prices, sold comps & seller leads.
- **[Craigslist Scraper](https://apify.com/scrapesage/craigslist-scraper)** — classifieds incl. cars & trucks with seller detail.
- **[US Property Records Scraper](https://apify.com/scrapesage/us-property-records-scraper)** — owner leads, values & characteristics from official county records.

### Tips

- **Pasted URLs win**: pick your exact filters on cars.com, then paste the URL into `searchUrls` — it's the most reliable way to reproduce a search.
- **Price-drop feed**: set `onlyWithPriceDrop: true` and sort by `listed_at_desc`, then run on a [Schedule](https://docs.apify.com/platform/schedules) with `monitorMode` for a continuous repricing / buying signal.
- **Dealer prospecting**: turn on `includeDealerLeads` and sort the dataset by `leadScore` to reach the biggest, best-rated dealers in a market first.
- **Full specs**: enable `includeCarDetails` only when you need the feature list / condition signals — it opens one extra page per car.
- **Go nationwide**: leave `radius` empty (or set it high) to include sellers that deliver to the buyer's ZIP.

### FAQ

**Where does the data come from?** From public Cars.com search-results and vehicle-detail pages.

**Does it need an API key or login?** No — no key, no login, no browser. The actor uses Apify's US residential proxy by default because Cars.com serves its data to US visitors.

**How fresh is it?** Every run fetches live pages. Run it on a [Schedule](https://docs.apify.com/platform/schedules) with `monitorMode` to capture new listings and price drops continuously.

**Does it include dealer phone numbers?** Dealer phone is shown on the vehicle-detail page, so it's included when you enable `includeCarDetails`. Search results always include the dealer name, rating and city/state.

**Will it return every car for a search?** It paginates through the results up to your `maxResults` / `maxResultsPerSearch` cap. Cars.com searches can have hundreds of pages — narrow with make/model/price/ZIP filters for focused, efficient runs.

**Can I export to Google Sheets, CSV, or Excel?** Yes — one click in the dataset view, or automatically on every run via the [Google Drive integration](https://docs.apify.com/platform/integrations/drive).

**Is scraping this data legal?** This actor collects publicly available listing data. You're responsible for using it in compliance with applicable laws and the site's terms.

### Need help?

Open an issue on the actor's **Issues** tab, or visit the [Apify help center](https://help.apify.com/). Feature requests are welcome — this actor is actively maintained.

# Actor input Schema

## `searchUrls` (type: `array`):

Paste one or more Cars.com search-results URLs (the page after you pick make/model/filters, e.g. https://www.cars.com/shopping/results/?stock\_type=used\&makes\[]=honda\&models\[]=honda-accord\&zip=10001). Every filter in the URL is respected. Easiest way to run an exact search.

## `listingUrls` (type: `array`):

Paste specific Cars.com vehicle-detail URLs (e.g. https://www.cars.com/vehicledetail/<id>/). These are fetched as full detail records (charged as carDetail).

## `makes` (type: `array`):

Build a search by brand (e.g. \["honda","toyota","ford"]). Combined with ZIP. Leave empty to use Search URLs instead.

## `models` (type: `array`):

Optional model names to pair with the first make (e.g. \["accord","civic"] for Honda). Use lower-case model names; the actor builds the cars.com make-model slug.

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

Which inventory to search.

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

US ZIP code to search around (e.g. "10001"). Required when searching by make/model (not needed for Search URLs that already contain a ZIP).

## `radius` (type: `integer`):

Distance from the ZIP in miles. Use a large number (e.g. 500) or leave empty for nationwide where the seller delivers.

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

Free-text keyword to add to the search (e.g. "leather", "awd", a trim name). Optional.

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

Keep only listings at or above this asking price.

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

Keep only listings at or below this asking price.

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

Keep only listings at or below this odometer reading.

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

Keep only listings from this model year or newer.

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

Keep only listings up to this model year.

## `sellerType` (type: `string`):

Limit to franchise/independent dealers or to private sellers.

## `onlyWithPriceDrop` (type: `boolean`):

Keep only listings that recently dropped in price — the highest-intent, most negotiable cars.

## `sortBy` (type: `string`):

Order Cars.com returns results in.

## `includeCarDetails` (type: `boolean`):

For every listing, also open its vehicle-detail page to add the full features list, cylinders/doors/transmission, condition signals (clean title, no accidents, single owner, open recall, vehicle-history report), geo and dealer phone. Slower and billed as carDetail instead of car.

## `includeDealerLeads` (type: `boolean`):

Also emit one deduplicated record per dealer / private seller found in the results, with inventory count, average price, location and a 0-100 lead score.

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

Maximum number of vehicle listings to return across all searches.

## `maxResultsPerSearch` (type: `integer`):

Cap listings taken from each individual search / URL (paginates as needed). Leave empty to use Max results.

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

Remember listings between runs in a named store and emit only NEW listings, price drops and price rises since the last run. Pair with Apify Schedules for a recurring price-drop / new-inventory feed.

## `monitorKey` (type: `string`):

Name for this monitor's memory so different saved searches don't collide (e.g. "honda-accord-nyc"). Only used when Monitor mode is on.

## `includeRawFields` (type: `boolean`):

Attach the raw Cars.com fields used to build each record (sourceFields) for debugging or extra data.

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

Cars.com serves clean data to US residential IPs. Leave the default (Apify Proxy, US residential) unless you know what you are doing.

## Actor input object example

```json
{
  "searchUrls": [],
  "listingUrls": [],
  "stockType": "all",
  "sellerType": "any",
  "onlyWithPriceDrop": false,
  "sortBy": "best_match_desc",
  "includeCarDetails": false,
  "includeDealerLeads": false,
  "maxResults": 100,
  "monitorMode": false,
  "monitorKey": "default",
  "includeRawFields": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# Actor output Schema

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

All scraped Cars.com vehicle listings (and any dealer-lead records) in the default dataset, each with pricing, specs, photos, deal rating and seller detail.

# 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 = {
    "searchUrls": [],
    "listingUrls": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapesage/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 = {
    "searchUrls": [],
    "listingUrls": [],
}

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

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/SaRqtuddbmG1Rj1Dr/builds/dN1Zqo6MFlsqFUXbJ/openapi.json