# AutoTrader.ca Scraper — Cars, Price, Mileage & Dealer (`khadinakbar/autotrader-ca-scraper`) Actor

Scrape Canadian vehicle listings from AutoTrader.ca by search URL, structured filters, or direct listing URLs. Returns price, specs, mileage, dealer contact. MCP-ready.

- **URL**: https://apify.com/khadinakbar/autotrader-ca-scraper.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** E-commerce, Lead generation, MCP servers
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 1,000 listing scrapeds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

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

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

## AutoTrader.ca Scraper — Cars, Price, Mileage & Dealer Contact

Scrape vehicle listings from **AutoTrader.ca**, Canada's largest car marketplace. Search by make, model, province, city, price, mileage and condition — or paste search URLs and individual listing URLs — and get back one clean, structured record per vehicle with price, full specs, mileage, location and **dealer phone number**.

Built HTTP-only against the site's embedded data layer, so it is fast, cheap and reliable. **MCP-ready** for AI agents (Claude, ChatGPT, Gemini).

### What you get

| Field | Example |
|---|---|
| `make` / `model` / `trim` | BMW / X5 / xDrive40i |
| `year` | 2023 |
| `priceCad` / `priceFormatted` | 57697 / `$ 57,697` |
| `priceEvaluation` | 1 (AutoTrader price rating, when shown) |
| `mileageKm` / `mileageRaw` | 33014 / `33,014 km` |
| `transmission` / `fuel` / `powertrain` | Automatic / Gas/Electric Hybrid / hybrid |
| `condition` | New / Used |
| `dealerName` / `dealerPhone` | Carhub North York Chrysler / 877-232-2270 |
| `sellerType` | Dealer / Private |
| `city` / `province` / `postalCode` | THORNHILL / ON / L4J1V8 |
| `images` / `imageCount` / `coverImage` | full-resolution photo URLs |
| `url` | canonical listing URL |
| `scrapedAt` | ISO 8601 UTC timestamp |

Turn on **detail enrichment** to also get `bodyType`, `exteriorColor`, `driveTrain`, `numberOfDoors`, `numberOfSeats`, `cylinders`, `features[]`, full `description`, GPS coordinates (`latitude`/`longitude`), `dealerGoogleRating` and `vin` (when the dealer publishes it). Every record — enriched or not — already carries the dealer's street, city and postal code.

### When to use it

- **Dealers & resellers** — track competitor prices and inventory across a city, province, or specific make/model.
- **Market analysts** — pull large samples of asking prices, mileage and model-year distributions.
- **Lead generation** — every dealer listing carries a dealer name and phone number.
- **AI agents** — a single search query or URL in, structured JSON out — ideal as a tool call.

Not the right tool for: AutoTrader.com (USA), private VIN history reports, or auction/wholesale data.

### Input

Three ways to drive it — use whichever fits:

1. **Structured search** — set `make`, `model`, `province`, `city`, `priceMin`, `priceMax`, `yearMin`, `yearMax`, `minMileageKm`, `maxMileageKm`, `condition`, `sortBy`.
2. **Search result URLs** — paste full AutoTrader.ca search pages into `searchUrls`; the actor auto-paginates them.
3. **Direct listing URLs** — paste individual vehicle pages into `directUrls` for targeted, fully-detailed scrapes.

