# Trade Me Motors Scraper (`parseforge/trade-me-motors-scraper`) Actor

Scrapes Trade Me Motors vehicle listings with filters for make, model, body style, transmission, fuel, price, year, odometer, region, and dealer status. Returns each vehicle as a flat row.

- **URL**: https://apify.com/parseforge/trade-me-motors-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** E-commerce, Marketing, Lead generation
- **Stats:** 4 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.01 / 1,000 result items

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?

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

[![ParseForge](https://raw.githubusercontent.com/ParseForge/apify-assets/main/banner.jpg)](https://apify.com/parseforge?fpr=vmoqkp)

### Trade Me Motors Scraper

**Scrape Trade Me Motors listings for used and new cars, with every filter you need.** Get make, model, year, price, odometer, fuel type, transmission, body style, region, and dealer status in one flat row. Export to CSV, JSON, Excel, or XML.

Trade Me Motors is New Zealand's biggest vehicle marketplace, but browsing it manually means clicking through pages and copying details by hand. This Actor reads the public search results directly, applies your filters as it goes, and returns each matching vehicle as a clean record. No login, no API key, no rate-limit headaches.

| Who uses it | What they scrape Trade Me Motors for |
|---|---|
| Car dealers | Monitor competitor pricing and stock levels across New Zealand |
| Market researchers | Track which makes and models are listed most in each region |
| Data analysts | Build price trend datasets for used and new vehicles |
| App developers | Feed vehicle listings into a comparison or alert tool |
| Fleet buyers | Find specific vehicles that match a purchase checklist |

### What it does

This Actor collects Trade Me Motors vehicle listings by make, model, body style, transmission, fuel type, price, year, odometer, region, and dealer status, and returns each one as a flat row.

- 🔍 **Search filters:** make, model, body style, transmission, fuel type, price range, year range, max odometer, region, and dealer-only.
- 📊 **Flat output:** every vehicle is one row with the same fields, ready for CSV, JSON, Excel, or XML.
- ⚡ **Fast collection:** up to 1,000,000 vehicles per run, with no login or API key required.
- 🇳🇿 **NZ-specific:** built for Trade Me Motors, the country's largest vehicle marketplace.

Results export to CSV, JSON, Excel, or XML, or straight from the API.

### What you can do with Trade Me Motors data

**📈 Track competitor pricing.**

A car dealer runs the Actor daily for a set of makes and models, then compares listed prices against their own stock to adjust margins.

**🗺️ Map regional supply.**

A market researcher filters by region and body style to see which vehicle types are concentrated in Auckland versus Canterbury.

**🔎 Find specific vehicles.**

A fleet buyer sets make, model, year range, and max odometer to get a shortlist of vans or utes that meet their replacement policy.

**📊 Build price datasets.**

A data analyst collects all used Toyota Corollas under $15,000 and plots price against year and odometer to spot depreciation curves.

**📱 Power a comparison app.**

An app developer scrapes Trade Me Motors nightly and feeds the flat rows into a mobile app that alerts users when a matching car appears.

### Why choose this scraper

| | What you get |
|---|---|
| **No API key** | Reads the public Trade Me Motors search pages directly, so you can start scraping in minutes. |
| **Full filter set** | Narrow by make, model, body style, transmission, fuel, price, year, odometer, region, and dealer status. |
| **Flat schema** | Every vehicle is one row with the same fields, so you can append runs and compare across time. |
| **Scale** | Collect up to 1,000,000 vehicles per run, enough for a full market snapshot. |

### How it compares

This Actor focuses on Trade Me Motors vehicle listings with a full filter set, while the other Trade Me scraper covers multiple categories and the AutoTrader scraper targets the UK market.

| Feature | ParseForge | Trade Me \[💰$1.5] - NZ marketplace listings | Autotrader.co.uk \[$0.85💰] | Unlimited | Richest output |
|---|---|---|---|
| Vehicle-specific filters (make, model, body style, transmission, fuel, price, year, odometer, region, dealer) | Yes | Not listed | Not listed |
| Flat row per vehicle | Yes | Not listed | Not listed |
| Export to CSV, JSON, Excel, XML | Yes | Not listed | Not listed |
| No login or API key | Yes | Not listed | Not listed |
| Up to 1,000,000 listings per run | Yes | Not listed | Not listed |

### Configure the run

Drive the Actor from make, model, body style, transmission, fuel type, price, year, odometer, region, and dealer status, alone or together, and filters run as each listing is read so only matches reach your dataset. The Input tab lists every parameter.

A first run with the defaults:

```json
{
 "listingType": "used",
 "maxItems": 10
}
```

A larger pull:

```json
{
 "listingType": "used",
 "maxItems": 200
}
```

### Pricing

Pay-per-result: **$0.005 per result** collected. You pay only for the results written to your dataset.

| Results collected | Approximate cost |
|---|---|
| 100 results | $0.50 |
| 1,000 results | $5.00 |
| 10,000 results | $50.00 |

New Apify accounts start with $5 in free credit.

### Free users

Free-plan runs return up to 10 results as a preview. [Upgrade your Apify plan](https://console.apify.com/sign-up?fpr=vmoqkp) to collect up to 1,000,000 results per run.

### Run it

1. [Create a free Apify account with $5 in credit](https://console.apify.com/sign-up?fpr=vmoqkp).
2. Open the [Trade Me Motors Scraper](https://apify.com/parseforge/trade-me-motors-scraper?fpr=vmoqkp).
3. Set your inputs and any filters, then click **Start**.
4. Export the results as CSV, Excel, JSON, or XML from the **Dataset** tab.

Run it programmatically through the [Apify API](https://docs.apify.com/api/v2) (`run-sync-get-dataset-items`) or the [ApifyClient](https://docs.apify.com/api/client/js) for JavaScript and Python.

### Use with AI agents (MCP)

Give an AI agent live access to Trade Me Motors through the Model Context Protocol. Add the Actor to Claude, Cursor, or any MCP client:

```bash
claude mcp add --transport http apify "https://mcp.apify.com/?tools=parseforge/trade-me-motors-scraper"
```

Then prompt it in plain language to run the scraper and read back the results.

### Troubleshooting

**Why am I getting no results?**

Your filters are too restrictive. Remove one filter at a time, starting with price or year, and run again. Also check that the make and model are spelled exactly as they appear on Trade Me Motors.

**Why did the run stop before reaching maxItems?**

The Actor stops when there are no more matching listings. If you expected more, loosen your filters or increase the price and year ranges.

**Why are some fields empty in the output?**

Not every listing includes every detail. Private sellers often omit odometer or body style. Empty fields are normal and mean the seller did not provide that information.

**Can I get the seller's phone number or email?**

No. Trade Me Motors hides contact details behind a login wall, and this Actor only reads the public listing data. You get the vehicle details, not the seller's contact information.

**Why is the price different from what I saw on the website?**

Prices can change between runs. The Actor captures the price at the moment it reads the listing. Run it again to get the latest price.

### FAQ

| Question | Answer |
|---|---|
| Do I need a Trade Me account or API key? | No. The Actor reads the public search results pages, so you can run it without logging in or registering an app. |
| Can I scrape both used and new cars? | Yes. Set listingType to used, new, or both. The default is used cars. |
| How many vehicles can I collect per run? | Up to 1,000,000. Set maxItems to the number you need, and the Actor stops when it reaches that count or runs out of matches. |
| Which filters are available? | Make, model, body style, transmission, fuel type, price range, year range, max odometer, region, and dealer-only. All filters are optional. |
| What does the output look like? | Each vehicle is a flat row with fields like make, model, year, price, odometer, fuel, transmission, body style, region, and dealer status. You can export to CSV, JSON, Excel, or XML. |
| Can I filter by region? | Yes. Use the region field with a New Zealand region name like Auckland, Wellington, or Canterbury. |
| Does it include private seller listings? | By default, yes. If you only want dealer listings, set isDealer to true. |
| Is the price in NZD? | Yes, all prices are in New Zealand dollars. |
| Can I schedule this Actor to run daily? | Yes, you can set up a schedule in Apify to run it at any interval, then export or push the results to your database. |
| What if I get no results? | Check your filters. A combination like a 2020 Ferrari under $5,000 will return nothing. Loosen one filter at a time to see where the mismatch is. |

### Related actors

Browse the full [ParseForge collection](https://apify.com/parseforge?fpr=vmoqkp) for more scrapers.

🆘 **Need help?** Email parseforge@protonmail.com with your run ID, your input, and what you expected.

⚠️ **Disclaimer.** This Actor is unofficial and is not affiliated with, endorsed by, or sponsored by Trade Me Limited. It collects only publicly available data. You are responsible for using the collected data in compliance with the source's terms of service and applicable data-protection laws, including GDPR, CCPA, and PIPL. Do not use it to collect personal data unlawfully.

# Actor input Schema

## `listingType` (type: `string`):

Type of vehicles to search: used cars, new cars, or both.

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

How many vehicles to collect per run.

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

Filter by vehicle make (brand). E.g. Toyota, Honda, Ford.

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

Filter by vehicle model. E.g. Corolla, Civic, Ranger.

## `bodyStyle` (type: `string`):

Filter by body style. E.g. Hatchback, Sedan, SUV, Ute, Van.

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

Filter by transmission type.

## `fuel` (type: `string`):

Filter by fuel type.

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

Minimum price in NZD.

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

Maximum price in NZD.

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

Minimum year of manufacture.

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

Maximum year of manufacture.

## `odometerMax` (type: `integer`):

Maximum odometer reading in kilometres.

## `region` (type: `string`):

Filter by NZ region. E.g. Auckland, Wellington, Canterbury.

## `isDealer` (type: `boolean`):

When enabled, only show dealer listings. Leave off to show all (dealer + private).

## Actor input object example

```json
{
  "listingType": "used",
  "maxItems": 10
}
```

# Actor output Schema

## `results` (type: `string`):

Dataset with all scraped items

# 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 = {
    "listingType": "used",
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/trade-me-motors-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 = {
    "listingType": "used",
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/trade-me-motors-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 '{
  "listingType": "used",
  "maxItems": 10
}' |
apify call parseforge/trade-me-motors-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,parseforge/trade-me-motors-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/2u4EMpMmMgY0fiovJ/builds/DPHfFEDNlxEdZaqjB/openapi.json