# Cars.com Scraper — US Car Listings, Prices & Dealers (`tortuga/cars-com-scraper`) Actor

Scrape Cars.com new & used car listings by search URL or make/model + filters: price, deal rating, mileage, VIN, specs, colors, MPG, dealer & rating, distance, photos; optional features & history.

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

## Pricing

from $0.70 / 1,000 car listing scrapeds

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Cars.com Scraper — US Car Listings, Prices & Dealers

Scrape new, used and certified pre-owned (CPO) car listings from **Cars.com**, one of the largest US car marketplaces.
Paste any Cars.com search URL, or search by make, model, ZIP code and filters (price, year, mileage, body style, fuel,
drivetrain, transmission, dealer vs private seller, deal rating). Every listing comes with price, deal rating
(great / good / fair deal), mileage, VIN, stock number, transmission, engine, MPG, exterior and interior color, dealer
name, rating, review count and address, distance from your ZIP and photos. Optionally add the feature list, seller's
notes, price history and history-report highlights (one owner, no accidents, clean title).

Export to JSON, CSV or Excel, or feed it to your app through the Apify API. Pay only for the listings you get.

### What data can you extract from Cars.com?

| Field | Example |
|---|---|
| `title`, `make`, `model`, `trim`, `year` | Used 2025 Toyota Camry LE, Toyota, Camry, LE, 2025 |
| `condition`, `stockType`, `certifiedPreOwned` | used, Certified, true |
| `price`, `msrp`, `priceDrop`, `monthlyPaymentEstimate` | 26980, 37705 (new cars), 400, 508 |
| `priceRating`, `priceRatingLabel`, `dealPriceThresholds` | good, Good Deal, {great: 25154, good: 27977, fair: 35934} |
| `badges` | High Demand, 2025 Award Finalist |
| `vin`, `stockNumber` | 4T1DAACK3SU131514, 9090 |
| `mileageMiles`, `mileageKm` | 42044, 67663 |
| `bodyType`, `fuel`, `gearbox`, `driveTrain`, `engine`, `cylinders`, `doors` | Sedan, Hybrid, Automatic, Front-wheel Drive, 2.5L 4 CYLINDER, 4, 4 |
| `mpgCity`, `mpgHighway`, `mpgCombined` | 53, 50, null |
| `exteriorColor`, `exteriorColorGroup`, `interiorColor` | Ice Cap, White, Black |
| `sellerType`, `sellerName`, `dealerName`, `dealerRating`, `dealerRatingCount` | dealer, Driven Auto of Waukegan, ..., 4.2, 51 |
| `dealerAddress`, `city`, `state`, `zip`, `distanceMiles` | 540 S Green Bay Road, Waukegan, IL, 60085, 35 |
| `shippable`, `deliveryFee`, `sponsored` | true, 399, false |
| `listedAt` | 2026-08-27T16:03:30 |
| `imageUrl`, `images`, `imageCount` | first photo, photo URLs, 43 |
| `url`, `id`, `searchUrl`, `scrapedAt` | https://www.cars.com/vehicledetail/b4945213-.../ |

With **Include listing details** on, each listing also gets `features` and `featuresByCategory` (convenience,
entertainment, exterior, safety, seating), `sellerNotes`, `priceHistory` (date + price of every change),
`historyOneOwner`, `historyNoAccidents`, `historyCleanTitle`, `historyPersonalUse`, `historyOpenRecall` (from the
AutoCheck panel, when the listing has one) and all photos.

### How to scrape Cars.com listings

1. Open the actor and either paste Cars.com search URLs into **Start URLs** (set your filters on cars.com first and
   copy the address bar), or fill in **Make**, **Model**, **ZIP code** and the filters.
2. Set **Max items** (default 100) and click **Start**.
3. Download the dataset as JSON, CSV or Excel, or read it through the API.

Example input:

```json
{
  "make": "Toyota",
  "model": "Camry",
  "zip": "60606",
  "radiusMiles": 50,
  "stockType": "used",
  "priceTo": 25000,
  "sort": "newest_listed",
  "maxItems": 200
}
```

Example output (shortened):

