# RealEstate.co.nz Scraper with Contacts & Financials (`fatihtahta/realestate-co-nz-scraper`) Actor

Scrape New Zealand property listings from Realestate.co.nz including  prices, addresses, specs, agent info and more. Perfect for real estate analytics, lead generation, or dashboards.

- **URL**: https://apify.com/fatihtahta/realestate-co-nz-scraper.md
- **Developed by:** [Fatih Tahta](https://apify.com/fatihtahta) (community)
- **Categories:** Real estate, Automation, Developer tools
- **Features:** Limited permissions
- **Stats:** 55 total users, 9 monthly users, 100.0% runs succeeded, 5 bookmarks
- **User rating**: No ratings yet

## Pricing

$1.00 / 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.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Realestate.co.nz Scraper | $1.8 / 1k | Fast & Reliable

### Overview

**Realestate.co.nz Scraper** captures structured property data from New Zealand’s leading real estate marketplace. It collects listing details such as titles, prices, locations, property types, bedrooms, bathrooms, land and floor areas, photos, open home schedules, and more. Realestate.co.nz aggregates nationwide listings across residential sales and rentals, making it an essential source for understanding market supply, pricing signals, and regional trends without manual browsing.

This actor automates the process from start to finish, ensuring dependable runs, consistent data quality, and significant time savings for teams that need fresh property intelligence at scale.

### Why Use This Actor

- **Market and pricing analysis:** Track inventory shifts, asking prices, and featured listings across cities, districts, and suburbs.
- **Lead generation and outreach:** Build contact-ready datasets for agencies, investors, and property services based on targeted locations or direct listing links.
- **Portfolio and product tracking:** Monitor listings that match investment criteria, compare attributes, and export structured records to your own tools.
- **Directory and data enrichment:** Create clean, location-aware datasets for dashboards, research projects, or downstream enrichment.
- **Repeatable automation:** Schedule recurring runs to keep datasets current without manual effort.

### Input Parameters

| Parameter | Type | Description | Default |
| --- | --- | --- | --- |
| `startUrls` | array of strings | One or more Realestate.co.nz search, category, or individual listing URLs to capture. Use this when you already have target pages. | Prefilled example provided |
| `city` | array of strings | City names to fetch listings from (e.g., Auckland, Bay of Plenty). Leave empty to include all New Zealand listings. | — |
| `district` | array of strings | District names within the selected city (e.g., Auckland City, Manukau City). | — |
| `suburbs` | array of strings | One or more suburbs within the chosen district (e.g., Auckland Central, Avondale). | — |
| `listing_type` | string | Listing channel for query-built searches: `sale`, `rental`, or `sold`. | `sale` |
| `sort_by` | string | Result ordering for query-built searches: `latest`, `featured`, or `latest-sale`. | `latest` |
| `min_price` / `max_price` | integer | Sale/sold price range, or weekly rent range for rentals. | — |
| `min_bedrooms` / `max_bedrooms` | integer | Bedroom range. | — |
| `min_bathrooms` / `max_bathrooms` | integer | Bathroom range. | — |
| `min_carparks` | integer | Minimum number of carparks. | — |
| `min_land_area` / `max_land_area` | integer | Land area range in square metres. | — |
| `min_floor_area` / `max_floor_area` | integer | Floor area range in square metres. | — |
| `has_swimming_pool` | boolean | Only include listings with a swimming pool. | `false` |
| `sale_property_types` | array of strings | Sale/sold property type IDs such as House `1`, Section `9`, or Townhouse `4`. | — |
| `rental_property_types` | array of strings | Rental property type IDs such as House `10`, Unit `14`, or Studio `12`. | — |
| `publication_date` | string | Optional publication-date window. Use `last_24_hours`, `last_3_days`, `last_7_days`, `last_30_days`, or `last_90_days` to keep only recently published listings. | — |
| `limit` | integer | Maximum number of listings to save per input. Minimum is 1. | `50000` |
| `get_valuations` | boolean | Collect council CV, estimated value, valuation history, and sale history when available. This makes extra property-profile requests and may slow the run. | `false` |
| `proxyConfiguration` | object | Connection settings. The default residential proxy keeps runs stable. | Uses Apify Residential Proxy |

### Example Input

```json
{
  "city": ["Auckland"],
  "district": ["Auckland City"],
  "suburbs": ["Blockhouse Bay"],
  "listing_type": "sale",
  "min_price": 200000,
  "min_bedrooms": 1,
  "max_bedrooms": 4,
  "sale_property_types": ["1", "9", "4"],
  "publication_date": "last_7_days",
  "limit": 200,
  "get_valuations": false
}
```

### Example Output

Each dataset item represents one normalized property listing record. Source-specific details that do not fit a stronger real estate group are preserved under `attributes` or `source_context`.

```json
{
  "record_type": "property_listing",
  "record_id": "43036571",
  "source_context": {
    "source_name": "Realestate.co.nz",
    "source_domain": "realestate.co.nz",
    "source_url": "https://platform.realestate.co.nz/search/v1/listings?filter%5Bsuburb%5D%5B%5D=2776&page%5Boffset%5D=0&page%5Blimit%5D=10",
    "listing_url": "https://www.realestate.co.nz/43036571/residential/sale/32-donovan-street-blockhouse-bay",
    "seed_type": "listing",
    "search_filters": {
      "suburb": "2776"
    },
    "search_paging": {
      "limit": 10,
      "offset": 0
    },
    "external_ids": {
      "listing_no": "1672920",
      "website_slug": "/43036571/residential/sale/32-donovan-street-blockhouse-bay"
    }
  },
  "entity": {
    "title": "Timeless 1950s home with dual title potential",
    "description": "Built in 1953, this solid and well-maintained home offers classic mid-century appeal combined with outstanding future potential.",
    "url": "https://www.realestate.co.nz/43036571/residential/sale/32-donovan-street-blockhouse-bay",
    "status": "active",
    "category": "House",
    "external_ids": {
      "listing_id": "1672920"
    }
  },
  "listing": {
    "listing_id": "1672920",
    "listing_type": "res_sale",
    "listing_status": "active",
    "listing_category_code": "res_sale",
    "listing_subtype": "House",
    "published_at": "2026-04-17T11:19:04",
    "is_featured": true,
    "auction": {
      "date": "2026-05-02",
      "time": "13:30:00",
      "location": "Onsite"
    },
    "open_houses": [
      {
        "start": "2026-05-02T14:00:00+12:00",
        "end": "2026-05-02T14:30:00+12:00"
      }
    ]
  },
  "pricing": {
    "price_text": "Auction"
  },
  "location": {
    "full_address": "32 Donovan Street, Blockhouse Bay, Auckland City, Auckland",
    "address": "32 Donovan Street, Blockhouse Bay",
    "suburb": "Blockhouse Bay",
    "district": "Auckland City",
    "region": "Auckland",
    "country": "New Zealand",
    "coordinates": {
      "lat": -36.9221307,
      "lng": 174.7033677
    }
  },
  "property": {
    "property_type": "House",
    "bedrooms": 3,
    "bathrooms": 1,
    "garages": 1,
    "floor_area": 98,
    "floor_area_unit": "sqm",
    "land_area": 677,
    "land_area_unit": "SQM"
  },
  "media": {
    "main_image_url": "/listings/43036571/5b80da40138d38c7b145b267cb804130",
    "photos": [
      {
        "order": 1,
        "base_url": "/listings/43036571/5b80da40138d38c7b145b267cb804130",
        "variants": {
          "thumbnail": ".crop.31x40.jpg",
          "large": ".resize.1024x768.jpg"
        }
      }
    ]
  },
  "relationships": {
    "agents": [
      {
        "id": "12345",
        "name": "Sample Agent",
        "email": "agent@example.com",
        "phone_mobile": "+64 21 000 0000"
      }
    ],
    "agencies": [
      {
        "id": "67890",
        "name": "Example Realty"
      }
    ]
  },
  "attributes": {
    "education": {
      "schools": []
    },
    "matched_listings": []
  }
}
```

- `record_type` and `record_id` identify each saved property row.
- `source_context` keeps source provenance, input filters, paging, listing URL, and source identifiers.
- `entity`, `listing`, `pricing`, `location`, and `property` hold the core real estate facts.
- `media`, `contact_details`, and `relationships` preserve photos, agents, agencies, and contact channels when the source returns them.
- `pricing` and `attributes` include council CV, estimated values, sale history, and valuation history when `get_valuations` is enabled and the source provides those fields.
- `attributes` keeps meaningful source-specific details such as school context, broadband data, matched listings, and valuation history.

### Notes & Limitations

- Use responsibly and respect Realestate.co.nz’s terms of service and any applicable legal requirements.
- Begin with smaller limits to confirm inputs before scaling up.
- Avoid storing or using personal data without the proper legal basis.

### Support

Questions or custom needs? Open an issue on the **Issues** tab of the actor page in Apify Console and it will be resolved around the clock.

Happy Scraping,

- Fatih

# Actor input Schema

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

Paste one or more supported Realestate.co.nz URLs, such as a residential search page or an individual property listing URL. Use this option for precise repeatability; leave it empty when you want the actor to build a search from city, district, suburb, listing type, price, size, and property-type filters.

## `city` (type: `array`):

Enter city or region names supported by Realestate.co.nz, such as Auckland or Bay of Plenty. Leave this empty to search the actor's default nationwide residential scope; add districts and suburbs when you need a more focused market for monitoring, comparison, or downstream deduplication.

## `district` (type: `array`):

Enter district names within the selected city or region, such as Auckland City or Manukau City. Use districts to reduce broad regional searches into cleaner local-market exports.

## `suburbs` (type: `array`):

Enter one or more suburb names within the selected district, such as Auckland Central, Avondale, or Blockhouse Bay. Suburb-level targeting is useful for repeatable neighborhood monitoring and smaller validation runs.

## `listing_type` (type: `string`):

Select whether the query-built search should collect properties for sale, rentals, or recently sold residential records. This only affects searches built from the structured query fields; direct URLs keep their own source scope.

## `sort_by` (type: `string`):

Choose the ordering used for structured searches. Use latest for fresh listing monitoring, featured for marketplace-style result order, or latest sale date for sold-history workflows.

## `min_price` (type: `integer`):

Enter the minimum sale price for sale or sold searches, or the minimum weekly rent for rental searches. Use price bounds to keep exports aligned with an investment, affordability, or competitive-tracking segment.

## `max_price` (type: `integer`):

Enter the maximum sale price for sale or sold searches, or the maximum weekly rent for rental searches. Combine this with the minimum price to create a bounded pricing band for analysis or scheduled syncs.

## `min_bedrooms` (type: `integer`):

Use this to keep only listings with at least the selected number of bedrooms. This is useful for family-home searches, investor criteria, or lead lists with minimum property requirements.

## `max_bedrooms` (type: `integer`):

Use this to cap the bedroom count for smaller-home, apartment, unit, or tightly scoped rental searches.

## `min_bathrooms` (type: `integer`):

Use this to keep listings that meet a minimum bathroom requirement. Combine it with bedroom, price, and property-type filters for cleaner downstream comparison.

## `max_bathrooms` (type: `integer`):

Use this to cap bathroom count when you want a tighter property profile or smaller export segment.

## `min_carparks` (type: `integer`):

Enter the minimum number of carparks required for each listing. This helps target properties that meet parking requirements for buyers, renters, or operational lead lists.

## `min_land_area` (type: `integer`):

Enter the minimum land area in square metres. Use this for section, lifestyle, redevelopment, or land-size-sensitive property searches.

## `max_land_area` (type: `integer`):

Enter the maximum land area in square metres. Combine this with the minimum land area to keep exports inside a specific land-size band.

## `min_floor_area` (type: `integer`):

Enter the minimum building or floor area in square metres. This helps filter for properties with enough internal space before records are saved.

## `max_floor_area` (type: `integer`):

Enter the maximum building or floor area in square metres. Use it with the minimum floor area for controlled property-size exports.

## `has_swimming_pool` (type: `boolean`):

Enable this when swimming pool availability is part of your property criteria. Leave it off for broader discovery.

## `sale_property_types` (type: `array`):

Choose one or more property types for sale and sold searches, such as House, Section, Apartment, or Townhouse. Leave empty to keep all supported sale or sold property types in scope.

## `rental_property_types` (type: `array`):

Choose one or more property types for rental searches, such as House, Apartment, Unit, Townhouse, or Studio. Leave empty to keep all supported rental property types in scope.

## `publication_date` (type: `string`):

Optionally keep only active listings published within a recent window. Use this for fresh-listing monitoring, scheduled alerts, or incremental ETL refreshes where older active listings are not needed.

## `get_valuations` (type: `boolean`):

Enable this to collect council CV, estimated value, valuation history, and sale history when Realestate.co.nz provides them. Leave it off for faster validation runs, high-volume listing exports, or workflows that only need the standard listing record.

## `limit` (type: `integer`):

Choose the maximum number of listings to save for each input source or query-built search. The actor stops saving records for that source after this limit is reached.

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

The default Apify Residential proxy configuration is suitable for most runs. Adjust only when your Apify workspace has a specific connection policy or you are testing a controlled local setup.

## Actor input object example

```json
{
  "startUrls": [
    "https://www.realestate.co.nz/residential/sale/auckland/auckland-city/blockhouse-bay"
  ],
  "listing_type": "sale",
  "sort_by": "latest",
  "has_swimming_pool": false,
  "get_valuations": false,
  "limit": 50000,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

Normalized Realestate.co.nz property records with source_context, entity, listing, pricing, location, property, media, relationships, and attributes buckets.

# 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": [
        "https://www.realestate.co.nz/residential/sale/auckland/auckland-city/blockhouse-bay"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("fatihtahta/realestate-co-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": ["https://www.realestate.co.nz/residential/sale/auckland/auckland-city/blockhouse-bay"] }

# Run the Actor and wait for it to finish
run = client.actor("fatihtahta/realestate-co-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": [
    "https://www.realestate.co.nz/residential/sale/auckland/auckland-city/blockhouse-bay"
  ]
}' |
apify call fatihtahta/realestate-co-nz-scraper --silent --output-dataset

```

## MCP server setup

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