RBA decision day: the live numbers, scripted

First Tuesday at 2:30pm. The RBA Board decides. Here's a Python script that wakes up, polls for the announcement, and texts you the implications.

First Tuesday of the month, 2:30pm AEST. The RBA Board hands down its monetary-policy decision. If you're a mortgage broker, a journalist, or a treasurer, you want the number the moment it lands, and you want the implications computed, not just the headline.

This is a 40-line Python script that handles both. Use it as a Zapier-replacement, run it on a cron, or wire it into your team's Slack.

The bare-minimum poller

# rba_decision_day.py
import time
import datetime
from ausdata import Ausdata

api = Ausdata()
DECISION_TIME = datetime.time(14, 30)  # AEST

def poll_until_decision(known_rate: float, timeout_minutes: int = 30) -> dict:
    """Poll cash rate from 2:30pm; return the new rate when it changes,
    or the unchanged rate if the timeout elapses (hold decision)."""
    deadline = time.monotonic() + timeout_minutes * 60
    while time.monotonic() < deadline:
        result = api.series("AU.CASHRATE")
        current = result["data"]["cash_rate_pct"]
        if current != known_rate:
            return {"changed": True, "from_pct": known_rate, "to_pct": current, "raw": result}
        time.sleep(15)
    return {"changed": False, "from_pct": known_rate, "to_pct": known_rate, "raw": result}

That's the polling loop. Fifteen-second cadence is polite, the RBA web page itself updates within about 60 seconds of 2:30pm, and you'll see the new number on the second or third poll.

Webhook, not polling, if you're on Pro

If you're on the Pro tier ($99/mo), polling is the wrong pattern. Register a webhook for RBA cash-rate changes and let the server push:

import os
import httpx

httpx.post(
    "https://api.ausdata.iowebhook registration",
    headers={"X-API-Key": os.environ["AUSDATA_API_KEY"]},
    json={
        "event": "rba.cash_rate.changed",
        "url": "https://yourservice.example.com/hooks/rba",
        "signing_secret": "whsec_..."
    },
).raise_for_status()

Your endpoint then receives a signed POST inside a few seconds of the rate moving. The signed payload includes the new rate, the prior rate, the period it applies from, and the source URL.

This is the path mortgage brokers and treasury desks actually use. The polling script is what the free-tier hobbyist runs.

Computing the mortgage impact

The number on its own isn't the story. Your customer wants to know what a 25bp move does to their repayment:

def repayment_delta(loan_balance: float, years_remaining: int, bp_change: int, current_rate_pct: float) -> dict:
    """Approximate change in monthly repayment for a P&I loan."""
    def monthly(rate_annual_pct: float) -> float:
        r = rate_annual_pct / 100 / 12
        n = years_remaining * 12
        if r == 0:
            return loan_balance / n
        return loan_balance * (r * (1 + r) ** n) / ((1 + r) ** n - 1)

    new_rate = current_rate_pct + bp_change / 100
    return {
        "current_monthly": round(monthly(current_rate_pct), 2),
        "new_monthly": round(monthly(new_rate), 2),
        "delta": round(monthly(new_rate) - monthly(current_rate_pct), 2),
        "current_rate_pct": current_rate_pct,
        "new_rate_pct": new_rate,
    }

# Example: $600k loan, 25 years remaining, 25bp hike from 6.20%
print(repayment_delta(600_000, 25, 25, 6.20))

{
  "current_monthly": 3937.85,
  "new_monthly": 4031.04,
  "delta": 93.19,
  "current_rate_pct": 6.20,
  "new_rate_pct": 6.45
}

A 25bp hike on a $600k mortgage with 25 years remaining is roughly $93/month. That's the number your client wants on the SMS, not "the cash rate is 4.60%".

The full Tuesday script

# Wires polling + delta + a hypothetical SMS provider.
import os
from ausdata import Ausdata

api = Ausdata()

def on_decision_day():
    known = api.series("AU.CASHRATE")["data"]["cash_rate_pct"]
    result = poll_until_decision(known)

    if not result["changed"]:
        message = f"RBA held cash rate at {result['to_pct']}%."
    else:
        bp = round((result["to_pct"] - result["from_pct"]) * 100)
        direction = "hike" if bp > 0 else "cut"
        # Assume average client mortgage rate is cash rate + 2pp spread
        client_rate = result["from_pct"] + 2.0
        delta = repayment_delta(600_000, 25, bp, client_rate)
        message = (
            f"RBA {direction}: {result['from_pct']}% -> {result['to_pct']}% ({abs(bp)}bp). "
            f"On a $600k / 25yr loan, monthly repayment moves by ${delta['delta']:+.0f}."
        )

    send_sms(os.environ["CLIENT_PHONE"], message)

def send_sms(to: str, body: str) -> None:
    # Bring your own Twilio / MessageBird / etc.
    print(f"-> {to}: {body}")

if __name__ == "__main__":
    on_decision_day()

Schedule with cron at 2:25pm on the first Tuesday:

25 14 * * 2 [ $(date +\%d) -le 7 ] && /usr/bin/python /path/to/rba_decision_day.py

(The [ $(date +%d) -le 7 ] clause ensures it only fires on a first-of-month Tuesday, cron has no native "nth weekday" syntax.)

The Zapier comparison

A Zapier "RBA cash rate changes -> SMS my client" Zap is roughly $30/month for the Zapier seat plus whatever the SMS provider charges, and it cannot do the repayment-delta calculation, Zapier's formula nodes are too limited.

A free ausdata.io key plus a $5/month Fly.io machine running this script does the same job, with the mortgage maths inline, for about a sixth the cost. The script is also yours, if you want to add client-specific spread assumptions or LVR-tiered messaging, you edit Python.

What this isn't

This script is not:

A regulated financial-advice tool. The repayment delta is an approximation, it doesn't account for offset balances, redraw, fee changes, or your lender's specific repricing behaviour.
A real-time feed in the trader sense. The 15-second poll lag is fine for client SMS, not fine for FX trading.
A guarantee on lender pass-through. Banks reprice mortgages on their own timetable, often days after the cash-rate move and not always in full.

For trading-grade latency, you want a direct feed and you're not reading this blog.

Pricing

Free: 500 calls/month, covers polling 12 RBA decisions a year with margin.
Analyst: $29/mo, 10k calls, for brokers running multiple client books in parallel.
Pro: $99/mo, 100k calls + webhooks, push-based, sub-second latency, signed payloads.

Free key at ausdata.io.