# Cars.com Vehicle Listings Scraper (`automation-lab/cars-com-vehicle-listings-scraper`) Actor

Extract Cars.com VINs, prices, mileage, photos, specifications, history signals, and dealer details for inventory monitoring and market analysis.

- **URL**: https://apify.com/automation-lab/cars-com-vehicle-listings-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** E-commerce
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## 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/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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 Vehicle Listings Scraper

Scrape **Cars.com vehicle listings** into structured, analysis-ready data.

Paste a filtered Cars.com search URL or an individual vehicle URL.

Get VINs, prices, mileage, specifications, photos, history signals, price history, and dealer details without a Cars.com login.

The Actor uses Cars.com's structured mobile data route instead of rendering a browser, making normal runs fast and efficient.

### What does Cars.com Vehicle Listings Scraper do?

Cars.com Vehicle Listings Scraper turns public inventory pages into one normalized row per vehicle.

It supports:

- 🚗 Cars.com search-result URLs with existing filters
- 🔎 Individual `/vehicledetail/` URLs
- 📄 Automatic pagination across search results
- 🆔 Stable listing-ID deduplication
- 💵 Price, MSRP, mileage, and price-history extraction
- 📷 Full-resolution vehicle photo galleries
- 🏪 Dealer identity, address, rating, phone, and website
- 🧰 Features, specifications, colors, drivetrain, and fuel data
- 🛡️ Available accident, ownership, title, and history-report signals

Use the small prefilled example to see useful data in a few seconds.

### Who is it for? Cars.com scraper users

**Dealership and inventory teams**

- Monitor competing dealer inventory by ZIP, make, and model.
- Detect newly listed or removed vehicles.
- Compare prices, mileage, trim, and days listed.

**Automotive pricing analysts**

- Build regional price samples from repeatable searches.
- Track price changes using stable listing IDs.
- Compare list price, MSRP, and available market-price signals.

**Marketplaces and data engineers**

- Feed normalized vehicle records into a warehouse.
- Export to JSON, CSV, Excel, XML, or RSS.
- Trigger downstream pipelines with schedules and webhooks.

**Car buyers, flippers, and researchers**

- Find vehicles matching precise Cars.com filters.
- Review VINs, photos, features, and history flags at scale.
- Build watchlists for price drops and fresh inventory.

### Why use this Cars.com vehicle data extractor?

- ✅ **No Cars.com account required** — it reads public listing data.
- ✅ **No browser overhead** — structured HTTP requests keep runs lightweight.
- ✅ **Search and direct lookup** — use either search-result or vehicle-detail URLs.
- ✅ **Rich details** — fetch photos, dealer data, features, specs, and histories.
- ✅ **Stable monitoring key** — deduplicate and diff by `listingId`.
- ✅ **User-controlled limits** — cap volume and detail concurrency.
- ✅ **Apify-native** — schedule runs, call the API, and connect integrations.
- ✅ **Consistent schema** — unavailable detail fields remain nullable instead of disappearing.

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

| Group | Example fields |
|---|---|
| Identity | `listingId`, `vin`, `stockNumber`, `stockType`, `url` |
| Vehicle | `year`, `make`, `model`, `trim`, `title`, `bodyStyle` |
| Pricing | `price`, `msrp`, `dealBadge`, `predictedPriceDifference` |
| Usage | `mileage`, `listedDate`, `sourceUpdatedAt` |
| Powertrain | `engine`, `transmission`, `drivetrain`, `fuelType`, `mpg` |
| Appearance | `exteriorColor`, `interiorColor`, `photos`, `photoCount` |
| Equipment | `features`, `specs` |
| History | `noAccidents`, `singleOwner`, `cleanTitle`, `personalUseOnly` |
| Dealer | name, address, ZIP, phone, website, rating, coordinates |
| Ratings | consumer rating, review count, recommendation percentage |
| Provenance | `searchUrl`, `scrapedAt`, canonical Cars.com URL |

A listing exposes only the fields supplied by Cars.com and its seller.

### How much does it cost to scrape Cars.com listings?

This Actor uses **pay-per-event pricing**.

You pay a small run-start fee plus one vehicle event for each unique dataset row.

| Apify plan | Vehicle price |
|---|---:|
| Free | $0.00016164 |
| Starter / Bronze | $0.00014056 |
| Scale / Silver | $0.00010964 |
| Business / Gold | $0.000084335 |

Higher plans receive additional volume discounts.

Example before final platform cost calibration:

| Workload | Approximate event charge |
|---|---:|
| 10 vehicles | $0.0165 including $0.005 start |
| 100 vehicles | $0.105 including $0.005 start |
| 1,000 vehicles | $1.005 including $0.005 start |

