# 🚘Autotrader car data 🇨🇦(💰1/1000) (`jordan-byte/autotrader-car-data-1-1000`) Actor

Canada's largest online marketplace for new and used cars, trucks, and SUVs. Search by city, by make and model, or hand it specific listing URLs, and get back clean, structured data for every matching vehicle: price, mileage, year, condition, seller details, photos, and more.

- **URL**: https://apify.com/jordan-byte/autotrader-car-data-1-1000.md
- **Developed by:** [Jordan Byte](https://apify.com/jordan-byte) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 66.7% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 results

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

🚗 Extract structured **vehicle listing data from [AutoTrader.ca](https://www.autotrader.ca)** — Canada's largest online marketplace for new and used cars, trucks, and SUVs. Search by city, by make and model, or hand it specific listing URLs, and get back clean, structured data for every matching vehicle: price, mileage, year, condition, seller details, photos, and more.

⚡ Built to run on the Apify platform, so you get scheduled runs, an API, webhooks, and integrations (Zapier, Make, Google Sheets, and 30+ others) out of the box — no server, browser, or maintenance required on your end.

### 🤔 Why use the AutoTrader.ca Car Scraper?

Manually browsing AutoTrader.ca doesn't scale if you need more than a handful of listings. This Actor is built for anyone who needs vehicle inventory data in bulk and on a schedule:

- 🏢 **Dealers & marketplaces** — track competitor pricing and inventory across the country or in a specific region.
- 📊 **Market researchers & analysts** — build pricing models, depreciation curves, or supply/demand reports for any make or model.
- 🔍 **Car shoppers & flippers** — get notified the moment a specific make/model/price combination hits the market.
- 📇 **Lead generation** — collect dealer and private-seller contact info attached to live listings.

Because it runs on Apify, you can schedule it to run daily or hourly, feed the results straight into a spreadsheet or database, and only pay for what you actually scrape.

### 🚀 How to use the AutoTrader.ca Car Scraper

1. Click **Try for free** (or **Start**) to open the Actor.
2. On the **Input** tab, either:
   - pick a **Location** (or leave it as "Canada-wide"), optionally narrow it by **Make**/**Model**, or
   - paste specific AutoTrader.ca listing URLs into **Specific listing URLs** to scrape only those.
3. Set a **Max items** limit (or leave it at 0 to collect as many matching listings as exist).
4. Click **Start** and wait for the run to finish.
5. Open the **Dataset** tab (or the **Output** tab) to preview, filter, and download your results as JSON, CSV, Excel, HTML, or XML.

No coding required — though everything here is also available through the [Apify API](https://docs.apify.com/api/v2) if you want to automate it.

### ⚙️ Input

All input options are configured through the **Input** tab in the Apify Console (or as a JSON object via the API). The main options:

| Field | Description |
| --- | --- |
| `location` | Search near a popular Canadian city, or "Canada-wide" to search the whole country. |
| `radiusKm` | Search radius around the chosen location, in kilometres. |
| `make` / `model` | Limit results to one make and, optionally, one model. Leave blank to include every make. |
| `condition` | New, used, or both. |
| `maxItems` | Stop after this many listings. Set to `0` for no limit — the Actor automatically broadens its search across makes and/or cities to keep finding new listings past a single search's own results cap. |
| `listingUrls` | Paste specific listing URLs to scrape exactly those vehicles instead of searching. |
| `scrapeListingDetails` | Fetch each listing's full page for complete data (equipment list, full description, vehicle history report link). Turn off for a faster, lighter scrape using only search-result data. |
| `useCache` | Reuse listings already scraped in a previous run instead of re-fetching them, so repeat/monitoring runs are faster and cheaper. On by default. |
| `sortBy` | Order results by relevance, price, distance, posting date, year, or mileage. |
| `proxyConfiguration` | Proxy servers used to fetch listings. Apify Proxy is enabled by default and recommended. |

See the Input tab for the complete list, including custom-location and advanced performance options.

Example input:

```json
{
  "location": "Toronto, ON",
  "make": "Ford",
  "model": "Bronco Sport",
  "condition": "used",
  "maxItems": 200,
  "scrapeListingDetails": true
}
```

### 📦 Output

Each scraped vehicle is saved as one item in the Actor's dataset. You can download the dataset in various formats such as JSON, HTML, CSV, or Excel.

Example output item:

```json
{
  "title": "2022 Ford Bronco Sport Outer Banks",
  "make": "Ford",
  "model": "Bronco Sport",
  "trim": "Outer Banks",
  "year": 2022,
  "condition": "Used",
  "price": 27488,
  "priceFormatted": "$ 27,488",
  "mileageKm": 37774,
  "transmission": "Automatic",
  "fuelType": "Gasoline",
  "bodyType": "SUV",
  "exteriorColor": "Black",
  "driveTrain": "4x4",
  "doors": 4,
  "equipment": ["Air conditioning", "Cruise control", "Heated Seats"],
  "description": "CARFAX Canada No Reported Accidents...",
  "images": ["https://..."],
  "carfaxReportUrl": "https://vhr.carfax.ca/?id=...",
  "location": { "city": "Toronto", "province": "ON", "postalCode": "M4M 2A5" },
  "seller": { "name": "Ford Downtown", "type": "Dealer", "phone": "647-947-8564" },
  "url": "https://www.autotrader.ca/offers/...",
  "scrapedAt": "2026-01-01T12:00:00.000Z"
}
```

### 🗂️ Data fields

| Field | Description |
| --- | --- |
| `title`, `make`, `model`, `trim`, `year` | Vehicle identification |
| `condition` | `New` or `Used` |
| `price`, `priceFormatted` | Listing price |
| `mileageKm` | Odometer reading, in kilometres |
| `transmission`, `fuelType`, `bodyType`, `driveTrain`, `exteriorColor`, `doors`, `seats`, `cylinders`, `horsepower` | Vehicle specifications |
| `equipment` | Flat list of features/options |
| `description` | Full seller description |
| `images` | Photo URLs |
| `carfaxReportUrl` | Link to the vehicle history report, when available |
| `location` | City, province, postal code, and distance from your search location |
| `seller` | Dealer/private seller name, type, and phone number |
| `url` | Link to the live listing |
| `scrapedAt` | Timestamp of when the item was scraped |

### 💰 Cost estimation

This Actor charges based on the Apify platform's standard compute-unit pricing for your plan — there's no separate per-item fee. A typical run scraping a few hundred listings with full details enabled uses a small fraction of a compute unit, well within the free tier for occasional use. Larger, unlimited runs (thousands of listings, full details) cost proportionally more compute time. To control cost:

- ✅ Set a specific **Max items** value instead of leaving it unlimited.
- ✅ Turn off **Scrape full listing details** if you only need the data already shown on search results (price, year, mileage, basic specs) — this roughly halves the number of requests.
- ✅ Leave **Reuse cached results across runs** on if you run this Actor repeatedly (e.g. daily) — previously-seen listings won't be re-fetched.

### 💡 Tips for better results

- Narrowing by **Location** and/or **Make** returns more relevant results faster than an unlimited, unfiltered nationwide run.
- AutoTrader.ca caps any single search view at roughly 4,000 results. When you leave **Make** blank or ask for more than that in one place, this Actor automatically splits the request across makes and/or nearby cities to keep collecting unique listings — this is expected behaviour, not an error, and you'll see it noted in the run log.
- For ongoing monitoring, schedule this Actor to run daily or hourly with **Reuse cached results across runs** enabled, and only look at the newest items in each run's dataset.

### ❓ FAQ

**Is this legal?** This Actor only accesses data that AutoTrader.ca already serves to any visitor's browser. You are responsible for using the scraped data in compliance with AutoTrader.ca's own Terms of Service and any applicable laws in your jurisdiction, particularly around reuse of dealer/seller contact information.

**Will this get blocked?** The Actor is built to run reliably against AutoTrader.ca's public pages. If you notice a drop in results, please open an issue — the site's markup can change over time and we monitor for that.

🐞 Found a bug or missing field? Please report it on the Actor's **Issues** tab so it can be fixed quickly.

# Actor input Schema

## `location` (type: `string`):

Search near a popular Canadian city, or choose "Canada-wide" to search the whole country. For a city not listed, use the custom location fields below instead.

## `radiusKm` (type: `integer`):

How far from the selected location to include listings. Only used when Location is not "Canada-wide".

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

Limit results to one make, e.g. "Ford", "Toyota", "BMW". Leave blank to scrape every make.

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

Limit results to one model within the chosen Make, e.g. "Bronco Sport". Ignored if Make is blank.

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

Which listings to include.

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

Configure the proxy servers used to fetch listings. Using Apify Proxy is recommended to keep the run reliable.

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

Stop after collecting this many listings. Set to 0 to collect as many as possible - the Actor will automatically broaden its search (across makes and/or cities) to keep going past a single search's own result limit.

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

Paste one or more AutoTrader.ca listing page URLs to scrape exactly those vehicles and skip searching entirely. When set, all search options above are ignored.

## `scrapeListingDetails` (type: `boolean`):

Visit each listing's own page for complete data (full description, equipment/features list, seller details, vehicle history report link). Turning this off returns only the data shown on the search results page, which is faster and uses fewer requests.

## `useCache` (type: `boolean`):

When enabled, listings already scraped in a previous run are reused instead of being fetched again, making repeat/monitoring runs faster and cheaper. Turn off to force a fully fresh scrape every time.

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

Order in which matching listings are collected.

## `detailConcurrency` (type: `integer`):

How many listing pages to fetch at the same time. Higher is faster but more likely to trigger rate limiting.

## `customLocationLabel` (type: `string`):

For a city not in the Location dropdown: a short label (e.g. "Banff, AB") plus the latitude/longitude below.

## `customLatitude` (type: `number`):

Used together with Custom location label and longitude. Leave all three blank to use the Location dropdown instead.

## `customLongitude` (type: `number`):

Used together with Custom location label and latitude. Leave all three blank to use the Location dropdown instead.

## Actor input object example

```json
{
  "location": "Canada-wide (no location filter)",
  "radiusKm": 100,
  "make": "Ford",
  "condition": "all",
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "maxItems": 100,
  "scrapeListingDetails": true,
  "useCache": true,
  "sortBy": "relevance",
  "detailConcurrency": 5
}
```

# Actor output Schema

## `dataset` (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 = {
    "make": "Ford"
};

// Run the Actor and wait for it to finish
const run = await client.actor("jordan-byte/autotrader-car-data-1-1000").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": "Ford" }

# Run the Actor and wait for it to finish
run = client.actor("jordan-byte/autotrader-car-data-1-1000").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": "Ford"
}' |
apify call jordan-byte/autotrader-car-data-1-1000 --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,jordan-byte/autotrader-car-data-1-1000"
        }
    }
}

```

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/w4lqZiSasxbINFdfR/builds/O1miTwxWGlQYzU3rf/openapi.json