# Domain Property API (`truefetch/domain-property-api`) Actor

Search Domain sale and rental listings across Australia. Collect 40 normalized property fields covering prices, addresses, bedrooms, bathrooms, area, images, agency data, and source URLs.

- **URL**: https://apify.com/truefetch/domain-property-api.md
- **Developed by:** [TrueFetch](https://apify.com/truefetch) (community)
- **Categories:** Real estate, Lead generation, Agents
- **Stats:** 2 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $10.80 / 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/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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

> **Affiliate disclosure:** Apify links in this README may include referral parameters. If you sign up through one of them, TrueFetch may receive a commission at no extra cost to you.

Domain Real Estate Listings produces structured Australian sale or rental listing records from one deliberately scoped, authorised location search.

- Search Domain inventory by Australian suburb, city, postcode, or supported region with a hard result ceiling.
- Choose sale or rent plus only the property categories that the current Domain route actually applies.
- Receive 40 normalised fields for identity, price, rooms, dimensions, place, media, agency details, source provenance, and processing time.
- Public Store proof is an old deployment snapshot: 4 total users, 0 monthly active users, 0 bookmarks, and no published ratings observed on July 21, 2026; local repository evidence remains the technical source of truth.

[Run Domain Real Estate Listings on Apify](https://console.apify.com/actors/CseuAxWPtN1kQFZlf/input?utm_source=truefetch\&utm_medium=readme\&utm_campaign=domain-real-estate-listings) with one authorised result before considering a production schedule.

### What does Domain Real Estate Listings do?

Domain Real Estate Listings is a single-platform Apify Actor for collecting listing-level property records exposed through Domain search flows in Australia. The current input contract requires a country, location, and maximum result count. Transaction type and property type are optional; if `listing_type` is empty, the runtime selects `for_sale`, while an empty `property_type` leaves that restriction out of the source path.

The Actor resolves the requested Australian area, finds matching listing cards, enriches them from detail pages when possible, normalises the result, and writes accepted items to the default dataset. The public dataset schema contains 40 named fields. A listing may populate only a subset because agencies and advertisements do not expose identical facts, and detail retrieval can be incomplete even when a search card is available.

TrueFetch is not Domain, is not endorsed by Domain, and does not grant a licence to Domain content. Domain's current general terms prohibit scraping or indexing its products and prohibit using them to build property-information databases, derivative products, or competing products. Domain also offers licensed APIs governed by approved-purpose and usage conditions. Use this Actor only if Domain has authorised the exact access and reuse, or if another applicable legal basis has been reviewed and documented by qualified counsel.

### How do I run Domain Real Estate Listings?

Start in the Apify Console and keep the first run intentionally small. The shared scenario in this README checks one townhouse offered for sale around Adelaide, South Australia. It exercises a property path that the current runtime explicitly maps instead of relying on an unsupported or silently broad category.

```json
{
  "country": "Australia",
  "location": "Adelaide, SA",
  "max_results": 1,
  "listing_type": "for_sale",
  "property_type": "townhouse"
}
```

Run the Actor, wait for a terminal status, and inspect both the default dataset and logs. Open the returned `source_url` only when your permission allows it, then compare the title, price, property classification, and address with the source. A requested maximum is not a promise: the source can have fewer matching listings, remove an advertisement during collection, or return pages the parser cannot safely convert.

Only increase `max_results` after confirming four things: the input selects the intended source path, your organisation can lawfully collect and reuse every needed field, the returned shape is suitable for downstream validation, and the observed event charges fit the budget. Do not use a successful HTTP response as evidence of permission or completeness.

### What data does Domain Real Estate Listings return?

Each saved item follows the same 40-field public schema. This illustrative record shows the shape of the Adelaide scenario; it is not a real or current advertisement:

```json
{
  "platform": "Domain",
  "title": "Example townhouse for sale in Adelaide",
  "listing_id": "example-listing-id",
  "listing_type": "for_sale",
  "property_type": "Townhouse",
  "price": {
    "display": "$780,000",
    "value": 780000,
    "currency": "AUD"
  },
  "rooms": {
    "bedrooms": 3,
    "bathrooms": 2,
    "parking_spaces": 1
  },
  "area": {
    "value": 165,
    "unit": "m2"
  },
  "location": "Adelaide SA",
  "address": {
    "suburb": "Adelaide",
    "state": "SA"
  },
  "cover_image": "https://example.com/property.jpg",
  "contact": {
    "name": "Example agency"
  },
  "source_url": "https://www.domain.com.au/example-12345678",
  "processed_at": "2026-07-21T12:00:00Z"
}
```

The schema covers identifiers and provenance (`platform`, `title`, `description`, `listing_id`, `mls_id`, `source_url`, `official_url`), classification (`listing_type`, `availability`, `market_type`, `property_type`, `subtype`, `category`, `business_type`), property facts (`price`, `rooms`, `area`, `land`, `building`, `dates`, `posted_time`, `fees`), location (`location`, `address`, `geo`, `country`, `nearby`), presentation and features (`cover_image`, `image_urls`, `media`, `open_houses`, `features`, `amenities`, `details`), contacts and policies (`contact`, `reviews`, `policies`, `units`), and collection metadata (`processor`, `processed_at`).

Nullable fields must be handled explicitly. An advertised price can be text rather than a numeric amount, an address can be partially withheld, and agency or floor-area data may not exist. Preserve the source link and processing time so reviewers can distinguish transformed observations from authoritative records.

### What inputs can I configure?

| Input | Required | Current accepted behaviour |
| --- | --- | --- |
| `country` | Yes | `Australia` only; it selects the Domain route. |
| `location` | Yes | Domain-recognised suburb, city, postcode, or region. |
| `max_results` | Yes | Integer from 1 to 10,000; actual output may be lower. |
| `listing_type` | No | `for_sale` or `for_rent`; omission uses `for_sale`. |
| `property_type` | No | `residential`, `house`, `apartment`, `townhouse`, `land`, or `new_development`. |

The current code maps `house`, `apartment`, and `townhouse` to corresponding sale or rental search paths. `land` maps to vacant-land sale searches, and `new_development` maps to new-home sale searches; do not combine either with `for_rent`. `residential` uses the general residential route. Leaving the field empty also uses the general route without pretending a narrower filter was applied.

`condo` was removed from the public schema during the July 21, 2026 readiness audit because the runtime did not map it to a Domain filter and would silently use a broad route. There is no public `posted_since`, price, bedroom, bathroom, radius, auction, inspection, or keyword input. Supplying undocumented keys does not make them supported request filters.

### What platforms and markets does Domain Real Estate Listings cover?

The Actor covers one publisher, Domain, and one country, Australia. It supports active sale and rental search modes. It does not document sold-property search, historical sale prices, valuations, ownership records, development applications, mortgage data, off-market stock, commercial-only routing, suburb profiles, or national statistical series.

Australian locations are resolved using source-compatible area identifiers. A suburb-and-state form such as `Adelaide, SA` is a practical starting point, while recognised postcodes and cities may also work. No claim is made that every Domain listing, every Australian territory, or every agency feed will appear. The source controls its inventory, geographic names, and visibility.

### Why use Domain Real Estate Listings?

For an authorised source-specific workflow, the Actor turns variable listing pages into a consistent review surface. Analysts can compare like fields across a small area, data teams can attach source provenance to an internal record, and operations teams can watch a narrowly defined set of advertisements without building separate extraction and normalisation plumbing.

Reasonable permissioned uses may include checking advertisements an agency owns, reviewing licensed comparable listings, validating an internal portfolio feed, or monitoring data-quality differences under a Domain agreement. Output is not a professional valuation, title search, building inspection, legal opinion, credit assessment, or investment recommendation. Asking prices differ from achieved prices, and listing descriptions are supplied by third parties.

The safest workflow uses the minimum fields and volume necessary, stores data only as long as authorised, limits access, and confirms significant facts using official or licensed sources. The Actor should not be used to assemble an unauthorised property database or direct-marketing list.

### Who is Domain Real Estate Listings for?

This Actor may fit Australian property teams, agencies, researchers, portfolio operators, and developers that already have explicit Domain permission or another reviewed legal basis for listing-level collection. It is useful when a small, source-specific dataset is more appropriate than the multi-platform Global Actor and when the team can test and monitor the integration.

It is not for users seeking unrestricted public-web data rights, unapproved database construction, competing products, bulk republication, unsolicited prospecting, or storage beyond an agreed purpose. Domain's official API may be the more appropriate route for customers with an approved use case. If authorisation is unclear, stop before running and contact the source or legal adviser.

### How can I use Domain Real Estate Listings through the API or MCP?

The Actor's API name is `truefetch~domain-real-estate-listings`. Send the same five-field JSON contract to the Apify run endpoint, then read the default dataset only after checking the run status. The synchronous dataset-items endpoint is convenient for the one-result example; asynchronous runs are easier to supervise for larger limits. See the [official Apify API page](https://apify.com/truefetch/domain-real-estate-listings/api) for current endpoints.

For an MCP client, register the current Actor ID and keep credentials outside the configuration committed to source control:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com/?tools=actors&actors=CseuAxWPtN1kQFZlf"
    }
  }
}
```

The [Actor MCP page](https://apify.com/truefetch/domain-real-estate-listings/api/mcp) contains the current setup route. An agent invocation has the same legal, privacy, cost, and input constraints as a manual run. Keep tokens in a secret manager, use least privilege, and require human review before increasing scope.

### How much does Domain Real Estate Listings cost?

Pricing is event based. One Actor start costs **$0.01000**. Each result saved to the default dataset costs **$0.01200** on FREE, **$0.01160** on BRONZE, **$0.01120** on SILVER, and **$0.01080** on GOLD, PLATINUM, or DIAMOND. The one-result Adelaide scenario therefore has a maximum Actor-event charge of **$0.02200 on FREE**, excluding separate Apify subscription or infrastructure usage.

The start event can be charged even if no result is saved. Result charges follow records actually pushed, not the number requested. Always inspect the current Store Pricing tab before production because rates can change after this README date.

### How does Domain Real Estate Listings compare with alternatives?

Choose this Actor when Domain is the required Australian source and the five public inputs are sufficient. Choose Global Real Estate Listings for a permissioned workflow that needs selectable publishers or countries. Zoopla and Rightmove focus on the United Kingdom; Zillow, Realtor, and Redfin focus on North American markets. A different portal is not a substitute when provenance matters.

Domain's licensed API products are a distinct alternative and may be the correct production path. Their published terms describe approved purposes, call limits, credential duties, privacy controls, geographic limits, attribution, and prohibited uses. Direct source authorisation can provide a clearer and more stable basis than page collection. Use the least intrusive licensed option that answers the business question.

### What are the limits and troubleshooting steps?

Domain can change search paths, markup, embedded data, bot controls, classifications, and listings without notice. Detail enrichment can fail while a card remains available. Addresses, prices, floor plans, agent fields, and images can be incomplete. Repeated runs can differ as advertisers update or remove records. The Actor does not guarantee coverage, accuracy, freshness, uptime, or a minimum result count.

Before technical troubleshooting, confirm authority. Current Domain general terms at `https://www.domain.com.au/group/domain-general-terms-and-conditions/` prohibit scraping or indexing and unauthorised property-database or derivative-product construction. Official API use is separately governed by `https://www.domain.com.au/group/api-terms-and-conditions/`. Actor payment does not override either document or applicable Australian privacy, intellectual-property, consumer, and marketing law.

