# Domain.com.au Scraper — AU Buy, Rent & Sold Listings (`sian.agency/domain-au-property-scraper`) Actor

Extract Australian property listings from Domain.com.au: search by suburb, coordinates, URL or bulk-suburb list across buy, rent and sold. Get prices, beds/baths/parking, addresses, agents, schools, floorplans and market insights with median-price A$ KPIs — export clean JSON, CSV or Excel.

- **URL**: https://apify.com/sian.agency/domain-au-property-scraper.md
- **Developed by:** [SIÁN OÜ](https://apify.com/sian.agency) (community)
- **Categories:** Real estate, Automation, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 1,000 property extracteds

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

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

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

## Domain.com.au Scraper 🇦🇺 Buy · Rent · Sold · Auction Data

[![SIÁN Agency Store](https://img.shields.io/badge/Store-SI%C3%81N%20Agency-1AE392)](https://apify.com/sian.agency?fpr=sian) [![Zillow Property Scraper](https://img.shields.io/badge/Store-Zillow%20Property%20Scraper-1F4E79)](https://apify.com/sian.agency/zillow-property-scraper?fpr=sian) [![Redfin Property Scraper](https://img.shields.io/badge/Store-Redfin%20Property%20Scraper-A02021)](https://apify.com/sian.agency/redfin-property-scraper?fpr=sian) [![Property Skip Tracing](https://img.shields.io/badge/Store-Property%20Skip%20Tracing-1AE392)](https://apify.com/sian.agency/property-skip-tracing?fpr=sian)

#### 🎉 The Domain.com.au scraper that ships structured schools, 5-year market insights and A$ median KPIs — not just a raw listing dump
##### Built for Australian property investors, buyer's agents, and PropTech teams who model markets, not just collect rows

---

### 📋 Overview

**Pull every Domain.com.au listing in your target Australian market — for-sale, to-rent, and recently-sold (with sold price + sold date) — and get ready-to-model A$ KPIs alongside the raw data.** Rank suburbs by median price, comp valuations against the sold archive, and export the lot to JSON / CSV / Excel before your next inspection round.

**Why property professionals choose this actor:**
- ✅ **Structured, not raw**: typed `schools[]`, 5-year `marketInsights`, and `floorplans` on detail enrichment — where the $0.001 raw scrapers hand you unstructured JSON
- ⚡ **Analysis-ready in one run**: median sale/rent/sold, price distributions, and suburb + property-type breakdowns computed in-actor and delivered as an HTML market report
- 🎯 **Four search modes**: free-text suburb, coordinates + radius, a pasted Domain.com.au URL, or a bulk-suburb sweep — with cross-page `propertyId` deduplication
- 💰 **Pay-per-result pricing**: charged per listing extracted; a hard-capped FREE tier lets you test the full feature set with no credit card
- 💎 **Sold + auction coverage**: pull the recently-sold archive with final sold price + sold date, and flag listings heading to auction
- ✨ **Agent & agency intel**: agency name, logo, brand colour, and listing agents captured on every row

---

### ✨ Features

- 🏠 **Buy + Rent + Sold in one actor**: switch channels with a single `listingType` field, or run all three at once (PAID)
- 🧭 **Four flexible search modes**: `bylocation`, `bycoordinates`, `byurl`, and PAID `bulklocations`
- 📊 **Run-level market KPIs**: median A$ prices, min/median/avg/p90/max distributions, suburb and property-type tallies
- 🏫 **Neighbourhood intelligence (PAID)**: typed nearby schools with level, sector, and year-range
- 📈 **Market insights (PAID)**: 5-year price series, price guide, recent-sales low/high band, and price direction
- 🖼 **Full media**: photo counts, complete photo URL lists, and floorplans on detail enrichment
- 🔨 **Auction + sold data**: auction flags plus the recently-sold archive with sold price and date
- 🔁 **Automatic dedup + pagination**: cross-page `propertyId` deduplication and auto-paginated result draining
- 📄 **HTML market report**: a shareable summary with KPIs, distributions, and per-query totals

---

### 🎬 Quick Start

Pick a search mode, give it a location (or a Domain.com.au URL), choose sale / rent / sold, and run. Results stream into the Apify dataset with A$ KPIs computed on top.

```bash
curl -X POST "https://api.apify.com/v2/acts/sian.agency~domain-au-property-scraper/runs?token=YOUR_APIFY_TOKEN" \
-H 'Content-Type: application/json' \
-d '{"searchMode": "bylocation", "location": "Bondi Beach NSW 2026", "listingType": "sale", "maxResults": 30}'
````

***

### 🚀 Getting Started (3 Simple Steps)

#### Step 1: Choose a search mode

Pick `bylocation` (free-text suburb), `bycoordinates` (lat/lon + radius), `byurl` (paste a Domain.com.au search URL), or `bulklocations` (array of suburbs, PAID).

#### Step 2: Set your market

Enter your suburb / coordinates / URL, pick `listingType` (sale, rent, sold, or all), and add optional filters (price, beds, baths, parking, property type, keywords).

#### Step 3: Run and export

Launch the actor. Toggle `includeDetails` (PAID) for schools, floorplans and market insights.

**That's it! In a couple of minutes, you'll have:**

- A clean dataset of Domain.com.au listings with 19 structured fields per row
- A$ market KPIs (median price, distributions, suburb breakdowns) in an HTML report
- Exportable JSON / CSV / Excel for your comps, models, or CRM

***

### 📥 Input Configuration

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `searchMode` | string | Yes | `bylocation`, `bycoordinates`, `byurl`, or `bulklocations` |
| `listingType` | string | No | `sale`, `rent`, `sold`, or `all` (PAID). Default `sale` |
| `location` | string | Conditional | Free-text suburb / state / postcode (`bylocation` mode) |
| `suburbId` | integer | No | Optional Domain suburb id to disambiguate a location |
| `latitude` / `longitude` | number | Conditional | Coordinates (`bycoordinates` mode) |
| `radius` | number | No | Search radius in km (`bycoordinates` mode) |
| `domainUrl` | string | Conditional | A Domain.com.au search-results URL (`byurl` mode) |
| `locations` | array | Conditional | Array of suburbs to sweep (`bulklocations`, PAID) |
| `propertyType` | string | No | e.g. `House`, `Apartment`, `Townhouse`, `Land` |
| `priceRange` / `bedsRange` / `bathsRange` / `parkingRange` | string | No | `min:N`, `max:N`, or `min:N,max:N` |
| `keywords` | string | No | Free-text amenity keywords (e.g. `pool`, `harbour view`) |
| `maxResults` | integer | No | Cap on listings per query (FREE capped at 25/run) |
| `includeDetails` | boolean | No | Fetch full detail — schools, floorplans, market insights (PAID) |

**Example — search by suburb:**

```json
{
  "searchMode": "bylocation",
  "location": "Surfers Paradise QLD 4217",
  "listingType": "sale",
  "propertyType": "Apartment",
  "priceRange": "min:500000,max:1500000",
  "maxResults": 50
}
```

**Example — bulk suburbs (PAID) with detail enrichment:**

```json
{
  "searchMode": "bulklocations",
  "locations": ["Bondi NSW", "Carlton VIC", "New Farm QLD"],
  "listingType": "rent",
  "includeDetails": true
}
```

***

### 📤 Output

Results are saved to the Apify dataset with **19 structured fields** per listing, plus an HTML market report in the key-value store.

| Field | Type | Description |
|-------|------|-------------|
| `propertyId` | string | Unique Domain.com.au listing id |
| `listingType` | string | `sale`, `rent`, or `sold` |
| `headline` | string | Listing headline / marketing title |
| `listingUrl` | string | Canonical Domain.com.au listing URL |
| `address` | object | Street, suburb, state, postcode, region |
| `pricing` | object | AUD price, min/max, display string, rent frequency |
| `specs` | object | Beds, baths, parking, property type |
| `location` | object | Latitude / longitude |
| `agency` | object | Agency name, logo, brand colour, listing agents |
| `media` | object | Photo count + full photo URL list |
| `inspections` | array | Scheduled inspection windows |
| `isAuction` | boolean | Heading to auction |
| `dateListed` | string | Publish date |
| `detail` | object | (PAID) description, floorplans, schools, market insights |

**Example row:**

```json
{
  "propertyId": "2019876543",
  "listingType": "sale",
  "status": "Live",
  "headline": "Renovated Beachside Apartment with Ocean Views",
  "listingUrl": "https://www.domain.com.au/2019876543",
  "address": { "suburb": "Bondi Beach", "state": "NSW", "postcode": "2026" },
  "pricing": { "price": 1850000, "priceDisplay": "$1,800,000 - $1,900,000", "priceCurrency": "AUD" },
  "specs": { "beds": 2, "baths": 1, "parking": 1, "propertyType": "Apartment" },
  "location": { "latitude": -33.891, "longitude": 151.277 },
  "agency": { "name": "Bondi Coastal Realty", "agents": [{ "name": "Jane Smith" }] },
  "media": { "photoCount": 18 },
  "isAuction": true
}
```

***

### 💼 Use Cases & Examples

#### 1. AU Property Investors

**Investors screening buy-side deals across multiple suburbs.**

**Input:** A `bulklocations` sweep of target suburbs with a `priceRange` and `propertyType` filter.
**Output:** Every matching listing plus median-price KPIs and suburb breakdowns.
**Use:** Shortlist under-priced stock and rank suburbs by median before booking inspections.

#### 2. Comparables (Comps) Valuation

**Buyer's agents and valuers building a comps set from sold data.**

**Input:** `listingType: "sold"` for a suburb or coordinate radius.
**Output:** The recently-sold archive with final sold price and sold date.
**Use:** Anchor a valuation against real, recent transactions — not asking prices.

#### 3. Auction & Sold-History Research

**Analysts tracking auction activity and clearance in a market.**

**Input:** A suburb search with `listingType: "all"` (sale + rent + sold).
**Output:** Auction-flagged listings alongside the sold archive.
**Use:** Model auction demand and price movement over time.

#### 4. Suburb-Level Market Reports

**Agencies producing branded suburb reports for vendors.**

**Input:** `bylocation` per target suburb with `includeDetails` on (PAID).
**Output:** Median A$ prices, distributions, school data, and 5-year market insights.
**Use:** Drop the HTML report and KPIs straight into a listing-presentation deck.

#### 5. Buyer's-Agent Lead & Agency Intel

**Buyer's agents mapping the agencies and agents active in a patch.**

**Input:** Any search mode across a target region.
**Output:** Agency name, logo, brand colour, and listing agents on every row.
**Use:** Build a live map of who's listing what, where — pair with [Property Skip Tracing](https://apify.com/sian.agency/property-skip-tracing?fpr=sian) for owner outreach.

***

### 🔗 Integration Examples

#### JavaScript/Node.js

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: 'YOUR_TOKEN' });

const run = await client.actor('sian.agency/domain-au-property-scraper').call({
  searchMode: 'bylocation',
  location: 'Bondi Beach NSW 2026',
  listingType: 'sale'
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items[0]);
```

#### Python

```python
from apify_client import ApifyClient
client = ApifyClient('YOUR_TOKEN')

run = client.actor('sian.agency/domain-au-property-scraper').call(run_input={
    'searchMode': 'bylocation',
    'location': 'Bondi Beach NSW 2026',
    'listingType': 'sale'
})

for item in client.dataset(run['defaultDatasetId']).iterate_items():
    print(item)
```

#### cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/sian.agency~domain-au-property-scraper/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN' \
-H 'Content-Type: application/json' \
-d '{"searchMode": "bylocation", "location": "Bondi Beach NSW 2026", "listingType": "sale"}'
```

#### Automation Workflows (N8N / Zapier / Make)

1. **Trigger**: Schedule (e.g. weekly suburb sweep) or webhook
2. **HTTP Request**: `POST /v2/acts/sian.agency~domain-au-property-scraper/runs?token=YOUR_TOKEN` with your input
3. **Process**: Handle the JSON listing rows + KPIs
4. **Action**: Save to your CRM / warehouse, notify, or transform

***

### 📊 Performance & Pricing

#### FREE Tier (Try It Now)

- **Up to 25 listings** per run — full feature access, same data quality
- No credit card required
- Perfect for testing a suburb or validating your filters

#### PAID Tier (Production Ready)

- **Unlimited** listings per run and bulk-suburb sweeps
- Detail enrichment (schools, floorplans, market insights) and `listingType: all`
- Pay-per-result: charged only for listings actually extracted

💰 **Pay-per-event, transparent pricing** — a per-listing rate for the structured dataset, with an optional per-listing detail-enrichment charge only when you turn it on.

🔗 [View live pricing on the Apify Store](https://apify.com/sian.agency/domain-au-property-scraper?fpr=sian)

***

### ❓ Frequently Asked Questions

**Q: How many listings can I extract?**
A: FREE tier: 25 per run. PAID tier: unlimited, with auto-pagination until your `maxResults` cap or the search is fully drained.

**Q: Does it cover Australia only?**
A: Yes. Domain.com.au is a major Australian property portal; this actor covers Australian listings only. For US property data, use [Redfin Property Scraper](https://apify.com/sian.agency/redfin-property-scraper?fpr=sian) or [Zillow Property Scraper](https://apify.com/sian.agency/zillow-property-scraper?fpr=sian).

**Q: Can I get sold prices and sold dates?**
A: Yes. Set `listingType: "sold"` to pull the recently-sold archive; each row carries the final sold price and sold-date stamp.

**Q: What extra data does detail enrichment add?**
A: With `includeDetails` on (PAID), each listing gains the full description, all photos, floorplans, typed nearby schools, and 5-year market insights (price series, price guide, recent-sales band, price direction).

**Q: What output formats are available?**
A: JSON, CSV, and Excel — export directly from the Apify dataset. An HTML market report is saved to the key-value store.

**Q: Is this legal?**
A: We only extract publicly available data from Domain.com.au — no auth bypass, no private content. You are responsible for complying with Domain.com.au's Terms of Service and applicable Australian law. See the [legal section](#️-is-it-legal-to-scrape-data) below.

**Q: How do I search a precise area?**
A: Use `bycoordinates` with a `latitude`, `longitude`, and `radius` (km), or paste a Domain.com.au search-results URL with `byurl`.

***

### 🐛 Troubleshooting

**Location not resolving / zero results**

- Domain.com.au is strict about location strings. Try `"Sydney NSW 2000"` (suburb + state + postcode) instead of `"Sydney"`.
- For ambiguous suburb names (Richmond exists in NSW, VIC, and QLD), always include the state, or pass the optional `suburbId`.

**`byurl` mode rejected the URL**

- The URL must be a Domain.com.au search-results page starting with `https://www.domain.com.au/`.
- Single-listing URLs are not search URLs — use `bylocation` or `bycoordinates` to find listings.

**Detail enrichment returned nothing**

- Detail enrichment is a PAID feature and is disabled on the FREE tier.
- A small number of listings may not expose full detail; those rows still include the search-level data.

**Radius pulling neighbouring suburbs**

- `radius` is in **kilometres**, capped at 50. In dense metro areas, a large radius reaches neighbouring postcodes — narrow the radius for a tighter market.

***

### ⚖️ Is it legal to scrape data?

Our actors are ethical and do not extract any private user data. They only extract what Domain.com.au has chosen to publish publicly — listing data, agency contact blocks, property descriptions, and photos that any visitor can see by browsing the public site.

However, you should be aware that your results could contain personal data. Personal data is protected by the **GDPR** in the European Union and by other regulations around the world (including the Australian **Privacy Act 1988**). You should not scrape personal data unless you have a legitimate reason to do so. If you're unsure whether your reason is legitimate, consult your lawyers.

You are also responsible for complying with **Domain.com.au's Terms of Service** when using the data downstream.

You can also read Apify's blog post on the [legality of web scraping](https://blog.apify.com/is-web-scraping-legal/).

### ⚠️ Trademark Disclaimer

This is an **independent tool** — not affiliated with, endorsed by, or sponsored by **Domain Holdings Australia Ltd**, the **Domain Group**, or **Domain.com.au**. All trademarks (including Domain, Domain.com.au, and any agency brand names appearing in extracted data) are the property of their respective owners. Use of this Actor must comply with Domain.com.au's Terms of Service and applicable Australian law (Privacy Act 1988, Spam Act 2003, Competition and Consumer Act 2010).

***

### 🤝 Support

[![Telegram Support](https://img.shields.io/badge/Telegram-Support%20Group-0088cc?logo=telegram)](https://t.me/+vyh1sRE08sAxMGRi)

**Join our active support community**

- For issues or questions, open an issue in the actor's Issues tab
- Check the [SIÁN Agency Store](https://apify.com/sian.agency?fpr=sian) for more automation tools
- 📧 <apify@sian-agency.online>

***

**Built by [SIÁN Agency](https://www.sian-agency.online)** | **[More Tools](https://apify.com/sian.agency?fpr=sian)**

# Actor input Schema

## `searchMode` (type: `string`):

How to specify what to scrape.

• **bylocation** — free-text Australian suburb / town (e.g. "Sydney NSW 2000", "Bondi")
• **bycoordinates** — latitude + longitude + radius (km)
• **byurl** — paste a Domain.com.au search-results URL
• **bulklocations** — array of suburbs in one run (PAID)

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

Which side of the Australian market to scrape.

• **sale** — properties for sale
• **rent** — properties to rent
• **sold** — recently-sold archive (with sold price + sold date)
• **all** — runs each query three times — sale + rent + sold (PAID)

Note: ignored when Search Mode = byurl (the URL itself encodes the channel).

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

Free-text Australian location — suburb, town, region, state, or postcode area.

Examples: `Sydney NSW 2000`, `Bondi Beach`, `Surfers Paradise`, `Melbourne CBD`, `Perth WA`

## `suburbId` (type: `integer`):

Optional Domain suburb identifier used to disambiguate an ambiguous location string (e.g. Richmond exists in NSW, VIC and QLD). Leave empty to resolve the location by text.

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

Array of Australian suburb / location strings to sweep in one run. PAID tier only.

## `latitude` (type: `number`):

Latitude in decimal degrees. Sydney CBD ≈ `-33.8688`. Australia is in the southern hemisphere — values are negative.

## `longitude` (type: `number`):

Longitude in decimal degrees. Sydney CBD ≈ `151.2093`. Australia uses positive longitudes (east of Greenwich).

## `domainUrl` (type: `string`):

Paste any search-results URL from Domain.com.au.

Examples:

- `https://www.domain.com.au/sale/sydney-nsw-2000/`
- `https://www.domain.com.au/rent/melbourne-vic-3000/`

## `radius` (type: `number`):

Search radius in kilometres (bycoordinates mode). Allowed: 0.1–50.

## `propertyType` (type: `string`):

Comma-separated property types. Leave empty to include all.

Allowed: `House, Apartment, Townhouse, Land, Rural, Retirement, House & Land, New Homes`

Examples: `Apartment`, `House,Townhouse`, `Land,Rural`

## `priceRange` (type: `string`):

Price range in AUD. Format: `min:N`, `max:N`, or `min:N,max:N`.

For sale/sold: total price. For rent: per-week rent (AU listings are weekly).

Examples: `min:500000,max:1500000`, `max:600`, `min:300000`

## `bedsRange` (type: `string`):

Bedroom range. Studio = `min:0`. Format: `min:N`, `max:N`, or `min:N,max:N`.

Examples: `min:2`, `min:3,max:3`, `min:2,max:5`

## `bathsRange` (type: `string`):

Bathroom range. Format: `min:N`, `max:N`, or `min:N,max:N`.

## `parkingRange` (type: `string`):

Parking-space range (cars / garages / off-street). Format: `min:N`, `max:N`, or `min:N,max:N`.

## `sizeSqftRange` (type: `string`):

Floor or land area in square feet. Format: `min:N`, `max:N`, or `min:N,max:N`.

## `constructionStatus` (type: `string`):

Construction status filter.

• **established** — existing properties
• **builder** — new builds
• **off\_plan** — sold off-plan
• (empty) — any

## `furnished` (type: `string`):

Furnishing state — only used when listingType = rent.

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

Free-text amenity keywords matched against listing descriptions.

Examples: `pool`, `harbour view`, `air conditioning`, `pool tennis`

## `sortOrder` (type: `string`):

How results are sorted. Default: Featured.

## `petsAllowed` (type: `boolean`):

Return only pet-friendly rentals.

## `includeSold` (type: `boolean`):

Also include under-contract / pending listings alongside live ones.

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

Hard cap on listings returned per query. Auto-paginates until the cap is reached or the search is fully drained. FREE tier is always capped at 25 listings per run.

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

When ON, fetches full listing detail (description, all photos, floorplans, nearby schools, market insights, days on market) for each listing — 1 extra API call per listing. Adds a detail-enriched charge per successful enrichment. Disabled on FREE tier.

## Actor input object example

```json
{
  "searchMode": "bylocation",
  "listingType": "sale",
  "location": "Sydney NSW 2000",
  "latitude": -33.8688,
  "longitude": 151.2093,
  "radius": 5,
  "constructionStatus": "",
  "furnished": "",
  "sortOrder": "",
  "petsAllowed": false,
  "includeSold": false,
  "maxResults": 30,
  "includeDetails": false
}
```

# Actor output Schema

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

Structured Domain.com.au listings (buy / rent / sold) with parsed prices, suburb-level data, agency block, and (optional) full-detail enrichment.

## `htmlReport` (type: `string`):

HTML summary with run stats, market KPIs (median A$, distributions), suburb + property-type breakdowns, and per-query totals.

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("sian.agency/domain-au-property-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("sian.agency/domain-au-property-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 '{}' |
apify call sian.agency/domain-au-property-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Domain.com.au Scraper — AU Buy, Rent & Sold Listings",
        "description": "Extract Australian property listings from Domain.com.au: search by suburb, coordinates, URL or bulk-suburb list across buy, rent and sold. Get prices, beds/baths/parking, addresses, agents, schools, floorplans and market insights with median-price A$ KPIs — export clean JSON, CSV or Excel.",
        "version": "1.0",
        "x-build-id": "g2dQXaPrVsop7NfVc"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/sian.agency~domain-au-property-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-sian.agency-domain-au-property-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/sian.agency~domain-au-property-scraper/runs": {
            "post": {
                "operationId": "runs-sync-sian.agency-domain-au-property-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/sian.agency~domain-au-property-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-sian.agency-domain-au-property-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",
                "properties": {
                    "searchMode": {
                        "title": "🧭 Search Mode",
                        "enum": [
                            "bylocation",
                            "bycoordinates",
                            "byurl",
                            "bulklocations"
                        ],
                        "type": "string",
                        "description": "How to specify what to scrape.\n\n• **bylocation** — free-text Australian suburb / town (e.g. \"Sydney NSW 2000\", \"Bondi\")\n• **bycoordinates** — latitude + longitude + radius (km)\n• **byurl** — paste a Domain.com.au search-results URL\n• **bulklocations** — array of suburbs in one run (PAID)",
                        "default": "bylocation"
                    },
                    "listingType": {
                        "title": "🏠 Listing Type",
                        "enum": [
                            "sale",
                            "rent",
                            "sold",
                            "all"
                        ],
                        "type": "string",
                        "description": "Which side of the Australian market to scrape.\n\n• **sale** — properties for sale\n• **rent** — properties to rent\n• **sold** — recently-sold archive (with sold price + sold date)\n• **all** — runs each query three times — sale + rent + sold (PAID)\n\nNote: ignored when Search Mode = byurl (the URL itself encodes the channel).",
                        "default": "sale"
                    },
                    "location": {
                        "title": "📍 Location  (used when Search Mode = bylocation)",
                        "type": "string",
                        "description": "Free-text Australian location — suburb, town, region, state, or postcode area.\n\nExamples: `Sydney NSW 2000`, `Bondi Beach`, `Surfers Paradise`, `Melbourne CBD`, `Perth WA`",
                        "default": "Sydney NSW 2000"
                    },
                    "suburbId": {
                        "title": "🆔 Suburb ID  (optional, bylocation mode)",
                        "type": "integer",
                        "description": "Optional Domain suburb identifier used to disambiguate an ambiguous location string (e.g. Richmond exists in NSW, VIC and QLD). Leave empty to resolve the location by text."
                    },
                    "locations": {
                        "title": "📋 Bulk Locations  (PAID, bulklocations mode)",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Array of Australian suburb / location strings to sweep in one run. PAID tier only.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "latitude": {
                        "title": "🗺 Latitude  (used when Search Mode = bycoordinates)",
                        "type": "number",
                        "description": "Latitude in decimal degrees. Sydney CBD ≈ `-33.8688`. Australia is in the southern hemisphere — values are negative."
                    },
                    "longitude": {
                        "title": "🗺 Longitude  (used when Search Mode = bycoordinates)",
                        "type": "number",
                        "description": "Longitude in decimal degrees. Sydney CBD ≈ `151.2093`. Australia uses positive longitudes (east of Greenwich)."
                    },
                    "domainUrl": {
                        "title": "🔗 Domain.com.au URL  (used when Search Mode = byurl)",
                        "type": "string",
                        "description": "Paste any search-results URL from Domain.com.au.\n\nExamples:\n- `https://www.domain.com.au/sale/sydney-nsw-2000/`\n- `https://www.domain.com.au/rent/melbourne-vic-3000/`"
                    },
                    "radius": {
                        "title": "📏 Search radius (km)",
                        "minimum": 0,
                        "maximum": 50,
                        "type": "number",
                        "description": "Search radius in kilometres (bycoordinates mode). Allowed: 0.1–50.",
                        "default": 5
                    },
                    "propertyType": {
                        "title": "🏘 Property type",
                        "type": "string",
                        "description": "Comma-separated property types. Leave empty to include all.\n\nAllowed: `House, Apartment, Townhouse, Land, Rural, Retirement, House & Land, New Homes`\n\nExamples: `Apartment`, `House,Townhouse`, `Land,Rural`"
                    },
                    "priceRange": {
                        "title": "💵 Price range (AUD)",
                        "type": "string",
                        "description": "Price range in AUD. Format: `min:N`, `max:N`, or `min:N,max:N`.\n\nFor sale/sold: total price. For rent: per-week rent (AU listings are weekly).\n\nExamples: `min:500000,max:1500000`, `max:600`, `min:300000`"
                    },
                    "bedsRange": {
                        "title": "🛏 Bedrooms",
                        "type": "string",
                        "description": "Bedroom range. Studio = `min:0`. Format: `min:N`, `max:N`, or `min:N,max:N`.\n\nExamples: `min:2`, `min:3,max:3`, `min:2,max:5`"
                    },
                    "bathsRange": {
                        "title": "🛁 Bathrooms",
                        "type": "string",
                        "description": "Bathroom range. Format: `min:N`, `max:N`, or `min:N,max:N`."
                    },
                    "parkingRange": {
                        "title": "🚗 Parking spaces",
                        "type": "string",
                        "description": "Parking-space range (cars / garages / off-street). Format: `min:N`, `max:N`, or `min:N,max:N`."
                    },
                    "sizeSqftRange": {
                        "title": "📐 Floor / land area (sqft)",
                        "type": "string",
                        "description": "Floor or land area in square feet. Format: `min:N`, `max:N`, or `min:N,max:N`."
                    },
                    "constructionStatus": {
                        "title": "🏗 Construction status",
                        "enum": [
                            "",
                            "established",
                            "builder",
                            "off_plan"
                        ],
                        "type": "string",
                        "description": "Construction status filter.\n\n• **established** — existing properties\n• **builder** — new builds\n• **off_plan** — sold off-plan\n• (empty) — any",
                        "default": ""
                    },
                    "furnished": {
                        "title": "🛋 Furnished state (rent only)",
                        "enum": [
                            "",
                            "furnished",
                            "unfurnished",
                            "part_furnished"
                        ],
                        "type": "string",
                        "description": "Furnishing state — only used when listingType = rent.",
                        "default": ""
                    },
                    "keywords": {
                        "title": "🔑 Free-text keywords",
                        "type": "string",
                        "description": "Free-text amenity keywords matched against listing descriptions.\n\nExamples: `pool`, `harbour view`, `air conditioning`, `pool tennis`"
                    },
                    "sortOrder": {
                        "title": "🔃 Sort order",
                        "enum": [
                            "",
                            "Featured",
                            "Newest",
                            "Price_Low_to_High",
                            "Price_High_to_Low",
                            "Suburb",
                            "Inspection"
                        ],
                        "type": "string",
                        "description": "How results are sorted. Default: Featured.",
                        "default": ""
                    },
                    "petsAllowed": {
                        "title": "🐾 Pets allowed only (rent)",
                        "type": "boolean",
                        "description": "Return only pet-friendly rentals.",
                        "default": false
                    },
                    "includeSold": {
                        "title": "📌 Include under-contract (sale)",
                        "type": "boolean",
                        "description": "Also include under-contract / pending listings alongside live ones.",
                        "default": false
                    },
                    "maxResults": {
                        "title": "📊 Max results per query",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Hard cap on listings returned per query. Auto-paginates until the cap is reached or the search is fully drained. FREE tier is always capped at 25 listings per run.",
                        "default": 30
                    },
                    "includeDetails": {
                        "title": "📋 Include full listing detail (PAID)",
                        "type": "boolean",
                        "description": "When ON, fetches full listing detail (description, all photos, floorplans, nearby schools, market insights, days on market) for each listing — 1 extra API call per listing. Adds a detail-enriched charge per successful enrichment. Disabled on FREE tier.",
                        "default": 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```