```json
{
  "make": "bmw",
  "model": "x5",
  "province": "ON",
  "city": "Toronto",
  "condition": "used",
  "priceMin": 20000,
  "priceMax": 60000,
  "yearMin": 2019,
  "maxMileageKm": 80000,
  "sortBy": "price_asc",
  "maxResults": 100,
  "enrichDetails": false
}
````

#### Notes on filters

- **Year filter** is applied to each vehicle's real **model year** after fetch (AutoTrader's own URL year filter is based on first-registration date, which Canadian listings rarely publish — so we filter the reliable field instead).
- A single AutoTrader search is **hard-capped at ~4,000 results (200 pages)**. To pull more, split into narrower searches (by make, price band, or city).
- `directUrls` are always scraped in full, regardless of `maxResults`.

### Output

One dataset record per vehicle, with flat, stable, semantic keys (see the table above). Null/empty fields are omitted. A `RUN_SUMMARY` is written to the key-value store with requested vs scraped counts and any warnings.

### Pricing (Pay Per Event)

| Event | Price |
|---|---|
| Actor start | $0.00005 |
| Listing scraped | **$0.004** per vehicle |
| Detail enriched | **+$0.002** per vehicle (only when `enrichDetails` is on, or for direct listing URLs) |

A typical 100-listing search costs about **$0.40**. With detail enrichment, about **$0.60**.

### Use from code

#### Apify JS client

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: 'YOUR_TOKEN' });
const run = await client.actor('khadinakbar/autotrader-ca-scraper').call({
    make: 'toyota', model: 'corolla', province: 'BC', city: 'Vancouver',
    condition: 'used', maxResults: 200,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python client

```python
from apify_client import ApifyClient
client = ApifyClient("YOUR_TOKEN")
run = client.actor("khadinakbar/autotrader-ca-scraper").call(run_input={
    "make": "ford", "model": "f-150", "province": "AB",
    "condition": "used", "maxResults": 100,
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["year"], item["make"], item["model"], item["priceFormatted"], item["dealerPhone"])
```

### MCP / AI agents

This actor is exposed in the Apify MCP server as `khadinakbar/autotrader-ca-scraper`. Point an MCP client at `https://mcp.apify.com?tools=khadinakbar/autotrader-ca-scraper` and the agent can call it directly: pass a make/model/location or a URL, get structured vehicle JSON back.

### FAQ

**Does it work for AutoTrader.com (USA)?** No — this is AutoTrader.ca (Canada) only.

**Does it return VIN?** Only on detail-enriched runs, and only when the dealer publishes it. Many Canadian listings omit VIN.

**Can I scrape a whole province?** Yes, but any single search tops out near 4,000 results. Split by make or price band to exceed that.

**Do I need a proxy?** No configuration needed — it defaults to Apify Proxy datacenter servers, which AutoTrader.ca accepts.

**How fresh is the data?** Live — each run fetches the site in real time.

### Legal

This actor scrapes only publicly available data and does not access any login-protected or private content. You are responsible for using the data in compliance with AutoTrader.ca's Terms of Use, applicable Canadian privacy law (e.g. PIPEDA), and any other relevant regulations. Do not use scraped personal contact data for unsolicited bulk communication where prohibited. This tool is provided for legitimate research, analytics and business-intelligence purposes.

# Actor input Schema

## `searchUrls` (type: `array`):

Use this when you already have AutoTrader.ca search pages you want scraped. Paste full listing-search URLs copied from the browser, e.g. 'https://www.autotrader.ca/cars/bmw/x5/reg\_on/cit\_toronto?pricefrom=20000'. The actor auto-paginates each URL up to maxResults (AutoTrader caps any single search at 200 pages / ~4,000 results). NOT for single vehicle pages — put those in 'Direct listing URLs' instead.

## `directUrls` (type: `array`):

Use this to scrape specific vehicles you already have links to. Paste AutoTrader.ca offer URLs, e.g. 'https://www.autotrader.ca/offers/bmw-x5-...'. Each URL is fetched and parsed individually with full detail. NOT for search pages — use 'Search result URLs' for those.

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

Vehicle make to search for, lowercase (e.g. 'bmw', 'toyota', 'ford'). Used to build a structured search when no Search result URLs are given. Combine with Model to narrow further. Leave empty to search all makes.

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

Vehicle model to search for, lowercase (e.g. 'x5', 'corolla', 'f-150'). Only applied when Make is also set. Leave empty to include all models of the chosen make. NOT a trim — trim/version filtering is not supported as a search param.

## `province` (type: `string`):

Canadian province/territory to search within (2-letter code). Combine with City to localize results. Leave empty for a Canada-wide search. Applies only to structured searches, not to pasted Search result URLs.

## `city` (type: `string`):

City to center the search on, e.g. 'Toronto', 'Vancouver', 'Calgary'. Spaces are auto-slugged (e.g. 'North York' -> 'north-york'). Requires Province to be set. If the city slug does not resolve, the search falls back to province-wide results.

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

Filter by listing condition. 'all' returns both new and used (default), 'new' returns only new vehicles, 'used' returns only used. Applies to structured searches.

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

Lowest asking price in Canadian dollars to include, e.g. 15000. Filters the structured search server-side. Leave empty for no lower bound.

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

Highest asking price in Canadian dollars to include, e.g. 45000. Filters the structured search server-side. Leave empty for no upper bound.

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

Earliest model year to include, e.g. 2018. Applied client-side against each vehicle's modelYear (AutoTrader's URL year filter is unreliable for Canadian data, so this is filtered after fetch). Leave empty for no lower bound.

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

