# Realestate.com.au Property API (`johnvc/realestate-au-property-api`) Actor

Australian property listings and sold property prices as clean, structured JSON. Search any suburb for buy, rent, or sold with no listing URL needed, and get beds, baths, parking, land size, sold date, agent details, and coordinates. Pay per listing, MCP-ready for Claude and AI agents.

- **URL**: https://apify.com/johnvc/realestate-au-property-api.md
- **Developed by:** [John](https://apify.com/johnvc) (community)
- **Categories:** AI, Real estate, Developer tools
- **Stats:** 6 total users, 5 monthly users, 96.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.43 / 1,000 listing returneds

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

## Realestate.com.au Property API: Australian Listings and Sold Property Prices

Australian property listings as clean, structured JSON. Look up sold property prices, current for-sale stock, or rentals in any suburb and get back confirmed sold dates, the selling agency, beds, baths, parking, and the source's price estimate, straight from public [realestate.com.au](https://www.realestate.com.au/) listing pages.

No listing URL required. The Actor builds the search for you from suburb, state, and postcode, so you can go straight from "Coomera, QLD, 4209" to structured data.

### What this actor returns

One row per listing. The two built-in dataset views cover the fields most people sort and filter on, and the full JSON export carries everything else.

- **Listings overview view:** street address, suburb, state, property type, bedrooms, bathrooms, parking spaces, price estimate, listing status, and the listing URL
- **Sold properties view:** street address, suburb, state, postcode, confirmed sold date, price estimate as displayed and as a number, the selling agency, and a link to the fuller property history
- **Full JSON export:** everything above plus land size and floor area with parsed numeric values, latitude and longitude, the `agents` block (agency, phone, star rating, review count), the full listing description, photo URLs and photo count, the off-market flag, rent price and currency on rental rows, and a last-seen timestamp

Land size, coordinates, and the `agents` block sit in the full JSON export rather than in either tabular view, so pull the raw dataset (or the `allResults` link) when you need them.

Every listing row also carries a one-line plain-language `summary`, so an AI agent can read a record without post-processing.

### About prices, stated plainly

This source gives a **confirmed sold date** but a **price estimate**, not a verified sale price. That is a fact about the Australian market rather than a gap in the data: sale prices are frequently not publicly disclosed here, unlike in the UK.

So `soldDate` is solid, and `estimatedPrice` is exactly what its name says. The field is labelled that way everywhere, including in the schema, so nothing downstream mistakes an estimate for a settled figure. Fields the source did not populate in live testing, including a separate valuation range and confidence score, are left out of the output rather than shipped permanently empty.

There is one more thing worth knowing before you build on the price fields. Sold rows and rental rows almost always carry a number. **For-sale rows frequently do not**: Australian agents routinely advertise a property as "Contact Agent", "AUCTION", or a written range instead of a figure, and when that happens `estimatedPriceValue` is null and `estimatedPrice` holds the text as published. Filter for a non-null `estimatedPriceValue` before you average anything on a `buy` search.

### Use cases

- **Research a suburb's sold market.** Search `sold` for a suburb and get every recent sale with its date, agency, and price estimate.
- **Track listings in a target area.** Search `buy` or `rent` on a schedule and diff the results for new stock and changes.
- **Build a comparable set.** Beds, baths, parking, and, from the full JSON export, land size and coordinates let you match like with like.
- **Map agency market share.** Sold listings carry the selling agency, so you can count sales by agency in a suburb.
- **Benchmark rents.** A `rent` search returns the advertised weekly rent and its currency across a whole suburb.

### Input parameters

| Parameter | Type | Required | Description | Example |
|---|---|---|---|---|
| `mode` | string | **Required** | `search` builds the search from suburb and state. `url` collects specific listing pages. | `search` |
| `listingType` | string | Optional | `buy`, `rent`, or `sold`. Defaults to `buy`. | `sold` |
| `locations` | array of strings | Optional (empty = nationwide) | `"Suburb, STATE"` or `"Suburb, STATE, POSTCODE"`. Up to 20. | `["Coomera, QLD, 4209"]` |
| `maxResultsPerSearch` | integer | Optional | Listings per search. Defaults to 50. This is your cost control. | `50` |
| `daysBack` | integer | Optional | Recency filter. It needs a date-sorted search, which the suburb searches this Actor builds are not, so leave it empty and use a schedule plus a diff instead. See the FAQ. | (leave empty) |
| `limitPages` | integer | Optional | Cap how many result pages to walk. | `5` |
| `splitByPropertyType` | boolean | Optional | Walk each property type separately to reach deeper into a large suburb. | `false` |
| `splitByPriceRange` | boolean | Optional | Same, by price band. | `false` |
| `listingUrls` | array of strings | Required in URL mode | Specific listing URLs. | |

```json
{
  "mode": "search",
  "listingType": "sold",
  "locations": ["Coomera, QLD, 4209"],
  "maxResultsPerSearch": 50
}
```

A suburb must be paired with its state. Several Australian suburbs share a name, so a bare suburb is rejected with a clear message rather than silently guessed.

### Example output

```json
{
  "result_type": "listing",
  "propertyId": "property-house-qld-coomera-136778134",
  "streetAddress": "17 Severn Street",
  "suburb": "Coomera",
  "state": "QLD",
  "postcode": "4209",
  "propertyType": "House",
  "listingType": "Sold",
  "bedrooms": 4,
  "bathrooms": 2,
  "parking": 2,
  "landSize": "454m²",
  "landSizeValue": 454,
  "estimatedPrice": "$585,000",
  "estimatedPriceValue": 585000,
  "soldDate": "2021-08-03T00:00:00.000Z",
  "lastSoldAgency": "Harcourts RG - Gold Coast",
  "agents": [
    { "agency": "Harcourts RG - Gold Coast", "phone": "07 5636 8963", "rating": 5, "reviewCount": 76 }
  ],
  "latitude": -27.84383141,
  "longitude": 153.33601549,
  "photoCount": 21,
  "offMarket": true,
  "summary": "4-bed house at 17 Severn Street, Coomera, QLD. Sold 2021-08-03. Price estimate $585,000."
}
```

A search that returns nothing produces a row with `result_type: "error"` and a plain-language `error_message`.

### Pricing

Pay per result. One event, `listing-scraped`, is charged once for every listing pushed to the dataset. Nothing is charged for a search that returns no listings.

`maxResultsPerSearch` caps what a run can cost, and the cap is applied at the source rather than by discarding rows already paid for. Current rates are shown on the Store card.

### How to get started

1. [View on Apify Store](https://apify.com/johnvc/realestate-au-property-api?fpr=9n7kx3) and click Try for free.
2. Leave **Mode** on `search`, set **Listing type**, and enter a location such as `Coomera, QLD, 4209`.
3. Run it. Results appear on the Output tab and export as JSON, CSV, or Excel. The **Sold properties** view shows sale dates and agencies directly.

Prefer to start from code? The [example repo with a Python quick start and MCP setup walkthrough](https://github.com/johnisanerd/Apify-Realestate-AU-Property-API) has runnable scripts for each of the three listing types.

### 🔌 Use this API from Claude (MCP)

Add this Actor as a tool in [Claude Code](https://claude.ai/referral/uIlpa7nPLg) (free trial), [Claude Cowork](https://claude.ai/referral/uIlpa7nPLg) (free trial), Cursor, or any other MCP client through the hosted Apify MCP server:

```
https://mcp.apify.com/?tools=actors,docs,johnvc/realestate-au-property-api
```

With [Claude Code](https://claude.ai/referral/uIlpa7nPLg) (free trial):

```
claude mcp add --transport http realestate-au "https://mcp.apify.com/?tools=actors,docs,johnvc/realestate-au-property-api"
```

Then ask your agent something like "what sold in Coomera QLD in the last year and which agencies handled it".

https://www.youtube.com/watch?v=jREWahDGhJM

Apify MCP integration docs: https://docs.apify.com/platform/integrations/mcp

### 💸 Pay per run with crypto (x402)

The Realestate.com.au Property API supports agentic payments via the [x402 protocol](https://docs.apify.com/platform/integrations/x402).
AI agents and MCP clients can pay for runs in USDC (on Base) with no Apify account or API token needed:
point your agent at the [Apify MCP server](https://mcp.apify.com/?tools=actors,docs,johnvc/realestate-au-property-api) and it can
discover, pay for, and run this Actor autonomously. Read the
[Apify x402 announcement](https://apify.com/change-log/pay-for-apify-actors-with-x402?fpr=9n7kx3) for details.

### 🔌 Integrations: Track Sold Property Prices on a Schedule

A single run tells you what one suburb looks like today. Run it every week and keep each dataset, and after a couple of months you can actually see the market move. That is where this Actor earns its keep. Everything below runs on [Apify platform integrations](https://docs.apify.com/platform/integrations), so none of it needs a server of your own.

#### Saved tasks plus schedules (start here)

Make one [saved task](https://docs.apify.com/platform/actors/running/tasks) per thing you are watching, for example "Coomera sold", "Coomera rentals", and "Coomera for sale", each with its locations and listing type baked into the input. Then open the Actor's **Actions** menu, choose **Schedule**, and point one [schedule](https://docs.apify.com/platform/schedules) at all of them.

Useful cron strings:

- `0 7 * * *` every day at 7 AM
- `0 */6 * * *` every six hours
- `0 9 * * 1` Mondays at 9 AM, which suits a weekly sold-market review

One schedule can trigger many tasks at once, so a whole watchlist of suburbs runs on a single trigger. Scheduling is also how you get recency here, since the source rejects a date filter on these searches. Compare each dataset against the previous one: new `propertyId` values are new stock, and a `propertyId` that moves from `buy` to `sold` is a sale. [Check Sold Property Prices in Any Australian Suburb](https://apify.com/johnvc/realestate-au-property-api/examples/check-sold-property-prices-in-any-australian-suburb?fpr=9n7kx3) is a ready-made task you can copy and schedule in a click.

#### n8n, Make, and Zapier

There is no dedicated community node for this Actor yet, so use the official [Apify n8n integration](https://docs.apify.com/platform/integrations/n8n) and its generic Actor node. A four-step workflow covers most alerting needs: **Schedule Trigger**, then the **Apify** node running `johnvc/realestate-au-property-api`, then a **Filter** on `listingType` or `estimatedPriceValue`, then **Slack** or **Email**. The same shape works in [Make](https://docs.apify.com/platform/integrations/make) and [Zapier](https://docs.apify.com/platform/integrations/zapier): trigger on the finished run, filter the rows, send the ones that matter.

#### Keep the history in Supabase

Property data is only interesting over time, so push each run into a table keyed on `propertyId`. No-code path: the Apify node followed by a Supabase node in n8n. In Python:

```python
from apify_client import ApifyClient
from supabase import create_client

apify = ApifyClient("<APIFY_TOKEN>")
supabase = create_client("<SUPABASE_URL>", "<SUPABASE_KEY>")

run = apify.actor("johnvc/realestate-au-property-api").call(run_input={
    "mode": "search",
    "listingType": "sold",
    "locations": ["Coomera, QLD, 4209"],
    "maxResultsPerSearch": 50,
})

rows = [
    {
        "property_id": item["propertyId"],
        "street_address": item.get("streetAddress"),
        "suburb": item.get("suburb"),
        "state": item.get("state"),
        "postcode": item.get("postcode"),
        "sold_date": item.get("soldDate"),
        "estimated_price": item.get("estimatedPrice"),
        "estimated_price_value": item.get("estimatedPriceValue"),
        "last_sold_agency": item.get("lastSoldAgency"),
    }
    for item in apify.dataset(run.default_dataset_id).iterate_items()
    if item.get("result_type") == "listing"
]

supabase.table("au_sold_listings").upsert(rows, on_conflict="property_id").execute()
```

Store `estimated_price_value` as nullable. On a `buy` search it often is null, for the "Contact Agent" reason described above.

#### MCP and AI agents

Point any MCP client at the [Apify MCP server](https://mcp.apify.com/) and the Actor becomes a tool your agent can call on its own. Claude and Cursor both work; [Claude Code](https://claude.ai/referral/uIlpa7nPLg) (free trial) and [Claude Cowork](https://claude.ai/referral/uIlpa7nPLg) (free trial) are the two setups covered in the example repo. A question an agent can answer end to end: "which agency handled the most sales in Coomera QLD last year, and what was the median price estimate". The [Get Australian Sold Property Data in Claude via MCP](https://apify.com/johnvc/realestate-au-property-api/examples/get-australian-sold-property-data-in-claude-via-mcp?fpr=9n7kx3) task is the shortest path to trying it.

#### Webhooks

For anything custom, attach an [Apify webhook](https://docs.apify.com/platform/integrations/webhooks) on `ACTOR.RUN.SUCCEEDED` and receive the dataset ID the moment a run finishes. That is the glue for pushing rows into your own warehouse, valuation model, or CRM.

### 🔗 Related Tools

Actors that pair well with Australian property data:

- [Zoopla UK Property API](https://apify.com/johnvc/zoopla-property-api?fpr=9n7kx3) is the UK sibling of this Actor, for listings and sold house prices in Britain.
- [Google Maps Places Scraper](https://apify.com/johnvc/google-maps-places-api?fpr=9n7kx3) pulls the schools, cafes, and transport around a shortlisted address, which is the context a listing page never gives you.
- [Google Maps Directions API](https://apify.com/johnvc/google-maps-directions-api?fpr=9n7kx3) turns a shortlist into commute times, so you can rank suburbs by travel rather than by postcode.
- [LinkedIn Company API](https://apify.com/johnvc/linkedin-company-api?fpr=9n7kx3) enriches the selling agencies you find in the `lastSoldAgency` field with headcount and firmographics.

For contrast, [realestate.com.au Scraper by silentflow](https://apify.com/silentflow/realestate-com-au-scraper?fpr=9n7kx3) covers similar ground but carries no Store reviews and no monthly active users at the time of writing. This API publishes two named dataset views, documents every input and output field, and labels its price data as an estimate rather than a sale price.

### 💡 Applications

Ready-to-run examples of this API in action. Open any one and run it in a single click.

#### Realestate.com.au Property Data API: Listings as JSON

The general-purpose starting point: any suburb, any listing type, straight to structured JSON.
[Run this task](https://apify.com/johnvc/realestate-au-property-api/examples/realestate-com-au-property-data-api-listings-as-json?fpr=9n7kx3)

#### Check Sold Property Prices in Any Australian Suburb

Every recent sale in a suburb with its confirmed date, selling agency, and price estimate.
[Run this task](https://apify.com/johnvc/realestate-au-property-api/examples/check-sold-property-prices-in-any-australian-suburb?fpr=9n7kx3)

#### Track Weekly Rent Prices by Australian Suburb

Advertised weekly rents across a suburb, ready to schedule so the series builds itself.
[Run this task](https://apify.com/johnvc/realestate-au-property-api/examples/track-weekly-rent-prices-by-australian-suburb?fpr=9n7kx3)

#### Get Australian Sold Property Data in Claude via MCP

Wire the Actor into an MCP client and ask questions about a suburb in plain language.
[Run this task](https://apify.com/johnvc/realestate-au-property-api/examples/get-australian-sold-property-data-in-claude-via-mcp?fpr=9n7kx3)

#### Export an Australian Property Dataset to CSV or Excel

Pull a suburb into a spreadsheet without writing any code.
[Run this task](https://apify.com/johnvc/realestate-au-property-api/examples/export-an-australian-property-dataset-to-csv-or-excel?fpr=9n7kx3)

#### Find Which Agency Sold Each Home in an Australian Suburb

Count sales by agency to see who actually holds a suburb's market share.
[Run this task](https://apify.com/johnvc/realestate-au-property-api/examples/find-which-agency-sold-each-home-in-an-australian-suburb?fpr=9n7kx3)

#### 查询澳洲各区已售房源的成交日期与价格估算 (Check Australian Sold Listings and Price Estimates)

按区查询澳洲已售房源的成交日期、成交中介与价格估算。Sold-market research for Chinese-speaking buyers and investors.
[Run this task](https://apify.com/johnvc/realestate-au-property-api/examples/chaxun-aozhou-yishou-fangyuan-chengjiao-jilu?fpr=9n7kx3)

#### 获取澳洲各区在租房源与每周租金数据 (Get Australian Rental Listings and Weekly Rents)

按区获取澳洲在租房源与每周租金。Rental benchmarking for Chinese-speaking landlords and tenants.
[Run this task](https://apify.com/johnvc/realestate-au-property-api/examples/huoqu-aozhou-zaizu-fangyuan-zhoujin-shuju?fpr=9n7kx3)

### ❓ FAQ

#### Does realestate.com.au have an API?

Not a public one. That is why this Actor exists: it turns the same listing data into structured JSON you can call programmatically, with no listing URLs to manage.

#### How do I check what a property sold for?

Set **Listing type** to `sold` and search the suburb. Each result carries a confirmed `soldDate`, the selling agency, and a price estimate. Read the section above on prices: the date is confirmed, the price is an estimate, because Australian sale prices are often undisclosed.

#### How do I find sold property prices for a whole suburb?

One search with `listingType: sold` and a location returns every recent sale the source holds for that suburb, up to your result cap.

#### Does this return an automated property valuation?

No. Automated valuation fields, including a separate valuation range and a confidence score, were empty in live testing and are deliberately not part of the output. What you get is the source's displayed price estimate on each listing, nothing modelled by this Actor.

#### Why does a for-sale listing come back with no price?

Because the agent did not publish one. On `buy` searches, Australian listings are often advertised as "Contact Agent", "AUCTION", or a written price range. In those rows `estimatedPrice` holds the published text and `estimatedPriceValue` is null. Sold and rent rows carry a number far more consistently, so filter on a non-null `estimatedPriceValue` before you compute any average.

#### Why do I need to include the state?

Several Australian suburbs share a name, so a suburb on its own is ambiguous. Pairing it with the state resolves that, and adding the postcode narrows it further.

#### Can I get only recently listed properties?

Not through the **Listed in the last N days** field on a suburb search. That filter only works against a date-sorted search, and the suburb searches this Actor builds are not date sorted, so supplying a value returns a single `result_type: error` row explaining the conflict instead of listings. Leave the field empty. To get recency, run the search on a [schedule](https://docs.apify.com/platform/schedules) and diff each run against the previous one, which the Integrations section above walks through.

#### Can I schedule this Australian property Scraper?

Yes, and this is the setup most people end up with. Save a [task](https://docs.apify.com/platform/actors/running/tasks) with your input, one per suburb or listing type, then open **Actions**, then **Schedule**, and attach a [schedule](https://docs.apify.com/platform/schedules) to it. Cron strings like `0 7 * * *` (daily at 7 AM), `0 */6 * * *` (every six hours), or `0 9 * * 1` (Mondays at 9 AM) all work, and a single schedule can trigger many tasks at once, so an entire watchlist of suburbs fires on one trigger. Because each run writes its own dataset, the history accumulates and you can diff runs to spot new listings, price changes, and sales. The Integrations section above has the full monitoring recipe including alerting and storage.

#### Should I use an API or a Web Scraper for Australian property data?

For most people the distinction matters less than it sounds. An official [API](https://en.wikipedia.org/wiki/API) is rate limited, quota bound, and often missing the fields you actually want, and in this case realestate.com.au does not offer a public one at all. A [web scraping](https://en.wikipedia.org/wiki/Web_scraping) tool reads the public pages instead. This Actor gives you both ergonomics at once: click Run in the Console like a no-code Scraper, or call it as a clean JSON endpoint from your own code, with no quota to manage either way.

#### Can I integrate this Realestate.com.au Scraper with other apps?

Yes. Through [Apify integrations](https://docs.apify.com/platform/integrations) the Actor connects to almost any cloud service, including [Make](https://docs.apify.com/platform/integrations/make), [Zapier](https://docs.apify.com/platform/integrations/zapier), [Slack](https://docs.apify.com/platform/integrations/slack), Google Drive, and Google Sheets, plus [n8n](https://docs.apify.com/platform/integrations/n8n) for self-hosted workflows. For anything custom, an [Apify webhook](https://docs.apify.com/platform/integrations/webhooks) on `ACTOR.RUN.SUCCEEDED` hands your own endpoint the dataset ID as soon as a run finishes. The Integrations section above has copy-paste recipes for each.

#### Can I use the Realestate.com.au Property API from my own code?

Yes. The Apify API lets you start runs, attach schedules, and fetch datasets programmatically, and the `apify-client` package exists for both Python and Node.js. The [API tab for this Actor](https://apify.com/johnvc/realestate-au-property-api/api?fpr=9n7kx3) shows the exact endpoints and a ready-made client snippet, and the [example repo](https://github.com/johnisanerd/Apify-Realestate-AU-Property-API) has a working Python quick start.

#### Can I use this Actor through an MCP server?

Yes. It can be added as a tool to any MCP client, including Claude and Cursor, through the hosted [Apify MCP server](https://mcp.apify.com/). The Actor-specific URL is `https://mcp.apify.com/?tools=actors,docs,johnvc/realestate-au-property-api`. In [Claude Code](https://claude.ai/referral/uIlpa7nPLg) (free trial) or [Claude Cowork](https://claude.ai/referral/uIlpa7nPLg) (free trial), add it once and your agent can query Australian suburbs on its own. See the [Apify MCP docs](https://docs.apify.com/platform/integrations/mcp) for client-by-client setup.

#### What if a suburb has more listings than one search returns?

Turn on **Split by property type** or **Split by price range**. Both walk the suburb in slices, which reaches deeper than a single result list, at the cost of a longer run.

#### Does it cover rentals?

Yes. Set **Listing type** to `rent`. Rental rows carry the advertised rent and its currency.

#### Does it return agent names?

Sometimes. The individual agent's name is often absent from the source while the agency, phone, rating and review count are present, so entries are kept for what they do carry rather than dropped.

#### How do I find commercial property sold prices?

Not with this Actor. It covers the residential listings published on [realestate.com.au](https://www.realestate.com.au/), which is where the `buy`, `rent`, and `sold` listing types come from. Commercial stock in Australia lives on a separate site and is out of scope here, so treat any commercial figure you need as a different data source rather than assuming this one covers it.

#### How can I research the area around a property?

A listing tells you about a building, not a neighbourhood. Pair this Actor with the [Google Maps Places Scraper](https://apify.com/johnvc/google-maps-places-api?fpr=9n7kx3) for nearby schools, shops, and transport, and the [Google Maps Directions API](https://apify.com/johnvc/google-maps-directions-api?fpr=9n7kx3) for commute times from a shortlist. If your search extends to Britain, the [Zoopla UK Property API](https://apify.com/johnvc/zoopla-property-api?fpr=9n7kx3) returns the equivalent listings and sold house prices there.

#### Is it affiliated with realestate.com.au?

No. This Actor is not affiliated with, endorsed by, or connected to REA Group or [realestate.com.au](https://www.realestate.com.au/). It is an independent tool that reads publicly available listing pages, and it makes no claim of feature parity with any product that company may offer.

#### Is it legal to scrape property listings?

Collecting publicly available data is generally permitted, though the specifics depend on your jurisdiction and what you do with the data. Apify's write-up on [the legality of web scraping](https://blog.apify.com/is-web-scraping-legal/) is a good starting point. This Actor reads only public listing pages and returns no personal data beyond the agency contact details the source publishes on the listing itself.

### 🔗 Resources

- [Realestate.com.au Property API on Apify Store](https://apify.com/johnvc/realestate-au-property-api?fpr=9n7kx3)
- [Example repo: Python quick start and MCP walkthroughs](https://github.com/johnisanerd/Apify-Realestate-AU-Property-API)
- [Apify schedules documentation](https://docs.apify.com/platform/schedules)
- [Apify MCP integration docs](https://docs.apify.com/platform/integrations/mcp)

### 🌐 About Alpha OSINT

This Actor is part of [Alpha OSINT](https://www.alphaosint.com), toolset of financial and operations data sources and APIs.
For support or requests for this actor, please start a ticket [directly on our support page](https://apify.com/johnvc/realestate-au-property-api/issues/open?fpr=9n7kx3).

Last Updated: 2026.08.10

# Actor input Schema

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

How to find properties. Search builds the search for you from suburb, state and postcode, and needs no URL. URL collects specific listing pages you already hold.

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

Whether to search properties for sale, for rent, or already sold. Sold is what powers sold-price research.

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

Australian locations as "Suburb, STATE" or "Suburb, STATE, POSTCODE", for example "Coomera, QLD, 4209". A suburb must be paired with its state, because several Australian suburbs share a name. Leave empty to search the whole country. Up to 20 per run.

## `maxResultsPerSearch` (type: `integer`):

How many listings to return for each search. You are charged per listing returned, so this is also your cost control.

## `daysBack` (type: `integer`):

Only return listings added in the last N days. Works in search mode, where the search is automatically sorted newest first so the filter applies. In URL mode, your own search URL must already be sorted by date or the source rejects the filter.

## `limitPages` (type: `integer`):

Cap how many pages of search results to walk. Useful on large suburbs.

## `splitByPropertyType` (type: `boolean`):

Walk each property type separately. Slower, but reaches deeper into a large suburb where a single result list is truncated.

## `splitByPriceRange` (type: `boolean`):

Walk each price band separately. Same trade-off as splitting by property type.

## `listingUrls` (type: `array`):

Specific listing URLs to collect, used in URL mode.

## Actor input object example

```json
{
  "mode": "search",
  "listingType": "buy",
  "locations": [
    "Coomera, QLD, 4209"
  ],
  "maxResultsPerSearch": 50,
  "splitByPropertyType": false,
  "splitByPriceRange": false
}
```

# Actor output Schema

## `allResults` (type: `string`):

Every dataset item from this run: collected listings and any error rows.

## `overview` (type: `string`):

Tabular overview: address, suburb, state, type, beds, baths, parking, price estimate, status.

## `sold` (type: `string`):

Sold listings with their confirmed sold date, price estimate, selling agency, and a link to the fuller history.

# 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 = {
    "locations": [
        "Coomera, QLD, 4209"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("johnvc/realestate-au-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 = { "locations": ["Coomera, QLD, 4209"] }

# Run the Actor and wait for it to finish
run = client.actor("johnvc/realestate-au-property-api").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 '{
  "locations": [
    "Coomera, QLD, 4209"
  ]
}' |
apify call johnvc/realestate-au-property-api --silent --output-dataset

```

## MCP server setup

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

```

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/Ni9pNhSXGT4Ul8vQL/builds/kBpLpFSoVZfV7rHhV/openapi.json