# Used Car Listings Scraper — US Cars For Sale (`prodiger/used-car-listings-scraper`) Actor

Search US used-car listings by make, model, year, price, mileage, and state via the official vehicles.dev API. One row per car with VIN, price, mileage, dealer, and location. No scraping, no proxies, no CAPTCHAs. Pay-per-result.

- **URL**: https://apify.com/prodiger/used-car-listings-scraper.md
- **Developed by:** [Arnas](https://apify.com/prodiger) (community)
- **Categories:** E-commerce, Lead generation
- **Stats:** 2 total users, 1 monthly users, 50.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.

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

Scrape **US used-car listings** — cars for sale by make, model, year, price, mileage, and state — with a **VIN on every row**. Powered by the official **[vehicles.dev](https://vehicles.dev)** API, so there's **no scraping, no proxies, no CAPTCHAs, and nothing that breaks** when a car marketplace changes its site.

### What does Used Car Listings Scraper do?

**Used Car Listings Scraper** searches normalized used-car inventory across sources like Autolist, TrueCar, and iSeeCars through the [vehicles.dev](https://vehicles.dev) `listings` API and returns **one clean row per vehicle**. Each listing includes the **VIN, year, make, model, trim, price, mileage, condition, dealer name, city/state, coordinates, days on market**, and a link to the original listing page.

Filter by make, model, year range, price range, max mileage, state, condition (used / new / CPO), seller type, and data quality — then set how many results you want. Run one search or **batch many in a single run**. Results download as **JSON, CSV, Excel, or HTML**, or stream live via the [Apify API](https://docs.apify.com/api/v2). Run it on demand or [schedule it](https://docs.apify.com/platform/schedules) to track the used-car market over time — with API access, scheduling, and monitoring included on the Apify platform.

### Why use Used Car Listings Scraper?

- **Official API, not a fragile scraper** — [vehicles.dev](https://vehicles.dev) is a licensed data source, so results are clean JSON that don't break when a marketplace redesigns. No proxies or CAPTCHAs to manage.
- **VIN on every row** — decode, match, and dedupe downstream with a real VIN, not a guessed one.
- **Server-side filters** — make, model, year, price, mileage, state, condition, seller type, source, and data quality are all applied at the API, so you only pay for the rows you want.
- **Pages past any single-response cap** — automatically iterates `limit`/`offset` up to your `maxItems`.
- **Run-level VIN dedup** — overlapping searches never emit (or bill) the same car twice.
- **Batch searches** — price whole model lists (e.g. Camry + Civic + Accord) in one run.

Common use cases: **used-car pricing & inventory tools**, **dealer competitive analysis**, **market and demand research**, **lead generation**, **arbitrage sourcing**, **auto lenders / insurers**, and **data science on the US car market**.

### How to use Used Car Listings Scraper

1. Click **Try for free** (or open the actor in your Apify Console).
2. Enter a **Make** and **Model** (e.g. `Toyota` / `Camry`) and any filters you want — year range, price range, max mileage, **State**.
3. Set **Max results** to how many listings to collect.
4. Click **Start**. Listings stream into the dataset as pages are fetched.
5. Download as **JSON / CSV / Excel**, or pull the dataset from the [Apify API](https://docs.apify.com/api/v2).

To run several searches at once, use the **Batch searches** field with a JSON array like `[{ "make": "Toyota", "model": "Camry" }, { "make": "Honda", "model": "Civic" }]` — each entry inherits your top-level filters.

### Input

| Field | Type | Description |
|-------|------|-------------|
| `make`, `model` | string | Vehicle make/model (case-sensitive). |
| `yearMin`, `yearMax` | int | Model-year range. |
| `priceMin`, `priceMax` | int | Price range (USD). |
| `mileageMax` | int | Maximum odometer reading. |
| `state` | string | 2-letter US state code. |
| `condition` | select | `used`, `new`, `cpo`, or any. |
| `sellerType` | select | `dealer`, `auction`, or any. |
| `source` | select | Restrict to one upstream source. |
| `sort` / `order` | select | Sort by price / miles / year / days on market, asc or desc. |
| `maxItems` | int | Max listings to save (`0` = unlimited). |
| `searches` | array | Batch: multiple filter objects in one run. |
| `apiKey` | string (secret) | Optional. Bring your own vehicles.dev key. |

### Output

Each dataset row is one listing:

```json
{
  "vin": "4T1BE32KX4U369954",
  "year": 2004,
  "make": "Toyota",
  "model": "Camry",
  "trim": "Standard",
  "body_style": "Sedan",
  "fuel": "Gasoline",
  "drivetrain": "FWD",
  "transmission": "Manual",
  "color": null,
  "price": 5794,
  "miles": 96287,
  "condition": "used",
  "seller_type": "dealer",
  "dealer_name": "University Kia",
  "city": "Waco",
  "state": "TX",
  "lat": 31.465128,
  "lng": -97.09254,
  "days_on_market": 0,
  "data_quality": 0.923,
  "vdp_url": "https://www.autolist.com/toyota-camry#vin=4T1BE32KX4U369954",
  "source": "autolist",
  "vin_valid": 1,
  "scrapedAt": "2026-08-15T10:49:38.000Z"
}
```

You can download the dataset in various formats such as JSON, HTML, CSV, or Excel.

#### Data fields

| Field | Meaning |
|-------|---------|
| `vin` / `vin_valid` | Vehicle VIN and whether it validated. |
| `price` / `miles` | Asking price (USD) and odometer. |
| `condition` / `title_status` | Listing condition and title status. |
| `seller_type` / `dealer_name` | Dealer vs auction, and the seller. |
| `city` / `state` / `lat` / `lng` | Listing location. |
| `days_on_market` | Days the listing has been live. |
| `data_quality` | Source confidence score (0–1). |
| `vdp_url` | Link to the original listing. |
| `source` | Upstream source (autolist, truecar, …). |

### How much does it cost?

Billing is **pay-per-result**: a small per-run start fee plus a charge for each listing written to the dataset ($0.50 per 1,000 listings). VIN deduplication means overlapping searches never double-bill, and failed pages cost nothing. Set `maxItems` to cap spend precisely.

### Tips & advanced options

- **Cap cost with `maxItems`** — the actor stops the moment your budget is hit, mid-page.
- **Narrow with filters** — a tight make/model/state/price query is cheaper and faster than a broad one.
- **Batch model lists** — use `searches` to sweep several models in one run; VINs are deduped across them.
- **Concurrency** — vehicles.dev rate-limits per account, so the default `maxConcurrency` of 5 suits the free tier; raise it with a higher-tier key.

### FAQ, disclaimers & support

**Is there a VIN on every listing?** Yes — and `vin_valid` tells you whether it passed validation. Set `validVin` to require only validated VINs.

**How fresh is the data?** Listings reflect vehicles.dev's crawl cadence; `days_on_market` and `scrapedAt` help you judge recency.

**Do I need a vehicles.dev account?** No — the actor is preconfigured. Advanced users can supply their own `apiKey` to run on their own quota.

**Something look off?** Use the **Issues** tab to report it. Custom fields or a tailored vehicle-data feed can be built on request.

*Data is provided by the official [vehicles.dev](https://vehicles.dev) API.*

# Actor input Schema

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

Vehicle make, e.g. `Toyota`. Case-sensitive (Title-Case). Leave empty for any.

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

Vehicle model, e.g. `Camry`. Case-sensitive. Leave empty for any.

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

Earliest model year to include.

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

Latest model year to include.

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

Lowest listing price to include.

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

Highest listing price to include.

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

Highest odometer reading to include.

## `state` (type: `string`):

2-letter US state code, e.g. `TX`. Leave empty for all states.

## `condition` (type: `string`):

Filter by listing condition.

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

Filter by seller type.

## `source` (type: `string`):

Restrict to one upstream listing source.

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

Result ordering field.

## `order` (type: `string`):

Ascending or descending order for the selected sort field.

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

Maximum number of listings to save. `0` = unlimited (the actor pages through all matching listings). With multiple `searches`, this budget is shared across them.

## `active` (type: `string`):

Whether to require currently-active listings.

## `sold` (type: `string`):

Whether to include (or restrict to) sold listings.

## `validVin` (type: `string`):

Whether to require a validated VIN.

## `minQuality` (type: `number`):

Only include listings whose `data_quality` is at least this value (0–1).

## `searches` (type: `array`):

Run several filtered searches in one run. Each entry is an object using the same filter keys (`make`, `model`, `state`, …) and inherits the top-level filters as defaults. `maxItems` is shared across all searches; results are deduplicated by VIN. Example: `[{ "make": "Toyota", "model": "Camry" }, { "make": "Honda", "model": "Civic" }]`.

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

How many searches to run in parallel. The vehicles.dev rate limit is per-account, so keep this at 5 on the free tier (higher on Pro/Scale).

## `maxRequestRetries` (type: `integer`):

Retry budget per API request for rate limits (429) and transient 5xx errors.

## `apiKey` (type: `string`):

Optional. The actor is preconfigured, so you can leave this blank. Supply your own vehicles.dev key (prefixed `vdev_`) to run against your own quota. Get one free at https://vehicles.dev.

## `customMapFunction` (type: `string`):

Optional JavaScript function body that transforms each listing before it is saved. Receives the item as `item` and must return the modified item. Example: `return { vin: item.vin, price: item.price, url: item.vdp_url };`

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

Optional. vehicles.dev is an official API (no anti-bot) with a per-account rate limit, so a proxy does not raise throughput. Off by default.

## Actor input object example

```json
{
  "make": "Toyota",
  "model": "Camry",
  "condition": "any",
  "sellerType": "any",
  "source": "any",
  "sort": "price",
  "order": "asc",
  "maxItems": 100,
  "active": "any",
  "sold": "any",
  "validVin": "any",
  "maxConcurrency": 5,
  "maxRequestRetries": 4,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `dataset` (type: `string`):

Scraped used-car listings — one row per vehicle.

# 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 = {
    "make": "Toyota",
    "model": "Camry"
};

// Run the Actor and wait for it to finish
const run = await client.actor("prodiger/used-car-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 = {
    "make": "Toyota",
    "model": "Camry",
}

# Run the Actor and wait for it to finish
run = client.actor("prodiger/used-car-listings-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 '{
  "make": "Toyota",
  "model": "Camry"
}' |
apify call prodiger/used-car-listings-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,prodiger/used-car-listings-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/Ezif3LBWJ9kDTTSmo/builds/8i1YIEGZIkjwjCRdg/openapi.json