Latest model year to include, e.g. 2024. Applied client-side against each vehicle's modelYear. Leave empty for no upper bound. NOT a registration-date filter.

## `minMileageKm` (type: `integer`):

Lowest odometer reading in kilometres to include, e.g. 0. Filters the structured search server-side. Leave empty for no lower bound.

## `maxMileageKm` (type: `integer`):

Highest odometer reading in kilometres to include, e.g. 80000. Filters the structured search server-side. Leave empty for no upper bound.

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

Order results are returned in. 'relevance' is AutoTrader's default ranking. Use price/mileage/year sorts to surface cheapest, lowest-km, or newest vehicles first. Applies to structured searches.

## `maxResults` (type: `integer`):

Maximum number of vehicle listings to return across all search URLs/queries combined, e.g. 100. The actor stops paginating once this is reached. AutoTrader hard-caps any single search at ~4,000 results (200 pages); to exceed that, split into narrower searches. Direct listing URLs are always all scraped regardless of this cap.

## `enrichDetails` (type: `boolean`):

When enabled, the actor visits each vehicle's detail page to add full description, all photos, VIN (when published), full feature list, GPS coordinates, and the dealer's Google rating. Adds one extra request per listing and is billed at the higher detail-enriched rate. Leave off for fast, cheaper listing-level data, which already includes price, specs, mileage, dealer phone, and dealer street/city/postal code.

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

Proxy settings. Defaults to Apify Proxy datacenter servers, which is sufficient for AutoTrader.ca (no aggressive anti-bot). Override only if you hit blocks.

## Actor input object example

```json
{
  "searchUrls": [],
  "directUrls": [],
  "make": "bmw",
  "model": "x5",
  "province": "ON",
  "city": "Toronto",
  "condition": "all",
  "sortBy": "relevance",
  "maxResults": 20,
  "enrichDetails": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": []
  }
}
```

# Actor output Schema

## `vehicles` (type: `string`):

Dataset of scraped vehicle listings.

## `runSummary` (type: `string`):

Requested vs scraped counts, charges, and warnings.

