# Realestate.co.nz Property Listings Scraper (`automation-lab/realestate-co-nz-property-listings-scraper`) Actor

🏠 Extract public New Zealand sale and rental listings with prices, specifications, descriptions, coordinates, images, open homes, listing agents, and agencies from Realestate.co.nz.

- **URL**: https://apify.com/automation-lab/realestate-co-nz-property-listings-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Real estate
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## Realestate.co.nz Property Listings Scraper

Collect structured New Zealand residential property listings from public **Realestate.co.nz** search pages and individual property pages. Export prices, addresses, specifications, descriptions, coordinates, photos, open homes, listing agents, and agencies to JSON, CSV, Excel, or your own workflow.

No Realestate.co.nz login is required. Start with a sale or rental search URL, choose a listing limit, and receive one clean dataset row per unique property.

- 🏠 Track residential inventory across NZ regions and suburbs
- 💰 Compare asking prices and property specifications
- 📅 Monitor new listings and upcoming open-home times
- 🤝 Build property and agency research workflows

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

The Actor turns public residential sale and rental pages into analysis-ready records. It accepts URLs you already use on Realestate.co.nz, follows search pagination, deduplicates properties by listing ID, and can visit each detail page for richer fields.

Use search-card-only mode for quick inventory snapshots. Keep detail enrichment enabled when you need descriptions, latitude and longitude, full image sets, title type, open homes, or agent context.

The scraper supports:

- residential sale search URLs;
- residential rental search URLs;
- individual residential sale listing URLs;
- individual residential rental listing URLs;
- multiple start URLs in one run;
- optional Apify Proxy or custom proxy routing.

### Who is it for?

#### Property analysts and investors

Build comparable-property tables, watch regional inventory, identify new stock, and compare bedroom, bathroom, land-area, and price attributes.

#### Buyer agents and brokerages

Schedule suburb searches, collect open-home times, and connect each property with its advertised listing agent and agency.

#### Portals and data teams

Feed normalized public listing records into a warehouse, dashboard, CRM, spreadsheet, or internal search product.

#### Researchers and journalists

Capture time-stamped snapshots of public sale and rental markets without manually copying every listing page.

### Why use this Realestate.co.nz scraper?

- ✅ **No account needed** — the Actor uses public anonymous pages.
- ✅ **Search and detail inputs** — run broad inventory jobs or one-property lookups.
- ✅ **Rich records** — combine visible page fields with public JSON-LD structured data.
- ✅ **Predictable limits** — cap records and search pages before a run starts.
- ✅ **Unique results** — duplicate listing IDs are saved only once across all inputs.
- ✅ **Ready to integrate** — export from Apify or call through API and MCP clients.

### What property data can you extract?

| Field | Description |
|---|---|
| `listingId` | Realestate.co.nz property identifier from the URL |
| `listingNumber` | Advertised listing reference when available |
| `url` | Canonical public property URL |
| `status` | `sale` or `rental` |
| `address` | Full advertised address |
| `suburb`, `district`, `region` | NZ location hierarchy |
| `headline`, `description` | Listing marketing copy |
| `priceDisplay` | Visible price or sale method text |
| `priceAmount`, `priceCurrency` | Numeric structured price when published |
| `bedrooms`, `bathrooms` | Main room counts |
| `garages`, `otherParking` | Parking details when shown |
| `floorAreaM2`, `landAreaM2` | Published areas in square metres |
| `propertyType`, `titleType` | House/unit/etc. and title information |
| `latitude`, `longitude` | Public listing coordinates |
| `listedDate`, `listedAge` | Detail date and search-card age |
| `imageUrl`, `imageUrls` | Primary and additional listing photos |
| `openHomeStarts`, `openHomeEnds` | ISO open-home event times |
| `agentNames`, `agentUrls` | Advertised listing agents |
| `agencyName`, `agencyUrl` | Listing office context |
| `scrapedAt` | UTC collection timestamp |

Fields are optional when the source listing does not publish them. Numeric values are emitted as numbers rather than formatted strings whenever the source provides a parseable value.

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

This Actor uses pay-per-event pricing:

- **Actor start:** $0.005 per run
- **Property listing:** tiered by your Apify plan; BRONZE is $0.00011815 per saved property

