# TradeMe Scraper | NZ Property, Motors & Marketplace (`haketa/trademe-scraper`) Actor

Scrape trademe.co.nz via public API. Property, motors, marketplace, jobs & services. Auction bids, watchers, reserve status, NZ tenure types & cross-lease. NZD pricing.

- **URL**: https://apify.com/haketa/trademe-scraper.md
- **Developed by:** [Haketa](https://apify.com/haketa) (community)
- **Categories:** Real estate, E-commerce, Jobs
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

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

## TradeMe Scraper — New Zealand Property, Motors, Marketplace & Jobs Data Extractor

> **The most complete TradeMe.co.nz extraction tool on Apify.** Pull live New Zealand listings across property (sale, rent, commercial, rural), motors (cars, motorbikes, boats), marketplace, jobs and services — with **NZD pricing, auction dynamics, watcher counts, region/district/suburb breakdowns** and vertical-specific fields ready for prop-tech, dealer intel, expat relocation and marketplace research workflows.

[![Apify Actor](https://img.shields.io/badge/Apify-Actor-blue)](https://apify.com/haketa/trademe-scraper)
[![Live Data](https://img.shields.io/badge/Data-Live%20at%20Run-orange)]()
[![Engine](https://img.shields.io/badge/Engine-Playwright-green)]()
[![Country](https://img.shields.io/badge/Country-New%20Zealand-black)]()
[![Verticals](https://img.shields.io/badge/Verticals-10-purple)]()
[![Pay Per Event](https://img.shields.io/badge/Pricing-Pay%20Per%20Event-yellow)]()
[![No Auth](https://img.shields.io/badge/Authentication-None%20Required-success)]()
[![Currency](https://img.shields.io/badge/Currency-NZD-lightgrey)]()

---

### What This Actor Does

The **TradeMe Scraper** is a production-ready Apify Actor that extracts live listings from **[trademe.co.nz](https://www.trademe.co.nz/)** — New Zealand's dominant online marketplace and the country's #1 destination for property, cars, jobs and second-hand goods. TradeMe is to NZ what eBay, Realestate.com.au, Carsales and Seek combined are to Australia: a single multi-vertical platform that touches almost every household in Aotearoa.

In a single run the actor returns structured records across **ten verticals**, with NZD pricing, **auction bid counts, watcher counts, reserve status, classified vs auction flags**, full geographic breakdown (region → district → suburb), and vertical-specific attributes such as bedrooms/bathrooms/land-area for property and make/model/year/odometer for motors.

Verticals covered:

- **Property — Residential Sale** — houses, apartments, townhouses, units, sections, lifestyle blocks, new builds
- **Property — Residential Rent** — long-term rentals across all 16 NZ regions
- **Property — Commercial** — retail, office, industrial, hospitality leases & sales
- **Property — Rural** — farms, lifestyle, horticulture, dairy, sheep & beef
- **Motors — Cars** — every dealer and private-listed vehicle in NZ
- **Motors — Motorbikes** — road, off-road, scooters, vintage
- **Motors — Boats & Marine** — power, sail, jetski, trailers
- **Marketplace** — general consumer goods across all categories
- **Jobs** — full-time, part-time, contract & casual roles
- **Services** — trades, professional services, lessons, events

Each listing includes the canonical TradeMe URL, image gallery, normalised sales method (Auction, Tender, Deadline Sale, By Negotiation, Enquiries Over, POA), and an ISO-8601 scrape timestamp — making this the **fastest way to populate or refresh a New Zealand listings dataset for prop-tech, automotive intel, agent benchmarking, expat relocation tooling or competitive marketplace analytics**.

#### Why scrape TradeMe yourself when this exists?

TradeMe is an Angular single-page app that renders cards client-side, throttles unauthenticated callers to roughly 60 requests per hour per IP, and ships its catalogue across a maze of vertical-specific URL shapes. Most teams that try a DIY scraper hit the same wall within a weekend:

- The site is fully **JavaScript-rendered** — `requests`/`urllib` returns an empty shell
- **60 req/hour/IP unauthenticated quota** kills naive scripts immediately
- **Angular icon-based attribute rendering** — bedrooms/bathrooms appear as `<tg-icon>` elements next to bare numbers, not text labels
- **Sales method strings** vary wildly: "Auction", "By Negotiation", "Deadline Sale 12 May 4pm", "Enquiries Over $1,200,000", "POA", "Tender"
- **Cross-lease, leasehold and freehold tenure** plus NZ-specific quirks like Unit Title and Cross-Lease need normalisation
- **REAA 2008 disclosure text** ("Licensed REAA 2008") leaks into agency/agent strings if you scrape naively
- URL geography is encoded as **region/district/suburb slugs** that need title-casing and stripping
- Pagination shape changes between verticals — `?page=2` works for property, marketplace uses different parameters
- **Anti-bot fingerprinting** triggers cloudflare-style challenges on poorly-disguised browsers
- Listing card class names are hashed and change on every TradeMe release

This actor solves every one of those problems — it ships a hardened Playwright browser with `en-NZ` locale, Pacific/Auckland timezone, NZ-tuned proxy rotation, multi-strategy attribute extraction, REAA text scrubbing, sales-method normalisation, and URL-slug geographic parsing — so you get clean JSON with no glue code.

---

### Quick Start

#### One-Click Run

1. Click **"Try for free"** on the [Apify Store page](https://apify.com/haketa/trademe-scraper)
2. Pick a **Vertical** (default: Property — Residential Sale)
3. Optionally add a keyword (e.g. `Ponsonby villa`, `Toyota Hilux`, `iPhone 15`) and region
4. Hit **Start** — your dataset streams in as the browser paginates

#### API Run (Python)

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")

run = client.actor("haketa/trademe-scraper").call(run_input={
    "vertical": "property-residential-sale",
    "keyword": "Ponsonby",
    "region": "1",          ## 1 = Auckland
    "priceMin": 1500000,
    "priceMax": 3500000,
    "auctionFilter": "all",
    "maxRecords": 200,
})

for listing in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(listing["listingId"], listing["title"], listing["priceDisplay"],
          listing["suburb"], listing["bedrooms"])
````

#### API Run (Node.js / TypeScript)

```typescript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });

const run = await client.actor('haketa/trademe-scraper').call({
    vertical: 'motors-cars',
    keyword: 'Toyota Hilux',
    region: '1',          // Auckland
    priceMin: 20000,
    priceMax: 60000,
    maxRecords: 500,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(`${items.length} Auckland Hilux listings`);
items.slice(0, 5).forEach(i => console.log(i.title, i.priceDisplay, i.odometer));
```

#### API Run (cURL)

```bash
curl -X POST "https://api.apify.com/v2/acts/haketa~trademe-scraper/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
        "vertical": "property-residential-rent",
        "region": "15",
        "keyword": "Te Aro",
        "priceMax": 850,
        "maxRecords": 100
      }'
```

***

### How It Works

TradeMe runs on an Angular SPA backed by an internal JSON API. This actor uses a hardened **Playwright (Chromium) browser** to load each search URL exactly the way a Kiwi user would — `en-NZ` locale, `Pacific/Auckland` timezone, realistic viewport and user-agent, `navigator.webdriver` masking, and human-paced delays. Listings are extracted from the rendered DOM using a three-tier strategy with API-response interception as a fallback.

#### Vertical → URL routing

| Vertical input | TradeMe URL path | Subcategory label |
|---|---|---|
| `property-residential-sale` | `/a/property/residential/sale` | residential-sale |
| `property-residential-rent` | `/a/property/residential/rent` | residential-rent |
| `property-commercial` | `/a/property/commercial` | commercial |
| `property-rural` | `/a/property/rural` | rural |
| `motors-cars` | `/a/motors/cars` | cars |
| `motors-motorbikes` | `/a/motors/motorbikes` | motorbikes |
| `motors-boats` | `/a/motors/boats-marine` | boats |
| `marketplace` | `/a/marketplace` | general |
| `jobs` | `/a/jobs` | jobs |
| `services` | `/a/services` | services |

#### Engineering details

- **Playwright Chromium** with `en-NZ` locale and `Pacific/Auckland` timezone — TradeMe geo-personalises results, so this matters
- **Stealth init script** — strips `navigator.webdriver`, injects `window.chrome.runtime`, masks automation fingerprints
- **Adaptive selector cascade** — tries `a[href*="/listing/"]`, then `[class*="ListingCard"]`, then class-fuzzy fallbacks (TradeMe hashes class names on every release)
- **Three-strategy attribute extraction** for bedrooms/bathrooms/parking:
  1. `aria-label` parsing on `[class*="attribute"]`/`[class*="feature"]`/`[class*="icon-text"]` nodes
  2. Text regex (`\d+\s*(?:bed|bath|park)`)
  3. Leaf-node digit collection beside Angular `<tg-icon>` elements with consecutive-duplicate deduplication
- **URL-slug geocoding** — region/district/suburb extracted from the listing URL path and title-cased (`/auckland-city/ponsonby/` → `Auckland City`, `Ponsonby`)
- **REAA scrubbing** — strips `Licensed REAA 2008`, `(Licensed: REAA 2008)`, and split-line variants from agency/agent strings
- **Known-agency splitter** — recognises Barfoot & Thompson, Ray White, Bayleys, Harcourts, LJ Hooker, Professionals, Century 21, Sotheby, Lodge, Eves, Tremain, Property Brokers, Lugtons, Mike Pero, Tall Poppy, NZ Sotheby, RE/MAX and more to cleanly separate agent name from agency
- **Sales-method normaliser** — maps free-text sale terms to canonical labels (Auction / Tender / Deadline Sale / By Negotiation / Enquiries Over / POA)
- **Session-rotated Apify proxy** — each browser session uses a fresh proxy session ID to multiply the 60 req/hour per-IP quota
- **Deduplication** — listingId-keyed `Set` prevents the same auction appearing twice across page boundaries
- **Auction state preserved** — `bidCount`, `maxBidAmount`, `isReserveMet`, `isClassified`, `watchersCount`, `viewCount` are all captured when present

***

### Input Parameters

```json
{
  "vertical": "property-residential-sale",
  "keyword": "Ponsonby villa",
  "region": "1",
  "priceMin": 1500000,
  "priceMax": 3500000,
  "auctionFilter": "all",
  "scrapeDetails": false,
  "maxRecords": 500,
  "rowsPerPage": 500,
  "requestDelay": 2000,
  "proxyConfiguration": { "useApifyProxy": true }
}
```

#### Parameter reference

| Parameter | Type | Default | Description |
|---|---|---|---|
| `vertical` | `string` | `property-residential-sale` | TradeMe section. See vertical reference table. |
| `keyword` | `string` | `""` | Search keyword. Examples: `"Auckland waterfront"`, `"Toyota Corolla"`, `"iPhone 15"`. Empty returns the unfiltered category index. |
| `region` | `string` | `""` | NZ region ID (1–16). See region reference. Empty = all of New Zealand. |
| `priceMin` | `integer` | `0` | Minimum price in NZD. |
| `priceMax` | `integer` | `0` | Maximum price in NZD. `0` = no upper cap. |
| `auctionFilter` | `string` | `all` | `all`, `auction`, `buy-now`, or `classified`. Filters by listing type. |
| `scrapeDetails` | `boolean` | `false` | Fetch full per-listing detail (description, all photos, agent contact, Q\&A count). Adds extra API calls. |
| `maxRecords` | `integer` | `0` | Cap total output. `0` = unlimited. Useful for sampling. |
| `rowsPerPage` | `integer` | `500` | Listings per pagination cycle (22–500). Higher = fewer round-trips, larger responses. |
| `requestDelay` | `integer` | `2000` | Milliseconds between pagination requests. **2000 ms recommended** for the 60 req/hour unauthenticated quota. |
| `proxyConfiguration` | `object` | Apify Proxy on | Apify proxy settings. Rotating residential or datacenter both work — rotation multiplies the per-IP quota. |

***

### Output Schema

Every record uses the same flat JSON schema so consumers (databases, CRMs, BI tools) can ingest cross-vertical data without per-category branching. Fields not relevant to a given vertical are `null`.

#### Common fields (all verticals)

| Field | Type | Description |
|---|---|---|
| `listingId` | `integer` | TradeMe-issued unique listing ID |
| `vertical` | `string` | One of `property`, `motors`, `marketplace`, `jobs`, `services` |
| `title` | `string` | Cleaned listing title (Video badge, "Listed" date, agency suffix stripped) |
| `priceDisplay` | `string` | Human-readable NZD price string as shown on TradeMe (e.g. `$1,250,000`, `By Negotiation`) |
| `startPrice` | `number` | Auction start price in NZD |
| `buyNowPrice` | `number` | Buy Now / asking price in NZD |
| `maxBidAmount` | `number` | Current highest bid in NZD |
| `bidCount` | `integer` | Number of bids placed |
| `isReserveMet` | `boolean` | `true` if reserve has been met |
| `isClassified` | `boolean` | `true` for classified listings (no auction) |
| `watchersCount` | `integer` | Number of users watching the listing |
| `viewCount` | `integer` | Total page views |
| `region` | `string` | NZ region (e.g. `Auckland`, `Wellington`, `Canterbury`) |
| `district` | `string` | Territorial authority (e.g. `Auckland City`, `Wellington City`, `Christchurch City`) |
| `suburb` | `string` | Suburb (e.g. `Ponsonby`, `Te Aro`, `Riccarton`) |
| `description` | `string` | Long-form listing description (when `scrapeDetails: true`) |
| `images` | `array<string>` | CDN image URLs |
| `listingUrl` | `string` | Canonical TradeMe listing URL |
| `startDate` | `string` | ISO-8601 listing start timestamp |
| `endDate` | `string` | ISO-8601 listing end / auction close timestamp |
| `sellerNickname` | `string` | TradeMe seller handle |
| `sellerType` | `string` | `private` or `dealer` / `agency` |
| `scrapedAt` | `string` | ISO-8601 timestamp of extraction |

#### Property-only fields

| Field | Type | Description |
|---|---|---|
| `propertyType` | `string` | House, Apartment, Townhouse, Unit, Section, Lifestyle Property, New Townhouse |
| `bedrooms` | `integer` | Number of bedrooms |
| `bathrooms` | `integer` | Number of bathrooms |
| `landArea` | `number` | Land area in m² |
| `floorArea` | `number` | Floor area in m² |
| `salesMethod` | `string` | Auction, Tender, Deadline Sale, By Negotiation, Enquiries Over, POA |

#### Motors-only fields

| Field | Type | Description |
|---|---|---|
| `make` | `string` | Vehicle make (Toyota, Holden, Ford, Mazda, Nissan, etc.) |
| `model` | `string` | Vehicle model |
| `year` | `integer` | Year of manufacture |
| `odometer` | `integer` | Odometer reading in km |

#### Example: Auckland residential sale (auction)

```json
{
  "listingId": 49823145,
  "vertical": "property",
  "title": "Renovated villa with city views",
  "priceDisplay": "Auction",
  "startPrice": null,
  "buyNowPrice": null,
  "maxBidAmount": 1820000,
  "bidCount": 14,
  "isReserveMet": true,
  "isClassified": false,
  "watchersCount": 87,
  "viewCount": 2143,
  "region": "Auckland",
  "district": "Auckland City",
  "suburb": "Ponsonby",
  "propertyType": "House",
  "bedrooms": 4,
  "bathrooms": 2,
  "landArea": 412,
  "floorArea": 198,
  "salesMethod": "Auction",
  "make": null, "model": null, "year": null, "odometer": null,
  "sellerNickname": "barfoot-ponsonby",
  "sellerType": "agency",
  "description": null,
  "images": ["https://trademe.tmcdn.co.nz/photoserver/full/3265482.jpg"],
  "listingUrl": "https://www.trademe.co.nz/a/property/residential/sale/auckland/auckland-city/ponsonby/listing/49823145",
  "startDate": "2026-05-09T08:00:00Z",
  "endDate":   "2026-05-23T14:00:00Z",
  "scrapedAt": "2026-05-16T22:30:00.000Z"
}
```

#### Example: Wellington used car

```json
{
  "listingId": 49801222,
  "vertical": "motors",
  "title": "2018 Toyota Hilux SR5 Double Cab 4WD",
  "priceDisplay": "$42,990",
  "buyNowPrice": 42990,
  "isClassified": true,
  "watchersCount": 31,
  "viewCount": 894,
  "region": "Wellington",
  "district": "Wellington City",
  "suburb": "Te Aro",
  "make": "Toyota",
  "model": "Hilux",
  "year": 2018,
  "odometer": 87500,
  "sellerNickname": "capital-motors",
  "sellerType": "dealer",
  "images": ["https://trademe.tmcdn.co.nz/photoserver/full/4421987.jpg"],
  "listingUrl": "https://www.trademe.co.nz/a/motors/cars/toyota/hilux/listing/49801222",
  "startDate": "2026-05-12T03:15:00Z",
  "endDate":   "2026-06-09T03:15:00Z",
  "scrapedAt": "2026-05-16T22:30:00.000Z"
}
```

***

### Vertical Reference

| Vertical | Audience | Typical fields populated |
|---|---|---|
| `property-residential-sale` | Buyers, agents, prop-tech | bedrooms, bathrooms, landArea, salesMethod, bids, watchers |
| `property-residential-rent` | Tenants, relocation, BTR investors | bedrooms, bathrooms, weekly rent (priceDisplay) |
| `property-commercial` | CRE brokers, investors | floorArea, salesMethod, classified flag |
| `property-rural` | Farm buyers, lifestyle, ag advisers | landArea, propertyType (Lifestyle / Dairy / Sheep & Beef) |
| `motors-cars` | Dealers, arbitrage, valuation | make, model, year, odometer, sellerType |
| `motors-motorbikes` | Dealers, enthusiasts | make, model, year, odometer |
| `motors-boats` | Marine dealers, brokers | make, model, year, length |
| `marketplace` | E-commerce, resellers, brand monitoring | title, priceDisplay, bidCount, watchersCount |
| `jobs` | Recruiters, salary benchmarking | title, region, employer (sellerNickname) |
| `services` | Trade-platform competitors, local SEO | title, region, suburb |

### NZ Region Reference

| ID | Region | Major centres |
|---|---|---|
| 1 | Auckland | Auckland CBD, Ponsonby, Remuera, North Shore, Manukau, Waitakere |
| 2 | Bay of Plenty | Tauranga, Rotorua, Whakatane |
| 3 | Canterbury | Christchurch, Timaru, Ashburton |
| 4 | Gisborne | Gisborne |
| 5 | Hawke's Bay | Napier, Hastings |
| 6 | Manawatu / Whanganui | Palmerston North, Whanganui |
| 7 | Marlborough | Blenheim, Picton |
| 8 | Nelson | Nelson |
| 9 | Northland | Whangarei, Kerikeri, Paihia |
| 10 | Otago | Dunedin, Queenstown, Wanaka |
| 11 | Southland | Invercargill |
| 12 | Taranaki | New Plymouth |
| 13 | Tasman | Richmond, Motueka |
| 14 | Waikato | Hamilton, Cambridge, Te Awamutu |
| 15 | Wellington | Wellington CBD, Te Aro, Mt Victoria, Lower Hutt, Porirua |
| 16 | West Coast | Greymouth, Hokitika |

### Sales Method Reference

| Canonical value | Source phrases on TradeMe |
|---|---|
| `Auction` | "Auction", "Auction 25 May 2pm" |
| `Tender` | "Tender", "Tender closing 30 May" |
| `Deadline Sale` | "Deadline Sale", "Deadline private treaty" |
| `By Negotiation` | "By Negotiation", "Price by negotiation" |
| `Enquiries Over` | "Enquiries Over $1,200,000", "EOI" |
| `POA` | "POA", "Price on Application" |

***

### Use Cases

#### New Zealand Prop-Tech & Real Estate Analytics

Prop-tech startups, REA platforms and NZ-focused valuation tools use this dataset to:

- **Build live comparable-sales (comps) datasets** across Auckland, Wellington, Christchurch, Hamilton, Tauranga and Queenstown
- **Track auction clearance dynamics** — bid count, watcher count, reserve-met flag — across every Saturday auction
- **Benchmark agency market share** by counting listings per Barfoot & Thompson / Ray White / Bayleys / Harcourts office
- **Monitor rental yields** by joining rent and sale listings on suburb to compute gross yield
- **Detect new development launches** — diff today's listings against last week to flag fresh new-build releases in Hobsonville Point, Mt Wellington and Long Bay

#### Used-Car Arbitrage & Dealer Intelligence

Used-car dealers, fleet buyers and import resellers use TradeMe motors data to:

- **Spot underpriced inventory** the day it lists — alert when a 2018 Hilux SR5 lists below $40k
- **Track dealer-vs-private price gaps** to negotiate trade-in offers more accurately
- **Monitor JDM import volumes** — Toyota Aqua, Mazda Demio, Nissan Note — across Auckland and Christchurch importers
- **Benchmark days-on-market** for each make/model/year combo by snapshotting daily
- **Inform shipping container loading** — Japanese auctioneers brief based on what's actually moving in NZ

#### Expat Relocation & Migration Tooling

Immigration consultants, relocation agencies and HR mobility teams use TradeMe data to:

- **Generate accurate cost-of-living reports** with live Auckland 2-bed rent figures (Ponsonby vs Mt Eden vs New Lynn)
- **Pre-populate suburb shortlists** for incoming senior hires moving from Sydney, London or San Francisco
- **Bundle rental + used-car + furniture marketplace data** into a single onboarding package
- **Benchmark school-zone rentals** in Auckland Grammar, Epsom Girls and Wellington College catchments
- **Provide weekly market briefings** to corporate sponsors of skilled-migrant employees

#### REA / Agent Competitive Intelligence

Real estate agencies, franchise operators and individual agents use TradeMe extracts to:

- **Track listing share** across Barfoot & Thompson, Ray White, Bayleys, Harcourts, Tall Poppy and Mike Pero
- **Identify agents with falling listing counts** as recruitment targets
- **Benchmark listing-to-sold ratios** by office and by suburb
- **Spot under-marketed listings** — properties with low watcher counts are candidates for switching agency
- **Build agent leaderboards** for franchise comp plans and internal scorecards

#### Marketplace & Resale Research

Resellers, drop-shippers and brand-monitoring teams use TradeMe marketplace data to:

- **Track second-hand iPhone, PlayStation, MacBook and Lego pricing** across the entire NZ market
- **Identify undervalued vintage inventory** in collectibles, art and electronics
- **Spot counterfeit listings** by joining seller nickname × suspiciously low price
- **Benchmark NZD resale value** of imported retail goods for arbitrage planning
- **Monitor brand presence and grey-market activity** for global consumer brands

#### Automotive Market Research & Valuation

Auto OEMs, lease companies and insurance carriers use motors data to:

- **Power residual-value models** for the next-generation Toyota Hilux, Ford Ranger, Mazda CX-5
- **Track NZ EV adoption** — count Tesla, BYD, Polestar and Nissan Leaf listings month-over-month
- **Inform lease pricing** based on actual market resale not generic depreciation tables
- **Benchmark insurance write-off recoveries** against open-market private listings

#### Recruitment & Salary Benchmarking

Recruiters, HR teams and salary-data startups use TradeMe Jobs to:

- **Map NZ job-market depth** by region — count Wellington tech roles vs Auckland finance roles vs Christchurch trades
- **Track salary-band shifts** across software, healthcare, construction and hospitality
- **Identify high-growth employers** by counting active listings per company
- **Benchmark contract-vs-permanent ratios** by industry

#### Rural, Lifestyle & Agribusiness

Ag-tech, farm-finance and lifestyle-block agents use TradeMe Rural to:

- **Monitor dairy, sheep & beef, horticulture and lifestyle listings** by district
- **Track rural land-value trends** across Waikato, Canterbury, Hawke's Bay and Otago
- **Benchmark per-hectare prices** for farm acquisitions and land banking
- **Identify forestry and horticulture conversion candidates** by land area and zoning

***

### Sample Queries & Recipes

#### Recipe 1: Every Auckland villa for sale between $1.5M and $3.5M

```json
{
  "vertical": "property-residential-sale",
  "keyword": "villa",
  "region": "1",
  "priceMin": 1500000,
  "priceMax": 3500000,
  "auctionFilter": "all",
  "maxRecords": 500
}
```

#### Recipe 2: Wellington Te Aro rentals under $850/week

```json
{
  "vertical": "property-residential-rent",
  "keyword": "Te Aro",
  "region": "15",
  "priceMax": 850,
  "maxRecords": 200
}
```

#### Recipe 3: All Toyota Hilux listings across NZ

```json
{
  "vertical": "motors-cars",
  "keyword": "Toyota Hilux",
  "priceMin": 15000,
  "priceMax": 80000,
  "maxRecords": 1000
}
```

#### Recipe 4: Christchurch lifestyle blocks over 1 hectare

```json
{
  "vertical": "property-rural",
  "keyword": "lifestyle",
  "region": "3",
  "priceMin": 800000,
  "maxRecords": 200
}
```

#### Recipe 5: Auctions only — Saturday auction tracker for Auckland CBD

```json
{
  "vertical": "property-residential-sale",
  "region": "1",
  "auctionFilter": "auction",
  "maxRecords": 300
}
```

#### Recipe 6: iPhone 15 second-hand pricing nationwide

```json
{
  "vertical": "marketplace",
  "keyword": "iPhone 15",
  "auctionFilter": "all",
  "maxRecords": 500
}
```

#### Recipe 7: Sample 50 records to validate schema before a full pull

```json
{
  "vertical": "property-residential-sale",
  "maxRecords": 50,
  "rowsPerPage": 50
}
```

***

### Integration Examples

#### Google Sheets (via Apify Integration)

1. Schedule the actor to run nightly at 7:00 AM NZST
2. Add the **"Export to Google Sheets"** integration to the schedule
3. Receive a fresh NZ listings sheet every morning — pre-filtered by suburb, vertical or price band

#### Make.com / Zapier / n8n

Use the **Apify** connector on any major automation platform. Trigger downstream workflows on:

- **New listings** (today's dataset minus yesterday's keyed on `listingId`)
- **Price drops** (`buyNowPrice` decreased week-over-week)
- **Auction close events** — when `endDate` lands in the next 24 hours
- **Watcher milestones** — alert when `watchersCount` crosses 100
- **Reserve-met flips** — `isReserveMet` changes from `false` to `true`

#### Power BI / Tableau / Looker

Connect Apify's REST dataset endpoint as a data source. Refresh on Apify schedule. Build dashboards covering:

- Median asking price by Auckland suburb
- Auction clearance % by district
- Dealer vs private listing share for top 20 NZ car models
- New-listing volume heatmap by NZ region
- Rental yield by suburb (rent ÷ sale price × 52)

#### Postgres / Snowflake / BigQuery

Use the [Apify webhook integration](https://docs.apify.com/platform/integrations/webhooks) to POST run results directly to your warehouse ingestion endpoint after every scheduled run. Recommended primary key: `listingId` + `scrapedAt` for slowly-changing-dimension history.

#### Salesforce / HubSpot CRM Enrichment

For agency-CRM use cases, upsert against Account records keyed on `sellerNickname`. New listings can auto-create Opportunities; auction-close events can fire Tasks. For dealer-CRM use cases, key on `make` + `model` + `year` to drive inventory-acquisition workflows.

#### Webhooks & Push Notifications

Use Apify's webhook integration to push events into Slack, Discord, Microsoft Teams or your own service the moment a run finishes — perfect for "new $2M+ Ponsonby listing" Slack alerts to the buying team.

***

### Major NZ Markets Covered

| Metro / Region | Population (approx) | What you'll find |
|---|---|---|
| Auckland (CBD, Ponsonby, Remuera, North Shore) | 1.7M | NZ's largest property market, biggest dealer car market, deepest marketplace inventory |
| Wellington (Te Aro, Mt Victoria, Kelburn) | 0.4M | Government & tech jobs, compact apartment market, strong rental data |
| Christchurch (Riccarton, Merivale, Fendalton) | 0.4M | Post-quake rebuild, family homes, strongest South Island listings |
| Hamilton (Hamilton East, Rototuna) | 0.18M | Waikato hub, growing satellite housing, education sector jobs |
| Tauranga (Mt Maunganui, Papamoa) | 0.16M | Coastal lifestyle, retirement & investor market |
| Dunedin | 0.13M | Student rental hub, Otago university precinct |
| Queenstown | 0.05M | Resort property, tourism real estate, lifestyle blocks |
| Napier / Hastings (Hawke's Bay) | 0.14M | Horticulture, wine country, regional centres |
| Whangarei / Kerikeri (Northland) | 0.10M | Subtropical lifestyle, retirement migration |
| Rotorua | 0.07M | Tourism, geothermal, forestry |

Every TradeMe region ID (1–16) is supported via the `region` parameter.

***

### Cost & Performance

| Metric | Value |
|---|---|
| Engine | Playwright (Chromium), `en-NZ` locale, `Pacific/Auckland` timezone |
| Runtime (50 listings) | ~30 seconds |
| Runtime (500 listings, single vertical) | 2–4 minutes |
| Runtime (full vertical sweep, ~5K listings) | 15–30 minutes |
| Pricing model | Pay-per-event (transparent per-record pricing) |
| Data freshness | Live — fetched at run time |
| Auth required | None |
| Proxy required | Recommended (Apify residential or datacenter) |
| Concurrency | Safe to run multiple verticals or regions in parallel |
| Memory footprint | 512 MB (Playwright Chromium baseline) |
| Quota awareness | Default 2000 ms delay respects the 60 req/hour unauthenticated limit |

***

### Compliance, Privacy & Legal Notes

- **Public data only** — every field returned is visible to any unauthenticated visitor on [trademe.co.nz](https://www.trademe.co.nz/)
- **No personally-identifiable information beyond what TradeMe publishes** — seller nicknames are TradeMe-issued handles, not real names; agency disclosures are scrubbed of the REAA 2008 licensee text
- **No phone numbers or emails** are extracted unless TradeMe displays them in the public listing body
- **HIPAA / PHI** does not apply — TradeMe is a commerce marketplace
- **NZ Privacy Act 2020 / GDPR / CCPA** compliance is the responsibility of the data consumer; this actor surfaces only data TradeMe itself publishes openly
- Honour TradeMe's [Terms of Use](https://www.trademe.co.nz/help/4087/general-terms-and-conditions) — do not republish full listings verbatim at scale, do not contact users with unsolicited messages, and do not use this data for stalking, harassment or fraudulent purposes
- The actor respects sensible request pacing (2-second default delay) to avoid undue load on TradeMe infrastructure
- Use case suitability: market analytics, internal CRM enrichment, prop-tech feeds, dealer pricing intelligence, academic and journalistic research

> **Important:** TradeMe data may not be used for spam, identity fraud, scraping for re-listing on a competing marketplace, or any purpose violating NZ law. Always consult a lawyer if your use case touches consumer protection, fair trading or privacy regulation.

***

### Frequently Asked Questions

#### How fresh is the data?

Live at the moment of the run. TradeMe listings update continuously — auctions tick, watchers grow, new listings appear. Each `scrapedAt` timestamp records exactly when the actor read the page.

#### How many records can I pull in one run?

Practical cap is bounded by TradeMe's pagination (typically up to ~5,000 listings per category-region combo) and your `requestDelay`. For broad sweeps, run multiple narrower configs in parallel rather than one massive run.

#### Does this actor require a TradeMe login or API key?

No. It scrapes the public unauthenticated catalogue. TradeMe's own API requires OAuth approval; this actor avoids that path entirely and works out of the box.

#### Do I need a proxy?

Recommended. Without rotation, unauthenticated TradeMe sessions are throttled to roughly 60 requests per hour per IP. Apify Proxy (residential or datacenter) rotates sessions so you can run faster. For small `maxRecords` runs (≤200) you can run without proxy.

#### Does it handle CAPTCHAs?

TradeMe rarely shows CAPTCHAs to well-disguised browsers. The actor uses a stealth init script (strips `navigator.webdriver`, injects `window.chrome.runtime`), `en-NZ` locale and Pacific/Auckland timezone, plus humane pacing — which dodges the CAPTCHA path in the overwhelming majority of runs.

#### What about Australian listings?

This actor is New Zealand only. For Australia, use the [Domain.com.au Property Scraper](https://apify.com/haketa/domain-com-au-scraper) for AU real estate or the [SEEK Scraper](https://apify.com/haketa/seek-scraper) for AU/NZ jobs.

#### Can I scrape just one suburb?

Use the `keyword` parameter (e.g. `"Ponsonby"`, `"Te Aro"`, `"Mt Maunganui"`) combined with the matching `region`. Suburb appears in URL slugs which the actor parses into the `suburb` field — post-filter downstream for exact match.

#### Does the actor capture auction bid history?

It captures the **current** snapshot — `bidCount`, `maxBidAmount`, `isReserveMet`, `watchersCount`. For full bid history, schedule the actor to run hourly and archive each dataset to your warehouse, then reconstruct timelines by joining on `listingId`.

#### Does it work for property rentals?

Yes — set `vertical: "property-residential-rent"`. The `priceDisplay` and `buyNowPrice` fields then represent weekly rent in NZD.

#### How does region filtering work?

Pass the numeric region ID (1–16) via the `region` parameter. See the NZ Region Reference table above. Empty string returns all of New Zealand.

#### Can I export the data in CSV or Excel?

Yes. Apify's dataset view exports to JSON, CSV, Excel (XLSX), HTML, XML, RSS and JSON Lines. Or stream via the API.

#### What if a build fails or no listings come back?

The actor logs the rendered HTML length, page title, and selector counts on the first page. If selectors return 0 hits, TradeMe likely shipped a layout change — open an Issue on the Apify Store page with the run ID and we'll patch the selector cascade.

#### Can I run this on a schedule?

Yes — Apify's built-in Scheduler supports cron expressions. Common patterns: every 30 minutes for auction monitoring, daily for prop-tech ingestion, weekly for market dashboards.

#### Does it deduplicate across pages?

Yes. A `listingId`-keyed `Set` ensures every listing appears once even if TradeMe's pagination overlaps.

#### What's `scrapeDetails` for?

When `true`, the actor follows each listing into its detail page to pull the full description, all photos, agent contact and Q\&A count. Uses extra requests so it's slower — leave `false` for fast index scrapes.

#### Are images downloaded?

Image **URLs** are captured (TradeMe CDN — `trademe.tmcdn.co.nz`). The actor does not download image bytes; consume the URLs directly or pipe them to your own download workflow.

#### Does this actor work on the Apify Free plan?

Yes. Free-plan compute is sufficient for small (`maxRecords ≤ 200`) runs. For multi-region or whole-vertical sweeps, the Personal / Team plans offer better headroom.

#### Can it pull motors odometer and year?

Yes for cars and motorbikes — both `year` and `odometer` (km) are captured directly from listing text when present.

***

### Related Apify Actors by Haketa

If you cover ANZ, broader marketplaces or international real estate, these companions pair naturally with the TradeMe scraper:

- [Domain.com.au Property Scraper (Australia)](https://apify.com/haketa/domain-com-au-scraper) — full AU residential and commercial property
- [SEEK Scraper (Australia/NZ)](https://apify.com/haketa/seek-scraper) — jobs across AU and NZ
- [Kleinanzeigen.de Scraper (Germany)](https://apify.com/haketa/kleinanzeigen-scraper) — Germany's #1 classifieds platform
- [Marktplaats.nl Scraper (Netherlands)](https://apify.com/haketa/marktplaats-scraper) — Dutch national marketplace
- [OfferUp Scraper (US)](https://apify.com/haketa/offerup-scraper) — US local marketplace
- [Kijiji.ca Scraper (Canada)](https://apify.com/haketa/kijiji-scraper) — Canadian national classifieds
- [Mudah.my Scraper (Malaysia)](https://apify.com/haketa/mudah-scraper) — Malaysia's leading marketplace
- [Chotot.com Scraper (Vietnam)](https://apify.com/haketa/chotot-scraper) — Vietnam's largest classifieds
- [Mourjan Scraper (MENA)](https://apify.com/haketa/mourjan-scraper) — Middle East & North Africa classifieds
- [Realtor.ca Scraper (Canada)](https://apify.com/haketa/realtor-ca-scraper) — Canada real estate
- [Apartments.com Scraper (US)](https://apify.com/haketa/apartments-com-scraper) — US rentals
- [Rent.com Scraper (US)](https://apify.com/haketa/rent-com-scraper) — US rental listings

***

### Comparison vs. Alternatives

| Approach | Setup time | Data freshness | NZ multi-vertical | Schema normalisation | Auction state captured |
|---|---|---|---|---|---|
| **This actor** | < 1 minute | Live | All 10 verticals | Built-in | Yes (bids, watchers, reserve) |
| Manual TradeMe browsing | n/a | Live | Yes | None | Manual only |
| Custom Python + Playwright | 2–5 days dev | Live | DIY per vertical | DIY | DIY |
| TradeMe official OAuth API | Days–weeks (approval) | Live | Limited categories | DIY normalisation | Yes |
| Paid NZ property data feed | Weeks of contracts | Daily | Property only | Vendor schema | Property auctions only |
| Generic web scraper | Hours | Live | None | None | None |

***

### Why Pay-Per-Event Pricing?

Most scrapers either charge a flat monthly subscription (you pay even if you don't use it) or per-Compute-Unit (unpredictable on browser actors). This actor uses **pay-per-event** pricing:

- You only pay when the actor actually runs
- Charges scale with the number of listings you consume — not browser seconds
- Transparent line-item billing in your Apify console
- No monthly minimums, no annual commitments
- Free to evaluate — sample with `maxRecords: 50` for cents
- Predictable for budgeting — same query → same cost shape

***

### Changelog

| Version | Date | Notes |
|---|---|---|
| 1.0.0 | 2026-05 | Initial public release — Playwright engine, 10 verticals, NZD pricing, auction state, region/district/suburb parsing, REAA scrubbing, sales-method normalisation, pay-per-event pricing |

***

### Keywords

TradeMe scraper · TradeMe data API · TradeMe.co.nz scraper · New Zealand property scraper · NZ property data · NZ real estate scraper · Auckland property data · Wellington property data · Christchurch property scraper · Hamilton property scraper · Tauranga real estate data · Queenstown property data · Dunedin property scraper · TradeMe motors data · TradeMe cars scraper · NZ used car data · Toyota Hilux NZ data · TradeMe marketplace scraper · NZ classifieds extractor · TradeMe price scraper · TradeMe listings API · TradeMe auction tracker · TradeMe watchers data · NZ rental data · Auckland rental scraper · Wellington rental data · NZ commercial property data · NZ rural property data · TradeMe jobs scraper · TradeMe services scraper · NZ marketplace API · Aotearoa real estate data · Ponsonby property data · Te Aro rental data · NZ prop-tech data · NZ dealer intelligence · NZD pricing API · Apify TradeMe actor · NZ classifieds API · TradeMe data extraction · TradeMe agent intelligence · Barfoot Thompson scraper · Ray White NZ data · Bayleys listings · Harcourts NZ data · TradeMe Saturday auction tracker · TradeMe data feed · New Zealand listings export · NZ real estate analytics

***

### Support

- **Bug reports:** Use the **Issues** tab on the Apify Store page — include run ID and vertical
- **Feature requests:** Same place, describe your use case (vertical, region, expected field)
- **Direct contact:** Through the Apify developer profile
- **Custom NZ data jobs:** Contact for bespoke filtering, scheduling or warehouse-direct delivery

If this actor saves you time, a **5-star rating** on the Apify Store helps other NZ prop-tech teams, dealers and marketplace researchers discover it. Tēnā koe!

# Actor input Schema

## `vertical` (type: `string`):

TradeMe section to scrape.

## `keyword` (type: `string`):

Search keyword. Examples: 'Auckland waterfront', 'Toyota Corolla', 'iPhone'

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

NZ region ID. 1=Auckland, 2=Bay of Plenty, 3=Canterbury, 4=Gisborne, 5=Hawke's Bay, 6=Manawatu, 7=Marlborough, 8=Nelson, 9=Northland, 10=Otago, 11=Southland, 12=Taranaki, 13=Tasman, 14=Waikato, 15=Wellington, 16=West Coast. Leave empty for all NZ.

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

Minimum price in NZD.

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

Maximum price in NZD. Set 0 for no limit.

## `auctionFilter` (type: `string`):

Filter by listing type.

## `scrapeDetails` (type: `boolean`):

Fetch full details for each listing via /v1/Listings/{id}.json. Includes full description, all photos, agent contact, Q\&A count. Uses extra API calls.

## `maxRecords` (type: `integer`):

Maximum total listings. Set 0 for unlimited.

## `rowsPerPage` (type: `integer`):

Results per API call. Max 500. Higher = fewer calls but larger responses.

## `requestDelay` (type: `integer`):

Delay between API calls. 2000ms recommended for unauthenticated (60 req/hour limit).

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

Datacenter proxy works. Rotate IPs to multiply the 60 req/hour/IP limit.

## Actor input object example

```json
{
  "vertical": "property-residential-sale",
  "priceMin": 0,
  "priceMax": 0,
  "auctionFilter": "all",
  "scrapeDetails": false,
  "maxRecords": 50,
  "rowsPerPage": 500,
  "requestDelay": 2000,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `listingId` (type: `string`):

No description

## `title` (type: `string`):

No description

## `vertical` (type: `string`):

No description

## `priceDisplay` (type: `string`):

No description

## `bidCount` (type: `string`):

No description

## `watchersCount` (type: `string`):

No description

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

No description

## `suburb` (type: `string`):

No description

## `listingUrl` (type: `string`):

No description

## `scrapedAt` (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 = {
    "vertical": "property-residential-sale",
    "keyword": "",
    "region": "",
    "scrapeDetails": false,
    "maxRecords": 50,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("haketa/trademe-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 = {
    "vertical": "property-residential-sale",
    "keyword": "",
    "region": "",
    "scrapeDetails": False,
    "maxRecords": 50,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("haketa/trademe-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 '{
  "vertical": "property-residential-sale",
  "keyword": "",
  "region": "",
  "scrapeDetails": false,
  "maxRecords": 50,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call haketa/trademe-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "TradeMe Scraper | NZ Property, Motors & Marketplace",
        "description": "Scrape trademe.co.nz via public API. Property, motors, marketplace, jobs & services. Auction bids, watchers, reserve status, NZ tenure types & cross-lease. NZD pricing.",
        "version": "0.0",
        "x-build-id": "EgphUfEPl6JXnIAXm"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/haketa~trademe-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-haketa-trademe-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/haketa~trademe-scraper/runs": {
            "post": {
                "operationId": "runs-sync-haketa-trademe-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/haketa~trademe-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-haketa-trademe-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",
                "required": [
                    "vertical"
                ],
                "properties": {
                    "vertical": {
                        "title": "Vertical",
                        "enum": [
                            "property-residential-sale",
                            "property-residential-rent",
                            "property-commercial",
                            "property-rural",
                            "motors-cars",
                            "motors-motorbikes",
                            "motors-boats",
                            "marketplace",
                            "jobs",
                            "services"
                        ],
                        "type": "string",
                        "description": "TradeMe section to scrape.",
                        "default": "property-residential-sale"
                    },
                    "keyword": {
                        "title": "Keyword",
                        "type": "string",
                        "description": "Search keyword. Examples: 'Auckland waterfront', 'Toyota Corolla', 'iPhone'"
                    },
                    "region": {
                        "title": "Region",
                        "type": "string",
                        "description": "NZ region ID. 1=Auckland, 2=Bay of Plenty, 3=Canterbury, 4=Gisborne, 5=Hawke's Bay, 6=Manawatu, 7=Marlborough, 8=Nelson, 9=Northland, 10=Otago, 11=Southland, 12=Taranaki, 13=Tasman, 14=Waikato, 15=Wellington, 16=West Coast. Leave empty for all NZ."
                    },
                    "priceMin": {
                        "title": "Min Price (NZD)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum price in NZD.",
                        "default": 0
                    },
                    "priceMax": {
                        "title": "Max Price (NZD)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum price in NZD. Set 0 for no limit.",
                        "default": 0
                    },
                    "auctionFilter": {
                        "title": "Auction Filter",
                        "enum": [
                            "all",
                            "auction",
                            "buy-now",
                            "classified"
                        ],
                        "type": "string",
                        "description": "Filter by listing type.",
                        "default": "all"
                    },
                    "scrapeDetails": {
                        "title": "Scrape Listing Details",
                        "type": "boolean",
                        "description": "Fetch full details for each listing via /v1/Listings/{id}.json. Includes full description, all photos, agent contact, Q&A count. Uses extra API calls.",
                        "default": false
                    },
                    "maxRecords": {
                        "title": "Max Records",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum total listings. Set 0 for unlimited.",
                        "default": 0
                    },
                    "rowsPerPage": {
                        "title": "Rows Per Page",
                        "minimum": 22,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Results per API call. Max 500. Higher = fewer calls but larger responses.",
                        "default": 500
                    },
                    "requestDelay": {
                        "title": "Request Delay (ms)",
                        "minimum": 500,
                        "maximum": 60000,
                        "type": "integer",
                        "description": "Delay between API calls. 2000ms recommended for unauthenticated (60 req/hour limit).",
                        "default": 2000
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Datacenter proxy works. Rotate IPs to multiply the 60 req/hour/IP limit."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```