# 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 = {
    "searchUrls": [],
    "directUrls": [],
    "province": "ON",
    "city": "Toronto",
    "maxResults": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/autotrader-ca-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 = {
    "searchUrls": [],
    "directUrls": [],
    "province": "ON",
    "city": "Toronto",
    "maxResults": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/autotrader-ca-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 '{
  "searchUrls": [],
  "directUrls": [],
  "province": "ON",
  "city": "Toronto",
  "maxResults": 20
}' |
apify call khadinakbar/autotrader-ca-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=khadinakbar/autotrader-ca-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "AutoTrader.ca Scraper — Cars, Price, Mileage & Dealer",
        "description": "Scrape Canadian vehicle listings from AutoTrader.ca by search URL, structured filters, or direct listing URLs. Returns price, specs, mileage, dealer contact. MCP-ready.",
        "version": "1.0",
        "x-build-id": "INzoe9vjd5B1zVOU3"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/khadinakbar~autotrader-ca-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-khadinakbar-autotrader-ca-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/khadinakbar~autotrader-ca-scraper/runs": {
            "post": {
                "operationId": "runs-sync-khadinakbar-autotrader-ca-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/khadinakbar~autotrader-ca-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-khadinakbar-autotrader-ca-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",
                "properties": {
                    "searchUrls": {
                        "title": "Search result URLs",
                        "type": "array",
                        "description": "Use this when you already have AutoTrader.ca search pages you want scraped. Paste full listing-search URLs copied from the browser, e.g. 'https://www.autotrader.ca/cars/bmw/x5/reg_on/cit_toronto?pricefrom=20000'. The actor auto-paginates each URL up to maxResults (AutoTrader caps any single search at 200 pages / ~4,000 results). NOT for single vehicle pages — put those in 'Direct listing URLs' instead.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "directUrls": {
                        "title": "Direct listing URLs",
                        "type": "array",
                        "description": "Use this to scrape specific vehicles you already have links to. Paste AutoTrader.ca offer URLs, e.g. 'https://www.autotrader.ca/offers/bmw-x5-...'. Each URL is fetched and parsed individually with full detail. NOT for search pages — use 'Search result URLs' for those.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "make": {
                        "title": "Make",
                        "type": "string",
                        "description": "Vehicle make to search for, lowercase (e.g. 'bmw', 'toyota', 'ford'). Used to build a structured search when no Search result URLs are given. Combine with Model to narrow further. Leave empty to search all makes."
                    },
                    "model": {
                        "title": "Model",
                        "type": "string",
                        "description": "Vehicle model to search for, lowercase (e.g. 'x5', 'corolla', 'f-150'). Only applied when Make is also set. Leave empty to include all models of the chosen make. NOT a trim — trim/version filtering is not supported as a search param."
                    },
                    "province": {
                        "title": "Province",
                        "enum": [
                            "",
                            "ON",
                            "QC",
                            "BC",
                            "AB",
                            "MB",
                            "SK",
                            "NS",
                            "NB",
                            "NL",
                            "PE",
                            "NT",
                            "YT",
                            "NU"
                        ],
                        "type": "string",
                        "description": "Canadian province/territory to search within (2-letter code). Combine with City to localize results. Leave empty for a Canada-wide search. Applies only to structured searches, not to pasted Search result URLs.",
                        "default": "ON"
                    },
                    "city": {
                        "title": "City",
                        "type": "string",
                        "description": "City to center the search on, e.g. 'Toronto', 'Vancouver', 'Calgary'. Spaces are auto-slugged (e.g. 'North York' -> 'north-york'). Requires Province to be set. If the city slug does not resolve, the search falls back to province-wide results.",
                        "default": "Toronto"
                    },
                    "condition": {
                        "title": "Condition",
                        "enum": [
                            "all",
                            "new",
                            "used"
                        ],
                        "type": "string",
                        "description": "Filter by listing condition. 'all' returns both new and used (default), 'new' returns only new vehicles, 'used' returns only used. Applies to structured searches.",
                        "default": "all"
                    },
                    "priceMin": {
                        "title": "Min price (CAD)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Lowest asking price in Canadian dollars to include, e.g. 15000. Filters the structured search server-side. Leave empty for no lower bound."
                    },
                    "priceMax": {
                        "title": "Max price (CAD)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Highest asking price in Canadian dollars to include, e.g. 45000. Filters the structured search server-side. Leave empty for no upper bound."
                    },
                    "yearMin": {
                        "title": "Min model year",
                        "minimum": 1900,
                        "maximum": 2030,
                        "type": "integer",
                        "description": "Earliest model year to include, e.g. 2018. Applied client-side against each vehicle's modelYear (AutoTrader's URL year filter is unreliable for Canadian data, so this is filtered after fetch). Leave empty for no lower bound."
                    },
                    "yearMax": {
                        "title": "Max model year",
                        "minimum": 1900,
                        "maximum": 2030,
                        "type": "integer",
                        "description": "Latest model year to include, e.g. 2024. Applied client-side against each vehicle's modelYear. Leave empty for no upper bound. NOT a registration-date filter."
                    },
                    "minMileageKm": {
                        "title": "Min mileage (km)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Lowest odometer reading in kilometres to include, e.g. 0. Filters the structured search server-side. Leave empty for no lower bound."
                    },
                    "maxMileageKm": {
                        "title": "Max mileage (km)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Highest odometer reading in kilometres to include, e.g. 80000. Filters the structured search server-side. Leave empty for no upper bound."
                    },
                    "sortBy": {
                        "title": "Sort order",
                        "enum": [
                            "relevance",
                            "price_asc",
                            "price_desc",
                            "mileage_asc",
                            "year_desc"
                        ],
                        "type": "string",
                        "description": "Order results are returned in. 'relevance' is AutoTrader's default ranking. Use price/mileage/year sorts to surface cheapest, lowest-km, or newest vehicles first. Applies to structured searches.",
                        "default": "relevance"
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of vehicle listings to return across all search URLs/queries combined, e.g. 100. The actor stops paginating once this is reached. AutoTrader hard-caps any single search at ~4,000 results (200 pages); to exceed that, split into narrower searches. Direct listing URLs are always all scraped regardless of this cap.",
                        "default": 100
                    },
                    "enrichDetails": {
                        "title": "Enrich with detail pages",
                        "type": "boolean",
                        "description": "When enabled, the actor visits each vehicle's detail page to add full description, all photos, VIN (when published), full feature list, GPS coordinates, and the dealer's Google rating. Adds one extra request per listing and is billed at the higher detail-enriched rate. Leave off for fast, cheaper listing-level data, which already includes price, specs, mileage, dealer phone, and dealer street/city/postal code.",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy settings. Defaults to Apify Proxy datacenter servers, which is sufficient for AutoTrader.ca (no aggressive anti-bot). Override only if you hit blocks.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": []
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