Your final charge depends on the number of unique dataset records, not the number of HTML pages requested. The Apify Console shows an estimate before and during a run.

A one-property lookup costs the start event plus one property event. A 100-property inventory snapshot costs the start event plus 100 property events at your plan tier. Apify Free plan users can test the prefilled one-property example within normal platform credits.

### How to scrape Realestate.co.nz in 5 steps

1. Open a public residential sale, rental, or property page on Realestate.co.nz.
2. Copy the complete URL, including search filters you want to preserve.
3. Add the URL under **Search or property URLs**.
4. Set **Maximum property listings** and choose whether to visit detail pages.
5. Click **Start**, then download the default dataset as JSON, CSV, Excel, XML, or RSS.

For a cheap first run, keep the prefilled single property URL and `maxItems: 1`.

### Input parameters

| Parameter | Type | Default | Purpose |
|---|---|---:|---|
| `startUrls` | array | required | Realestate.co.nz residential search/detail URLs |
| `maxItems` | integer | 10 | Global cap on unique saved properties |
| `includeDetails` | boolean | `true` | Follow each property page for rich fields |
| `maxPages` | integer | 20 | Pagination safety limit per search URL |
| `proxyConfiguration` | object | direct | Optional Apify/custom proxy settings |

Only `realestate.co.nz` residential sale/rental search and detail URLs are accepted. Unsupported domains and unrelated paths fail before scraping, which prevents accidental out-of-scope runs.

### Example input: Auckland sale listings

```json
{
  "startUrls": [
    { "url": "https://www.realestate.co.nz/residential/sale/auckland?by=latest&oad=true" }
  ],
  "maxItems": 25,
  "includeDetails": true,
  "maxPages": 3,
  "proxyConfiguration": { "useApifyProxy": false }
}
````

To monitor rentals, use a public `/residential/rental/...` search URL with the same settings.

### Example output

```json
{
  "listingId": "43070114",
  "listingNumber": "936151",
  "url": "https://www.realestate.co.nz/43070114/residential/sale/46-mountain-road-epsom",
  "status": "sale",
  "address": "46 Mountain Road, Epsom, Auckland City",
  "suburb": "Epsom",
  "district": "Auckland City",
  "region": "Auckland",
  "priceDisplay": "$5,280,000",
  "priceAmount": 5280000,
  "priceCurrency": "NZD",
  "bedrooms": 5,
  "bathrooms": 4,
  "landAreaM2": 1212,
  "propertyType": "House",
  "titleType": "Freehold",
  "latitude": -36.869541168213,
  "longitude": 174.76983642578,
  "agentNames": ["Wayne Guo"],
  "agencyName": "Barfoot & Thompson Ltd (Licensed: REAA 2008) - Epsom",
  "scrapedAt": "2026-07-18T00:00:00.000Z"
}
```

Actual values reflect the source at run time. Listings may omit numeric prices when they advertise negotiation, auction, tender, or another sale method.

### Search-card-only versus detailed mode

Set `includeDetails` to `false` when you primarily need IDs, URLs, listed age, addresses, displayed prices, basic specifications, property types, main images, and agency names. This avoids detail requests and is useful for frequent inventory-change detection.

Keep `includeDetails` at `true` for full research. Detail mode adds descriptions, structured price values, coordinates, listed dates, title type, more images, open-home events, and agent links.

Both modes save one property entity per dataset row and charge the same per saved item.

### Tips for reliable property collection

- 🎯 Reuse filtered source URLs so the website determines region, suburb, category, and price scope.
- 🔢 Start with a small `maxItems` while validating a new workflow.
- 📄 Raise `maxPages` only when your item cap requires more than one search page.
- ⚡ Disable detail enrichment for high-frequency inventory checks.
- 🌐 Enable an Apify proxy only if direct access becomes unreliable at your desired scale.
- 🕒 Schedule recurring Actors at a considerate interval rather than continuously polling.

### Integrations and workflow patterns

#### Google Sheets or Airtable inventory

Schedule a regional search, export the dataset, and upsert by `listingId`. Compare `priceDisplay`, `listedAge`, and open-home arrays between snapshots.

#### Property CRM enrichment

Send new dataset items through Make, Zapier, or a webhook. Map the address, URL, agency, and agent fields into a property or opportunity record.

#### Data warehouse analysis

Use the Apify API client to pull JSON into BigQuery, Snowflake, PostgreSQL, or S3. Partition on `scrapedAt` and retain `listingId` as the stable source key.

#### Open-home calendar

Expand matching `openHomeStarts` and `openHomeEnds` arrays into calendar events, grouped by property URL and agent.

### API usage with JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/realestate-co-nz-property-listings-scraper').call({
  startUrls: [{ url: 'https://www.realestate.co.nz/residential/sale/auckland?by=latest&oad=true' }],
  maxItems: 10,
  includeDetails: true,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("automation-lab/realestate-co-nz-property-listings-scraper").call(run_input={
    "startUrls": [{"url": "https://www.realestate.co.nz/residential/rental/auckland"}],
    "maxItems": 10,
    "includeDetails": True,
})
items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items)
```

