# Realestate.co.nz Scraper (`parsebird/realestate-nz-scraper`) Actor

Scrape property listings from Realestate.co.nz: prices, bedrooms, bathrooms, agents, images, and addresses for sale, rental, and sold NZ real estate.

- **URL**: https://apify.com/parsebird/realestate-nz-scraper.md
- **Developed by:** [ParseBird](https://apify.com/parsebird) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.79 / 1,000 property listings

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

### Realestate.co.nz Scraper

Scrape [Realestate.co.nz](https://www.realestate.co.nz/) property listings by search URL — sale, rental, or sold — into clean, structured JSON with price, address, agent contacts, and photos.

<table><tr>
<td style="border-left:4px solid #1C1917;padding:12px 16px;font-weight:600">
Paste any Realestate.co.nz search link — region, district, or suburb, with price, bedroom, bathroom, land/floor area, property type, and feature filters applied — and get up to 10,000 structured listings back, no proxy required.
</td>
</tr></table>

<br>

##### Copy to your AI assistant

Copy this block into ChatGPT, Claude, Cursor, or any LLM to start using this Realestate.co.nz scraper: `parsebird/realestate-nz-scraper` on Apify. Call it with the `ApifyClient` (Python: `ApifyClient(token).actor("parsebird/realestate-nz-scraper").call(run_input={"startUrls": [{"url": "https://www.realestate.co.nz/residential/sale/auckland"}], "fullScrape": False})`) or the equivalent JS client. Key inputs: `startUrls` (array of `{url}` objects — any Realestate.co.nz `/residential/sale/`, `/residential/rent/`, or `/residential/sold/` search URL, filters and `?page=N` read straight from the URL), `fullScrape` (boolean, default `false` — off scrapes one page/20 results, on scrapes every result up to 10,000), and `proxyConfiguration` (default off; the listings API has no bot protection). Output is one JSON object per unique listing: `listingId`, `title`, `price`, `propertyType`, `bedrooms`, `bathrooms`, `landArea`, `floorArea`, `address`, `suburb`, `region`, `latitude`/`longitude`, `agentName`, `agentEmail`, `agentPhone`, `mainImage`, `images`, `openHomes`, `url`. Full API reference: https://apify.com/parsebird/realestate-nz-scraper/api. Get an API token at https://console.apify.com/account/integrations.

### What does Realestate.co.nz Scraper do?

This Realestate.co.nz scraper extracts structured property data directly from the site's own listings API — no HTML parsing, no missed fields.

- 🔍 **Any search URL** — paste a nationwide, region, district, or suburb search link for sale, rent, or sold listings, filters included.
- 🎯 **Full filter support** — price, bedrooms, bathrooms, car parks, land/floor area, property type, pricing method (auction/tender/asking price/etc.), new construction, coastal waterfront, swimming pool, mortgagee sale, open homes, and more — all read straight from the URL query string, exactly as the Realestate.co.nz search page applies them.
- 🏠 **Rich property data** — price, bedrooms/bathrooms, parking, land and floor area, property type, description, and listing status for every result.
- 📍 **Full address and geolocation** — street, suburb, district, region, postcode, and GPS coordinates for mapping or geospatial analysis.
- 🧑‍💼 **Agent and office contacts** — name, email, phone, photo, and agency details for every listing agent.
- 📸 **Full-resolution photos** — every listing photo, plus open home dates and times.
- 🚀 **No proxy needed** — Realestate.co.nz's listings API has no bot protection, so runs are fast and cheap by default.

Because it runs on the [Apify platform](https://apify.com), you also get scheduling (track new listings and price changes daily), instant API and webhook access, and one-click export to JSON, CSV, Excel, HTML, or XML.

### What data can you extract from Realestate.co.nz?

| Field | Description |
|-------|-------------|
| `listingId`, `listingNo`, `url` | Realestate.co.nz's internal listing ID, agency reference number, and direct listing URL |
| `title`, `price`, `description` | Listing headline, display price (e.g. `$1,125,000`, `Auction`, `Negotiation`), and full description |
| `listingStatus`, `publishedDate` | Current status and date first published |
| `propertyType`, `bedrooms`, `bathrooms`, `parking` | House/townhouse/apartment/etc., bedroom and bathroom counts, total parking spaces |
| `landArea`, `floorArea` (+ units) | Land and floor size |
| `address`, `suburb`, `district`, `region`, `postcode` | Flattened address fields |
| `latitude`, `longitude` | GPS coordinates |
| `swimmingPool`, `newConstruction`, `waterfront`, `mortgageeSale` | Feature flags (Yes/No) |
| `mainImage`, `images` | Primary photo and full photo gallery URLs |
| `openHomes` | Array of open home start/end times |
| `agentName`, `agentEmail`, `agentPhone`, `agentOfficeName`, `agents`, `offices` | Listing agent(s) and office(s) |

### How to scrape Realestate.co.nz property data

1. Open the [Realestate.co.nz Scraper](https://apify.com/parsebird/realestate-nz-scraper) page on Apify.
2. Search on [realestate.co.nz](https://www.realestate.co.nz/) as you normally would — apply the region, price, bedroom, or property-type filters you want — then copy the resulting URL from your browser.
3. Paste that URL into `startUrls`.
4. Leave `fullScrape` off for a quick single-page test (20 results), or turn it on to collect every matching result (up to 10,000).
5. Click **Start** and watch results land in the dataset in real time.
6. Export the finished dataset as JSON, CSV, Excel, HTML, or XML, or pull it via the [API](https://apify.com/parsebird/realestate-nz-scraper/api) / [integrations](https://docs.apify.com/platform/integrations).

### Input / Output

Single search page (default, cheapest way to test):

```json
{
  "startUrls": [{ "url": "https://www.realestate.co.nz/residential/sale/auckland" }],
  "fullScrape": false
}
```

Full region scrape with price, bedroom, and property-type filters:

```json
{
  "startUrls": [
    { "url": "https://www.realestate.co.nz/residential/sale/auckland?minp=500000&maxp=900000&minbe=2&maxbe=4&scat=house,apartment" }
  ],
  "fullScrape": true
}
```

Mix sale, rental, and a specific page of results in one run:

```json
{
  "startUrls": [
    { "url": "https://www.realestate.co.nz/residential/sale/auckland/auckland-city/parnell" },
    { "url": "https://www.realestate.co.nz/residential/rent/wellington?minbe=2" },
    { "url": "https://www.realestate.co.nz/residential/sale/canterbury?page=3" }
  ],
  "fullScrape": false
}
```

Output example:

```json
{
  "listingId": "43125712",
  "listingNo": "939045",
  "url": "https://www.realestate.co.nz/43125712/residential/sale/492-beach-road-murrays-bay",
  "title": "Come Home to the Beach",
  "price": "Auction",
  "listingStatus": "active",
  "propertyType": "House",
  "bedrooms": 3,
  "bathrooms": 2,
  "parking": 4,
  "landArea": 604,
  "landAreaUnit": "SQM",
  "address": "492 Beach Road, Murrays Bay, North Shore City, Auckland",
  "suburb": "Murrays Bay",
  "region": "Auckland",
  "latitude": -36.7306137,
  "longitude": 174.7517089,
  "mainImage": "https://mediaserver.realestate.co.nz/listings/43125712/57b33c2059c82a902400b0bbea766016.jpg",
  "agentName": "Nadja Court",
  "agentEmail": "n.court@barfoot.co.nz",
  "agentOfficeName": "Barfoot & Thompson Ltd (Licensed: REAA 2008) - Mairangi Bay"
}
```

Download results as **JSON, CSV, Excel, HTML, or XML** from the Console, or via the [Apify API](https://docs.apify.com/api/v2).

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_API_TOKEN>")
run = client.actor("parsebird/realestate-nz-scraper").call(run_input={
    "startUrls": [{"url": "https://www.realestate.co.nz/residential/sale/auckland"}],
    "fullScrape": True,
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["title"], item["price"])
```

#### JavaScript

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

const client = new ApifyClient({ token: '<YOUR_API_TOKEN>' });
const run = await client.actor('parsebird/realestate-nz-scraper').call({
    startUrls: [{ url: 'https://www.realestate.co.nz/residential/sale/auckland' }],
    fullScrape: true,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### Use cases

- **Market research** — analyze prices, property types, and sizes across a region, district, or suburb.
- **Price monitoring** — schedule daily runs on a search URL to track new listings and price changes over time.
- **Lead generation** — pull agent and office contact details for a target market segment.
- **Investment analysis** — filter by price range, land area, and property type to screen for investment opportunities.
- **Portfolio and map building** — use the GPS coordinates and address fields to plot listings or feed a geospatial dashboard.

### How it works

1. The Actor reads the same listings data API that powers the Realestate.co.nz search page — no HTML scraping, no missed or stale fields.
2. It parses your search URL to identify the listing type (sale/rent/sold), location (nationwide, region, district, or suburb), and every filter in the query string, then maps them onto the API's native filter parameters.
3. For `fullScrape`, it pages through results in batches until every matching listing (up to Realestate.co.nz's 10,000-result search limit) is collected; otherwise it fetches a single page of 20 results (or the page set by `?page=N`).
4. Every listing is deduplicated by its Realestate.co.nz listing ID as it's found, and pushed to the dataset immediately.

> **Note on sold listings:** `/residential/sold/...` URLs use a different Realestate.co.nz data model (property sale-history records, not active listings) — supported fields are limited to price, address, size, and bedrooms/bathrooms, with no agent, image gallery, or open-home data, and results are not guaranteed to be sorted by most-recent sale.

### How much does it cost to scrape Realestate.co.nz?

This Actor uses the [Pay-Per-Event](https://docs.apify.com/platform/actors/publishing/monetize#pay-per-event-pricing-model) pricing model — you only pay for what you get, with no separate compute charge.

| Event | Free | Bronze | Silver | Gold |
|-------|------|--------|--------|------|
| Listing (per 1,000) | $0.99 | $0.89 | $0.79 | $0.79 |

Collecting 1,000 unique listings costs $0.99 on the Free plan, down to $0.79 on Silver/Gold. Apify's monthly platform usage credits apply to any plan.

### Is it legal to scrape Realestate.co.nz?

Yes — scraping publicly available data is generally legal, as confirmed in cases like *hiQ Labs v. LinkedIn*. This Actor only collects property information that's publicly visible on realestate.co.nz to anyone browsing the site. You are responsible for how you use the collected data — always check the target site's terms of service and applicable law before reusing scraped data commercially. See Apify's [blog post on web scraping legality](https://blog.apify.com/is-web-scraping-legal/) for more detail.

### FAQ

**Does this use an official Realestate.co.nz API?**
No — Realestate.co.nz does not offer a public listings API for third-party use. This Actor reads the same data feed the realestate.co.nz website itself loads, structured into clean JSON.

**Why does `fullScrape` stop before 10,000 results sometimes?**
Realestate.co.nz's search backend caps any single search at 10,000 matching results. If your search matches more than that, narrow it with additional filters (price, bedrooms, property type, or a smaller location) to reach the listings you want.

**Which URL filters are supported?**
All of them: price (`minp`/`maxp`), bedrooms (`minbe`/`maxbe`), bathrooms (`minba`/`maxba`), car parks (`mincp`), land area (`minla`/`maxla`), floor area (`minfa`/`maxfa`), property type (`scat`), pricing method (`pm`), new construction (`nc`), coastal waterfront (`cw`), swimming pool (`sp`), open homes only (`ooh`), floor plans (`fps`), video (`vid`), 3D walkthroughs (`3dw`), keyword (`k`), address (`ad`), school zone (`school`), mortgagee sale (`ms`), and rental furnishing (`off`/`uf`/`pf`). Just build the search on realestate.co.nz and paste the resulting URL.

**Can I scrape a specific suburb or district instead of a whole region?**
Yes — paste the URL for whatever level you searched at (e.g. `.../sale/auckland`, `.../sale/auckland/auckland-city`, or `.../sale/auckland/auckland-city/parnell`); the Actor resolves the location automatically.

**Do I need a proxy?**
No. Realestate.co.nz's listings API has no bot protection, so `proxyConfiguration` defaults to off. Only turn it on if you're running very high volumes and want to distribute requests across IPs.

**Can I schedule this to run automatically?**
Yes. Use Apify's [Scheduler](https://docs.apify.com/platform/schedules) to run it daily, weekly, or at any interval, and combine it with [Apify's storage integrations](https://docs.apify.com/platform/integrations) (Google Sheets, Slack, Make, Zapier, webhooks) to get notified of new listings.

**I found a bug or missing field — where do I report it?**
Open an issue on the Actor's **Issues** tab in Apify Console, or use the [API](https://apify.com/parsebird/realestate-nz-scraper/api) directly for programmatic access.

# Actor input Schema

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

Realestate.co.nz search URLs to scrape, e.g. residential sale, rent, or sold pages. Copy the URL straight from your browser after applying filters on the site — filters and pagination (`?page=2`) are read from the URL.

## `fullScrape` (type: `boolean`):

ON scrapes every result for the search (up to 10,000, Realestate.co.nz's search limit). OFF scrapes a single page only (20 results, or the page set by `?page=N` in the URL) — cheapest way to test the Actor.

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

Realestate.co.nz's listing data API has no bot protection, so a proxy is not required. Turn this on only if you scrape at very high volume and want to distribute requests across IPs.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.realestate.co.nz/residential/sale/auckland"
    }
  ],
  "fullScrape": false,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `dataset` (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.realestate.co.nz/residential/sale/auckland"
        }
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("parsebird/realestate-nz-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.realestate.co.nz/residential/sale/auckland" }],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("parsebird/realestate-nz-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.realestate.co.nz/residential/sale/auckland"
    }
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call parsebird/realestate-nz-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,parsebird/realestate-nz-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/FOirC19OhIMh0wwzT/builds/YUjoEBqJ5HDkQolCx/openapi.json