For an authorised failure, rerun the exact one-result Adelaide input; remove `property_type`; confirm the location spelling and state; inspect logs and dataset count; and compare any result with its source URL. A useful support report contains the run ID, sanitised input, UTC timestamp, expected and actual behaviour, and exact error. Never publish an Apify token, source credential, or unnecessary personal information.

### Frequently asked questions

#### Does this Actor support sold listings?

No. The public transaction values are `for_sale` and `for_rent`.

#### Why is `condo` not an input option?

The readiness audit found no Domain route mapping for it. Removing it prevents a broad search from being mistaken for a condo filter.

#### Can I search land for rent?

No documented land rental path exists. `land` and `new_development` are sale-only choices.

#### Are all 40 fields always present?

No. The schema is a normalised envelope and source availability determines populated values.

#### Does this Actor replace Domain's official API?

No. If a licensed API meets the use case, it may provide the clearer authorised production route.

### Related TrueFetch Actors

- [Global Real Estate Listings](https://apify.com/truefetch/global-real-estate-listings) — multi-source, multi-country routing.
- [Zoopla Real Estate Listings](https://apify.com/truefetch/zoopla-real-estate-listings) — United Kingdom sale and rental listings.
- [Rightmove Real Estate Listings](https://apify.com/truefetch/rightmove-real-estate-listings) — another United Kingdom listing source.
- [Zillow Real Estate Listings](https://apify.com/truefetch/zillow-real-estate-listings) — Zillow searches in the United States and Canada.

Choose based on authorised source, market, inputs, and provenance—not catalogue breadth alone.

### Support and last updated

Report reproducible Actor defects through the [Actor Issues tab](https://apify.com/truefetch/domain-real-estate-listings/issues) using a run ID and sanitised evidence. Keep permission documents, credentials, and personal data out of public issues.

Documentation last verified **July 21, 2026** against the current repository's metadata, revised input schema, dataset and storage schemas, pricing events, and read-only Domain runtime path. The opening Store figures are explicitly an older deployed snapshot and do not determine current repository behaviour.

[Open Domain Real Estate Listings and run the one-result check](https://console.apify.com/actors/CseuAxWPtN1kQFZlf/input?utm_source=truefetch\&utm_medium=readme\&utm_campaign=domain-real-estate-listings-support).

# Actor input Schema

## `country` (type: `string`):

Country where Domain listings will be searched

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

Suburb, city, postcode, or region supported by Domain

## `max_results` (type: `integer`):

Maximum number of Domain property listings to return

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

Choose the transaction status to search

## `property_type` (type: `string`):

Optional property type filter. Land and new development apply to sale searches only; leave empty to include all supported property types

## Actor input object example

```json
{
  "country": "Australia",
  "location": "Sydney, NSW",
  "max_results": 10
}
```

# Actor output Schema

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

Overview table for the default dataset of normalized property listings.

# 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 = {
    "country": "Australia",
    "location": "Sydney, NSW",
    "max_results": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("truefetch/domain-property-api").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 = {
    "country": "Australia",
    "location": "Sydney, NSW",
    "max_results": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("truefetch/domain-property-api").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 '{
  "country": "Australia",
  "location": "Sydney, NSW",
  "max_results": 10
}' |
apify call truefetch/domain-property-api --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/CseuAxWPtN1kQFZlf/builds/rvrq56ZrAjkA8qEgf/openapi.json