Your Apify Free plan includes platform credits that can cover many small evaluations.

### How to scrape Cars.com vehicle listings

1. Open a search on [Cars.com](https://www.cars.com/).
2. Apply the make, model, ZIP, radius, price, year, and other filters you need.
3. Copy the resulting `/shopping/results/` URL.
4. Open this Actor on Apify.
5. Paste the URL into **Cars.com URLs**.
6. Set a small **Maximum vehicle listings** value for your first run.
7. Keep **Fetch full vehicle details** enabled for rich output.
8. Click **Start**.
9. Preview the dataset or export it in your preferred format.

You can also paste a direct `/vehicledetail/{listing-id}/` URL for one vehicle.

### Input parameters

| Parameter | Type | Default | Description |
|---|---|---:|---|
| `startUrls` | array | required | Cars.com search-result or vehicle-detail URLs |
| `fetchDetails` | boolean | `true` | Enrich cards with full listing details |
| `maxItems` | integer | `10` | Maximum unique vehicles across all URLs |
| `maxConcurrency` | integer | `3` | Parallel detail requests, from 1 to 10 |
| `proxyConfiguration` | object | direct | Optional Apify or custom proxy settings |

Search URL example:

```json
{
  "startUrls": [
    {
      "url": "https://www.cars.com/shopping/results/?stock_type=used&makes[]=toyota&models[]=toyota-camry&maximum_distance=20&zip=10001"
    }
  ],
  "fetchDetails": true,
  "maxItems": 25,
  "maxConcurrency": 3
}
````

Direct vehicle example:

```json
{
  "startUrls": [
    {
      "url": "https://www.cars.com/vehicledetail/2efe758d-c3d1-42e3-868c-bee54a86a014/"
    }
  ],
  "fetchDetails": true,
  "maxItems": 1
}
```

### Output example

```json
{
  "source": "cars.com",
  "searchUrl": "https://www.cars.com/shopping/results/?stock_type=used&zip=10001",
  "listingId": "2efe758d-c3d1-42e3-868c-bee54a86a014",
  "vin": "4T1DBADK9TU549864",
  "stockType": "Used",
  "title": "2026 Toyota Camry SE",
  "year": 2026,
  "make": "Toyota",
  "model": "Camry",
  "trim": "SE",
  "price": 33055,
  "mileage": 2260,
  "bodyStyle": "Sedan",
  "drivetrain": "All-wheel Drive",
  "fuelType": "Gasoline",
  "noAccidents": true,
  "cleanTitle": true,
  "dealerName": "New Rochelle Toyota",
  "dealerCity": "New Rochelle",
  "dealerState": "NY",
  "dealerRating": 4.1,
  "photoCount": 53,
  "url": "https://www.cars.com/vehicledetail/2efe758d-c3d1-42e3-868c-bee54a86a014/",
  "scrapedAt": "2026-07-14T02:05:37.740Z"
}
```

The actual record contains more fields than this shortened example.

### Search-card mode versus full details

Set `fetchDetails` to `true` for the richest record.

This adds:

- full photos
- equipment and key specifications
- dealer contact and location data
- price history
- vehicle-history signals
- consumer ratings

Set it to `false` when you need a fast inventory snapshot with core identity, price, mileage, colors, preview photos, and seller ZIP.

Detail-only fields are then returned as `null` or empty collections.

### Tips for reliable Cars.com extraction

- 🎯 Start with a narrow ZIP, radius, make, and model search.
- 🧪 Test 5–10 vehicles before increasing `maxItems`.
- 🔁 Reuse the exact same search URL for monitoring comparisons.
- 🆔 Compare records by `listingId`, not by title.
- 🕒 Sort by newest listed on Cars.com before copying the URL when tracking arrivals.
- ⚙️ Keep detail concurrency between 2 and 5 for normal workloads.
- 🌎 Enable a US proxy only if your network cannot reach the direct data route.
- 🧹 Expect inventory to change between runs as cars are listed or sold.

### Schedule an inventory or price monitor

Apify schedules can rerun this scraper hourly, daily, or weekly.

A practical monitoring workflow is:

1. Save one filtered Cars.com search URL.
2. Run it on a fixed schedule.
3. Store each dataset or merge rows into a database.
4. Compare `listingId`, `price`, `sourceUpdatedAt`, and `listedDate`.
5. Alert when a listing appears, disappears, or changes price.

Use webhooks to notify your service as soon as a run succeeds.

### Integrations for automotive workflows

**Cars.com → Google Sheets**

Append current inventory rows for a pricing analyst or acquisition team.

**Cars.com → Slack or Discord**

Post alerts for fresh listings under a target price or new price drops.

**Cars.com → Make or Zapier**

Filter records by VIN, mileage, CPO status, or dealer and route qualified vehicles.

**Cars.com → a data warehouse**

Load scheduled snapshots into BigQuery, Snowflake, PostgreSQL, or another analytics store.

**Cars.com → webhook service**

Start VIN decoding, valuation, CRM, or marketplace ingestion after each run.

### API usage with Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/cars-com-vehicle-listings-scraper').call({
  startUrls: [{ url: 'https://www.cars.com/shopping/results/?stock_type=used&zip=10001&maximum_distance=20' }],
  fetchDetails: true,
  maxItems: 20,
});

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

### Use the Apify API with Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/cars-com-vehicle-listings-scraper').call(run_input={
    'startUrls': [{'url': 'https://www.cars.com/shopping/results/?stock_type=used&zip=10001&maximum_distance=20'}],
    'fetchDetails': True,
    'maxItems': 20,
})

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

### Use the Apify API with cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~cars-com-vehicle-listings-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "startUrls": [{"url": "https://www.cars.com/shopping/results/?stock_type=used&zip=10001&maximum_distance=20"}],
    "fetchDetails": true,
    "maxItems": 20
  }'
```

Poll the returned run ID or use a webhook for completion.

### Use Cars.com data with AI agents via MCP

This Actor can be exposed to Claude Code, Claude Desktop, Cursor, or VS Code through the hosted [Apify MCP server](https://docs.apify.com/platform/integrations/mcp).

For Claude Code:

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/cars-com-vehicle-listings-scraper"
```

For Claude Desktop, Cursor, or VS Code:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/cars-com-vehicle-listings-scraper"
    }
  }
}
```

Example prompts:

- “Use `automation-lab/cars-com-vehicle-listings-scraper` to find used Toyota Camrys near 10001 under $30,000.”
- “Extract this Cars.com vehicle URL and summarize its VIN, price history, features, and dealer rating.”
- “Compare today’s Cars.com dataset with yesterday’s and list new vehicles and price drops.”

OAuth connects the MCP server to your Apify account on first use.

### Data quality and field availability

Cars.com listings are supplied by dealerships and private sellers.

That means some fields vary by listing.

For example:

- used vehicles may expose history signals that new vehicles do not
- dealer listings usually contain richer contact information
- photos and feature lists depend on seller uploads
- MSRP may be absent or zero for some used inventory
- price-history records exist only when Cars.com exposes changes

The Actor preserves a consistent shape and uses nullable fields when source data is unavailable.

### Legality: is it legal to scrape Cars.com?

Scraping publicly available web data is generally lawful in many jurisdictions, but the exact rules depend on your location and use case.

This Actor does not log in, bypass account permissions, or access private user data.

Use it responsibly:

- collect only data you need
- respect applicable laws and contractual obligations
- avoid personal-data misuse
- follow GDPR, CCPA, and other privacy rules where applicable
- consult legal counsel for regulated or high-risk use cases

This independent Actor is not affiliated with, endorsed by, or sponsored by Cars.com or Cars Commerce.

### FAQ: frequently asked questions

**Do I need a Cars.com account or API key?**

No. The Actor uses public structured listing data and does not require Cars.com credentials.

**How fast is the scraper?**

Core search cards arrive in pages of up to 24. Full detail mode adds one lightweight request per vehicle and processes several concurrently.

**Why are some fields null?**

The seller or Cars.com may not provide that attribute. Disable full details only if you intentionally want a lighter search-card record.

**Why did my search return fewer vehicles than yesterday?**

Cars.com inventory changes continuously as vehicles are added, sold, removed, or moved outside your filters.

**Why did the run reject my URL?**

Use a `cars.com/shopping/results/` URL or a `cars.com/vehicledetail/{uuid}/` URL. Home pages and editorial pages are not listing inputs.

**Can I scrape multiple searches in one run?**

Yes. Add multiple URLs. The Actor deduplicates repeated vehicles by stable listing ID and applies one global `maxItems` limit.

**Can I use my Cars.com sort order?**

Yes. Keep the sort parameter in the copied search URL. Unsupported source-side sort values fall back to Cars.com's default ranking.

**How does this compare with a browser scraper?**

The Actor reads structured data directly, avoiding page rendering and visual-selector breakage. This is faster and uses less memory than a browser-first approach.

### Related automotive scrapers and tools

Explore related Actors from Automation Lab:

- [AutoTempest Car Listings Scraper](https://apify.com/automation-lab/autotempest-car-listings-scraper)
- [Autotrader Canada Vehicle Listings Scraper](https://apify.com/automation-lab/autotrader-canada-vehicle-listings-scraper)
- [Autohero Cars Scraper](https://apify.com/automation-lab/autohero-cars-scraper)
- [BOVAG Vehicle Listings Scraper](https://apify.com/automation-lab/bovag-vehicle-listings-scraper)
- [Bring a Trailer Auctions Scraper](https://apify.com/automation-lab/bringatrailer-auctions-scraper)
- [NHTSA Vehicle Complaints Scraper](https://apify.com/automation-lab/nhtsa-vehicle-complaints-scraper)
- [RockAuto Parts Catalog Scraper](https://apify.com/automation-lab/rockauto-parts-catalog-scraper)

Use Cars.com Vehicle Listings Scraper when your workflow specifically needs current Cars.com US inventory and its source-specific details.

### Support and responsible use

If a valid listing URL fails, include the URL type, approximate run time, and run ID in an Apify issue.

Do not include private credentials or personal information in issue reports.

Start with a small reproducible input so the behavior can be investigated quickly.

For source changes, the Actor’s structured-query implementation can be updated without changing your dataset contract.

# Actor input Schema

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

Add Cars.com /shopping/results/ search URLs or /vehicledetail/ URLs. Search filters in each URL are preserved.

## `fetchDetails` (type: `boolean`):

Enrich every search card with full photos, specifications, features, dealer data, price history, and vehicle-history signals.

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

Stop after this many unique vehicles across all input URLs.

## `maxConcurrency` (type: `integer`):

Number of vehicle-detail API requests processed together. Keep this conservative for stable runs.

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

Optional Apify Proxy or custom proxy settings. Direct API access is used by default; enable a US proxy if your network requires one.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.cars.com/shopping/results/?stock_type=used&makes[]=toyota&models[]=toyota-camry&maximum_distance=20&zip=10001"
    }
  ],
  "fetchDetails": true,
  "maxItems": 5,
  "maxConcurrency": 2,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `vehicleListings` (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": [
        {
            "url": "https://www.cars.com/shopping/results/?stock_type=used&makes[]=toyota&models[]=toyota-camry&maximum_distance=20&zip=10001"
        }
    ],
    "fetchDetails": true,
    "maxItems": 5,
    "maxConcurrency": 2,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/cars-com-vehicle-listings-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": [{ "url": "https://www.cars.com/shopping/results/?stock_type=used&makes[]=toyota&models[]=toyota-camry&maximum_distance=20&zip=10001" }],
    "fetchDetails": True,
    "maxItems": 5,
    "maxConcurrency": 2,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/cars-com-vehicle-listings-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 '{
  "startUrls": [
    {
      "url": "https://www.cars.com/shopping/results/?stock_type=used&makes[]=toyota&models[]=toyota-camry&maximum_distance=20&zip=10001"
    }
  ],
  "fetchDetails": true,
  "maxItems": 5,
  "maxConcurrency": 2,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call automation-lab/cars-com-vehicle-listings-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Cars.com Vehicle Listings Scraper",
        "description": "Extract Cars.com VINs, prices, mileage, photos, specifications, history signals, and dealer details for inventory monitoring and market analysis.",
        "version": "0.1",
        "x-build-id": "KJnYcEnMlBODZ6rvD"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~cars-com-vehicle-listings-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-cars-com-vehicle-listings-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/automation-lab~cars-com-vehicle-listings-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-cars-com-vehicle-listings-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/automation-lab~cars-com-vehicle-listings-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-cars-com-vehicle-listings-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": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "🚗 Cars.com URLs",
                        "type": "array",
                        "description": "Add Cars.com /shopping/results/ search URLs or /vehicledetail/ URLs. Search filters in each URL are preserved.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "fetchDetails": {
                        "title": "Fetch full vehicle details",
                        "type": "boolean",
                        "description": "Enrich every search card with full photos, specifications, features, dealer data, price history, and vehicle-history signals.",
                        "default": true
                    },
                    "maxItems": {
                        "title": "Maximum vehicle listings",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Stop after this many unique vehicles across all input URLs.",
                        "default": 10
                    },
                    "maxConcurrency": {
                        "title": "Detail concurrency",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Number of vehicle-detail API requests processed together. Keep this conservative for stable runs.",
                        "default": 3
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional Apify Proxy or custom proxy settings. Direct API access is used by default; enable a US proxy if your network requires one.",
                        "default": {
                            "useApifyProxy": false
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```