```json
{
  "id": "7dc658a7-c642-4b99-a157-29ddbbae2094",
  "url": "https://www.cars.com/vehicledetail/7dc658a7-c642-4b99-a157-29ddbbae2094/",
  "title": "Used 2026 Toyota Camry LE",
  "make": "Toyota", "model": "Camry", "trim": "LE", "year": 2026,
  "condition": "used", "stockType": "Used", "certifiedPreOwned": false,
  "vin": "4T1DAACK2TU714089", "stockNumber": "N9430",
  "price": 30111, "currency": "USD", "monthlyPaymentEstimate": 567,
  "mileageMiles": 12348, "bodyType": "Sedan", "fuel": "Gasoline", "gearbox": "eCVT",
  "driveTrain": "Front-wheel Drive", "engine": "Dynamic Force 2.5L I-4 port/direct injection, DOHC, VVT-iE/VVT-i",
  "mpgCity": 52, "mpgHighway": 49,
  "exteriorColor": "Midnight Black Metallic", "interiorColor": "Black",
  "sellerType": "dealer", "dealerName": "Bill Kay Downers Grove Nissan", "dealerRating": 4.6,
  "dealerRatingCount": 2639, "dealerAddress": "1601 Ogden Ave.", "city": "Downers Grove", "state": "IL",
  "zip": "60515", "distanceMiles": 21, "listedAt": "2026-10-10T00:52:35",
  "imageUrl": "https://platform.cstatic-images.com/in/v2/0a85f76e-.../ah7Z-PM2aJBZTG_xhA4IPwYzbXc.jpg"
}
```

### Which Cars.com URLs work?

- Search results: `https://www.cars.com/shopping/results/?stock_type=used&makes[]=ford&models[]=ford-f_150&zip=75201&maximum_distance=100&list_price_max=40000`
  (every filter in the URL is applied, including ones the input form does not have, such as colors, features or
  trims).
- SEO search pages: `https://www.cars.com/shopping/toyota-camry-2020/`, `https://www.cars.com/shopping/chicago-il/`.
- Single listings: `https://www.cars.com/vehicledetail/<id>/` (output with the full record).

### How many listings can I get per search?

Cars.com shows counts only up to 10,000 and serves at most 50,000 listings per search. With **Split large searches**
on (default), bigger searches are walked in price windows (cheapest first) so you can export every listing, e.g. all
used pickups in Texas. Listings without a price ("Not Priced") can be missed by price windows.

### Monitor changes on a schedule

Turn on **Only new or changed items** and save the input as a task with a daily Schedule: the actor remembers what
earlier runs of the same search returned and outputs only listings that are new or whose price changed, so a daily
run usually returns a handful of items. Unchanged listings are not charged. Output items then carry `changeType`
(`new` or `changed`) and, for changed ones, `previousValues` (e.g. `{"price": 27380}`). In Apify open the actor, set
the input, click **Save as task**, then **Schedule** it. Use **Monitoring key** to keep several watches on the same
search apart; **Max items** is the number of listings checked per run (use sort "Newest listed" for new arrivals).

### Does it work without login? Is it legal?

Yes, no account or login is needed. The actor reads only what Cars.com shows publicly to every visitor. Dealer phone
numbers (behind "Call" buttons) and lead forms are never touched; e-mail addresses in seller's notes are removed (the
site masks them too), and for private sellers phone numbers in the notes are removed as well. Private sellers appear
with the first name Cars.com displays and no address. Scrape responsibly and check that your use of the data
complies with Cars.com's terms and the laws that apply to you (e.g. GDPR/CCPA for personal data).

### Proxy note and cost

Cars.com blocks datacenter IPs, so the default (and required) proxy is **Apify Residential, US**. The actor uses
Cars.com's compact JSON API (100 listings per request plus one batched request per 50 listings for specs), about
0.75 MB of proxy traffic per 1,000 listings (about 2 MB with listing details), which Apify bills to your account at
the residential rate: roughly $0.006 per 1,000 listings at $8/GB ($0.016 with details). A 1,000-listing run takes
about 30 seconds. Pricing is pay-per-event: one `result` per listing and, only with **Include listing details**, one
`detail` per listing; platform usage (proxy, compute, storage, about $0.012 per 1,000 listings) is paid by you.

### FAQ

**Can I scrape only dealer listings or only private sellers?** Yes, use **Seller type**.

**Can I get certified pre-owned cars only?** Set **New / used** to "Certified pre-owned only".

**Why is `distanceMiles` empty?** Distance is only meaningful around a ZIP code; without one the whole US is
searched and distance is left out.

**Why are `historyNoAccidents` etc. empty for some cars?** Cars.com shows the history panel only for listings that
have an AutoCheck report.

# Actor input Schema

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

