# Carsales Scraper \[From $0.40💰] | Price Monitoring | Car Data (`ahmed_jasarevic/carsales-scraper`) Actor

Scrape carsales.com.au used car listings - price, make, model, year, odometer, seller, state, images. Breaks the 440-listing search cap via price-band and sort partitioning. Pay-per-result, AU residential proxy included. Ideal for used car price monitoring and Australian market research.

- **URL**: https://apify.com/ahmed\_jasarevic/carsales-scraper.md
- **Developed by:** [Ahmed Jasarevic](https://apify.com/ahmed_jasarevic) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.30 / 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/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

## Carsales Scraper — Australian Car Listings Data Extraction

Scrape **carsales.com.au** — Australia's #1 car marketplace with 200,000+ live used and new car listings — and get clean structured data on price, make, model, year, odometer, transmission, fuel, body style, seller and state for every vehicle. Built for **used car price monitoring**, **dealer stock tracking** and **Australian used car market research**, this Actor automatically breaks through carsales' ~440-result single-search cap using price-band and sort-order partitioning — no manual pagination hacks needed.

### Main Use Cases

- **Used car price monitoring** — track asking prices, odometer readings and stock levels for any make/model over time.
- **Australian used car market research** — build price and inventory trend datasets, segmented by state, body style, fuel type and seller channel.
- **Dealer stock and competitor pricing tracking** — monitor dealer inventories and competitor pricing across makes and models.
- **Car price comparison & listings databases** — feed a clean, structured feed of live listings into comparison tools, dashboards or BI systems.
- **Private vs dealer seller analysis** — compare private-seller and dealer-listed stock using the seller type field on every row.

### How It Works

This Actor is a plain-HTTP crawler (CheerioCrawler) that reads carsales.com.au's embedded Next.js state (`__NEXT_DATA__`) and its internal search API — no browser rendering, roughly 10x faster and cheaper than browser-based scrapers. Give it one or more carsales search URLs, and it:

1. Paginates each search in parallel until **Max Listings** is reached.
2. Detects carsales' "live feed" pagination behaviour (repeated listings across `?page=N` pages) and automatically re-partitions the search by **sort order** (`~Price`, `~Year`, `~Kilometers`, `~StockNumber`) and **price bands** (`/between-{min}-{max}/` path facets) to break through the ~440-result per-search cap and surface genuinely distinct listings.
3. Deduplicates every listing by its network ID across all pages, sorts and price bands.
4. Returns one clean JSON row per listing, exportable as CSV, JSON, HTML or Excel from the Apify dataset.

### Scrape Carsales Listings For Used Car Price Monitoring

Asking prices on carsales.com.au change weekly (and faster in a soft market — more than half of one-to-five-year-old used cars were discounted before sale in H1 2026). This Actor makes ongoing price monitoring easy:

- Point it at any search URL — `https://www.carsales.com.au/cars/used/toyota/corolla/` for a model, or `/cars/used/ford/ranger/` for another segment.
- Each row includes the numeric `priceValue` field, so you can compute price deltas between scheduled runs and spot price drops instantly.
- Schedule the Actor daily or weekly in Apify Console and get a time-series of asking prices, odometer levels and inventory counts.

### Build An Australian Used Car Market Research Dataset

Every listing row carries a `state` field (VIC, NSW, QLD, WA and more), plus body style, engine, transmission, odometer, price and seller type. In one run you can collect a nationwide sample of the Australian used car market:

- Analyze price and odometer trends by state, make, model or body style.
- Segment dealer vs private supply, and compare price positioning across channels.
- Export the dataset via the Apify API (`GET /v2/datasets/{datasetId}/items`) into Python, R, Sheets or a BI tool for further analysis.
- Combine multiple search URLs (one per make/model/state) in a single run for a broader sample — results merge into one dataset.

### Track Dealer Stock And Competitor Pricing Data

Dealers, remarketers and fleet managers use this Actor to keep an eye on the market:

- Monitor competitor stock: every row includes `sellerTitle` and `sellerId`, so you can track individual dealers or sellers across runs.
- Watch price changes on specific models and price bands (e.g. `https://www.carsales.com.au/cars/used/bmw/x5/between-30000-80000/`).
- Detect new listings and stock movements with scheduled runs — the `totalResults` field on each row reflects the search's total inventory at scrape time.

### Input — Search URLs, Max Listings & Proxy Settings

| Field | Type | Required | Default | Notes |
|-------|------|----------|---------|-------|
| `startUrls` | array of `{ url }` | ✅ | `https://www.carsales.com.au/cars/used/toyota/corolla/` | carsales.com.au search result URLs to scrape. Multiple URLs are paginated in parallel and merged into one dataset. |
| `maxItems` | integer | — | `50` | Maximum number of listings to scrape across all search URLs (min 1, max 10,000). |
| `proxyConfiguration` | proxy object | — | AU residential (`RESIDENTIAL` group, `AU` country) | Anti-bot proxy settings. **AU residential is required** — carsales.com.au serves a DataDome challenge to datacenter IPs. |
| `maxConcurrency` | integer | — | `8` | Maximum concurrent requests (min 1, max 20). |
| `debug` | boolean | — | `false` | Dump raw internal structures to the dataset for debugging. Leave off for normal runs. |

### Output — Structured Car Listing Fields

Each dataset row contains the following fields (pulled from the live scraper code):

| Field | Description |
|-------|-------------|
| `networkId` | Unique listing ID (e.g. `OAG-AD-26257099`) |
| `url` | Direct link to the listing detail page |
| `title` | Listing title (year + make + model) |
| `badge` | Trim / variant badge (e.g. "Ascent Sport Hybrid Auto F") |
| `year` | Model year |
| `make` | Vehicle make (Toyota, Ford, BMW...) |
| `model` | Vehicle model |
| `price` | Displayed price (e.g. "$28,990") |
| `priceValue` | Numeric price as integer (e.g. `28990`) — ideal for price-change calculations |
| `priceType` | Price type (e.g. "Excl. Govt. Charges", "Drive away") |
| `priceInfo` | Additional price info text |
| `bodyStyle` | Body style (Hatch, Sedan, SUV, Ute...) |
| `engine` | Engine spec (e.g. "4cyl 1.8L Petrol") |
| `transmission` | Transmission (Automatic / Manual) |
| `odometer` | Odometer reading (e.g. "98,680 km") |
| `sellerType` | Seller type (Dealer used / Private) |
| `sellerTitle` | Seller display name |
| `sellerId` | Seller network ID (e.g. `AGC-SELLER-7493`) |
| `state` | Australian state (VIC, NSW, QLD, WA...) |
| `imageCount` | Number of photos on the listing |
| `images` | Array of image URLs |
| `adType` | Raw ad type from the listing |
| `searchUrl` | The search URL this listing came from |
| `totalResults` | Total result count of the originating search |
| `page` | Page number the listing was found on |

### Example Input

```json
{
  "startUrls": [
    { "url": "https://www.carsales.com.au/cars/used/toyota/corolla/" },
    { "url": "https://www.carsales.com.au/cars/used/ford/ranger/" }
  ],
  "maxItems": 200,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"],
    "apifyProxyCountry": "AU"
  },
  "maxConcurrency": 8
}
```

### Example Output

```json
{
  "networkId": "OAG-AD-26257099",
  "url": "https://www.carsales.com.au/cars/details/2020-toyota-corolla-ascent-sport-hybrid-auto/OAG-AD-26257099/",
  "title": "2020 Toyota Corolla",
  "badge": "Ascent Sport Hybrid Auto F",
  "year": "2020",
  "make": "Toyota",
  "model": "Corolla",
  "price": "$28,990",
  "priceValue": 28990,
  "priceType": "Excl. Govt. Charges",
  "priceInfo": "",
  "bodyStyle": "Sedan",
  "engine": "4cyl 1.8L Petrol",
  "transmission": "Automatic",
  "odometer": "98,680 km",
  "sellerType": "Dealer used",
  "sellerTitle": "Example Motors",
  "sellerId": "AGC-SELLER-7493",
  "state": "NSW",
  "imageCount": 22,
  "images": ["https://carsales.pxcrush.net/carsales/cars/dealer/example.jpg"],
  "adType": "Dealer used",
  "searchUrl": "https://www.carsales.com.au/cars/used/toyota/corolla/",
  "totalResults": "2036",
  "page": 1
}
```

### Integrations & Automation

- **Apify API** — trigger runs programmatically and pull datasets with `GET /v2/datasets/{datasetId}/items`.
- **Scheduling** — recommend a **daily** schedule for new-listing feeds and a **weekly** schedule for price monitoring; scheduled runs also feed Apify's recommendation signals.
- **Webhooks** — notify your app or Slack when a run finishes.
- **Zapier / Make** — connect the dataset to Sheets, Slack, Notion or your internal tools via Apify's native integrations.
- **MCP / AI agents** — this Actor is callable from any Apify MCP client or LLM app (see the agent reference below).

### Related Actors

- [Carsales.com.au $0.6+ Bypass 440 Limit](https://apify.com/memo23/carsales-cheerio) (`memo23/carsales-cheerio`) — the largest carsales actor on Apify, with filter-based search modes.
- [Carsales AU Scraper 💰 $1/1K](https://apify.com/azzouzana/carsales-au-scraper) (`azzouzana/carsales-au-scraper`) — another popular carsales.com.au scraper.
- [All Car Data Scraper Australia](https://apify.com/mrdoe/all-car-data-scraper-australia) (`mrdoe/all-car-data-scraper-australia`) — normalized listings across six Australian car sites.
- [Drive.com.au Car Listings Scraper](https://apify.com/crawlerbros/drive-au-scraper) (`crawlerbros/drive-au-scraper`) — Australian car data from the Drive.com.au marketplace.
- [Pickles.com.au Car Auction Scraper](https://apify.com/mrdoe/pickles-com-au-scraper) (`mrdoe/pickles-com-au-scraper`) — used car auction listings from Australia's leading auction marketplace.

### FAQ

**Why use this actor instead of the official Carsales API?**
carsales.com.au does not publish a public developer API for listing data. The only official API is the dealer-facing Lead Service (Autogate), which requires an approved dealer account and is for submitting leads — not extracting listings. This Actor is the practical way to get structured carsales listing data programmatically.

**What are alternatives to scraping carsales.com.au?**
Other Australian car marketplaces include CarsGuide, Autotrader Australia, Gumtree Cars and Pickles. If you need multi-site data in one run, see the related actors above.

**How do I scrape carsales.com.au without getting blocked?**
carsales.com.au is protected by DataDome. This Actor requires **AU residential proxies** — datacenter IPs get blocked (HTTP 200 challenge pages with no data). Each request automatically uses a fresh residential IP and fresh tokens; blocked pages are retried up to 3 times. Do not switch the proxy to AUTO or datacenter groups.

**How many results can one carsales search return?**
A single carsales.com.au search is effectively capped at ~440 results (~20 pages) — the site repeats the same "live feed" listings across `?page=N` URLs. This Actor detects that repetition and automatically re-partitions the search by sort order and price bands to extract a far deeper result set, deduplicated by network ID.

**Can I track used car prices over time?**
Yes. Schedule the Actor (daily or weekly) and use the numeric `priceValue` field to compute price deltas between runs. Each row also includes `odometer` and `totalResults`, so you can track price-per-km and inventory changes too.

**What does it cost to scrape carsales?**
Pay-per-result: **$0.0008 per dataset item** on the FREE tier, $0.0004 (BRONZE), $0.00035 (SILVER), $0.0003 (GOLD+) — i.e. roughly **$0.80 per 1,000 listings** on the free tier and **$0.40 per 1,000** on Bronze — plus a negligible per-run start fee (1 event per GB, minimum one event). Free accounts are capped at 10 listings per run; paid runs can go up to your `maxItems` (max 10,000).

**What is the best way to monitor car price drops in Australia?**
Set up a scheduled run against the search URL of the car you follow (e.g. `https://www.carsales.com.au/cars/used/toyota/hilux/`), with a recurring schedule, and compare `priceValue` across runs — drops of $1,000+ on popular models show up immediately in the dataset.

**Does carsales.com.au have an official API?**
No public one. There is no official third-party developer API for carsales.com.au listing data (see the first FAQ item).

**How can I get used car market data for Australia?**
Run this Actor against one or more carsales search URLs and export the dataset (JSON/CSV/Excel). The `state`, `priceValue`, `odometer`, `year` and `sellerType` fields give you the core dimensions used in Australian used car market analysis.

### Competitive Positioning

Verified from public Apify Store listings (August 2026), for comparable carsales.com.au actors that also break the 440-listing cap:

| Capability | memo23/carsales-cheerio | azzouzana/carsales-au-scraper | abotapi/carsales-au-scraper | This Actor |
|---|---|---|---|---|
| Per-result list price (BRONZE) | $0.0008 | $0.001 | $0.0012 | **$0.0004** |
| Per-run start fee | $0.01 | $0.005 | $0.03667 | **~$0.00005** |
| Detail-enrichment surcharge | $0.0011 | — | $0.0006 | **None** |
| 440-cap deep collection | manual mode | advertised | advertised | **automatic** (price bands + sort probes) |
| Search input style | filter/URL modes | single URL | filter/URL modes | **one or more URLs, parallel** |

### For AI Agents & LLM Apps

**Purpose:** Given carsales.com.au search URLs, returns one structured JSON row per car listing — price, specs, seller, state and images — as an Apify dataset.

**Minimal working input:**

```json
{
  "startUrls": [
    { "url": "https://www.carsales.com.au/cars/used/toyota/corolla/" }
  ]
}
```

Defaults: `maxItems` 50, AU residential proxy, concurrency 8.

**Variant input — multiple searches with a higher cap:**

```json
{
  "startUrls": [
    { "url": "https://www.carsales.com.au/cars/used/toyota/hilux/" },
    { "url": "https://www.carsales.com.au/cars/used/ford/ranger/" }
  ],
  "maxItems": 200
}
```

**Output fields (per row):** `networkId`, `url`, `title`, `badge`, `year`, `make`, `model`, `price`, `priceValue`, `priceType`, `priceInfo`, `bodyStyle`, `engine`, `transmission`, `odometer`, `sellerType`, `sellerTitle`, `sellerId`, `state`, `imageCount`, `images`, `adType`, `searchUrl`, `totalResults`, `page`.

**Behaviors an agent should know:**

- `startUrls` is required; entries that are not carsales.com.au URLs are filtered out, and a run with zero valid URLs exits with an error.
- Free (non-paying) accounts are hard-capped at **10 results per run** regardless of `maxItems`; paid accounts honor `maxItems` (default 50, max 10,000).
- Do **not** override `proxyConfiguration` away from AU residential — datacenter IPs are blocked by DataDome and return empty results. The default (`RESIDENTIAL` + `AU`) is already set when the field is omitted.
- Pagination on numbered `?page=N` pages often repeats the same listings; the Actor auto-probes sort orders and `/between-{min}-{max}/` price bands to reach deeper result sets. This is automatic, may add extra requests, and results are deduplicated by `networkId`.
- `debug: true` adds raw internal dump rows to the dataset — keep it off for production runs.
- The site's markup can change; an empty result set usually means carsales updated its frontend — retry on a later date.

**Billing:** pay-per-result — $0.0008 per dataset item (FREE tier; $0.0004 BRONZE, $0.00035 SILVER, $0.0003 GOLD+) plus a per-run start fee (1 event per GB, minimum one event). A 1,000-listing run costs ≈ $0.40–$0.80.

### Legal & Compliance Disclaimer

This Actor is an independent tool and is **not affiliated with, endorsed by, or sponsored by carsales.com.au Pty Ltd or CAR Group Limited**. "carsales" is a trademark of its respective owner.

The Actor accesses **only publicly visible** carsales.com.au listing and search pages (including the public `__NEXT_DATA__` state embedded in those pages). It does not log in, bypass authentication, solve CAPTCHAs, or access private-account data.

carsales.com.au is protected by DataDome, and its Terms of Service and robots.txt apply to all access. **Users are responsible for their own compliance** with the source site's Terms of Service and with applicable laws — including the Australian Privacy Act 1988 (Cth) and, where EU or California personal data is processed, the GDPR or CCPA. Listing rows include seller display names and identifiers: do not use them for unsolicited commercial outreach in breach of the Australian Spam Act 2003 (Cth), CAN-SPAM, GDPR or similar laws. This section is a factual disclosure, not legal advice.

### SEO Keywords

carsales scraper, carsales.com.au scraper, scrap carsales.com.au, carsales data extraction, carsales API alternative, carsales.com.au API, used car price monitoring Australia, used car price tracking, Australian used car market data, used car listings Australia, car price comparison Australia, dealer stock monitoring, car listings database, Australian automotive market research, used car valuation data, carsales car data, second-hand car market Australia, car inventory scraping, used car market analysis, car resale value tracking, electric car listings Australia, used ute prices Australia, cars for sale Sydney, cars for sale Melbourne

# Actor input Schema

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

carsales.com.au search result URLs to scrape, e.g. https://www.carsales.com.au/cars/used/toyota/corolla/ or https://www.carsales.com.au/cars/used/

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

Maximum number of listings to scrape across all search URLs.

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

Proxy settings for anti-bot protection. carsales.com.au requires RESIDENTIAL proxy (datacenter IPs get blocked by DataDome).

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

Maximum number of concurrent requests.

## `debug` (type: `boolean`):

Dump raw internal structures to the dataset for debugging. Leave off for normal runs.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.carsales.com.au/cars/used/toyota/corolla/"
    }
  ],
  "maxItems": 50,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "AU"
  },
  "maxConcurrency": 8,
  "debug": false
}
```

# Actor output Schema

## `results` (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 = {
    "startUrls": [
        {
            "url": "https://www.carsales.com.au/cars/used/toyota/corolla/"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("ahmed_jasarevic/carsales-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": [{ "url": "https://www.carsales.com.au/cars/used/toyota/corolla/" }] }

# Run the Actor and wait for it to finish
run = client.actor("ahmed_jasarevic/carsales-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 '{
  "startUrls": [
    {
      "url": "https://www.carsales.com.au/cars/used/toyota/corolla/"
    }
  ]
}' |
apify call ahmed_jasarevic/carsales-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,ahmed_jasarevic/carsales-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/tbsIfHKR6eoyuzo2O/builds/gOvdeIMCRZt1Gkq3O/openapi.json