# realestate.com.au Scraper | AU Sale Rent Sold API (`lentic_clockss/realestate-com-au-scraper`) Actor

Scrape realestate.com.au Australian sale, rent, and sold listings by suburb/city. Extract prices, beds, baths, land size, agencies, photos & URLs — realestate.com.au API alternative.

- **URL**: https://apify.com/lentic\_clockss/realestate-com-au-scraper.md
- **Developed by:** [kane liu](https://apify.com/lentic_clockss) (community)
- **Categories:** Real estate, Lead generation, Automation
- **Stats:** 1 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#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.

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.com.au Scraper — AU Sale, Rent & Sold Listings

**Scrape realestate.com.au for-sale, rental, and sold property listings by Australian suburb or city — then download structured data as Excel, CSV, or JSON.**

This Actor is a practical **realestate.com.au API alternative** for market research, investor comps, rental screening, agency monitoring, and lead lists. Enter a location such as `Melbourne, VIC`, choose **sale**, **rent**, **sold**, **both**, or **all**, and get listing rows with prices, beds, baths, land size, agency, photos, and direct listing URLs.

> Thin Actor + Cloud Run worker. Worker URL is config (`WORKER_BASE_URL`), not hardcoded-only — migrate the worker by updating Actor env without a code change. Set `WORKER_PROVIDES_PROXY=1` when the worker supplies its own `PROXY_URL`.

- Pull **Australian homes for sale**, **rentals**, and **sold** results from [realestate.com.au](https://www.realestate.com.au/)
- Filter by property type (house, unit, apartment, land, rural, retirement, and more), beds, and price
- Optionally enrich listings from detail pages, or scrape specific property URLs
- Export to **Excel / CSV / JSON**, or connect Make, n8n, Zapier, Python, or Apify MCP / API
- **Pay per event** — Actor start + each Dataset listing; platform compute is included (you do not pay separate Apify usage)

---

### What does the realestate.com.au Scraper do?

It turns a realestate.com.au search (or detail URLs) into a clean Apify Dataset of Australian residential listings.

Under the hood, the Actor:

1. Validates your input (location, listing type, filters, optional detail URLs)
2. Calls a managed Cloud Run worker that unlocks realestate.com.au pages (Kasada-aware)
3. Collects search-result and/or detail listing data across sale / rent / sold channels
4. Normalizes records into Dataset rows with preview fields (`name`, `type`, `status`, `country`, `authority`)
5. Writes `RUN_SUMMARY` (and `ERROR_SUMMARY` on failure) to the key-value store

You run the Actor like any other Apify Actor — schedule it, call it from the API, or plug it into automations. No local browser or proxy setup is required.

---

### What data can you extract from realestate.com.au?

| Data point | Sale | Rent | Sold |
| --- | :---: | :---: | :---: |
| Address / listing name | ✅ | ✅ | ✅ |
| Listing ID & property type | ✅ | ✅ | ✅ |
| Price / rent display | ✅ | ✅ | ✅ |
| Beds / baths / parking | ✅ | ✅ | ✅ |
| Land / building size (when shown) | ✅ | ✅ | ✅ |
| Suburb, state, postcode | ✅ | ✅ | ✅ |
| Agency / authority | ✅ | ✅ | ✅ |
| Listing URL & main image | ✅ | ✅ | ✅ |
| Description & inspections (when present) | ✅ | ✅ | ✅ |

Every Dataset row includes `source` = `realestate.com.au` and `country` = `Australia`. A `RUN_SUMMARY` record reports counts, provider, and warnings.

---

### What you can do with it

#### 1. Scrape Australian homes for sale

Enter a suburb/city like `Melbourne, VIC`, set `listingType` to **sale**, and get structured rows with price, beds, baths, agency, and a direct listing URL — ready for comps or investor shortlists.

#### 2. Scrape Australian rentals

Set `listingType` to **rent**. Rows include weekly rent display, beds/baths, parking, and agency when present.

#### 3. Scrape sold property results

Set `listingType` to **sold** to pull recently sold listings for pricing analysis and comparable sales.

#### 4. Cover multiple channels or locations in one run

Use `listingType` = `both` or `all`, add extra suburbs in `locations`, and optionally filter by `propertyTypes`, beds, and price.

#### 5. Scrape specific property detail pages

Paste one or more realestate.com.au property URLs into `detailUrls` to skip search and fetch those listings directly.

#### 6. Feed AU property data into automations

Schedule the Actor and send the Dataset to Sheets, Slack, CRM, Make, n8n, Zapier, or an AI agent via Apify MCP / API.

---

### How to scrape realestate.com.au (no code required)

1. Click **Try for free** on this Actor page
2. Enter a location (`Melbourne, VIC` or `Sydney, NSW`)
3. Choose **sale**, **rent**, **sold**, **both**, or **all**
4. Optionally set property types, beds/price filters, and max results
5. Click **Start** — open the **Dataset** tab when the run finishes

Start with `maxResults: 5–10` to verify the market, then scale up.

---

### How much does it cost to scrape realestate.com.au?

This Actor uses **pay-per-event** pricing. You are charged for:

| Event | Price |
| --- | --- |
| Actor Start (`apify-actor-start`) | **$0.005** per start |
| Result (`apify-default-dataset-item`) | **$3.00 / 1,000** listings (**$0.003** each) |

**Platform usage costs are included** — you do **not** pay separate Apify compute/proxy usage for this Actor on top of the event prices above.

#### Example cost estimates

| Listings collected | Approx. event cost* |
| --- | --- |
| 100 | ~$0.31 |
| 1,000 | ~$3.01 |
| 10,000 | ~$30.01 |

\*Assumes one Actor start at default memory billing for start events, plus `$0.003` per Dataset item. Exact start billing can scale with allocated memory (one start event per GB, minimum one).

Free Apify trial credit can cover a small test run — try `maxResults: 5` first.

#### Free Apify plan limits (set by this Actor's developer)

| Limit | Free Apify plan | Paid Apify plan |
| --- | --- | --- |
| Runs of this Actor | **10** total | Unlimited |
| Listings per run | **200** | Up to schema max (500) |

These caps are enforced in Actor code (not by Apify). Upgrade to a paid Apify plan for unlimited runs.

---

### Input

Open the **Input** tab for the full form. Common fields:

| Field | Description |
| --- | --- |
| `location` | Australian suburb/city + state, e.g. `Melbourne, VIC` |
| `locations` | Extra locations in the same run |
| `listingType` | `sale` / `rent` / `sold` / `both` / `all` |
| `propertyTypes` | Optional: `house`, `unit`, `apartment`, `land`, `rural`, `retire`, … |
| `minBeds` / `maxBeds` | Bedroom filters |
| `minPrice` / `maxPrice` | Price filters (AUD) |
| `maxResults` | Cap on listings (1–500; free plan also capped at 200/run) |
| `maxPages` | Cap on search pages per location/channel (1–80) |
| `enrichDetails` | Open detail pages for richer fields (slower) |
| `detailUrls` | Skip search; scrape these property URLs |
| `failover` | Allow worker provider failover (default true) |
| `workerBaseUrl` | Optional https override (allowlisted hosts only) |

`proxyConfiguration` may appear in the form for compatibility but is **ignored** — unlock/proxy traffic is handled by the managed worker.

**Free Apify plan:** up to **10 runs** of this Actor and **200 listings per run**. Upgrade to a paid Apify plan for unlimited runs. (Limits set by the Actor developer.)

#### Example input

```json
{
  "location": "Melbourne, VIC",
  "listingType": "sale",
  "propertyTypes": ["apartment"],
  "minBeds": 2,
  "maxResults": 20,
  "maxPages": 2,
  "enrichDetails": false,
  "failover": true
}
````

***

### Output example

You can download the Dataset as **JSON, CSV, Excel, or HTML**.

```json
{
  "name": "1211/12 Queens Road",
  "type": "Apartment",
  "status": "for_sale",
  "country": "Australia",
  "authority": "First National Real Estate Central - CARLTON",
  "listingId": "148388492",
  "listingType": "sale",
  "address": "1211/12 Queens Road",
  "fullAddress": "1211/12 Queens Road, Melbourne, Vic 3004",
  "suburb": "Melbourne",
  "state": "Vic",
  "zipCode": "3004",
  "priceDisplay": "$500,000 Private Sale",
  "beds": 2,
  "baths": 1,
  "parking": 1,
  "propertyType": "Apartment",
  "listingUrl": "https://www.realestate.com.au/property-apartment-vic-melbourne-148388492",
  "imageUrl": "https://i2.au.reastatic.net/800x600/.../image.jpg",
  "source": "realestate.com.au"
}
```

Key-value store records:

- `INPUT_ECHO` — normalized non-secret input
- `RUN_SUMMARY` — counts, provider, diagnostics, timestamps
- `ERROR_SUMMARY` — structured failure details when a run fails

***

### How to scrape realestate.com.au with Python or the Apify API

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_API_TOKEN>")
run = client.actor("lentic_clockss/realestate-com-au-scraper").call(
    run_input={
        "location": "Sydney, NSW",
        "listingType": "sold",
        "maxResults": 10,
        "maxPages": 1,
    }
)
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["listingUrl"], item.get("priceDisplay"))
```

You can also schedule runs, set webhooks, or connect the Dataset to Make / Zapier / n8n from the Apify Console.

***

### Is it legal to scrape realestate.com.au?

Our scrapers are ethical and do not extract private user data such as email addresses, gender, or private contact details that are not publicly shown on listing pages. They only extract what is publicly available on realestate.com.au listing cards and property pages.

You should still be aware that results can include personal data (for example agent names). Personal data is protected by the **Australian Privacy Act**, the **GDPR** in the EU, and other regulations. You should not scrape personal data unless you have a legitimate reason. If you are unsure, consult your lawyers. See also Apify’s guidance on the [legality of web scraping](https://blog.apify.com/is-web-scraping-legal/).

***

### FAQ

#### Does this Actor replace the official realestate.com.au API?

There is no broadly available public listing API for most third-party use cases. This Actor is an **API alternative** that returns structured JSON/CSV/Excel you can use in research and automations.

#### Why do some sold listings put the price in `priceDisplay`?

The worker normalizes sale/rent/sold displays into `priceDisplay` for a consistent schema. `soldPriceDisplay` may be empty even when a sold price string is present in `priceDisplay`.

#### Do I need Apify Proxy?

No. Proxy / unlock traffic is handled by the managed worker. The `proxyConfiguration` input field is ignored.

#### Why did my free-plan run stop after 10 runs?

This Actor allows **10 runs** and **200 listings per run** for free Apify plan users. That limit is set by the Actor developer (not Apify). Upgrade to a paid Apify plan for unlimited runs.

#### Can I scrape commercial property or Flatmates?

Not in this Actor. Coverage is residential sale / rent / sold on realestate.com.au (including common residential property types such as house, unit, land, rural, and retirement).

#### Where can I get help?

Open an issue on the Actor’s **Issues** tab in Apify Console with your run ID and a short description. Include a sample input when possible.

***

### Tips for better results

- Prefer specific suburbs (`Richmond, VIC`) when you need local comps; use CBD/city names for broader coverage
- Keep `maxPages` low while testing; raise it after you confirm filters
- Use `propertyTypes` + beds/price filters to reduce noise before scaling `maxResults`
- Enable `enrichDetails` only when you need LDP-only fields — it increases run time

***

Built for Australian property data workflows on the Apify platform — scheduling, monitoring, API access, and Dataset exports included.

# Actor input Schema

## `location` (type: `string`):

Australian suburb/city and state, e.g. 'Brisbane, QLD' or 'Perth, WA'. Required for search runs; ignored when detailUrls is set.

## `locations` (type: `array`):

Optional additional locations to scrape in the same run.

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

Sale / rent / sold / both / all channels supported by the Cloud Run worker.

## `propertyTypes` (type: `array`):

Optional filters, e.g. house, unit, apartment, land, rural, retire.

## `minBeds` (type: `integer`):

Optional minimum bedrooms filter (must be ≤ maxBeds when both set).

## `maxBeds` (type: `integer`):

Optional maximum bedrooms filter.

## `minPrice` (type: `integer`):

Optional minimum price (AUD; must be ≤ maxPrice when both set).

## `maxPrice` (type: `integer`):

Optional maximum price (AUD).

## `maxResults` (type: `integer`):

Maximum listings to collect (1–500). Free Apify plan users are also limited to 10 total runs of this Actor and 200 listings per run — limits set by the Actor developer.

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

Maximum SRP pages to crawl per location/channel (REA max 80).

## `enrichDetails` (type: `boolean`):

When true, worker opens each listing LDP to merge detail fields (slower).

## `detailUrls` (type: `array`):

Optional realestate.com.au property detail URLs. When set, location search is skipped (calls /v1/listings).

## `failover` (type: `boolean`):

Allow the worker to fail over Bright Data → RiskByPass → browser.

## `workerBaseUrl` (type: `string`):

Override the Cloud Run worker origin for this run. Must be https:// and an allowlisted host (Actor env WORKER\_BASE\_URL host, built-in default, or ALLOWED\_WORKER\_HOSTS). Production migrations should update WORKER\_BASE\_URL in Actor settings (no code change).

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

Ignored. Anti-bot / unlock traffic runs on the Cloud Run worker (Bright Data Unlocker). Set Actor env WORKER\_PROVIDES\_PROXY=1 when the worker supplies PROXY\_URL.

## Actor input object example

```json
{
  "location": "Melbourne, VIC",
  "locations": [],
  "listingType": "sale",
  "propertyTypes": [],
  "maxResults": 5,
  "maxPages": 3,
  "enrichDetails": false,
  "detailUrls": [],
  "failover": true,
  "workerBaseUrl": "",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `listings` (type: `string`):

Normalized realestate.com.au listing records.

## `runSummary` (type: `string`):

Location, listing type, counts, engine, and timestamps for the run.

## `inputEcho` (type: `string`):

Normalized non-secret input for the run.

## `errorSummary` (type: `string`):

Structured failure details when input validation or acquisition fails.

# 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 = {
    "location": "Melbourne, VIC",
    "locations": [],
    "listingType": "sale",
    "propertyTypes": [],
    "maxResults": 5,
    "maxPages": 3,
    "enrichDetails": false,
    "detailUrls": [],
    "failover": true,
    "workerBaseUrl": "",
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("lentic_clockss/realestate-com-au-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 = {
    "location": "Melbourne, VIC",
    "locations": [],
    "listingType": "sale",
    "propertyTypes": [],
    "maxResults": 5,
    "maxPages": 3,
    "enrichDetails": False,
    "detailUrls": [],
    "failover": True,
    "workerBaseUrl": "",
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("lentic_clockss/realestate-com-au-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 '{
  "location": "Melbourne, VIC",
  "locations": [],
  "listingType": "sale",
  "propertyTypes": [],
  "maxResults": 5,
  "maxPages": 3,
  "enrichDetails": false,
  "detailUrls": [],
  "failover": true,
  "workerBaseUrl": "",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call lentic_clockss/realestate-com-au-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "realestate.com.au Scraper | AU Sale Rent Sold API",
        "description": "Scrape realestate.com.au Australian sale, rent, and sold listings by suburb/city. Extract prices, beds, baths, land size, agencies, photos & URLs — realestate.com.au API alternative.",
        "version": "0.3",
        "x-build-id": "Xs1SiXYaph0LqMbJ5"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/lentic_clockss~realestate-com-au-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-lentic_clockss-realestate-com-au-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/lentic_clockss~realestate-com-au-scraper/runs": {
            "post": {
                "operationId": "runs-sync-lentic_clockss-realestate-com-au-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/lentic_clockss~realestate-com-au-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-lentic_clockss-realestate-com-au-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": [
                    "location"
                ],
                "properties": {
                    "location": {
                        "title": "Location",
                        "maxLength": 120,
                        "type": "string",
                        "description": "Australian suburb/city and state, e.g. 'Brisbane, QLD' or 'Perth, WA'. Required for search runs; ignored when detailUrls is set.",
                        "default": "Melbourne, VIC"
                    },
                    "locations": {
                        "title": "Extra locations",
                        "type": "array",
                        "description": "Optional additional locations to scrape in the same run.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "listingType": {
                        "title": "Listing type",
                        "enum": [
                            "sale",
                            "rent",
                            "sold",
                            "both",
                            "all"
                        ],
                        "type": "string",
                        "description": "Sale / rent / sold / both / all channels supported by the Cloud Run worker.",
                        "default": "sale"
                    },
                    "propertyTypes": {
                        "title": "Property types",
                        "type": "array",
                        "description": "Optional filters, e.g. house, unit, apartment, land, rural, retire.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "minBeds": {
                        "title": "Min bedrooms",
                        "minimum": 0,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Optional minimum bedrooms filter (must be ≤ maxBeds when both set)."
                    },
                    "maxBeds": {
                        "title": "Max bedrooms",
                        "minimum": 0,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Optional maximum bedrooms filter."
                    },
                    "minPrice": {
                        "title": "Min price",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Optional minimum price (AUD; must be ≤ maxPrice when both set)."
                    },
                    "maxPrice": {
                        "title": "Max price",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Optional maximum price (AUD)."
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum listings to collect (1–500). Free Apify plan users are also limited to 10 total runs of this Actor and 200 listings per run — limits set by the Actor developer.",
                        "default": 20
                    },
                    "maxPages": {
                        "title": "Max pages",
                        "minimum": 1,
                        "maximum": 80,
                        "type": "integer",
                        "description": "Maximum SRP pages to crawl per location/channel (REA max 80).",
                        "default": 80
                    },
                    "enrichDetails": {
                        "title": "Enrich from detail pages",
                        "type": "boolean",
                        "description": "When true, worker opens each listing LDP to merge detail fields (slower).",
                        "default": false
                    },
                    "detailUrls": {
                        "title": "Detail URLs (optional)",
                        "type": "array",
                        "description": "Optional realestate.com.au property detail URLs. When set, location search is skipped (calls /v1/listings).",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "failover": {
                        "title": "Provider failover",
                        "type": "boolean",
                        "description": "Allow the worker to fail over Bright Data → RiskByPass → browser.",
                        "default": true
                    },
                    "workerBaseUrl": {
                        "title": "Worker base URL (optional)",
                        "type": "string",
                        "description": "Override the Cloud Run worker origin for this run. Must be https:// and an allowlisted host (Actor env WORKER_BASE_URL host, built-in default, or ALLOWED_WORKER_HOSTS). Production migrations should update WORKER_BASE_URL in Actor settings (no code change).",
                        "default": ""
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration (unused)",
                        "type": "object",
                        "description": "Ignored. Anti-bot / unlock traffic runs on the Cloud Run worker (Bright Data Unlocker). Set Actor env WORKER_PROVIDES_PROXY=1 when the worker supplies PROXY_URL."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
