# Autotrader Australia Scraper (`solidcode/autotrader-com-au-scraper`) Actor

\[💰 $0.9 / 1K] Extract new and used car listings from Autotrader.com.au — price, odometer, year, make/model, body, fuel, transmission, drive type, dealer contacts, location, and photos. Search by make, model, state, condition, price and year, or paste any Autotrader URL.

- **URL**: https://apify.com/solidcode/autotrader-com-au-scraper.md
- **Developed by:** [SolidCode](https://apify.com/solidcode) (community)
- **Categories:** E-commerce, Lead generation, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.90 / 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.
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 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

## Autotrader Australia Scraper

Pull new and used car listings from Autotrader.com.au at scale — advertised and driveaway pricing, odometer, VIN, full specifications, itemised features, dealer contacts, coordinates, and every photo, across roughly 78,000 live listings nationwide. Search by make and model, or paste any Autotrader search or car page address. Built for dealer-network analysts, automotive market researchers, lead-generation teams, and price-comparison and valuation builders who need a clean, structured Australian vehicle dataset without hand-crafting search links or maintaining their own extraction stack.

### Why This Scraper?

- **Structured search across ~78,000 live listings** — set make, model, state, suburb, price and year as plain input fields. Competing Autotrader actors accept nothing but hand-built search addresses; here you never have to construct one.
- **Thirteen filters, every one verified against returned rows** — make, model, 8 states and territories, exact suburb, 4 conditions, 9 body types, 7 fuel types, 2 transmissions, 4 drive types, plus a price band and a year band.
- **Arbitrary price and year bands the website itself cannot do** — Autotrader's own filters snap to preset buckets like "under $10,000". Here `priceMin: 23456` with `priceMax: 23999` is honoured exactly, so you can slice inventory at any threshold your model needs.
- **VIN on every single row, dealer stock number on 9 in 10** — decode build specs, reconcile against auction or finance records, and spot the same car re-advertised by a second dealership.
- **Up to 168 itemised features per car** — every factory and dealer-fitted option as a clean string array ("Adjustable Steering Col. - Tilt & Reach", "Bluetooth Connectivity"), not one comma-jammed blob you have to split yourself.
- **Australian driveaway vs advertised pricing kept strictly separate** — `price`, `priceDisplay`, `priceType`, `driveawayPrice` and `isDriveawayPricing`, so "$25,990 excl. gov. charges" is never silently compared against a driveaway figure.
- **Dealer contact block on 100% of rows** — trading name, phone, suburb and state, plus the listing's own latitude and longitude for mapping and catchment analysis; switch on full listing details and the dealership's street address is added too.
- **Up to 70 full-resolution photos per listing** — ordered exactly as the dealer arranged them, alongside ANCAP safety rating, engine size, power in kW, cylinders, seats, doors and exterior colour.
- **Eight result orderings, so you pay for the cars you actually want** — cheapest first, dearest first, recently updated, newest or oldest model year, lowest or highest odometer. Ask for the 20 cheapest Toyotas and you are billed for 20 rows, not for all 11,800 sorted afterwards.
- **Exact result counts, never an overshoot** — ask for 120 cars and you get exactly 120 unique listings, so you are never charged for rows you did not request.

### Use Cases

**Pricing & Valuation**

- Build residual-value and depreciation curves from year, odometer and advertised price
- Benchmark a specific variant against every comparable listing in a state
- Track driveaway vs excl.-charges pricing spreads by make and dealer group
- Slice inventory at any price threshold to size a target segment

**Dealer & Inventory Intelligence**

- Map a dealer group's full live inventory by trading name and location
- Measure stock mix by body type, fuel type and condition across competitors
- Monitor how long specific stock numbers stay advertised
- Compare new, demo and certified pre-owned mix between metro and regional dealers

**Market Research**

- Track electric and hybrid share of listings by state over time
- Compare 4WD and AWD availability across Queensland, NSW and Victoria
- Quantify supply of a model before a launch or facelift
- Analyse ANCAP rating distribution across the used market

**Lead Generation**

- Build dealer contact lists with trading name, phone and street address
- Target dealerships holding specific makes, models or price bands
- Segment prospects by state, suburb and inventory size
- Prioritise outreach by photo count and listing completeness

**Data Enrichment & Product Build**

- Power car-comparison sites and valuation tools with fresh listing data
- Enrich internal vehicle records using VIN, stock number and full specifications
- Feed listing photos and descriptions into classification or pricing models
- Sync live inventory into dashboards, spreadsheets and CRMs

### Getting Started

#### Simple make and model search

```json
{
    "make": "Toyota",
    "model": "HiLux",
    "maxResults": 20
}
```

#### Filtered search in one state

The 200 cheapest diesel 4WD utes in Victoria, between $30,000 and $60,000:

```json
{
    "make": "Ford",
    "model": "Ranger",
    "state": "vic",
    "bodyType": ["ute-tray"],
    "fuelType": ["diesel"],
    "driveType": "four-wheel-drive",
    "priceMin": 30000,
    "priceMax": 60000,
    "sortBy": "price-asc",
    "maxResults": 200
}
```

#### Paste Autotrader addresses

Mix a search page and an individual car page in the same run:

```json
{
    "startUrls": [
        "https://www.autotrader.com.au/for-sale/toyota/hilux",
        "https://www.autotrader.com.au/car/15224329/toyota/hilux/qld/underwood/single-cab"
    ],
    "includeListingDetails": true,
    "maxResults": 100
}
```

#### Advanced — electrified SUVs nationwide

```json
{
    "state": "nsw",
    "condition": "used",
    "bodyType": ["suv", "wagon"],
    "fuelType": ["hybrid", "electric"],
    "transmission": "automatic",
    "driveType": "all-wheel-drive",
    "priceMin": 23456,
    "priceMax": 89999,
    "yearMin": 2021,
    "yearMax": 2026,
    "sortBy": "newest",
    "includeListingDetails": true,
    "maxResults": 500
}
```

### Input Reference

#### What to scrape

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `startUrls` | array | `[]` | Autotrader.com.au search result addresses or individual car pages. When supplied, the search options below are ignored. |
| `make` | string | `"Toyota"` | Car manufacturer, for example Toyota, Ford, Mazda or Hyundai. Leave empty to include every make. |
| `model` | string | `"HiLux"` | Model name, for example HiLux, Ranger or Corolla. Must belong to the make you chose. Leave empty for every model. |

#### Location

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `state` | string | `"any"` | One of: Anywhere in Australia, New South Wales, Victoria, Queensland, Western Australia, South Australia, Tasmania, Australian Capital Territory, Northern Territory. |
| `city` | string | `""` | Exact suburb name, for example Melbourne, Richmond or Underwood. Matches the suburb the car is listed in — not a radius search. |

#### Vehicle filters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `condition` | string | `"any"` | Any condition, New, Used, Demo, or Certified pre-owned. |
| `bodyType` | array | `[]` | Any of: SUV, Sedan, Hatchback, Wagon, Coupe, Convertible, Ute / Tray, People mover, Van. Empty means every body type. |
| `fuelType` | array | `[]` | Any of: Diesel, Unleaded, Premium unleaded, Hybrid, Electric, LPG, Leaded. Empty means every fuel type. |
| `transmission` | string | `"any"` | Any, Automatic, or Manual. |
| `driveType` | string | `"any"` | Any, Front wheel drive, Rear wheel drive, Four wheel drive (4WD), or All wheel drive (AWD). |

#### Price and year

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `priceMin` | integer | — | Lowest advertised price in Australian dollars. Any value up to 5,000,000. Leave empty for no lower limit. |
| `priceMax` | integer | — | Highest advertised price in Australian dollars. Leave empty for no upper limit. |
| `yearMin` | integer | — | Earliest year, for example 2018. Leave empty to include cars of any age. |
| `yearMax` | integer | — | Latest year, inclusive. Leave empty to include cars of any age. |

#### Output

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `sortBy` | string | `"relevance"` | One of: Best match (Autotrader's own order), Price: lowest first, Price: highest first, Recently updated first, Model year: newest first, Model year: oldest first, Odometer: lowest first, Odometer: highest first. Decides which cars you get when you limit the number of results. |
| `includeListingDetails` | boolean | `true` | Adds the seller's full description, the itemised feature list, and the dealer's street address to every car. Everything else is included either way. |
| `maxResults` | integer | `20` | Largest number of cars to return per search. If you paste several search addresses, each one collects up to this many, so the total can be higher; individual car pages share one limit between them. Set to `0` to collect everything available, up to 50,000 cars. |

### Output

One row per car listing. Empty fields are omitted rather than returned as nulls.

```json
{
    "listingId": "15224329",
    "url": "https://www.autotrader.com.au/car/15224329/toyota/hilux/qld/underwood/single-cab",
    "title": "2018 Toyota HiLux Sr (4X4)",
    "make": "Toyota",
    "model": "HiLux",
    "variant": "Sr (4X4)",
    "year": 2018,
    "condition": "Used",
    "price": 25990,
    "priceDisplay": "$25,990 excl. gov. charges",
    "priceType": "excl. government charges",
    "isDriveawayPricing": false,
    "currency": "AUD",
    "odometer": 141190,
    "odometerUnit": "km",
    "bodyType": "Ute Tray",
    "fuelType": "Diesel",
    "transmission": "Manual",
    "driveType": "4WD",
    "engineSize": "2.80",
    "cylinders": 4,
    "enginePowerKw": 130,
    "seats": 2,
    "doors": 2,
    "exteriorColour": "Glacier White",
    "ancapRating": 5,
    "vehicleSegment": "Pick Up Or Cab Chassis 4X4",
    "vin": "MR0KA3CB001123832",
    "stockNumber": "110",
    "sellerType": "dealer",
    "dealerId": "1019145",
    "dealerName": "Iman Motors",
    "dealerPhone": "0721438018",
    "dealerAddress": "1/24 Ferguson Street",
    "dealerCity": "Underwood",
    "dealerState": "QLD",
    "locationCity": "Underwood",
    "locationState": "QLD",
    "latitude": -27.6122015,
    "longitude": 153.1135526,
    "images": ["https://images.autotrader.com.au/inventory/.../2018_toyota_hilux_Used_1.jpg"],
    "imageCount": 35,
    "features": ["12V Socket(s) - Auxiliary", "2 Speaker Stereo", "Bluetooth Connectivity"],
    "description": "2018 TOYOTA HILUX SR MANUAL SINGLE CAB ...",
    "scrapedAt": "2026-07-31T20:54:20+00:00"
}
```

#### Core fields

| Field | Type | Description |
|-------|------|-------------|
| `listingId` | string | Autotrader listing identifier |
| `url` | string | Full address of the car's page |
| `title` | string | Year, make, model and variant combined |
| `make` | string | Manufacturer |
| `model` | string | Model name |
| `variant` | string | Trim, badge or series |
| `year` | integer | Build or model year |
| `condition` | string | New, Used, Demo or Certified pre-owned |

#### Pricing

| Field | Type | Description |
|-------|------|-------------|
| `price` | integer | Advertised price in Australian dollars |
| `priceDisplay` | string | Price exactly as shown, including the qualifier text |
| `priceType` | string | `driveaway` or `excl. government charges` |
| `driveawayPrice` | integer | Driveaway price when the dealer quotes one |
| `isDriveawayPricing` | boolean | Whether the headline price is a driveaway figure |
| `currency` | string | Always `AUD` |

#### Vehicle specifications

| Field | Type | Description |
|-------|------|-------------|
| `odometer` | integer | Distance travelled |
| `odometerUnit` | string | Always `km` |
| `bodyType` | string | SUV, Sedan, Hatch, Ute Tray, Wagon and similar |
| `fuelType` | string | Diesel, Unleaded, Hybrid, Electric and similar |
| `transmission` | string | Automatic or Manual |
| `driveType` | string | Front, Rear, 4WD or AWD |
| `engineSize` | string | Engine displacement in litres |
| `cylinders` | integer | Cylinder count |
| `enginePowerKw` | integer | Peak power output in kilowatts |
| `seats` | integer | Seat count |
| `doors` | integer | Door count |
| `exteriorColour` | string | Exterior colour as advertised |
| `ancapRating` | integer | ANCAP safety star rating |
| `vehicleSegment` | string | Autotrader's segment classification |

#### Identity and registration

| Field | Type | Description |
|-------|------|-------------|
| `vin` | string | Vehicle identification number, when published |
| `stockNumber` | string | Dealer stock number |
| `registration` | string | Registration plate, when published |
| `registrationExpiry` | string | Registration expiry date |

#### Dealer and location

| Field | Type | Description |
|-------|------|-------------|
| `sellerType` | string | Always `dealer` — the platform lists dealer inventory only |
| `dealerId` | string | Dealer identifier, stable across that dealer's listings |
| `dealerName` | string | Dealership trading name |
| `dealerPhone` | string | Dealership contact phone number |
| `dealerAddress` | string | Dealership street address (with full listing details on) |
| `dealerCity` | string | Dealership suburb |
| `dealerState` | string | Dealership state or territory |
| `locationCity` | string | Suburb the car is listed in |
| `locationState` | string | State or territory the car is listed in |
| `latitude` | number | Listing latitude |
| `longitude` | number | Listing longitude |

#### Media and text

| Field | Type | Description |
|-------|------|-------------|
| `images` | array | Full-size photo addresses, in the dealer's display order |
| `imageCount` | integer | Number of photos on the listing |
| `features` | array | Itemised features and options — present when the dealer listed them, about 6 cars in 10 (with full listing details on) |
| `description` | string | Seller's full written description (with full listing details on) |
| `scrapedAt` | string | Timestamp of collection, ISO 8601 |

### Tips for Best Results

- **Sort first, then set a small `maxResults`** — this is the single biggest saving available. "The 20 cheapest Toyotas in Victoria" is `sortBy: "price-asc"` with `maxResults: 20`, which bills 20 rows. Without the sort you would have to collect every matching car and sort them yourself. The same trick with `"newest"` gives you a cheap daily monitor of fresh stock.
- **Use any price band you like** — `priceMin` and `priceMax` accept any whole dollar amount, so a band like 23,456 to 23,999 works even though the website only offers coarse preset ranges. This is the fastest way to isolate a single trim level's real market position.
- **Prefer `state` over `city`** — `city` is an exact suburb match, not a radius. "Melbourne" returns only cars listed in the suburb of Melbourne itself, not the wider metro area. If a suburb search comes back thin, clear it and use the state.
- **Turn off full listing details for speed** — specifications, VIN, stock number, price, dealer name and phone, and every photo all arrive either way. Switching `includeListingDetails` off only drops the written description, the itemised feature list and the dealer's street address, and makes large runs noticeably faster.
- **Certified pre-owned is a small, specialist pool** — combining that condition with a narrow make, model or price band often returns nothing. Start with the condition on its own, then add filters one at a time.
- **Start small, then scale** — run 20 to 50 cars first to confirm the fields match your needs, then raise `maxResults`, or set it to `0` to collect everything matching your filters up to 50,000 cars.
- **Paste addresses or use filters, not both** — when `startUrls` is filled in, the make, model, location and filter fields are ignored (the sort order and result limit still apply). Copy addresses straight from your browser's address bar: a news, dealer profile or hand-typed address is skipped with a note in the log rather than quietly collecting the whole site, and combined addresses like `/for-sale/electric/suv` are best rebuilt with the filter fields instead.
- **De-duplicate on `vin`, not `listingId`** — the same physical car is sometimes re-advertised under a new listing identifier or by a second dealership. Grouping on VIN gives you a true unique-vehicle count, and grouping on `dealerId` gives you a clean per-dealership inventory roll-up.

### Pricing

**From $0.90 per 1,000 results** at the Gold tier — for a 48-field schema with full specifications, dealer contacts, coordinates and every photo, on a scraper you drive with plain search fields instead of hand-built addresses. Bronze, Silver, and Gold subscribers pay progressively less; the table below shows total cost at each discount tier.

| Results | No discount | Bronze | Silver | Gold |
|---------|-------------|--------|--------|------|
| 100 | $0.105 | $0.100 | $0.095 | $0.090 |
| 1,000 | $1.05 | $1.00 | $0.95 | $0.90 |
| 10,000 | $10.50 | $10.00 | $9.50 | $9.00 |
| 100,000 | $105.00 | $100.00 | $95.00 | $90.00 |

A "result" is one car listing row in your dataset. No compute or time-based charges — you pay per result, plus a small fixed per-run start fee.

### Integrations

Export data in JSON, CSV, Excel, XML, or RSS. Connect to 1,500+ apps via:

- **Zapier** / **Make** / **n8n** — Workflow automation
- **Google Sheets** — Direct spreadsheet export
- **Slack** / **Email** — Notifications on new results
- **Webhooks** — Trigger your own services when a run finishes
- **Apify API** — Full programmatic access

### Legal & Ethical Use

This actor is built for legitimate automotive market research, pricing analysis, inventory intelligence, and business development. You are responsible for complying with applicable laws and Autotrader.com.au's Terms of Service. Dealer contact details are published business information — use them for professional outreach only, and honour Australian Spam Act and Do Not Call Register obligations. Do not use the collected data for spam, harassment, or any unlawful purpose.

# Actor input Schema

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

Paste Autotrader.com.au search result URLs or individual car listing URLs (for example 'https://www.autotrader.com.au/for-sale/toyota/hilux' or a single car's page). When you provide URLs here, the search options below are ignored.

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

Car manufacturer, for example 'Toyota', 'Ford', 'Mazda' or 'Hyundai'. Leave empty to include every make.

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

Model name, for example 'HiLux', 'Ranger' or 'Corolla'. Must belong to the make you chose above. Leave empty to include every model.

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

Limit results to one Australian state or territory. Choose 'Anywhere in Australia' to search the whole country.

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

Exact suburb name, for example 'Melbourne', 'Richmond' or 'Underwood'. This matches the suburb the car is listed in — it is not a radius search, so a big-city name returns only cars in that exact suburb, not the surrounding area. Leave empty to search the whole state.

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

Only include cars in this condition. Note that 'Certified pre-owned' is a small, specialist pool of cars — combining it with other filters often returns nothing.

## `bodyType` (type: `array`):

Only include these body shapes. Leave empty to include every body type.

## `fuelType` (type: `array`):

Only include cars running on these fuels. Leave empty to include every fuel type.

## `transmission` (type: `string`):

Gearbox type.

## `driveType` (type: `string`):

Which wheels the car drives.

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

Only include cars at or above this advertised price in Australian dollars. Leave empty for no lower limit.

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

Only include cars at or below this advertised price in Australian dollars. Leave empty for no upper limit.

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

Only include cars from this year onwards, for example 2018. Leave empty to include cars of any age.

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

Only include cars up to and including this year. Leave empty to include cars of any age.

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

The order cars come back in. This decides which cars you get when you limit the number of results — 'Price: lowest first' with 20 results gives you the 20 cheapest matches, instead of 20 taken from anywhere in the list.

## `includeListingDetails` (type: `boolean`):

Adds the seller's full description, the itemised feature list, and the dealer's street address to every car. Everything else — specifications, VIN, stock number, every photo, price, dealer name and phone — is included either way, so turning this off still gives you a rich row and makes the run noticeably faster.

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

Largest number of cars to return per search. You get exactly this many (or fewer, if the search has fewer matches) — results are collected in batches of up to 50, sized down automatically near the end so you're never charged for extra cars. If you paste several search addresses, each one collects up to this many, so the total can be higher; individual car pages share one limit between them. Set to 0 to collect everything available, up to a safety limit of 50,000 cars.

## Actor input object example

```json
{
  "startUrls": [],
  "make": "Toyota",
  "model": "HiLux",
  "state": "any",
  "condition": "any",
  "bodyType": [],
  "fuelType": [],
  "transmission": "any",
  "driveType": "any",
  "sortBy": "relevance",
  "includeListingDetails": true,
  "maxResults": 20
}
```

# Actor output Schema

## `overview` (type: `string`):

Table of car listings with the key fields — make, model, year, price, odometer, body, fuel, transmission, and location.

## `details` (type: `string`):

Full per-listing rows including complete specifications, VIN and registration, dealer contact details, GPS coordinates, and photo URLs.

# 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": [],
    "make": "Toyota",
    "model": "HiLux",
    "state": "any",
    "city": "",
    "condition": "any",
    "bodyType": [],
    "fuelType": [],
    "transmission": "any",
    "driveType": "any",
    "sortBy": "relevance",
    "includeListingDetails": true,
    "maxResults": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/autotrader-com-au-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": [],
    "make": "Toyota",
    "model": "HiLux",
    "state": "any",
    "city": "",
    "condition": "any",
    "bodyType": [],
    "fuelType": [],
    "transmission": "any",
    "driveType": "any",
    "sortBy": "relevance",
    "includeListingDetails": True,
    "maxResults": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/autotrader-com-au-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": [],
  "make": "Toyota",
  "model": "HiLux",
  "state": "any",
  "city": "",
  "condition": "any",
  "bodyType": [],
  "fuelType": [],
  "transmission": "any",
  "driveType": "any",
  "sortBy": "relevance",
  "includeListingDetails": true,
  "maxResults": 20
}' |
apify call solidcode/autotrader-com-au-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/weVTKdPJjFtntZlWE/builds/JYwrqWT5ahDlLB26K/openapi.json