Cars.com search pages with filters set in the browser, e.g. https://www.cars.com/shopping/results/?stock_type=used\&makes\[]=toyota\&models\[]=toyota-camry\&zip=60606\&maximum_distance=50\&list_price_max=25000, SEO search pages such as https://www.cars.com/shopping/toyota-camry-2020/, or single listings (https://www.cars.com/vehicledetail/<id>/). Leave empty to use the Make / Model search below.

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

Brand as shown on Cars.com, e.g. Toyota, Ford, Chevrolet, Honda, Tesla, Land Rover, Mercedes-Benz. Several makes: separate with commas. The filters below apply to this search only, not to Start URLs. Leave empty for all makes.

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

Model as shown on Cars.com, e.g. Camry, RAV4, F-150, CR-V, Model 3. Several models of the same make: separate with commas. Needs one Make.

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

US ZIP code to search around (e.g. 60606, 90001, 10001). Adds the distance in miles to every listing. Leave empty to search the whole US.

## `radiusMiles` (type: `integer`):

Only cars within this many miles of the ZIP code (Cars.com offers 10-1000; 9999 = all). Needs a ZIP code.

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

New, used, certified pre-owned (CPO) or all listings.

## `priceFrom` (type: `integer`):

Minimum list price in US dollars.

## `priceTo` (type: `integer`):

Maximum list price in US dollars.

## `yearFrom` (type: `integer`):

Earliest model year, e.g. 2018.

## `yearTo` (type: `integer`):

Latest model year.

## `mileageTo` (type: `integer`):

Only cars with at most this many miles.

## `bodyStyles` (type: `array`):

Only these body styles. Leave empty for all.

## `fuelTypes` (type: `array`):

Only these fuel types. Leave empty for all.

## `drivetrains` (type: `array`):

Only these drivetrains. Leave empty for all.

## `transmissions` (type: `array`):

Only these transmissions. Leave empty for all.

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

Only dealerships or only private sellers.

## `dealRatings` (type: `array`):

Only listings Cars.com rates as a great, good or fair deal. Leave empty for all (including unrated and new cars).

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

Free-text keyword Cars.com matches against the listing, e.g. 'sunroof' or 'tow package'.

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

Order of the Make / Model search. 'Newest listed' is best for monitoring new listings. 'Distance' needs a ZIP code (otherwise best match is used).

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

Stop after this many listings in total (across all searches). Keeps cost predictable. With 'Only new or changed items' on, this is the number of listings checked per run.

## `includeDetails` (type: `boolean`):

Also read each listing's full record: feature list by category (convenience, safety, entertainment, ...), seller's notes, price history, history-report highlights (one owner, no accidents, clean title, personal use, open recall) and all photos. Charged as an extra 'detail' event per listing; fetched in batches of 50, so it adds little run time.

## `splitLargeSearches` (type: `boolean`):

Cars.com serves at most 50,000 listings per search (and shows counts only up to 10,000). When a search is larger and Max items asks for more than 50,000, it is walked in price windows automatically so you can get all of them (results then come cheapest first).

## `onlyNewOrChanged` (type: `boolean`):

Remember what earlier runs of this search returned and output only new items or items whose price/status changed. Use with a Schedule; unchanged items are not charged.

## `monitoringKey` (type: `string`):

Name for this watch, so several schedules on the same search stay separate; defaults to a key derived from the search input

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

Residential US proxy is required: Cars.com blocks datacenter IPs (Cloudflare). Apify bills the proxy traffic to your account at the residential rate. The actor uses Cars.com's compact JSON API: about 0.75 MB per 1,000 listings (about $0.006 at $8/GB), about 2 MB per 1,000 with listing details (about $0.016).

## Actor input object example

```json
{
  "startUrls": [],
  "make": "Toyota",
  "model": "Camry",
  "zip": "60606",
  "radiusMiles": 50,
  "stockType": "all",
  "sort": "best_match",
  "maxItems": 100,
  "includeDetails": false,
  "splitLargeSearches": true,
  "onlyNewOrChanged": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# 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 = {
    "startUrls": [],
    "make": "Toyota",
    "model": "Camry",
    "zip": "60606",
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "US"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("tortuga/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 = {
    "startUrls": [],
    "make": "Toyota",
    "model": "Camry",
    "zip": "60606",
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "US",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("tortuga/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 '{
  "startUrls": [],
  "make": "Toyota",
  "model": "Camry",
  "zip": "60606",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}' |
apify call tortuga/cars-com-scraper --silent --output-dataset

```

## MCP server setup

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