# Domain Real Estate Listings (`truefetch/domain-real-estate-listings`) Actor

Search Domain real estate listings in Australia. Collect sale and rental property data with prices, suburbs, bedrooms, bathrooms, property details, images, agents, and source URLs.

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

## Pricing

from $12.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.

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

> **Affiliate disclosure:** Apify links on this page may include referral parameters. If you sign up through one of these links, TrueFetch may earn a commission from Apify at no extra cost to you. Pricing, features, and Actor access are unaffected.

[![Domain Real Estate Listings](https://img.shields.io/badge/Domain%20Listings-1B4F9A?style=for-the-badge&logoColor=white)](https://apify.com/truefetch/domain-real-estate-listings?fpr=aiagentapi)
[![Real Estate Data](https://img.shields.io/badge/Real%20Estate%20Listings-1F8A70?style=for-the-badge)](https://apify.com/truefetch/domain-real-estate-listings?fpr=aiagentapi)
[![Pay per Result](https://img.shields.io/badge/%2412.00%20per%201%2C000%20listings-2E8B57?style=for-the-badge)](https://apify.com/truefetch/domain-real-estate-listings?fpr=aiagentapi)
[![No Cookies](https://img.shields.io/badge/No%20Login%20%7C%20No%20Cookies-555555?style=for-the-badge)](https://apify.com/truefetch/domain-real-estate-listings?fpr=aiagentapi)
[![Telegram Support](https://img.shields.io/badge/Telegram-Support-26A5E4?style=for-the-badge&logo=telegram&logoColor=white)](https://t.me/AiAgentApi)
[![Telegram Group](https://img.shields.io/badge/Telegram-Group-26A5E4?style=for-the-badge&logo=telegram&logoColor=white)](https://t.me/Apify_Actor)

## Domain Real Estate Listings — Australia Property Data API

**Search Domain — Australia's second-largest real estate marketplace, covering residential property for sale, for rent, and recently sold across Sydney, Melbourne, Brisbane, Perth, Adelaide, and all major Australian markets — and return structured real estate data in one Apify Actor run.** Results include prices, listing status, property type, descriptions, images, agent or agency details, and source URLs as clean JSON / CSV / Excel. No platform login, cookies, or API keys required.

> **TL;DR (40-word answer):** Domain Real Estate Listings is a no-login Apify Actor that returns 40+ structured fields per Domain property listing from Australia at **$12.00 per 1,000 results**, with location-aware inputs, managed reliability, and JSON / CSV / Excel export.

> **What it is NOT:** Domain Real Estate Listings is _not_ a real estate agent account, listing publication service, auction bidding platform, property valuation tool, or buyer's advocate service — it reads public Domain listing pages and returns structured listing data only.

> **Domain Real Estate Listings is an Apify Actor for collecting public property listing data from Domain across Australia.** Search by location, choose listing status such as `for_sale`, `for_rent`, or `sold`, and export a dataset with price, address, property type, media, agent metadata, and source URL. Built for Australian property market research, suburb investment analysis, buyer agent tooling, rental market monitoring, and AI agents using the Apify API or MCP. Maintained by TrueFetch on the Apify Store.

---

### 💼 Why choose Domain Real Estate Listings

**Domain Real Estate Listings is best for** Australian property investors, buyer agents, suburb researchers, rental market analysts, and AI agents that need structured Domain listing data for residential and investment property across Australia.

- **🌍 Domain coverage across Australia** — collect listings from Domain with location-aware inputs covering Sydney, Melbourne, Brisbane, Perth, Adelaide, Canberra, Gold Coast, and all major Australian suburbs and postcodes.
- **🏠 40+ fields per listing** — title, listing type, property type, price, currency, bedrooms, bathrooms, area, address, location, images, agent or agency fields, and source URLs when available.
- **🛡️ Managed reliability built in** — request retries, proxy-aware collection, deduplication, and consistent dataset output are handled by the Actor.
- **📊 Unified export format** — use JSON, JSONL, CSV, Excel, XML, RSS, or the Apify dataset API without building your own parser.
- **⚡ Pay-per-result, not per-CPU** — flat **$12.00 per 1,000 successful listings** (`$0.0120` per result). Free Apify plan includes $5 monthly credits ≈ **~416 free listings per month**.

---

### 🚀 Quick Start — run in 3 steps

#### Run in Apify Console

1. **Open the Actor** — go to [Domain Real Estate Listings on Apify](https://apify.com/truefetch/domain-real-estate-listings?fpr=aiagentapi) and click **Try for free**.
2. **Configure inputs** — choose a `country`, enter a `location`, set `listing_type`, and choose `max_results`.
3. **Click Start** — the Actor streams real estate listings to the dataset. Export as JSON, JSONL, CSV, Excel, XML, RSS, or pull via the dataset API.

#### Run via Apify API

```bash
curl -X POST "https://api.apify.com/v2/acts/TrueFetch~domain-real-estate-listings/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "country": "Australia",
    "location": "Sydney, NSW",
    "listing_type": "for_sale",
    "max_results": 100
}'
````

#### Run via MCP (for AI agents)

Domain Real Estate Listings is callable from Claude, ChatGPT, Cursor, and any MCP-compatible client through the [Apify MCP Server](https://docs.apify.com/platform/integrations/mcp?fpr=aiagentapi). Reference the Actor as `TrueFetch/domain-real-estate-listings` and pass the same JSON input as above.

***

### ⚙️ Input parameters

| Parameter       | Type    | Required | Default    | Description                                                                               | Example       |
| --------------- | ------- | :------: | ---------- | ----------------------------------------------------------------------------------------- | ------------- |
| `country`       | string  |    ✅    | —          | Supported Domain market. Australia is supported.                                          | `Australia`   |
| `location`      | string  |    ✅    | —          | City, region, neighborhood, postal code, or address to search.                            | `Sydney, NSW` |
| `max_results`   | integer |    ✅    | —          | Maximum number of real estate listings to return. Each successful listing is billed once. | `100`         |
| `listing_type`  | string  |    ❌    | `for_sale` | Listing status such as `for_sale`, `for_rent`, or `sold` where supported.                 | `for_sale`    |
| `property_type` | string  |    ❌    | empty      | Optional property type filter. Leave empty to include all supported property types.       | `house`       |

**Default behavior:** the Actor queries the supported source for the selected country and location, deduplicates by source URL or listing ID, and streams results to the default dataset.

```json
{
  "country": "Australia",
  "location": "Sydney, NSW",
  "listing_type": "for_sale",
  "max_results": 100
}
```

***

### 📦 Output dataset

Each run writes structured real estate objects to the **default Apify dataset**, exportable as JSON, JSONL, CSV, Excel, XML, RSS, or via the dataset API.

| Field           | Type   | Always present? | Description                                                   | Example                                               |
| --------------- | ------ | :-------------: | ------------------------------------------------------------- | ----------------------------------------------------- |
| `platform`      | string |       ✅        | Source platform name.                                         | `Domain`                                              |
| `source_url`    | string |       ✅        | Original listing URL for verification.                        | `https://example.com/listing/123`                     |
| `title`         | string |       ✅        | Listing title.                                                | `Modern 2 bedroom apartment`                          |
| `description`   | string |    optional     | Clean listing description when available.                     | `Bright apartment near transit with updated kitchen.` |
| `listing_id`    | string |    optional     | Platform listing identifier.                                  | `123456789`                                           |
| `listing_type`  | string |    optional     | `for_sale`, `for_rent`, or `sold`.                            | `for_sale`                                            |
| `property_type` | string |    optional     | House, apartment, condo, land, commercial, or similar.        | `house`                                               |
| `price`         | object |    optional     | Price value, text, and currency when available.               | `{"value": 750000, "currency": "USD"}`                |
| `beds`          | number |    optional     | Bedroom count.                                                | `3`                                                   |
| `baths`         | number |    optional     | Bathroom count.                                               | `2`                                                   |
| `area`          | object |    optional     | Floor area or lot area with unit.                             | `{"value": 1450, "unit": "sqft"}`                     |
| `address`       | object |    optional     | Structured address fields when available.                     | `{"city": "Denver", "region": "CO"}`                  |
| `location`      | string |    optional     | Human-readable location.                                      | `Sydney, NSW`                                         |
| `geo`           | object |    optional     | Latitude and longitude when available.                        | `{"lat": 39.7392, "lon": -104.9903}`                  |
| `image_urls`    | array  |    optional     | Deduplicated listing image URLs.                              | `["https://images.example.com/1.jpg"]`                |
| `agent`         | object |    optional     | Agent, agency, phone, email, or profile data when available.  | `{"name": "Jane Agent"}`                              |
| `official_url`  | string |    optional     | Official outbound URL when explicitly provided by the source. | `https://agency.example.com/listing/123`              |

#### Sample output

```json
{
  "platform": "Domain",
  "source_url": "https://example.com/listing/123",
  "title": "Modern 2 bedroom apartment",
  "listing_type": "for_sale",
  "property_type": "apartment",
  "price": { "value": 750000, "currency": "USD", "text": "$750,000" },
  "beds": 2,
  "baths": 2,
  "location": "Sydney, NSW",
  "image_urls": ["https://images.example.com/property.jpg"]
}
```

***

### 💡 Use cases

#### For real estate investors and analysts

Track for-sale, for-rent, or recently sold Domain listings across Australian suburbs, compare median asking prices in target postcodes, monitor days-on-market trends, and export clean datasets for investment analysis and suburb comparison.

#### For buyer agents and lead generation teams

Collect Domain listing metadata, agent or agency fields where available, source URLs, and suburb-level location data to build prospecting workflows, property intelligence dashboards, and vendor lead pipelines.

#### For property portals and data products

Use scheduled runs to refresh your Australian listing feed with Domain data. Deduplicate on `source_url` or `listing_id`, then push structured fields to your database or downstream data product.

#### For AI agents and research assistants

Call this Actor through the Apify API or MCP server to answer Australian property market questions — price ranges by suburb, rental stock levels, listing volumes — with live Domain data instead of stale training data.

***

### 💰 Pricing, limits, and performance

| Fact                        | Value                                             |
| --------------------------- | ------------------------------------------------- |
| Pricing model               | Pay-per-result (event: `result`)                  |
| Per-result price            | **$0.0120 per listing = $12.00 per 1,000**        |
| Free-tier monthly allowance | $5 Apify credits ≈ **~416 free listings / month** |
| Supported source            | Domain                                            |
| Supported markets           | Australia                                         |
| Output fields per listing   | **40+**                                           |
| Login / cookies required    | **No** — works without a platform account         |
| Export formats              | JSON, JSONL, CSV, Excel, XML, RSS, dataset API    |

You are billed only for **successfully delivered, deduplicated real estate listings**. Blocked requests, retries, and duplicates are not billed as result events.

***

### ⚖️ Compared with alternatives

| Capability                    | **Domain Real Estate Listings** | Manual browsing |   In-house scraper   |
| ----------------------------- | :-----------------------------: | :-------------: | :------------------: |
| Structured listing dataset    |               ✅                |       ❌        |      you build       |
| No platform login required    |               ✅                |     varies      |        varies        |
| JSON / CSV / Excel export     |               ✅                |       ❌        |      you build       |
| Managed retries and stability |               ✅                |       ❌        |     you maintain     |
| Source URL for verification   |               ✅                |     manual      |      you build       |
| Pay-per-result pricing        |               ✅                |    time cost    | infrastructure + dev |
| Setup time to first result    |          < 60 seconds           |     manual      |    days to weeks     |

**Verdict.** Use Domain Real Estate Listings when you need structured real estate listing data without building and maintaining platform-specific scraping infrastructure.

***

### ⚠️ Common mistakes to avoid

1. **Using a vague location.** Prefer city, postal code, neighborhood, or address formats supported by the selected platform.
2. **Expecting every field on every listing.** Some platforms or sellers do not publish agent, area, geo, or fee fields.
3. **Setting `max_results` too high for narrow searches.** A small neighborhood may not have enough matching listings.
4. **Confusing missing fields with parser failure.** If the raw source does not publish a field, the output should stay empty rather than invent a value.
5. **Ignoring source URLs.** Always keep `source_url` for verification and downstream deduplication.

***

### 🛠️ Troubleshooting

| Problem                               | Likely cause                                           | Fix                                                               |
| ------------------------------------- | ------------------------------------------------------ | ----------------------------------------------------------------- |
| Fewer results than `max_results`      | The source has fewer matching listings.                | Try a broader location, different listing type, or larger market. |
| Run returns 0 results                 | Location or listing type is too narrow or unsupported. | Try a major city, postal code, or a supported listing type.       |
| Some prices or agent fields are empty | The source listing did not publish those fields.       | Treat empty values as expected and filter downstream if needed.   |
| Results look unrelated                | Location format may not match the platform's routing.  | Use city/state, postal code, or a more precise address.           |
| Charge limit reached                  | Account-level run or monthly spend limit hit.          | Raise the run or monthly limit in your Apify settings.            |

***

### ❓ FAQ

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

It returns structured Domain listing data including platform, source URL, title, description, listing type, property type, price, bedrooms, bathrooms, floor area, address, location, geo coordinates, images, and agent or agency details when published on Domain.

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

Domain Real Estate Listings uses pay-per-result pricing at **$0.0120 per listing**, or **$12.00 per 1,000 listings**. The Apify Free plan includes $5 of monthly platform credits, covering approximately **416 free listings per month**.

#### Does Domain Real Estate Listings require a login or cookies?

No. The Actor reads public Domain listing pages without a Domain account, cookies, or source-site API key. You only need an Apify token to invoke the Actor programmatically.

#### Can I export results to CSV or Excel?

Yes. Apify datasets can be exported as JSON, JSONL, CSV, Excel, XML, RSS, or consumed through the dataset API.

#### Does this cover all Australian states and territories?

The Actor searches Domain listings using the location input you provide. Domain has national coverage across all Australian states and territories. Use city, suburb, state, or postcode in the `location` field to target your market.

***

### 🔌 Integrations

Use Domain Real Estate Listings with:

- **Apify API** for backend ingestion.
- **MCP clients** such as Claude, ChatGPT, Cursor, and other AI tools through Apify MCP Server.
- **Make, n8n, Zapier, and webhooks** for no-code workflows.
- **CSV / Excel exports** for analysts and operations teams.
- **Data warehouses** such as BigQuery, Snowflake, Postgres, and internal BI systems.

***

### 🧱 Sister Actors from TrueFetch

#### Jobs

- [Best Job Listing](https://apify.com/truefetch/best-job-listing?fpr=aiagentapi)
- [Indeed Job Listing](https://apify.com/truefetch/indeed-job-listing?fpr=aiagentapi)
- [LinkedIn Job Listing](https://apify.com/truefetch/linkedin-job-listing?fpr=aiagentapi)
- [Glassdoor Job Listing](https://apify.com/truefetch/glassdoor-job-listing?fpr=aiagentapi)

#### Shopping & Deals

- [Amazon Product Listing](https://apify.com/truefetch/amazon-product-listing?fpr=aiagentapi)
- [eBay Listing](https://apify.com/truefetch/ebay-listing?fpr=aiagentapi)
- [Walmart Product Listing](https://apify.com/truefetch/walmart-product-listing?fpr=aiagentapi)
- [Target Product Listing](https://apify.com/truefetch/target-product-listing?fpr=aiagentapi)

#### Vehicles

- [AutoTrader Car Listing](https://apify.com/truefetch/autotrader-car-listing?fpr=aiagentapi)
- [Cars.com Car Listing](https://apify.com/truefetch/carscom-car-listing?fpr=aiagentapi)
- [Webmotors Car Listing](https://apify.com/truefetch/webmotors-car-listing?fpr=aiagentapi)

#### Real Estate

- [Global Real Estate Listings](https://apify.com/truefetch/global-real-estate-listings?fpr=aiagentapi)
- [Zillow Real Estate Listings](https://apify.com/truefetch/zillow-real-estate-listings?fpr=aiagentapi)
- [Realtor Real Estate Listings](https://apify.com/truefetch/realtor-real-estate-listings?fpr=aiagentapi)
- [Rightmove Real Estate Listings](https://apify.com/truefetch/rightmove-real-estate-listings?fpr=aiagentapi)
- [Zoopla Real Estate Listings](https://apify.com/truefetch/zoopla-real-estate-listings?fpr=aiagentapi)
- [Redfin Real Estate Listings](https://apify.com/truefetch/redfin-real-estate-listings?fpr=aiagentapi)

***

### 📞 Support, changelog, last updated

#### Support

- 💬 **Telegram group:** [t.me/Apify\_Actor](https://t.me/Apify_Actor)
- 📧 **Support:** [t.me/AiAgentApi](https://t.me/AiAgentApi)
- 📖 **Actor page & docs:** <https://apify.com/truefetch/domain-real-estate-listings?fpr=aiagentapi>

Maintained by **TrueFetch** on the [Apify Store](https://apify.com/TrueFetch?fpr=aiagentapi).

> **Cost of doing nothing:** building and maintaining an Australian real estate data pipeline means tracking Domain's frequent interface updates, monitoring for listing format drift, and keeping suburb and postcode routing logic current. Domain Real Estate Listings replaces all of that maintenance with a managed, metered, ready-to-run Actor.

#### Changelog

- **2026-06-02** — Updated TrueFetch real estate README, pricing copy, input descriptions, output schema summary, and platform-specific positioning.

***

### JSON-LD

```json
{
  "@context": "https://schema.org",
  "@graph": [
    {
      "@type": "WebSite",
      "@id": "https://apify.com/truefetch/domain-real-estate-listings#website",
      "url": "https://apify.com/truefetch/domain-real-estate-listings",
      "name": "Domain Real Estate Listings",
      "publisher": { "@id": "https://apify.com/TrueFetch#publisher" }
    },
    {
      "@type": "SoftwareApplication",
      "@id": "https://apify.com/truefetch/domain-real-estate-listings#software",
      "name": "Domain Real Estate Listings",
      "applicationCategory": "BusinessApplication",
      "operatingSystem": "Cloud",
      "dateModified": "2026-06-03",
      "url": "https://apify.com/truefetch/domain-real-estate-listings",
      "offers": {
        "@type": "Offer",
        "price": "0.0120",
        "priceCurrency": "USD",
        "description": "Pay per delivered real estate listing"
      },
      "author": { "@id": "https://apify.com/TrueFetch#author-TrueFetch" }
    },
    {
      "@type": "Organization",
      "@id": "https://apify.com/TrueFetch#publisher",
      "name": "TrueFetch",
      "url": "https://apify.com/TrueFetch"
    }
  ]
}
```

***

**Last Updated:** June 03, 2026

**Maintained by:** [TrueFetch](https://apify.com/TrueFetch?fpr=aiagentapi) · 💬 [Telegram Group](https://t.me/Apify_Actor) · 📧 [Support](https://t.me/AiAgentApi)

# Actor input Schema

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

Country where the target real estate listings are located

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

City, region, neighborhood, postal code, or address to search

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

Maximum number of real estate listings to return per platform

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

Listing status to search: for sale, for rent, or sold where supported

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

Optional property type filter. Leave empty to include all supported property types

## Actor input object example

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

# Actor output Schema

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

All property listings found across platforms with structured listing details and source URLs.

# 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,
    "listing_type": "for_sale",
    "property_type": ""
};

// Run the Actor and wait for it to finish
const run = await client.actor("truefetch/domain-real-estate-listings").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,
    "listing_type": "for_sale",
    "property_type": "",
}

# Run the Actor and wait for it to finish
run = client.actor("truefetch/domain-real-estate-listings").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,
  "listing_type": "for_sale",
  "property_type": ""
}' |
apify call truefetch/domain-real-estate-listings --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Domain Real Estate Listings",
        "description": "Search Domain real estate listings in Australia. Collect sale and rental property data with prices, suburbs, bedrooms, bathrooms, property details, images, agents, and source URLs.",
        "version": "1.0",
        "x-build-id": "P3GUhUHwaQsNSqaTM"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/truefetch~domain-real-estate-listings/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-truefetch-domain-real-estate-listings",
                "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/truefetch~domain-real-estate-listings/runs": {
            "post": {
                "operationId": "runs-sync-truefetch-domain-real-estate-listings",
                "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/truefetch~domain-real-estate-listings/run-sync": {
            "post": {
                "operationId": "run-sync-truefetch-domain-real-estate-listings",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "country",
                    "location",
                    "max_results"
                ],
                "properties": {
                    "country": {
                        "title": "Country",
                        "enum": [
                            "Australia"
                        ],
                        "type": "string",
                        "description": "Country where the target real estate listings are located"
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "City, region, neighborhood, postal code, or address to search"
                    },
                    "max_results": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of real estate listings to return per platform"
                    },
                    "listing_type": {
                        "title": "Listing Type",
                        "enum": [
                            "for_sale",
                            "for_rent"
                        ],
                        "type": "string",
                        "description": "Listing status to search: for sale, for rent, or sold where supported"
                    },
                    "property_type": {
                        "title": "Property Type",
                        "enum": [
                            "residential",
                            "house",
                            "apartment",
                            "condo",
                            "townhouse",
                            "land",
                            "commercial",
                            "new_development",
                            "room",
                            "student_housing",
                            "senior_housing",
                            "auction",
                            "ready_to_build",
                            "other"
                        ],
                        "type": "string",
                        "description": "Optional property type filter. Leave empty to include all supported property types"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
