# AU Residential Property Scraper (`abotapi/property-au-scraper`) Actor

Scrape Australian real estate listings with detailed property information. Extract addresses, prices, bedrooms, bathrooms, property features, descriptions, photos and other available listing details. Includes rich detail-page enrichment for comprehensive property research.

- **URL**: https://apify.com/abotapi/property-au-scraper.md
- **Developed by:** [Abot API](https://apify.com/abotapi) (community)
- **Categories:** AI, Real estate, Automation
- **Features:** Limited permissions
- **Stats:** 30 total users, 2 monthly users, 86.8% runs succeeded, 2 bookmarks
- **User rating**: No ratings yet

## Pricing

from $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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

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

## Property.com.au Scraper: Listings, Price History, Schools and Market Data

Property.com.au Scraper turns Property.com.au into structured property data. Search by suburb, postcode or free text, or paste search page links, and get back full listing records: address, price, features, a complete price history timeline, nearby schools, planning overlays, internet availability and estimated sale or rental value. Covers buy, rent and sold listings, and exports to JSON, CSV or Excel, or straight into your app through the API.

### Why This Scraper?

- **Two ways to search.** Give it a suburb name, postcode or free text and it resolves the location itself, or paste Property.com.au search page URLs directly and let it walk the pages.
- **Detail-page enrichment, not just search cards.** Every listing is opened individually for its full price history timeline, nearby schools, planning overlays, internet availability and an estimated sale/rental value, on top of the usual address, price and features.
- **Fine grained filters.** Price range, bedrooms, bathrooms, car spaces, land size, property type, keywords, under-offer exclusion and sort order, all in listing mode.
- **Buy, rent and sold in one actor.** Switch listing type per run, or auto-detect it from a pasted URL.
- **Accumulate across runs.** Name a dataset to keep appending results from repeated or scheduled runs into one growing collection, with an option to clear it first.
- **Export to your apps.** Pipe results into Notion, Linear, Airtable or Apify through MCP connectors, no extra glue code.
- **Clear stop conditions.** A run only fails on a real configuration problem, such as an unresolvable location or a missing proxy; everything else returns whatever could be read.

### Use Cases

- **Buyers and agents:** track new listings and price movement for suburbs you're watching.
- **Property investors and analysts:** build a dataset of prices, land size and estimated values across suburbs to compare opportunities.
- **Renters:** monitor rental listings and price changes in target areas.
- **PropTech and research teams:** feed schools, planning overlay and internet availability data into your own tools.
- **Comparables tracking:** pull sold listings to benchmark recent sale prices near a property you're evaluating.

### Data You Get

> Sample shape: values are illustrative placeholders, not from a live record.

| Field | Example |
| --- | --- |
| `id` | `"8292817364"` |
| `address` | `"12 Example Street, Southbank VIC 3006"` |
| `suburb` / `state` / `postcode` | `"SOUTHBANK"` / `"VIC"` / `"3006"` |
| `latitude` / `longitude` | `-37.8226` / `144.9648` |
| `listing_type` | `"buy"` (also `"rent"`, `"sold"`) |
| `listing_status` | `"For Sale"` |
| `property_type` | `"apartment"` |
| `price` / `price_details` | `"$750,000 - $800,000"` / `"Contact agent for a price guide"` |
| `features.bedrooms` / `features.bathrooms` / `features.car_spaces` | `2` / `2` / `1` |
| `features.land_size` / `features.floor_area` / `features.built_year` | `"450m2"` / `"120m2"` / `2015` |
| `description` | property description text |
| `timeline` | price history events: listed, sold, leased, auction, each with date, price and agent when available |
| `value_estimates` | estimated sale and rental value, with a confidence rating and range, when published for the property |
| `schools` | nearby primary and secondary schools with zoning and distance |
| `planning_overlays` | bushfire, flood and heritage overlay flags |
| `land_description` / `council` | zoning text / local council name |
| `internet` | NBN connection type and quality for the address |
| `market_insights` | suburb median price and rent, with 12 month growth |
| `media` | image count and image URLs (full set on a residential proxy, see Plan Requirement) |
| `property_url` | Property.com.au link to the listing |
| `rea_url` | link to the same listing on a partner listings site, when available |
| `breadcrumbs` | location hierarchy shown on the listing page |
| `status` | `"success"` |
| `source_listing` / `source_listing_type` / `scraped_at` | the search URL, listing type and timestamp this record came from |

A separate run summary (mode, total listings scraped, duration, throughput, end time) is written to the run's key-value store as `METADATA`.

### How to Use

1. Pick a **mode**: `listing` (search by suburb, postcode or free text, with filters) or `url` (paste Property.com.au search page URLs directly).
2. In listing mode, set your location and filters. In URL mode, paste one or more search URLs; listing-mode filters are ignored there, so encode them into the URL instead.

   **Supported URL shape:** search pages of the form `https://www.property.com.au/search/?locations=Southbank%2C+VIC+3006`, optionally with `propertyStatus=FOR_RENT`, `pageNumber=N` and any filter the site puts in the query string (these are applied as pasted). Property detail pages (`...-pid-<id>/`) and path-style `/buy/`, `/rent/`, `/sold/` pages are not supported: each is skipped with a warning in the log. If you leave **Search Page URLs** untouched in URL mode, the run scrapes the three example search URLs (for sale, for rent and sold, Southbank VIC 3006) shipped as the default. **Max Properties** is a run-wide total filled in URL order, so the default of 20 can be used up by the first URL before the others are reached; raise it to cover all three; this is a change from earlier versions, which stopped with a no-URLs error.
3. Set **Max Properties** and **Max Pages** to control run size and cost, and choose a proxy (Residential + AU gives the complete dataset, see Plan Requirement).
4. Click **Start**, then download the dataset as JSON, CSV or Excel, or read it through the API.

**Search a suburb, buy listings:**

```json
{
  "mode": "listing",
  "search": "southbank",
  "listing_type": "buy",
  "max_properties": 20
}
```

**Search by postcode with price and bedroom filters:**

```json
{
  "mode": "listing",
  "search": "3006",
  "listing_type": "buy",
  "propertyTypes": ["HOUSE", "TOWNHOUSE"],
  "priceMin": 500000,
  "priceMax": 900000,
  "bedroomsMin": 2,
  "max_properties": 100,
  "max_pages": 5
}
```

**Paste a search page URL (rentals):**

```json
{
  "mode": "url",
  "urls": ["https://www.property.com.au/search/?locations=Sydney%2C+NSW+2000&propertyStatus=FOR_RENT"],
  "max_properties": 60,
  "max_pages": 3
}
```

**Recently sold listings, highest price first:**

```json
{
  "mode": "listing",
  "search": "brisbane",
  "listing_type": "sold",
  "sortBy": "PRICE_DESC",
  "max_properties": 50
}
```

#### Run it from your code

Python:

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("abotapi/property-au-scraper").call(run_input={"mode": "listing", "search": "southbank", "listing_type": "buy", "max_properties": 20})
for listing in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(listing["address"], listing["price"])
```

JavaScript:

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

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });
const run = await client.actor('abotapi/property-au-scraper').call({ mode: 'listing', search: 'southbank', listing_type: 'buy', max_properties: 20 });
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

Or connect it to Make, Zapier, n8n, Google Sheets or webhooks from the **Integrations** tab.

#### Pagination and limits

Pagination walks forward from the URL's own `?pageNumber=N` (default 1). **Max Pages** is a per URL budget, not a global one: pass three URLs with `max_pages: 5` and the run walks up to 5 pages for each of them. Both caps are bounded: `max_properties: 0` means the hard cap of 100000 properties per run and `max_pages: 0` means the hard cap of 1000 pages per URL.

### Send results into your apps (MCP connectors)

Optionally pipe the scraped results into the apps you already use, via Model Context Protocol (MCP) connectors. This is an extra delivery step **after** the scrape: the Apify dataset is never changed.

**What gets written to the connector:** a condensed, human-readable summary of each record, not the full JSON. Each item becomes one entry with a title and its key fields flattened to plain text.

1. Authorize a connector once under **Apify → Settings → Integrations** (Notion, Linear, Airtable, or Apify).
2. Select it in the **"Pipe results into your apps"** input field. (If the picker is empty, you haven't authorized a connector yet.)
3. For **Notion**, also set `notionParentPageUrl` to the page where items should be created.

Notion gets one page per item. Other authorized connectors get one record per item where the connector supports it, or a summarized digest when it only supports posting a message. Leave the field empty to skip.

### Input Parameters

| Parameter | Type | Default | Description |
| --- | --- | --- | --- |
| `mode` | string | `listing` | `listing` to search by suburb/postcode, or `url` to scrape specific search page URLs directly. |
| `search` | string | `southbank` | A suburb name, postcode, or partial name (listing mode). Resolved automatically; unresolvable queries fail fast. |
| `urls` | array | three example search URLs (for sale, for rent and sold, Southbank VIC 3006) | Property.com.au search page URLs (URL mode). Listing type is auto-detected from the URL's `propertyStatus` / `marketStatuses` query. |
| `listing_type` | string | `buy` | `buy`, `rent`, or `sold`. In URL mode, used as a fallback when the type can't be auto-detected from the URL. |
| `propertyTypes` | array | (none) | Filter by property type: HOUSE, APARTMENT, TOWNHOUSE, VILLA, LAND, ACREAGE, RURAL, BLOCK_OF_UNITS, RETIREMENT (listing mode only). |
| `priceMin` | integer | (none) | Minimum property price in AUD (listing mode only). |
| `priceMax` | integer | (none) | Maximum property price in AUD (listing mode only). |
| `bedroomsMin` | integer | (none) | Minimum number of bedrooms (listing mode only). |
| `bathroomsMin` | integer | (none) | Minimum number of bathrooms (listing mode only). |
| `landSizeMin` | integer | (none) | Minimum land size in square metres (listing mode only). |
| `carSpacesMin` | integer | (none) | Minimum number of car spaces (listing mode only). |
| `keywords` | string | (none) | Search keywords, e.g. pool, renovated, corner block (listing mode only). |
| `excludeUnderOffer` | boolean | `false` | Exclude properties that are under offer (listing mode, buy only). |
| `sortBy` | string | `NEW_DESC` | Sort order for search results: RELEVANCY, NEW_DESC, NEW_ASC, PRICE_ASC, PRICE_DESC, NEXT_AUCTION, NEXT_INSPECTION. Listing mode only. |
| `max_properties` | integer | `20` | Maximum number of properties to scrape (0 = the hard cap of 100000 per run). |
| `max_pages` | integer | `0` | Maximum number of listing pages to scrape per URL (0 = the hard cap of 1000 pages per URL). |
| `proxy` | object | Residential, AU | Connection settings. Residential proxy with country AU gives the complete dataset. |
| `dataset_name` | string | (none) | Optional named dataset for cross-run accumulation, in addition to the run's default dataset. |
| `clear_dataset` | boolean | `false` | Clear the named dataset before scraping (only applies when Dataset Name is set). |
| `mcpConnectors` | array | (none) | Optional: send a summary of each record to apps you authorized under Integrations. |
| `notionParentPageUrl` | string | (none) | Notion connector only: page under which records are created. |
| `maxNotifyListings` | integer | `50` | Cap on items written to each connector per run. |
| `resumeFromRunId` | string | (none) | ID of an earlier run of this actor whose listings are skipped (continue an interrupted run). |
| `incrementalMode` | boolean | `false` | Output only NEW, UPDATED, REAPPEARED and EXPIRED listings against the remembered baseline for this search. |
| `stateKey` | string | (auto) | Optional name for the remembered baseline; empty keys it on your search and filters. |
| `emitUnchanged` | boolean | `false` | Incremental mode only: also output listings identical to the last run. Each UNCHANGED row counts as a result for the per-result event; when off, unchanged listings are neither output nor charged. |
| `emitExpired` | boolean | `true` | Incremental mode only: output EXPIRED rows for listings that left the results. Each EXPIRED row counts as a result for the per-result event. |
| `ignoreFieldsForChanges` | array | (none) | Incremental mode only: top-level fields whose changes are not counted. |

### Output Example

> Sample shape: values are illustrative placeholders, not from a live record.

```json
{
  "id": "8292817364",
  "address": "12 Example Street, Southbank VIC 3006",
  "suburb": "SOUTHBANK",
  "state": "VIC",
  "postcode": "3006",
  "latitude": -37.8226,
  "longitude": 144.9648,
  "listing_type": "buy",
  "listing_status": "For Sale",
  "property_type": "apartment",
  "price": "$750,000 - $800,000",
  "price_details": "Contact agent for a price guide",
  "features": {
    "bedrooms": 2,
    "bathrooms": 2,
    "car_spaces": 1,
    "land_size": "450m2",
    "floor_area": "120m2",
    "built_year": 2015
  },
  "description": "Modern two bedroom apartment close to the river and CBD.",
  "timeline": [
    { "event": "listed_for_sale", "year": "current", "price": "$750,000", "date": "12 Mar 2026", "agent": "Jane Smith", "details": "Listed 12 Mar 2026 by Jane Smith" }
  ],
  "value_estimates": {
    "sale": { "value": 780000, "display": "$780,000", "confidence": "HIGH", "range_min": 750000, "range_max": 810000 }
  },
  "schools": {
    "primary": [{ "name": "Sample Primary School", "is_zoned": true, "distance": "0.8km" }],
    "secondary": [{ "name": "Sample Secondary College", "is_zoned": false, "distance": "1.5km" }]
  },
  "planning_overlays": { "bushfire": false, "flood": false, "heritage": false },
  "land_description": "Land is within the Melbourne local government area.",
  "council": "Melbourne",
  "internet": { "connection_type": "NBN Ready", "quality": "Good" },
  "market_insights": { "median_price": "$820,000", "price_growth_12mo": 5.2, "median_rent": "$550/wk", "rent_growth_12mo": 3.1 },
  "media": { "image_count": 12, "images": ["https://www.property.com.au/images/example-1.jpg"] },
  "property_url": "https://www.property.com.au/vic/southbank-3006/12-example-street-pid-12345678",
  "breadcrumbs": [{ "title": "Victoria", "url": "/vic" }, { "title": "Southbank", "url": "/vic/southbank-3006" }],
  "status": "success",
  "source_listing": "https://www.property.com.au/search/?locations=Southbank%2C+VIC+3006",
  "source_listing_type": "buy",
  "scraped_at": "2026-03-12T04:15:00.000Z"
}
```

### Plan Requirement

Property.com.au refuses ordinary datacenter connections, so this actor needs Apify proxy access, which means a paid Apify plan: free plans do not include proxy access. If the proxy connection is refused for your account, the run stops with the message "The proxy connection was refused for this account, so no page could be read. Your Apify plan does not include proxy access; a paid plan is required" and a link to https://apify.com/pricing.

The actor chooses the connection itself and falls back automatically. When it has to use the backup connection, the log says "Served over the backup connection (the default connection was unavailable)." If residential proxies are not available to your account and the backup connection cannot load the pages either, the run fails with "No results: residential proxies are unavailable on this run (Apify free plans do not include them)..." and asks you to upgrade. If every results page request fails for another reason, you get "Could not load any results page (the requests failed), so nothing was collected. This is a connection problem, not an empty search. Please try again later."

For the complete dataset, including images, select the Residential proxy group with country AU under Proxy & connection. On any other connection the run still returns full listing data, but images are omitted and the log says so.

### FAQ

#### How much does it cost?

You pay per record returned. In Incremental mode every output row, including EXPIRED rows and UNCHANGED rows when **Also output unchanged listings** is on, counts as a result for the per-result event; unchanged listings that are suppressed are not output and not charged. The **Pricing** tab shows the current rates. Use **Max Properties** to cap the cost of any run.

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

This actor collects only publicly available property listing data. You are responsible for how you use it: follow Property.com.au's terms and the laws that apply to you, and get legal advice if you plan commercial redistribution.

#### Can I get only new listings on a schedule?

Yes. Turn on **Incremental mode** and schedule the actor from the **Schedules** tab. The actor remembers what earlier runs saw for the same search and filters, and outputs only NEW, UPDATED and REAPPEARED listings, plus EXPIRED ones that dropped out of the results (only when the search was walked to its end). Each row gets `changeType`, `changedFields`, `firstSeenAt` and `lastSeenAt`, and the dataset has a Changes view. Unchanged listings are skipped unless you enable **Also output unchanged listings**. Change detection compares the full listing, so a different connection plan between runs (which hides images and agent details in the output) does not by itself make listings UPDATED. With Incremental mode off, every run outputs all listings and appends them to the run's default dataset (and your named dataset if set), without checking earlier runs.

#### Why don't I see any photos in my results?

Images are included when the run uses an Apify Residential proxy (country AU recommended). Any other proxy configuration returns full listing data except photos.

#### Why did my run return an empty dataset instead of an error?

The run fails outright only for a configuration problem: no location could be resolved, no search URLs were given, no proxy could be initialized at all, or an invalid named dataset was supplied. If a search page or a listing's detail page can't be read after that point, the run logs a warning and moves on, finishing normally with fewer, or zero, results rather than raising an error. Check the run log for warnings before assuming a bug.

#### Can I use it with AI agents or MCP?

Yes. Call it from any Apify integration or MCP client, and use the connector field to push results into Notion, Linear or Airtable.

### 🔗 Want more AI data?

Pair this actor with these related scrapers from the same team:

<table>
<tr><td>🏠 <a href="https://apify.com/abotapi/realestate-au-scraper"><b>Real Estate AU</b></a><br>Extract detailed Australian real estate property listings with 30+ structured fields...</td><td>🏠 <a href="https://apify.com/abotapi/domain-com-au-scraper"><b>Domain.com.au</b></a><br>Extract enriched Domain.com.au property listings across buy, rent, and sold, with...</td></tr>
<tr><td>🏠 <a href="https://apify.com/abotapi/homely-com-au-scraper"><b>Homely.com.au</b></a><br>Scrape Homely.com.au properties for sale, rent, and sold, plus agent finder, suburb...</td><td>🏠 <a href="https://apify.com/abotapi/realestate-co-nz-scraper"><b>RealestateCo NZ</b></a><br>Search and extract all real estate properties for sale, rent, and sold across New Zealand...</td></tr>
<tr><td>🏠 <a href="https://apify.com/abotapi/realcommercial-au-scraper"><b>Commercial Property AU Scraper</b></a><br>Scrape Australian commercial property listings with full detail data. Extract...</td><td>🏠 <a href="https://apify.com/abotapi/realtor-ca-scraper"><b>Realtor.ca</b></a><br>Scrape Realtor.ca property listings with prices, descriptions, images, agent and...</td></tr>
</table>

👉 [Browse all abotapi scrapers](https://apify.com/abotapi)

### 💬 Support

- 🐞 **Found a bug or a missing field?** Open a ticket on the [Issues tab](https://apify.com/abotapi/property-au-scraper/issues/open). We usually reply within hours.
- 🛠️ **Need another site, extra fields or a private build?** Email <contact@abotapi.com>.
- ⭐ **Enjoying it?** A quick review on the actor page helps other users find it.

# Actor input Schema

## `mode` (type: `string`):

Choose scraping mode: 'listing' to scrape by suburb/postcode, or 'url' to scrape specific search page URLs directly.

## `search` (type: `string`):

Enter a suburb name (e.g. 'southbank'), a postcode (e.g. '3006'), or a partial name (e.g. 'wantir'). The location is resolved automatically. Invalid or ambiguous queries will fail fast rather than run against the wrong location.

## `urls` (type: `array`):

List of property.com.au search page URLs of the form /search/?locations=... (used when Scraping Mode is 'url'). Listing type is auto-detected from the propertyStatus / marketStatuses query. Detail pages and /buy|rent|sold/ path pages are skipped with a warning. Pagination walks forward from the URL's own ?pageNumber=N (default 1).

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

Type of listings to scrape. In listing mode this drives the search URL. In URL mode it's used as a fallback when the listing type can't be auto-detected from the URL path (/buy/, /rent/, /sold/).

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

Filter by property type, leave empty for all (listing mode only; in URL mode, encode propertyTypes directly in your URLs).

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

Minimum property price in AUD (listing mode only).

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

Maximum property price in AUD (listing mode only).

## `bedroomsMin` (type: `integer`):

Minimum number of bedrooms (listing mode only).

## `bathroomsMin` (type: `integer`):

Minimum number of bathrooms (listing mode only).

## `landSizeMin` (type: `integer`):

Minimum land size in square metres (listing mode only).

## `carSpacesMin` (type: `integer`):

Minimum number of car spaces (listing mode only).

## `keywords` (type: `string`):

Search keywords e.g. pool, renovated, corner block (listing mode only).

## `excludeUnderOffer` (type: `boolean`):

Exclude properties that are under offer (listing mode, buy only).

## `sortBy` (type: `string`):

Sort order for search results. Default is 'Date (Newest First)'. Only applies in listing mode; in URL mode, include sortOption in your URLs directly.

## `max_properties` (type: `integer`):

Maximum number of properties to scrape (0 = the hard cap of 100000 per run)

## `max_pages` (type: `integer`):

Maximum number of listing pages to scrape per URL. Walks forward from the URL's own ?pageNumber=N (default 1). Set to 0 for the hard cap of 1000 pages per URL.

## `dataset_name` (type: `string`):

Optional named dataset for cross-run accumulation. Results are always written to the run's default dataset (visible on the run page); when this field is set, each record is ALSO appended to the named dataset. Name must be lowercase letters, digits, and hyphens only (e.g. my-dataset-1). Leave empty to write only to the run's default dataset.

## `clear_dataset` (type: `boolean`):

Clear the named dataset before scraping (only applies when Dataset Name is set). Useful for refreshing an accumulating dataset.

## `proxy` (type: `object`):

Property.com.au accepts Australian residential connections. Keep Residential + country AU.

## `resumeFromRunId` (type: `string`):

Paste the ID of an earlier run of this actor to skip listings it already collected (continue an interrupted run). Leave empty to start fresh.

## `incrementalMode` (type: `boolean`):

Remember what earlier runs saw for this exact search and output only NEW, UPDATED and REAPPEARED listings (plus EXPIRED ones that left the results). Each row gets changeType, changedFields, firstSeenAt and lastSeenAt. Off = every listing is output, exactly as before.

## `stateKey` (type: `string`):

Optional name for the remembered baseline. Leave empty to key it automatically on your search and filters (raising the item caps does not start a new baseline).

## `emitUnchanged` (type: `boolean`):

Off by default: listings identical to the last run are skipped.

## `emitExpired` (type: `boolean`):

Emit an EXPIRED row for listings seen before that are no longer in the results. Only when the search was walked to its end.

## `ignoreFieldsForChanges` (type: `array`):

Top-level output fields (for example media or timeline) that must not count as a change. Their values are still output.

## `mcpConnectors` (type: `array`):

Optionally send the scraped results into the apps you already use, via Model Context Protocol (MCP) connectors. Authorize a connector once under Apify → Settings → Integrations, then select it here. Notion gets a page per item; other connectors receive a best-effort write/digest. Leave empty to skip — this never changes the dataset output. Supported: Notion (https://mcp.notion.com/mcp), Linear (https://mcp.linear.app/sse), Airtable (https://mcp.airtable.com/mcp), Apify (https://mcp.apify.com).

## `notionParentPageUrl` (type: `string`):

URL (or id) of the Notion page under which item pages are created. Required to enable the Notion export; ignored by other connectors.

## `maxNotifyListings` (type: `integer`):

Cap on items written to each connector per run. Does not affect the dataset.

## Actor input object example

```json
{
  "mode": "listing",
  "search": "southbank",
  "urls": [
    "https://www.property.com.au/search/?locations=Southbank%2C+VIC+3006&propertyStatus=FOR_SALE",
    "https://www.property.com.au/search/?locations=Southbank%2C+VIC+3006&propertyStatus=FOR_RENT",
    "https://www.property.com.au/search/?locations=Southbank%2C+VIC+3006&propertyStatus=SOLD"
  ],
  "listing_type": "buy",
  "excludeUnderOffer": false,
  "sortBy": "NEW_DESC",
  "max_properties": 20,
  "max_pages": 0,
  "clear_dataset": false,
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "AU"
  },
  "incrementalMode": false,
  "emitUnchanged": false,
  "emitExpired": true,
  "maxNotifyListings": 50
}
```

# Actor output Schema

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

Full listing records with address, coordinates, price, features, description, price history timeline, schools, planning overlays, internet availability, market insights, and image URLs.

## `details` (type: `string`):

Table view: description, land_description, council, internet per listing.

## `price_history` (type: `string`):

Table view: timeline, value_estimates per listing.

## `schools_overlays` (type: `string`):

Table view: schools, planning_overlays per listing.

## `market_insights` (type: `string`):

Table view: market_insights per listing.

## `metadata` (type: `string`):

Scraping run summary: mode, total listings scraped, duration, throughput, end time.

## `changes` (type: `string`):

Table view for incremental mode: changeType, changedFields, firstSeenAt, lastSeenAt per listing.

# 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 = {
    "search": "southbank",
    "urls": [
        "https://www.property.com.au/search/?locations=Southbank%2C+VIC+3006&propertyStatus=FOR_SALE",
        "https://www.property.com.au/search/?locations=Southbank%2C+VIC+3006&propertyStatus=FOR_RENT",
        "https://www.property.com.au/search/?locations=Southbank%2C+VIC+3006&propertyStatus=SOLD"
    ],
    "proxy": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "AU"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("abotapi/property-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 = {
    "search": "southbank",
    "urls": [
        "https://www.property.com.au/search/?locations=Southbank%2C+VIC+3006&propertyStatus=FOR_SALE",
        "https://www.property.com.au/search/?locations=Southbank%2C+VIC+3006&propertyStatus=FOR_RENT",
        "https://www.property.com.au/search/?locations=Southbank%2C+VIC+3006&propertyStatus=SOLD",
    ],
    "proxy": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "AU",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("abotapi/property-au-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 '{
  "search": "southbank",
  "urls": [
    "https://www.property.com.au/search/?locations=Southbank%2C+VIC+3006&propertyStatus=FOR_SALE",
    "https://www.property.com.au/search/?locations=Southbank%2C+VIC+3006&propertyStatus=FOR_RENT",
    "https://www.property.com.au/search/?locations=Southbank%2C+VIC+3006&propertyStatus=SOLD"
  ],
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "AU"
  }
}' |
apify call abotapi/property-au-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,abotapi/property-au-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/lJgOYqHV86ZGqIpOt/builds/CGQXSNfNoDToy0bwi/openapi.json