# Autotrader Scraper & API - US Cars, VIN, Price & Mileage (`s-r/autotrader-scraper`) Actor

Get US Autotrader car listings with VIN, price, mileage, dealer fees and specifications. Built for dealers and researchers tracking vehicle prices and inventory. Export JSON, CSV or Excel.

- **URL**: https://apify.com/s-r/autotrader-scraper.md
- **Developed by:** [SR](https://apify.com/s-r) (community)
- **Categories:** E-commerce, Business
- **Stats:** 1 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 run start fees

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

## Autotrader API - US Car Listings Scraper

This Autotrader API turns US Autotrader search pages into structured car listings for dealer price monitoring, vehicle research and inventory analysis. Get VIN, asking price, mileage, dealer fees, specifications and days on site in a dataset you can export or collect through the Apify API.

The actor is an independent data collection tool, operated by ShoppingResult. Its Store address remains `s-r/autotrader-scraper`. It reads the United States marketplace at autotrader.com; Auto Trader UK and Canadian AutoTrader are separate sources.

### How to use the Autotrader API

1. Open an Autotrader search for your target location and vehicle category.
2. Apply the make, model, price, mileage, radius and condition filters you need, then copy the search address.
3. Paste that address into `search_url`, choose your maximum number of listings and start the actor.
4. Open the dataset or export it as JSON, CSV or Excel. Use `listing_id` to identify an advertisement and `vin` to join records for the same physical vehicle.

The actor follows subsequent pages automatically and removes repeated listing ids. A large search uses the same three input settings as a small one. The requested limit is a maximum, and collection stops after 25 source pages or when that maximum is reached. Available inventory and interrupted pages can reduce the delivered total.

Search pages can include promoted or recommended vehicles alongside direct matches. Those listings remain in the output, preserving the actor's existing behaviour. If your analysis requires strict price, make or condition criteria, check the returned fields and filter your dataset accordingly.

### Input reference

All existing input names and defaults remain available:

| Field | JSON type | Default and behaviour |
|---|---|---|
| `search_url` | string | An Autotrader search URL. The Run form is prefilled with Seattle, all cars. There is no API default: supply the URL explicitly when starting a run through the API. |
| `limit` | integer | Default `100`, range `1` to `2000`. Maximum listings requested; available inventory and the page limit still apply. |
| `retries` | integer | Default `4`, range `1` to `8`. Maximum attempts for a page before its failure is reported. |

Make, model and regional settings belong in the search URL. There are no separate dealer-contact, vehicle-history or detail-enrichment input switches.

The following input was used for the captured Seattle response illustrated below on 9 October 2026. It requests the maximum volume; it does not promise 2000 results:

```json
{
  "search_url": "https://www.autotrader.com/cars-for-sale/all-cars/seattle-wa",
  "limit": 2000,
  "retries": 8
}
```

For routine monitoring, choose a limit appropriate to the inventory you need. Keep the same search URL between scheduled runs so that changes in filters do not look like changes in the market.

### Output: one record per vehicle listing

Each dataset row represents a unique listing. All 28 original dataset fields keep their names and JSON types, including nested body-style objects. Missing values remain `null`; a missing price, fee or mileage reading is not replaced with zero.

| Field | JSON type | Meaning |
|---|---|---|
| `listing_id` | string | Source advertisement identifier. |
| `vin` | string or null | Vehicle Identification Number, uppercased and checked for the 17-character VIN format. |
| `title` | string or null | Listing title. |
| `year` | integer or null | Vehicle model year. |
| `make`, `model`, `trim` | string or null | Vehicle make, model and trim. |
| `price` | number or null | Advertised asking price, excluding separately reported dealer fees. |
| `currency` | string | `USD`. |
| `dealer_fees` | number or null | Sum of fees declared by the listing. |
| `mileage` | integer or null | Odometer reading in miles. |
| `engine`, `transmission`, `drive_type`, `fuel_type` | string or null | Listed vehicle specifications. |
| `body_styles` | array or null | Body-style objects; `body_styles[].code` and `body_styles[].name` remain strings. |
| `doors` | string or null | Listed door count, retained as text. |
| `exterior_color`, `interior_color` | string or null | Exterior and interior colours. |
| `listing_type` | string or null | Source condition, such as `NEW`, `USED` or `CERTIFIED`. |
| `days_on_site` | integer or null | Listing age as reported by the source. |
| `is_reduced_price`, `is_newly_listed` | boolean | Source price-reduction and recent-listing flags. |
| `has_special_offer`, `has_leather_seats` | boolean | Source offer and equipment flags. |
| `image` | string or null | First listing image URL. |
| `url` | string | Autotrader vehicle listing link. |
| `position` | integer | Consecutive position, starting at 1, in the delivered dataset. |

Additional fields are `brand` (the `make` value), `condition` (the `listing_type` value), `image_url` (the `image` value), `country` (`US`), `source` (`autotrader-scraper`) and `fetched_at` (the search's UTC collection timestamp). Existing integrations can continue using `make`, `listing_type` and `image`.

#### Real output example

This is the complete first vehicle row from the captured Seattle response on 9 October 2026. It is a historical observation, rather than a promise that this advertisement or price is still available:

```json
{
  "listing_id": "764719862",
  "vin": "1GNSKBE05BR389327",
  "title": "Used 2011 Chevrolet Tahoe LT",
  "year": 2011,
  "make": "Chevrolet",
  "model": "Tahoe",
  "trim": "LT",
  "price": 5450,
  "currency": "USD",
  "dealer_fees": null,
  "mileage": 193000,
  "engine": "8-Cylinder",
  "transmission": "Automatic",
  "drive_type": "AWD4WD",
  "fuel_type": "Flexible Fuel",
  "body_styles": [
    {
      "code": "SUV",
      "name": "Sport Utility"
    }
  ],
  "doors": "4",
  "exterior_color": "Black",
  "interior_color": "Black",
  "listing_type": "USED",
  "days_on_site": 335,
  "is_reduced_price": false,
  "is_newly_listed": false,
  "has_special_offer": false,
  "has_leather_seats": true,
  "image": "https://assets.cai-media-management.com/ps-vehicle-media/0721909d-cec1-4a72-8cf0-43b3d1a73ab9.jpg",
  "url": "https://www.autotrader.com/cars-for-sale/vehicle/764719862",
  "position": 1,
  "source": "autotrader-scraper",
  "fetched_at": "2026-10-09T19:22:02.867Z",
  "country": "US",
  "brand": "Chevrolet",
  "condition": "USED",
  "image_url": "https://assets.cai-media-management.com/ps-vehicle-media/0721909d-cec1-4a72-8cf0-43b3d1a73ab9.jpg"
}
```

#### Output and run summary

The `summary` key-value record reports `listingsReturned`, `pagesFetched`, `withVin`, `withPrice`, `withMileage`, `reducedPrice` and `errorCount`. It also identifies the source through `servedBy`. If Autotrader cannot serve the initial search, the actor can read the corresponding Kelley Blue Book inventory; listing ids, VINs and Autotrader vehicle links retain their meaning. Conditional fields such as `autotraderRefusal` and `fallbackNote` explain that fallback, and an unsuccessful search can include `refusal`, `outcome` and `reason`.

An `errors` record appears when a page fails. A page without usable listings can be reported as `no_listings`. Earlier delivered rows remain available if a later page fails. A search with no usable output or a source-access failure finishes successfully with an empty dataset and an explanation in the run records. Empty output incurs no listing fee.

### Fields worth knowing about

**VIN identifies one physical car.** Use it to follow a vehicle across dealers, sources and repeated snapshots. A listing can omit its VIN. Values outside the 17-character VIN format, including the excluded letters I, O and Q, become `null`. Format checking does not verify ownership, vehicle history or a VIN checksum.

**Dealer fees are separate from price.** `dealer_fees: null` means no fees were declared in the source data. It does not mean the final transaction has no fees. The sum of a non-null price and declared fees helps compare advertised costs, but does not include every possible tax or charge.

**Listing age and price flags support monitoring.** `days_on_site` describes the source's listing age. `is_reduced_price` is the source's flag, rather than a price history computed by this actor. To measure your own price changes, save successive datasets and join them on VIN or listing id.

Prices are advertised US dollar amounts, rather than transaction prices. Mileage stays in miles. New vehicles can legitimately show delivery mileage above zero.

### Use cases for dealers, researchers and developers

- **Dealer price monitoring:** compare repeated snapshots for the same VIN, including advertised price reductions and declared fees.
- **Local market pricing:** group listings by make, model, year, mileage and region to compare similar stock. Review promoted or recommended rows before applying strict search criteria.
- **Inventory ageing:** combine `days_on_site`, condition and price flags to identify listings that have remained advertised for longer.
- **Total advertised cost comparison:** examine `price` and `dealer_fees` together while retaining the distinction between unknown and zero fees.
- **Specification analysis:** filter collected rows by fuel, transmission, drive type, body style, equipment and colours.
- **Recurring data feeds:** schedule the actor in Apify and collect datasets through its API for spreadsheets, dashboards or your own inventory application.

### Comparison with other Autotrader data tools

Choose a tool according to the records your workflow needs:

| Tool or approach | Published scope | Fit of this actor |
|---|---|---|
| Manual browsing and copying | Individual search and vehicle pages | Collects a structured, deduplicated dataset for repeated analysis. |
| [epctex Autotrader Scraper](https://apify.com/epctex/autotrader-scraper) | Search and listing-detail URLs, with optional reviews | Uses one search URL and preserves the existing flat listing fields. |
| [memo23 AutoTrader.com Scraper](https://apify.com/memo23/autotrader-com-scraper) | Search and vehicle inputs, dealer records and optional vehicle-page enrichment | Focuses on VIN, asking price, mileage, fees and search-page specifications. |
| Auto Trader UK or Canadian AutoTrader tools | Separate country marketplaces and schemas | Covers the United States, with USD prices and mileage in miles. |

The competitor scope above comes from their Store documentation. This actor has no dealer phone or address output, vehicle-history report, financing terms or monthly-payment estimate. Use the VIN with an appropriate separate service when your workflow needs history or additional vehicle information. It also has no built-in price-history dataset; history comes from the snapshots you retain.

### Pricing

The existing price remains **$0.001 per run plus $0.002 per delivered listing**. The `run_start` event is charged once, including an invalid or empty search. The `listing` event counts only listings actually delivered to the dataset. Automatically collecting further pages does not add another run fee.

Users without a paid Apify plan receive at most ten listings per run. Those listings use the same run and listing prices; the cap limits delivery. Paid-plan users retain the requested limit up to 2000, subject to available inventory and the 25-page maximum. Check the actor's Pricing tab for the current Apify price display before starting a run.

### FAQ

#### Is this an official Autotrader API?

No. This is ShoppingResult's independent Autotrader Scraper, accessed through Apify. It collects public US search listings. It does not provide dealer-account access, listing publication or the official Auto Trader UK partner API.

#### Does this scrape the United States or Auto Trader UK?

It reads US Autotrader searches and reports USD prices and mileage in miles. Auto Trader UK and Canadian AutoTrader are separate sources with different data contracts.

#### Will every listing have a VIN and price?

No. Either value can be missing. Missing data stays `null`, and a VIN outside the expected 17-character format is returned as `null`. The summary reports VIN, price and mileage coverage.

#### Why can the returned total be lower than the requested limit?

The limit is a maximum. Pages can overlap, inventory can change during collection, a later page can fail, and the actor stops after 25 pages. Each listing id is delivered once. Check the summary and errors records when a search is interrupted.

#### Are all delivered vehicles strict matches for my filters?

Search pages can carry recommendations and promoted listings. The actor preserves those records alongside other inventory. Apply your exact criteria to the returned values when your analysis requires a strict subset.

#### Can I start a run without supplying a search URL?

The Run form provides a Seattle search as its prefill. An API request does not receive that URL as a default. Supply `search_url` explicitly; missing input gives an empty run with a reason in the run records and the existing start fee.

#### Can I run this on a schedule and collect results through an API?

Yes. Create an Apify task with your search URL and settings, schedule it, and retrieve each run's dataset through the Apify API. Save the collection timestamp with your snapshots and use VIN or listing id for comparisons over time.

# Actor input Schema

## `search_url` (type: `string`):

An Autotrader search page, for example https://www.autotrader.com/cars-for-sale/all-cars/seattle-wa. Apply make, model, price and mileage filters on Autotrader first and paste the resulting address.

## `limit` (type: `integer`):

How many listings to return. Autotrader returns roughly 25 to 50 per page.

## `retries` (type: `integer`):

Retries with backoff before a page is reported as an error. Each retry uses a fresh exit IP.

## Actor input object example

```json
{
  "search_url": "https://www.autotrader.com/cars-for-sale/all-cars/seattle-wa",
  "limit": 100,
  "retries": 4
}
```

# Actor output Schema

## `listings` (type: `string`):

One row per car listing.

## `summary` (type: `string`):

Counts and coverage of VIN, price and mileage.

## `errors` (type: `string`):

Failures with a code and a redacted message.

# 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 = {
    "search_url": "https://www.autotrader.com/cars-for-sale/all-cars/seattle-wa",
    "limit": 100,
    "retries": 4
};

// Run the Actor and wait for it to finish
const run = await client.actor("s-r/autotrader-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 = {
    "search_url": "https://www.autotrader.com/cars-for-sale/all-cars/seattle-wa",
    "limit": 100,
    "retries": 4,
}

# Run the Actor and wait for it to finish
run = client.actor("s-r/autotrader-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 '{
  "search_url": "https://www.autotrader.com/cars-for-sale/all-cars/seattle-wa",
  "limit": 100,
  "retries": 4
}' |
apify call s-r/autotrader-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,s-r/autotrader-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/X6jlybwy6Eq9zYNU7/builds/8wMvVLsuXK5FGFNTI/openapi.json