# Domain.com.au Scraper \[$1💰] | AU Property | Agent Emails (`ahmed_jasarevic/domain-com-au-property-scraper`) Actor

Extract Australian property listings from Domain.com.au for sale, rent and sold: price, beds/baths/parking, land size, geo coords, inspections, auction dates and agency & agent contacts. Pay only per result — $0.001 per listing, no API key needed.

- **URL**: https://apify.com/ahmed\_jasarevic/domain-com-au-property-scraper.md
- **Developed by:** [Ahmed Jasarevic](https://apify.com/ahmed_jasarevic) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.88 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Domain.com.au Property Scraper — Australian Property Data & Agent Leads

Extract Australian property listings data from [Domain.com.au](https://www.domain.com.au/) at $0.001 per result: for-sale, for-rent and sold properties with price, beds/baths/parking, land size, geo coordinates, inspection times, auction dates, and agency + agent contact details (name, email, mobile) for real estate lead generation and Australian property market research.

### Main Use Cases

- **Australian property price monitoring** — track asking prices, rent, and sold results per suburb, city, or state (NSW, VIC, QLD, WA, SA) without manual browsing.
- **Auction results tracking** — capture auction-dated listings and sold records to build your own auction clearance dataset over time.
- **Real estate agent lead generation** — collect agent and agency contacts (name, email, mobile, landline, photo) from every listing for targeted outreach.
- **Property investment research** — build clean datasets of price, yield-relevant features, and location data for asset research and valuations.
- **Rental market analysis** — extract weekly rent, property type, and bedroom mix from rent search URLs for rental price benchmarking.
- **Suburb price databases** — assemble structured property databases by suburb for market reports, dashboards, and price comparisons.

### How It Works

The Actor speaks Domain's own internal **GraphQL protocol** over plain HTTP — no browser, no HTML parsing, no official Domain API key required:

1. **Search** — one `searchListings` query returns up to 100 listings with price, features, property type, and agency name.
2. **Details** — batched `listingById` aliases (25 per request) add each listing's full description plus agency and agent contact data.
3. **Fallback** — unusual URL shapes that GraphQL can't serve are parsed from the page's embedded `__NEXT_DATA__` JSON instead.

Because a whole suburb needs only ~3-4 light JSON requests (vs ~45 slow HTML pages), runs are orders of magnitude faster than DOM-scraping approaches. All traffic runs through **Apify's Unblocker proxy (AU)** so Domain's Akamai bot management is solved automatically — no residential proxy management on your side.

### Track Australian House Prices By Suburb

Paste any Domain.com.au search URL — sale, rent, or sold — and the Actor returns structured, flat JSON for every listing in that search. `includeSurroundingSuburbs` (default on) keeps result counts consistent with what the website itself shows (e.g. "Bondi Beach, NSW, 2026 and surroundings"), so a suburb run is a complete, dedupable snapshot you can schedule weekly.

### Extract Real Estate Agent Contacts for Lead Generation

Every listing carries `agencyId`, `agencyName`, `agencyWebsite`, `agencyPhone`, `agentNames`, and — with `enrichAgents` enabled (default on) — a full agent roster with name, job title, email, mobile, landline, profile photo and profile URL, pulled **from the same GraphQL detail request at no extra network cost**. That turns a price-monitoring run into a lead-generation run in one pass.

### Build Australian Property Databases Without An Official API Key

Domain's official partner API (developer.domain.com.au) requires a commercial agreement and OAuth credentials. This Actor needs none of that: it reads the public website's own data through the same GraphQL channel the site's frontend uses. Sale, rent and sold searches all work, so you can assemble whole-market datasets per suburb or city and export to JSON, CSV, Excel, or SQL.

### Input

| Field | Type | Required | Default | Notes |
|---|---|---|---|---|
| `startUrls` | array | ✅ (prefill) | `https://www.domain.com.au/sale/bondi-beach-nsw-2026/` | Domain search-result URLs — sale, rent, and sold all work. Paste any search URL from the site. |
| `maxItems` | integer | — | `50` | Max listings across all search URLs. `0` = no explicit limit (still capped by the run's internal request budget). |
| `maxPages` | integer | — | `3` | Max pagination pages per search URL. Each GraphQL page returns ~100 listings, so 1 page usually covers a suburb. |
| `maxConcurrency` | integer | — | `4` | Parallel requests. Everything runs on ONE warm (Akamai-solved) session, so keep modest (max `20`) to stay under Domain's per-IP threshold. |
| `requestDelayMs` | integer | — | `250` | Random delay (0–2×) between requests to avoid rate-limiting. |
| `includeSurroundingSuburbs` | boolean | — | `true` | Keep ON to match the website's own result counts (suburb + surroundings). OFF returns exact-suburb listings only. |
| `surroundingRadiusMeters` | integer | — | `0` | Optional radius (max 200,000 m) around the suburb centre, on top of the suburb itself. `0` = let Domain choose surrounding suburbs. |
| `enrichAgents` | boolean | — | `true` | Pull each listing's agent roster (name, job title, email, mobile, landline, photo, profile URL) from the same GraphQL detail request. No extra network cost. |
| `proxy` | object | — | `{"useApifyProxy":true,"apifyProxyGroups":["UNBLOCKER"],"apifyProxyCountry":"AU"}` | Proxy configuration. Domain sits behind Akamai bot management — keep the default Unblocker + AU to solve the JS challenge automatically. |

### Output

One flat JSON record per listing, pushed to the default dataset. Fields:

| Field | Description |
|---|---|
| `listingId` | Domain's internal listing ID — use as the dedupe key for re-runs and warehouse loads. |
| `url` | Canonical listing URL. |
| `priceDisplay` / `price` | Human-readable price plus parsed `{type, amount}` — types: `sale`, `rent-weekly`, `rent-monthly`, `auction`, `eoi`, `contact`. |
| `beds`, `baths`, `parking` | Bedroom / bathroom / parking counts. |
| `landSize`, `landUnit` | Land size and unit (e.g. m²) — populated where the source payload exposes it. |
| `propertyType` | e.g. House, Apartment / Unit / Flat, Townhouse. |
| `streetAddress`, `suburb`, `state`, `postcode` | Full address breakdown. |
| `latitude`, `longitude` | Geo coordinates — populated where the source payload exposes them. |
| `inspectionTimes` | Open-home slots — populated where available. |
| `auctionDate` | Auction date/time — populated where available. |
| `agencyId`, `agencyName`, `agencyWebsite`, `agencyPhone` | Agency identity and contact. |
| `agentNames`, `agentContacts` | Agent names plus `{name, email, phone}` contact roster (enrichment: job title, mobile, landline, photo, profile URL). |
| `images` | Image gallery URLs. |
| `promoType` | `standard` / `premium` / `premiumplus` — Domain's paid placement. |
| `description` | Full listing description. |
| `phone`, `listingSummary`, `agentPhoto`, `brandLogo` | Populated on the HTML fallback path. |

### Example Input

```json
{
  "startUrls": [
    { "url": "https://www.domain.com.au/sale/bondi-beach-nsw-2026/" },
    { "url": "https://www.domain.com.au/rent/melbourne-vic-3000/" },
    { "url": "https://www.domain.com.au/sold/surry-hills-nsw-2010/" }
  ],
  "maxItems": 100,
  "maxPages": 3,
  "maxConcurrency": 4,
  "requestDelayMs": 250,
  "includeSurroundingSuburbs": true,
  "surroundingRadiusMeters": 0,
  "enrichAgents": true,
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["UNBLOCKER"],
    "apifyProxyCountry": "AU"
  }
}
```

### Example Output

```json
{
  "listingId": 2020715701,
  "url": "https://www.domain.com.au/9-100-warners-avenue-bondi-beach-nsw-2026-2020715701",
  "priceDisplay": "$1,250,000",
  "price": { "type": "sale", "amount": 1250000, "qualifier": null, "raw": "$1,250,000" },
  "promoType": "standard",
  "beds": 2,
  "baths": 1,
  "parking": 1,
  "landSize": null,
  "landUnit": null,
  "propertyType": "Apartment / Unit / Flat",
  "streetAddress": "9/100 Warners Avenue",
  "suburb": "Bondi Beach",
  "state": "NSW",
  "postcode": "2026",
  "latitude": null,
  "longitude": null,
  "inspectionTimes": null,
  "auctionDate": null,
  "agencyId": 22908,
  "agencyName": "PPD Real Estate",
  "agencyWebsite": "http://www.ppdre.com.au",
  "agencyPhone": "02 8355 1111",
  "agentNames": "Annika Daube, ...",
  "agentContacts": [{ "name": "Annika Daube", "email": "", "phone": "" }],
  "images": ["https://rimh2.domainstatic.com.au/..."],
  "description": "Perfectly positioned just moments from the sand and surf..."
}
```

### Integrations & Automation

- **Apify API** — pull results programmatically via the Apify REST API (JSON, CSV, Excel, XML, HTML).
- **Scheduling** — use Apify's built-in scheduler to run weekly or daily for **Australian property price tracking**: persist by `listingId` and your warehouse stays deduplicated across runs.
- **Webhooks** — trigger downstream pipelines (Slack alerts, databases, BI dashboards) when each run finishes.
- **Zapier / Make** — connect the Actor's dataset to thousands of apps via Apify's official integrations.
- **Client SDKs** — `apify-client` for Python/JavaScript to embed extraction in your own product.

Recommended cadence: weekly for price monitoring and suburb databases; daily during auction season if you track **auction results**; one-off batches for agent lead database builds.

### Related Actors

Australian property data ecosystem on Apify — pair this Domain scraper with:

- [Realestate.com.au Scraper Pro](https://apify.com/azzouzana/real-estate-au-scraper-pro) — Australia's largest portal (buy/sold/rent) for market-wide coverage.
- [Realestate.com.au Listings](https://apify.com/memo23/realestate-au-listings) — buy/rent/sold listings from the #1 AU portal's official services APIs.
- [Realestate.com.au Scraper](https://apify.com/one-api/realestate-com-au-scraper) — suburb/postcode/coordinate search with filters across the AU market.
- [domain.com.au Scraper](https://apify.com/dz_omar/domain-scraper) — another Domain.com.au extraction option with property-detail enrichment.
- [Harcourts Scraper](https://apify.com/ahmed_jasarevic/harcourts-scraper) — AU property listings (buy/sold/rent/leased) with agent email harvesting, by the same developer.

Combining Domain + realestate.com.au covers both major Australian property portals in one pipeline.

### FAQ

#### Is there a Domain API?

Yes — Domain operates an official partner API (developer.domain.com.au) with rich data, but it requires a commercial agreement and OAuth credentials. This Actor uses the public website's own GraphQL data instead, so no API key, contract, or approval is needed — you get listing-level data for a fraction of the cost.

#### What is the cheapest way to get Australian property data?

At **$0.001 per result** this Actor prices at roughly one-third of comparable Domain.com.au scraping actors on the Apify Store, and agent enrichment is included in the same request — no per-contact surcharges. A full suburb snapshot of ~44 listings typically runs in well under 30 seconds.

#### How do I track auction clearance rates in Australia?

Domain and Cotality publish aggregate clearance rates. With this Actor you can build your own **auction results dataset**: scrape `/sale/` URLs (auction-type listings carry `price.type: "auction"` and `auctionDate`) and `/sold/` URLs, then compute your own clearance-rate series per suburb or city over time.

#### Do I need Australian proxies or Unblocker for Domain.com.au?

Yes. Domain.com.au sits behind **Akamai bot management** — plain residential/datacenter IPs hit a JavaScript challenge page. The default input (`UNBLOCKER` proxy group, country `AU`) solves the challenge automatically, and the single warm session keeps solve costs to roughly one per search group.

#### How do I get real estate agent emails from Domain.com.au?

Keep `enrichAgents` enabled (default). The agent roster — name, job title, email, mobile, landline, profile photo and profile URL — is pulled from the same batched GraphQL detail request as the listing data, so there is **no extra network cost and no extra charge** for agent contact data.

#### How to use this actor for property investment research?

Run sale + rent searches for your target suburbs (e.g. `https://www.domain.com.au/sale/parramatta-nsw-2150/` and `https://www.domain.com.au/rent/parramatta-nsw-2150/`), join on `listingId`/`suburb`, and compare asking price vs weekly rent and bedroom mix to shortlist investment candidates — then export the clean dataset to your valuation model or Excel.

#### Domain.com.au vs realestate.com.au — which data should I use?

Both are Australia's dominant property portals (realestate.com.au leads on audience, ~13M monthly uniques vs Domain ~8–9M per Ipsos data). Domain's listing payloads include rich agency/agent contact data and price details that pair well with lead generation. For full-market research, run this Actor alongside a realestate.com.au scraper and merge on address/suburb to remove cross-portal gaps.

#### Is scraping Domain.com.au legal?

The Actor reads publicly visible listing data from a public website over its own GraphQL endpoints — no login bypass, no CAPTCHA solving. Users remain responsible for complying with Domain's Terms of Service and applicable data-protection law. See the disclaimer below.

### SEO Keywords

domain.com.au scraper, domain.com.au api, domain api alternative, australian property data, australian real estate listings, australian property market research, sydney house prices, sydney property data, melbourne property data, brisbane rental prices, perth housing market data, auction results australia, auction clearance rates, real estate agent leads, real estate agent emails, agency contacts australia, property price tracking, property investment data australia, suburb price database, sold price history, rental market analysis australia, realestate.com.au alternative, nsw property data, vic real estate data, qld rental data

### For AI Agents & LLM Apps

- **Purpose:** Returns flat JSON records of Australian property listings (sale/rent/sold) from Domain.com.au — price, beds/baths/parking, land size, property type, address, suburb/state/postcode, geo coords, inspections, auction date, agency + agent contacts (name/email/mobile), image gallery, promo type, description.
- **Minimal working input** (smallest valid run — one suburb search, defaults otherwise):

```json
{
  "startUrls": [
    { "url": "https://www.domain.com.au/sale/bondi-beach-nsw-2026/" }
  ]
}
```

- **Variant inputs:** rent search — `https://www.domain.com.au/rent/melbourne-vic-3000/`; sold search — `https://www.domain.com.au/sold/surry-hills-nsw-2010/`; multi-suburb — pass more entries in `startUrls`.
- **Output fields:** `listingId, url, priceDisplay, price{type,amount,qualifier,raw}, promoType, beds, baths, parking, landSize, landUnit, propertyType, streetAddress, suburb, state, postcode, latitude, longitude, inspectionTimes, auctionDate, agencyId, agencyName, agencyWebsite, agencyPhone, agentNames, agentContacts{name,email,phone}, images, description, phone, listingSummary, agentPhoto, brandLogo`.
- **Behaviors an agent should know:**
  - Everything runs on ONE warm Akamai-solved session — keep `maxConcurrency` modest (default 4; max 20) and keep the default `UNBLOCKER` + `AU` proxy or runs may fail on the Akamai JS challenge.
  - `includeSurroundingSuburbs` (default `true`) matches the website's own result counts — with it ON, a suburb URL returns the suburb **plus** its surrounding suburbs.
  - `surroundingRadiusMeters` (max 200,000) only applies when `includeSurroundingSuburbs` is ON; `0` lets Domain pick the surrounding suburbs.
  - `enrichAgents` (default `true`) adds each listing's agent roster at no extra network cost — disable only for lean rows.
  - `maxPages` default 3; each GraphQL search page returns ~100 listings.
  - `maxItems` default 50; `0` means no explicit limit but the run's **internal request budget still caps total work** — set `maxItems` if you need deterministic billing.
  - Use `listingId` as the dedupe key across scheduled runs.
- **Billing:** pay-per-result — USD $0.001 per result (first-tier plan; lower tiers from $0.00088) + $0.00005 per GB-min actor start; no per-contact surcharge for agent enrichment.

### Legal & Compliance Disclaimer

This Actor is an independent tool and is **not affiliated with, endorsed by, or sponsored by Domain Group Pty Ltd or Domain.com.au**. It accesses only publicly available listing pages and the same GraphQL data the public website serves to visitors; it performs no login bypass, no private-data access, and no CAPTCHA solving.

Users are solely responsible for their use of the extracted data: comply with Domain.com.au's Terms of Service and with applicable Australian data-protection law (including the Privacy Act 1988 (Cth) and the Australian Privacy Principles) and any other jurisdiction's law that applies to your use. Agent contact details are personal information — do not use them for unsolicited commercial outreach that would breach Australian spam/telemarketing rules (e.g. the Spam Act 2003 (Cth)) or equivalent laws in your jurisdiction. This disclaimer is not legal advice.

# Actor input Schema

## `startUrls` (type: `array`):

One or more Domain.com.au search-result URLs, e.g. https://www.domain.com.au/sale/bondi-beach-nsw-2026/ . Sale, rent and sold search URLs all work. Paste any search URL from the site.

## `scrapeDetails` (type: `boolean`):

Also fetch each listing's detail page to enrich results with full description, image gallery, agent photos/contacts, inspection times, auction date and structured features.

## `maxItems` (type: `integer`):

Maximum number of listings to scrape across all search URLs. 0 means no explicit limit (still capped by the run's internal request budget).

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

Maximum number of pagination pages to visit per search URL (~20 listings per page).

## `maxConcurrency` (type: `integer`):

Parallel requests. Everything runs on ONE warm (Akamai-solved) session, so concurrency is kept modest to stay under Domain's per-IP request threshold. Default 4, up to 20.

## `requestDelayMs` (type: `integer`):

Random delay (0-2x this value) added between requests to avoid rate-limiting. Lower values are faster but risk more Akamai challenges.

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

Proxy used for the crawl. Domain.com.au sits behind Akamai bot management; the Apify Unblocker proxy (UNBLOCKER group, AU country) solves the JS challenge automatically. Disable proxy only if you run from lightly-flagged IPs.

## `useGraphQLSearch` (type: `boolean`):

Fetch search results via Domain's GraphQL endpoint instead of parsing the search HTML page (memo23-method: lists 100 listings per request, then enqueues detail pages). Requires scrapeDetails=true to be useful; keeps the Akamai-heavy search page out of the critical path.

## `useJsonApi` (type: `boolean`):

Request pages as JSON (Accept: application/json) instead of rendered HTML. On the platform the AU Unblocker usually answers accept-json requests with rendered HTML anyway, so it is OFF by default — the HTML **NEXT\_DATA** payload carries exactly the same data. Enable only to experiment.

## `useResidentialProxy` (type: `boolean`):

EXPERIMENTAL — currently blocked: as tested, Apify RESIDENTIAL AU exits are hard-rejected (HTTP 403) by Domain's WAF, while UNBLOCKER solves it. Only turn this on to retry residential after code changes. Requires residential proxy enabled on your plan.

## `debugPhoenix` (type: `boolean`):

Warm a session on the search page, then POST to the internal /phoenix/api/listings/residential/\_search endpoint with 3 candidate payloads and save raw responses to the key-value store (debug-phoenix-\*.json). Use to reverse-engineer Domain's fast JSON search API.

## `debugSaveHtml` (type: `boolean`):

Save the first search page HTML to the key-value store for debugging.

## `debugGraphQL` (type: `string`):

Send a GraphQL query to Domain's /graphql endpoint via Unblocker. Use 'introspection' to discover the full schema, or 'search' to try search queries. Results saved to key-value store.

## `debugSearchQuery` (type: `string`):

Location text for GraphQL search debug mode (e.g. 'Bondi Beach NSW').

## `debugGraphQLQuery` (type: `string`):

When set with debugGraphQL=search, this exact query string is POSTed to Domain's /graphql endpoint (instead of the default probes) and the raw response saved to debug-graphql-probe-1.json. Use to reverse-engineer searchListings / listingById fields.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.domain.com.au/sale/bondi-beach-nsw-2026/"
    }
  ],
  "scrapeDetails": true,
  "maxItems": 50,
  "maxPages": 3,
  "maxConcurrency": 4,
  "requestDelayMs": 250,
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "UNBLOCKER"
    ],
    "apifyProxyCountry": "AU"
  },
  "useGraphQLSearch": false,
  "useJsonApi": false,
  "useResidentialProxy": false,
  "debugPhoenix": false,
  "debugSaveHtml": false,
  "debugSearchQuery": "Bondi Beach NSW",
  "debugGraphQLQuery": ""
}
```

# Actor output Schema

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

No description

## `dataset` (type: `string`):

No description

# 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 = {
    "startUrls": [
        {
            "url": "https://www.domain.com.au/sale/bondi-beach-nsw-2026/"
        }
    ],
    "proxy": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "UNBLOCKER"
        ],
        "apifyProxyCountry": "AU"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("ahmed_jasarevic/domain-com-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 = {
    "startUrls": [{ "url": "https://www.domain.com.au/sale/bondi-beach-nsw-2026/" }],
    "proxy": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["UNBLOCKER"],
        "apifyProxyCountry": "AU",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("ahmed_jasarevic/domain-com-au-property-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "startUrls": [
    {
      "url": "https://www.domain.com.au/sale/bondi-beach-nsw-2026/"
    }
  ],
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "UNBLOCKER"
    ],
    "apifyProxyCountry": "AU"
  }
}' |
apify call ahmed_jasarevic/domain-com-au-property-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,ahmed_jasarevic/domain-com-au-property-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/gw68vkMQGFRpqmkzA/builds/SzrgfBlHrsmqUMQco/openapi.json