### API usage with cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~realestate-co-nz-property-listings-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "startUrls": [{"url":"https://www.realestate.co.nz/residential/sale/auckland?by=latest&oad=true"}],
    "maxItems": 10,
    "includeDetails": true
  }'
```

Poll the returned run ID or use an Apify client to wait for completion, then read `defaultDatasetId`.

### Use the scraper through Apify MCP

Connect the Actor to Claude Code:

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/realestate-co-nz-property-listings-scraper"
```

For Claude Desktop, Cursor, or VS Code, add this HTTP server configuration:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/realestate-co-nz-property-listings-scraper"
    }
  }
}
```

Example prompts:

- “Collect the 20 latest Auckland residential sale listings and summarize prices by suburb.”
- “Extract this Realestate.co.nz property page and list its next open-home time and agency.”
- “Run a rental search without detail enrichment and return listing IDs not present in yesterday's file.”

### Scheduling and change monitoring

Create an Apify schedule with a stable filtered search URL. Save each run to a downstream table keyed by `listingId`, then classify IDs as new, continuing, or missing.

A missing ID does not necessarily prove a sale or withdrawal: search rankings, filters, source updates, and item caps can change. Confirm important status changes against the current public property page.

Use `scrapedAt`, `listedDate`, and `listedAge` to distinguish the collection timestamp from the source's own listing-age labels.

### Data quality and limitations

The Actor reports what Realestate.co.nz publicly renders at run time. It does not estimate property values, infer sale prices, reveal hidden contact details, or bypass private account features.

Some listings publish a sale method instead of a numeric price. Some omit floor area, title type, coordinates, open homes, or agents. Those optional fields are absent rather than invented.

Detail-page markup can change. The extractor uses public JSON-LD and stable test attributes, bounded retries, and total-failure detection, but no scraper can guarantee that every upstream field remains available forever.

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

Public web data can often be collected for legitimate research and business purposes, but your use case, jurisdiction, contractual obligations, and treatment of personal information matter.

Use the Actor responsibly. Review Realestate.co.nz terms, respect applicable laws, avoid excessive request rates, and collect only data you need. Agent names and agency details are professional context on public listing pages; do not use them for spam, harassment, discrimination, or unlawful profiling.

You are responsible for deciding whether your collection and downstream use are permitted.

### Troubleshooting

#### Why did my input fail immediately?

Check that every URL uses `realestate.co.nz` and points to a residential sale/rental search or property detail path. Homepage, agent-directory, commercial, rural, and third-party URLs are intentionally rejected.

#### Why is a field missing?

The source listing may not publish it. Compare the public detail page and keep `includeDetails: true` for fields unavailable on search cards.

#### Why did the run save fewer listings than requested?

Your source search may contain fewer unique listings, `maxPages` may stop pagination, or individual details may have disappeared between discovery and fetch. Review logs for skipped URLs.

#### When should I enable a proxy?

Direct anonymous HTTP is the default and works for normal runs. For large recurring jobs that encounter network blocks, enable Apify Proxy and retry with conservative limits.

### Frequently asked questions

#### Can I scrape both sale and rental listings in one run?

Yes. Add multiple residential sale and rental URLs to `startUrls`. `maxItems` applies globally and results deduplicate by listing ID.

#### Can I pass a single property URL?

Yes. This is the cheapest way to enrich or monitor one known listing.

#### Does the Actor scrape sold prices or valuations?

No. This release focuses on current public residential sale/rental listing pages and does not claim private, inferred, or separately licensed valuation data.

#### Does it download image files?

It exports public image URLs. Your downstream system can download media separately when your use is authorized.

#### How do I avoid duplicate rows?

Duplicates within one run are removed by listing ID. Across runs, upsert into your destination using `listingId` as the key.

### Related property scrapers

- [Zillow Scraper](https://apify.com/automation-lab/zillow-scraper) — US property search and detail workflows.
- [Realtor.com Scraper](https://apify.com/automation-lab/realtor-scraper) — US Realtor.com property data.
- [Realtor.ca Property Listings Scraper](https://apify.com/automation-lab/realtor-ca-property-listings-scraper) — Canadian property listings.
- [Property Finder Scraper](https://apify.com/automation-lab/propertyfinder-scraper) — Property Finder market listings.

Choose this Actor specifically for public residential listings on New Zealand's Realestate.co.nz domain.

### Support

For reproducible support, share the Actor run URL, the affected public source URL, and what you expected to receive. Do not include private credentials or unrelated personal data.

The run log records pagination, skipped detail pages, total discovered listings, and saved records. This evidence helps distinguish invalid input, a removed listing, source markup changes, and transient network failures.

# Actor input Schema

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

Add Realestate.co.nz residential sale/rental search URLs or individual property listing URLs.

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

Stop after saving this many unique property listings across all start URLs.

## `includeDetails` (type: `boolean`):

Enable full descriptions, coordinates, images, open homes, title type, and agent context. Disable for a faster search-card-only export.

## `maxPages` (type: `integer`):

Safety limit for pagination. The Actor stops earlier after reaching maximum property listings.

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

Optional Apify Proxy or custom proxy settings for larger recurring runs. Anonymous direct access is used by default.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.realestate.co.nz/43070114/residential/sale/46-mountain-road-epsom"
    }
  ],
  "maxItems": 1,
  "includeDetails": true,
  "maxPages": 2,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `overview` (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/43070114/residential/sale/46-mountain-road-epsom"
        }
    ],
    "maxItems": 1,
    "includeDetails": true,
    "maxPages": 2,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/realestate-co-nz-property-listings-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/43070114/residential/sale/46-mountain-road-epsom" }],
    "maxItems": 1,
    "includeDetails": True,
    "maxPages": 2,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/realestate-co-nz-property-listings-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 '{
  "startUrls": [
    {
      "url": "https://www.realestate.co.nz/43070114/residential/sale/46-mountain-road-epsom"
    }
  ],
  "maxItems": 1,
  "includeDetails": true,
  "maxPages": 2,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call automation-lab/realestate-co-nz-property-listings-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=automation-lab/realestate-co-nz-property-listings-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Realestate.co.nz Property Listings Scraper",
        "description": "🏠 Extract public New Zealand sale and rental listings with prices, specifications, descriptions, coordinates, images, open homes, listing agents, and agencies from Realestate.co.nz.",
        "version": "0.1",
        "x-build-id": "pMIG4sTjcWOmmcX0g"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~realestate-co-nz-property-listings-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-realestate-co-nz-property-listings-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/automation-lab~realestate-co-nz-property-listings-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-realestate-co-nz-property-listings-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/automation-lab~realestate-co-nz-property-listings-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-realestate-co-nz-property-listings-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": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "🏠 Search or property URLs",
                        "type": "array",
                        "description": "Add Realestate.co.nz residential sale/rental search URLs or individual property listing URLs.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Maximum property listings",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Stop after saving this many unique property listings across all start URLs.",
                        "default": 10
                    },
                    "includeDetails": {
                        "title": "Visit property detail pages",
                        "type": "boolean",
                        "description": "Enable full descriptions, coordinates, images, open homes, title type, and agent context. Disable for a faster search-card-only export.",
                        "default": true
                    },
                    "maxPages": {
                        "title": "Maximum search pages per URL",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Safety limit for pagination. The Actor stops earlier after reaching maximum property listings.",
                        "default": 20
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional Apify Proxy or custom proxy settings for larger recurring runs. Anonymous direct access is used by default.",
                        "default": {
                            "useApifyProxy": false
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```