Retrieve and display property listings in a format you can share with friends and family when you are house-hunting (to purchase).
PropertyPiles uses RealtyAPI to retrieve property listings. It has only been tested with Domain.com.au but should theoretically work with other APIs offered through this service, with some minor modifications to the code.
PropertyPiles is not affiliated with or endorsed by RealtyAPI, Domain, or any other property industry entity.
Entry of properties into the "piles" is via a simple JSON file.
For privacy reasons, it's not committed to Git. Leaving a public record of houses one is considering buying doesn't pass the vibe check, so it's Gitignored locally and expected to be in Azure Blob Storage in production.
The app takes the paths from your JSON file and queries the RealtyAPI for the Domain.com.au listing data. It then transforms the combination of your shortlist data (e.g., notes) and the listing data and displays it in a table, showing key information like asking price, land size, and bedroom/bathroom/car space counts. It also marks when a property has gone under offer, been sold, or the listing has been removed.
For Australian users: National Broadband Network, Opticomm or alternative coverage data is fetched from the same endpoint that the Aussie Broadband "check your address" page uses (at the time of writing, anyway). The responses are cached as this data is not likely to change frequently, and I do not wish to draw attention to or generally abuse the endpoint that they have so kindly (possibly unintentionally...) left open that allows this to be done.
Alternative APIs
At the time of writing:
- The TPG endpoint used by iiNet provides similar data, but only for NBN (including fixed wireless).
- The endpoint used on the Opticomm site itself provides data for suburbs that do not have NBN fibre but do have theirs.
The nature of the API's capabilities are such that a request is made for every property on every page load, so a rudimentary caching mechanism has been implemented in the form of saving the API responses to JSON files, and only querying the API when the data is more than 24 hours old. Customise the cache max time by setting the MAX_CACHE_AGE environment variable to your desired expiry time in seconds.
Auth is rudimentary by design. Do you want to deal with your boomer family members asking why they need to sign into Google or whatever (or worse, create an account on your random app) just to view your property shortlist, and provide the associated tech support? No, I didn't think so. But, as I mentioned above, privacy is a consideration.
The app is essentially a single page, with a single password protecting it. This is just so that you can have some basic control over who you share your list with, and it shouldn't show up on the Wayback machine or anything like that. The password is set as an environment variable.
The most obvious evidence of the short-term nature of this project is the data input. It's just a JSON file. No interface to edit it, just...JSON.
The format is as follows:
[
{
"path": "14-dreamer-circuit-mount-duneed-vic-3217-2020738365",
"notes": [],
"priority": true
},
](And no, that's not the house I bought. That listing got taken down before my old place was even on the market.)
Valid fields are "notes" (array of strings), "dismissedReasons" (array of strings), and "priority" (boolean).
You do not need to manually mark when a property you shorlisted gets sold. The app will automatically account for this when processing the data.
- RealtyAPI account and API key
- Azure App Service instance for a .NET 10 app
- Azure Blob Storage account
- Azure Key Vault (optional but recommended)
To develop and test the app locally, create a .env file in the project root with your API key, your name to put above the site title (optional), the base URL for the RealtyAPI endpoints you are using, the base URL for the source site (to be used for links to the real listings), and Azure blob storage credentials. For example:
APP_USER_NAME="Leesa and Michael"
REALTY_API_KEY=your_api_key_here
REALTY_API_BASE_URL=https://domain.realtyapi.io/
MAX_CACHE_AGE=3600
SOURCE_SITE_BASE_URL=https://www.domain.com.au/
NBN_BASE_URL=https://wrapper.aussiebroadband.com.au
BLOB_STORAGE_ACCOUNT_NAME=propertypilesfiles
BLOB_STORAGE_CONTAINER_NAME=propertypilescontainer
BLOB_STORAGE_ACCESS_KEY=your_key_here
FRONT_END_PASSWORD=some_password_hereFor production deployment, you will need to set the same environment variables in your hosting environment. For sensitive credenitals, you can have these refer to Azure Key Vault secrets instead of hardcoding the values in the environment variables.
From the solution or project root:
dotnet publishThe compiled files will be in ./PropertyPiles/bin/Release/net10.0/publish.
Important
Neue Montreal is free for personal use. If you use this codebase for any commercial project, you must either purchase a licence or replace the font with something you have the rights to use commercially.
PropertyPiles is a Blazor Web App, so you will need:
- RealtyAPI account and API key
- .NET 10 SDK (
choco install dotnet-sdkor download) - Sass installed globally (
choco install sass) - A .NET IDE such as JetBrains Rider or Visual Studio
And you will also need to:
- Create a
.envfile in the project root as per the setup instructions above. - Create a
data.jsonfile in the project root as per the format described above. - Configure your IDE to compile Sass files when they are edited. In Rider, do this by creating a file watcher with the default settings (it will prompt you the first time you open a .scss file) and enabling it to run on save.
Tip
Restart the app after changing environment variables to make sure the new value takes effect.
To run with hot reloading in Rider, use the CLI instead of the IDE's Run configurations.
From the solution directory:
cd PropertyPiles && dotnet watch run