# Australian Property Zoning and Development API (`nabeelbaghoor/property-development-potential-api`) Actor

Australian property planning data by address, property ID or coordinate: the zone and overlays over a parcel, permitted and prohibited uses, flood, bushfire and heritage flags, lot identifier and area, development potential with built precedents, and a rendered planning map.

- **URL**: https://apify.com/nabeelbaghoor/property-development-potential-api.md
- **Developed by:** [Nabeel Hassan](https://apify.com/nabeelbaghoor) (community)
- **Categories:** Real estate, Business, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $18.00 / 1,000 property planning record returneds

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/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

## Australian Property Zoning and Development API

Ask an Australian address what you are allowed to build on it, and what somebody already built next door.

### What it collects

- **Zoning** for any parcel: the primary zone code and label, and every zone on a split-zoned site rather than only the first.
- **Overlays** as the provider publishes them, each with its category, key and value, plus the flood, bushfire, heritage, environment, infrastructure and industry flags.
- **Permitted and prohibited uses** under the parcel's planning instrument, as filterable lists rather than one long string.
- **Parcel facts**: lot identifier, property type, area in square metres, strata lot count, local government area, locality, linked GNAF addresses and the parcel centre point.
- **Development potential**: estimated dwelling yield with the provider's complexity, confidence and slope grades, heritage, flood and fire flags, and the nearby built precedents behind the estimate with their address, zone, site area, dwelling count and frontage.
- **Granny flat eligibility**: whether a secondary dwelling can be built on the property.
- **Planning maps**: a rendered image of the parcel with zoning, heritage, bushfire, flood or contours drawn over it, with legend labels and colours.

### FAQ

#### What can I build on an Australian property?

Run planning essentials on the address. It returns the zone or zones covering the parcel, the overlays that restrict it, and the permitted and prohibited use lists under the relevant planning instrument, along with the lot identifier, parcel area and local government area. Run development potential on the same address for an estimated dwelling yield and the comparable approvals it rests on.

#### Which states does this Australian planning API cover?

The provider's planning coverage spans Australian states and territories, and parcels come back tagged with their own region, for example nsw or vic, along with the local government area. Address matching accepts NSW, VIC, QLD, SA, WA, TAS, NT and ACT.

#### Can I look up a property by coordinate instead of address?

Yes. Every mode accepts a latitude and longitude pair as well as an address or a property ID. Give the pair latitude first; the actor sends them as the separate named fields this API expects, so a swapped pair cannot quietly return a real parcel somewhere else. Each row records which of the three input kinds produced it.

#### Why does my address need matching first?

This API takes no free text on its data endpoints. An address has to become a property ID before the zoning, potential, eligibility or image endpoints will answer, so the actor matches every address for you and carries the match through. Use the match addresses mode on its own when you only want the IDs.

#### What is a development potential estimate?

A modelled dwelling yield for a site, published with a complexity grade, a confidence grade, a slope grade, and the nearby built precedents that support it. The grades are the provider's own words rather than numbers and are kept as written, because turning "Low" confidence into a score would invent precision the model does not claim.

#### Does a blank development potential mean the property is unknown?

No, and the difference matters. The provider returns an explicit empty result when it holds the property and has no development potential recorded for it, and a different answer when it has no record of the property at all. This actor reports those as two different notes, and charges for neither.

#### How long is the property image link valid?

The provider issues a temporary link that its documentation says lasts seven days. Every image row carries the moment the link was issued and the moment it lapses, so a stored row can be told apart from one that has quietly expired.

#### Do I need my own API key?

Yes. This actor is bring-your-own-key: it calls the provider with your own account credentials and never ships a key of its own. Paste the key on its own rather than a whole header line.

#### What does it cost?

Pay per result. Development potential and planning records are the richest rows and cost the most; an eligibility check or an address match costs a fraction of that. Platform usage is included. Addresses, property IDs and points the provider has no record for are never charged.

### Example output

```json
{
  "recordType": "planning",
  "requested": "3 Kooyongkoot Road, Hawthorn VIC 3122",
  "subjectType": "address",
  "found": true,
  "propertyId": "4BBB64B6C2C8C7D30411E9D56831204F",
  "lotIdentifier": "\\RP10699",
  "localities": ["HAWTHORN"],
  "region": "vic",
  "propertyType": "Lot",
  "propertyAreaSqm": 2339.34,
  "zoneCode": "NRZ3",
  "zoneLabel": "NRZ3 - Neighbourhood Residential Zone - Schedule 3",
  "zoneCount": 1,
  "localGovernmentArea": "Boroondara City",
  "overlayCount": 0,
  "hasFloodOverlay": false,
  "hasBushfireOverlay": false,
  "hasHeritageOverlay": false,
  "latitude": -37.83036173778157,
  "longitude": 145.0392984627507
}
```

### Keyword map

Australian property API, zoning data API, planning overlay API, development potential API, site feasibility data, granny flat eligibility, secondary dwelling rules, NSW VIC QLD zoning lookup, local government area planning data, bushfire flood heritage overlay data, lot and plan identifier lookup, GNAF address matching, property development site finder, planning map image API.

### Notes

Bring your own key. Read only: every route this actor calls reads data, so a scheduled run cannot change anything in your provider account. Rate limiting and retries are handled for you, and a missing or refused key ends the run cleanly with an explanation rather than failing it. This API reports a miss inside a successful response rather than as an error status, and the actor detects that in the body so a property it cannot find never arrives as a row of empty columns.

# Actor input Schema

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

Planning essentials reads the zone, overlays, permitted and prohibited uses and parcel details. Development potential reads the estimated dwelling yield with the built precedents behind it. Granny flat checks eligibility for a secondary dwelling. Property image renders a map with a planning layer drawn over the parcel. Match addresses turns street addresses into the property IDs the other modes use.

## `addresses` (type: `array`):

One Australian street address per line. This API takes no free text on its data endpoints, so each address is matched to a property ID first and the match travels on every row it produces.

## `propertyIds` (type: `array`):

One provider property ID per line, if you already have them from a previous run. Skips the address matching step entirely.

## `points` (type: `array`):

One "latitude,longitude" pair per line, in that order. The actor sends them as the separate named fields this API expects, so a swapped pair cannot quietly return a real parcel somewhere else.

## `suburb` (type: `string`):

Suburb to use for every address, overriding anything parsed out of the address line. Leave empty to let the actor read it from the address.

## `state` (type: `string`):

State or territory to use for every address, overriding anything parsed out of the address line.

## `postCode` (type: `integer`):

Four digit postcode to use for every address, overriding anything parsed out of the address line.

## `includePrecedents` (type: `boolean`):

Adds the nearby built precedents behind a development potential estimate to each row: their address, zone, site area, dwelling count and estimated frontage. These are the comparable approvals the estimate rests on, so they are on by default.

## `overlay` (type: `string`):

Which planning layer the property image mode draws over the parcel.

## `addLegend` (type: `boolean`):

Returns the legend items for the overlay alongside the image, so a stored row can be read without opening the picture.

## `imageWidth` (type: `integer`):

Width of the generated property image in pixels.

## `imageHeight` (type: `integer`):

Height of the generated property image in pixels.

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

Stop after this many rows. Counts every row: planning records, development potential, eligibility checks, images and address matches alike.

## `requestsPerMinute` (type: `integer`):

How fast to call the provider. The default of 60 is one a second, which is polite for a metered API. Raise it if your contract allows more.

## `apiKey` (type: `string`):

Your own account key, issued by the provider. Sent in an x-api-key header. Paste the key on its own rather than a whole header line or a bearer token. Stored encrypted and never written into the dataset. Can also be supplied as the DATA\_API\_KEY environment secret.

## `baseUrl` (type: `string`):

Overrides the host the API is called on. Leave empty unless the provider has given you a different one.

## Actor input object example

```json
{
  "mode": "planningEssentials",
  "state": "",
  "includePrecedents": true,
  "overlay": "zoning",
  "addLegend": true,
  "imageWidth": 660,
  "imageHeight": 845,
  "maxResults": 100,
  "requestsPerMinute": 60
}
```

# Actor output Schema

## `records` (type: `string`):

One row per record, alongside the address, property ID or point that produced it.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {};

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

# Run the Actor and wait for it to finish
run = client.actor("nabeelbaghoor/property-development-potential-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 '{}' |
apify call nabeelbaghoor/property-development-potential-api --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,nabeelbaghoor/property-development-potential-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/vv6vhg1fBva3WvAdn/builds/OrxC38zzZjFZLNows/openapi.json