Getting started with the Australian address API
WattleAddr adds an address box to your website or app. As someone types, it suggests real Australian addresses. When they pick one, you get it back in separate fields: street, suburb, state, postcode and coordinates.
Step 1: Get an API key
1. Create an account. Go to the sign-up page. Enter your name, work email and a password, tick the box to accept the Terms, then press Create account. You start on the Free plan: 5,000 lookups a month, no card.

2. Create your first key. The console opens on your new workspace. Open API Keys in the left menu and press Create my first key.

3. Copy the key. You get a secret key in test mode, starting waddr_sk_test_. The console shows it once, under Copy your key now. Copy it somewhere safe. Test mode uses the real address data. It costs nothing and does not count against your 5,000 monthly lookups. It works for the first 15 days of your account. On Enterprise, test keys covered by your agreement do not expire.

The key then appears in your list. Only its first few characters are shown from now on.

Which key do I need?
To pick the key yourself, press Choose the options myself (or + New API key once you have one). Choose:
- Secret (server) for code that runs on your server. Never put a secret key in a web page or a public repository.
- Publishable (browser) for code that runs in a web page. A live publishable key should list the domains it may run on. One with no domains works on any site.
- Live or Test. Test keys stop after the 15-day test period, except on Enterprise, where test keys covered by your agreement do not expire. They have their own cap and rate, described in test and UAT environments. Live keys work on every plan, including Free. The one exception is the suburb and postcode API, which needs a paid plan on a live key.
Step 2: Try it without code
Open the interactive reference. It needs no key. Type an address and you see the request and the JSON that comes back. Click a suggestion to fetch its full record.

1 martin pl sydney.You can also take the OpenAPI 3.1 spec or the Postman collection into your own tools.
Step 3: Add it to your site
In the browser, use a publishable key (waddr_pk_…). In the console, press Choose the options myself or + New API key, pick Publishable (browser), and list your website’s domain. Test mode is fine while you build.

The widget and the React component handle the session for you. With the headless client, create one with createSession() and pass it to each call. All the keystrokes behind one address count as a single lookup.
Option A: the browser widget (one script tag)
No build step and no dependencies. Paste this into your page, with your publishable key in place of waddr_pk_live_….
<script src="https://api.wattleaddr.com.au/v1/widget.js"></script>
<script>
const wa = new WattleAddr('waddr_pk_live_…');
wa.attach('#address', {
onSelect: (a) => console.log(a.formatted, a.components, a.geo)
});
</script>
As someone types, the widget shows suggestions under the box:

To fill your own form as well, pass fill. It maps address parts to the ids or names of your fields. The unit, shop, level and lot rules are built in, so you do not write them.
fill: {
address_line1: 'address1',
address_line2: 'address2',
suburb: 'city',
state: 'state',
postcode: 'zip'
}
});
The widget looks for each field by id or name in the form the box sits in, then on the page. A CSS selector also works. A part name it does not know throws an error when you call attach. A field it cannot find is skipped, with one console warning. Text in a drop-down is matched to its options, and a drop-down with no matching option is left as it is. Line 2 text that the person typed is never overwritten or cleared. In that case the unit goes in line 1.
In the script tag version, fill takes ids, names or CSS selectors. The npm package also accepts the elements themselves. A form inside another iframe is not filled. The widget does not shorten a value to a field’s maxlength, so check that your server accepts the full text.
| Part | What it holds | Example |
|---|---|---|
address_line1 | The street line. With no unit or line 2 field, the unit joins it. | 121 Marcus Clarke Street |
address_line2 | The unit, level or shop. With no unit, the building name. | Level 1, Suite 2 |
unit | The unit, level or shop on its own. | Level 1, Suite 2 |
building_name | The building name. | Villaggio Italiano |
street_number | The street number. A lot-only address gives the lot. | 121 or Lot 10 |
street_name | The street name, type and suffix. | Marcus Clarke Street |
suburb | The suburb or town. | City |
state | The state or territory code. | ACT |
state_name | The state or territory in full. | Australian Capital Territory |
postcode | The postcode. | 2601 |
country | Australia. A drop-down also matches AU or AUS. | Australia |
full_address | The whole address on one line. | Level 1, Suite 2, 121 Marcus Clarke St, City ACT 2601 |
latitude, longitude | The coordinates, when we have them. | -35.28 |
address_id | The address id, for a hidden field. | GAACT717000003 |
WattleAddr.addressParts(record) returns the same parts without touching the page. onSelect still runs after the fill, with the full record, if you want to add to it. The console has an Add to your form page. You type your field names and it writes this snippet for you. An owner or admin can also save those names to an API key, so the API returns them too. See Your own field names.

| Option | Default | What it does |
|---|---|---|
fill | none | Fills your own form fields. See the parts above. |
onSelect | none | Called with the full record once someone picks an address. |
onError | console warning | Called instead of logging, if you want to handle failures yourself. |
theme | light | light, dark, or auto to follow the visitor’s system setting. |
limit | 6 | How many suggestions to show. |
state | all | Restrict to one state, for example NSW. |
Your own field names
An owner or admin can save your form’s field names against an API key, on the Add to your form page in the console. Any key can have them, secret or publishable. Responses for that key then carry a fields object, keyed by your own names, as well as every standard field. Code that reads the standard fields does not change.
fields appears on retrieve, on each suggestion in a detail=full autocomplete, and inside match in a verify response. It is not on bulk verify, reverse geocoding or suburb and postcode calls. You choose which calls carry it: retrieve, autocomplete with detail=full and verify. All three are on by default.
"fields": { "address1": "1 Martin Place", "city": "Sydney", "postcode": "2000" }
- Every value is a string. A part the address does not have is
"". - A change you save reaches the API within about a minute.
- It does not change what is billed.
fieldscosts nothing extra and does not change the lookup count. - The widget
filloption works as before.
The step by step guide, with the response before and after and the limits, is Keep your field names when you switch address API.
Option B: the npm packages (React or Node)
Official, typed, MIT-licensed packages. Use @wattleaddr/react for React. Use @wattleaddr/js (no dependencies) for plain JavaScript or server-side Node.
npm install @wattleaddr/react
# Vanilla JS / Node: headless client + the same drop-in widget
npm install @wattleaddr/js
The React component drops into any form:
<AddressAutocomplete
apiKey="waddr_pk_live_…"
onSelect={(a) => console.log(a.formatted, a.components.postcode)}
/>
Or use the client with no UI. It runs in the browser and in Node 18+. On a server, set keyTransport: 'header' so a secret key is sent as a Bearer token and not in the URL:
const client = new WattleAddrClient('waddr_sk_live_…', { keyTransport: 'header' });
const session = createSession();
const { suggestions } = await client.autocomplete('1 mart', { session });
const addr = await client.retrieve(suggestions[0].id, { session }); // the charged call
Worked examples: a React form, a Next.js App Router form and a checkout with the widget.
Step 4: Get the full address from your server (about 5 minutes)
This is what the widget does for you, as two plain HTTPS calls. Use it from a server, or try it in a terminal with curl. Replace YOUR_KEY with your secret key. The same two calls in Node.js, Python, PHP, Ruby, Go, Java and C# are further down.
a. Ask for suggestions as someone types
Pick any unique string as the session. Reuse it for every request about this one address. Suggestions start from three characters. With default autocomplete, keystrokes are fair use and are not billed on their own. To get the full record from autocomplete in one call, see Full detail in one call.
"https://api.wattleaddr.com.au/v1/addresses/autocomplete?q=1+martin+place+sydney&session=demo-1"
"session": "demo-1",
"query": "1 martin place sydney",
"suggestions": [
{ "id": "GANSW705988020", "formatted": "1 Martin Pl, Sydney NSW 2000", "score": 16.08 },
… more suggestions
]
}
The -H line sends your key in the Authorization header. A secret key is always sent that way. In the response, id is the address’s identifier in G-NAF, the national address dataset (see Words we use). formatted is the text to show in your list. score only ranks suggestions within this one response, and you can ignore it. Show the list and let the person pick one.
b. Retrieve the one they picked
Use the same session. This is the charged call. One session is one lookup, however many keystrokes it took.
"https://api.wattleaddr.com.au/v1/addresses/GANSW705988020?session=demo-1"
"id": "GANSW705988020",
"formatted": "1 Martin Pl, Sydney NSW 2000",
"components": {
"flat_number": null, "level_number": null,
"street_number": "1", "street_name": "Martin", "street_type": "Place", "street_suffix": null,
"locality": "Sydney", "state": "NSW", "postcode": "2000",
"lot_number": null, "flat_type": null, "level_type": null, "building_name": null
},
"geo": { "lat": -33.86777884, "lng": 151.20775353 },
"confidence": "high",
"source": "gnaf", "gnaf_release": "2026-08",
"billed": false, "test": true
}
Here is a live call in the interactive reference:

| Field | What it is |
|---|---|
components | The address in parts. All strings, any may be null. locality is the suburb or town. Keep postcode as a string: Darwin is 0800. lot_number is the G-NAF lot number when the record has one. A lot-only address has it and no street_number. Some street-numbered addresses carry one too, so use street_number when it is set. flat_type (Unit, Shop, Suite), level_type and building_name are set when the address has them. level_number includes any level letter, so Level B reads B. |
geo | Latitude and longitude (GDA2020), or null if the record has no coordinates. |
confidence | G-NAF’s own confidence in this record. Not a match score. |
gnaf_release | The quarterly dataset that answered. Store it with the address. |
billed | Whether this call used one lookup from your plan. false on a test key. |
test | Present, and true, only on a test key. Nothing is ever charged on one. |
c. What you were charged
Nothing, on a test key. That is what "billed": false and "test": true mean. On a live key the same two calls use exactly one lookup, for the retrieve, and billed comes back true. The keystrokes are not billed because they shared the session. If you leave the session out, every retrieve is charged on its own.
On a plan with a quota, every successful response also carries X-WattleAddr-Quota-Limit and X-WattleAddr-Quota-Remaining headers. On a live key you can watch your monthly allowance drop by one.
d. Save the address
Store id, formatted and components together. Ids can change between G-NAF releases, so never keep the id on its own. There is a schema to copy in how to store an Australian address. The address format checker shows how a messy address splits into these fields.
Before you go live: create a Live key. Test keys stop working after the test period with 402 test_mode_expired. On Enterprise, test keys covered by your agreement do not expire. Performance and load tests must use a live key, which is billed. They need our written agreement to the date and rate first. Live keys work on every plan, including Free. The one exception is the suburb and postcode API, which needs a paid plan on a live key.
Full detail in one call
By default, autocomplete returns only id, formatted and score, and you make a second call to retrieve the record. If you would rather store the address straight from the suggestion, add detail=full. Each suggestion then carries the same record a retrieve returns, so you do not need the second call.
"https://api.wattleaddr.com.au/v1/addresses/autocomplete?q=33+hib&session=abc123&detail=full"
Sample response. The score and coordinates are placeholders; a real call returns the address’s own. The first call in a new session returns the record and bills the session as one lookup, so billed is true:
"session": "abc123",
"query": "33 hib",
"suggestions": [
{
"id": "GAACT717000002",
"formatted": "Shop 29, 33 Hibberson St, Gungahlin ACT 2912",
"score": 40,
"components": {
"flat_number": "29",
"level_number": null,
"street_number": "33",
"street_name": "Hibberson",
"street_type": "Street",
"street_suffix": null,
"locality": "Gungahlin",
"state": "ACT",
"postcode": "2912",
"lot_number": null,
"flat_type": "Shop",
"level_type": null,
"building_name": null
},
"geo": {
"lat": -35.3,
"lng": 149.1
},
"confidence": "high",
"source": "gnaf",
"gnaf_release": "2026-08"
}
],
"billed": true
}
The same call again in the same session returns the same suggestions and billed is false. This is the second response, trimmed: components, geo, confidence, source and gnaf_release are the same as above and are left out here.
"session": "abc123",
"query": "33 hib",
"suggestions": [
{
"id": "GAACT717000002",
"formatted": "Shop 29, 33 Hibberson St, Gungahlin ACT 2912",
"score": 40,
"components": … the same as the first response
}
],
"billed": false
}
| Parameter | What it does |
|---|---|
q | The text typed so far. Suggestions start from three characters. |
session | Required with detail=full. Any string you choose, kept for one search. |
detail | Optional. full returns the full record with each suggestion. Any other value is ignored, and the call is plain autocomplete. |
limit | Optional. How many suggestions to return. With detail=full the most you get is 5. |
state | Optional. Limits suggestions to one state or territory. |
What it costs.
- The price per lookup is the same. See the pricing page.
- The billing is different. With
detail=full, a search session is one lookup the first time it returns at least one suggestion, whether or not anyone picks one. - An abandoned search is billed in this mode. The same traffic can cost more than with default autocomplete.
- Later calls in that session, and a retrieve in it, are usually not billed again.
- A full-detail session covers calls for up to 10 minutes, and up to 50 calls that return suggestions, counting the call that was billed, after it is first billed. After that, the next call that returns a suggestion is a new lookup.
- Default autocomplete is unchanged. Abandoned searches are not billed, and the retrieve is the one billed call. If many of your searches are abandoned, the default two calls stay the cheapest.
Switching it on.
- An owner or admin opens Settings in the console and ticks Allow full-detail autocomplete in the Full-detail autocomplete box. It is off by default.
- While it is off,
detail=fullreturns403and nothing is charged. - A full-detail call is refused, with nothing charged, whenever your workspace’s billable requests are refused under quotas and overage, even in a session already billed. Default autocomplete keeps working.
- Test keys are never billed. Shopify plans cannot use it. Every other plan can, including Free.
There is a longer comparison, with a worked cost example, in Autocomplete with full detail: when to use it.
The same two calls in your language
Each example asks for suggestions, then retrieves the first one with the same session, and stops with the API’s error code if a call fails. Run them on your server, never in a browser: they use your secret key. Each reads the key from the WATTLEADDR_KEY environment variable, so it never sits in your code. In your app, retrieve the suggestion the person picked, not the first one. Longer guides with verification, a form check and error handling: Python, Node.js and PHP.
# Needs curl 7.76 or later and jq. Run: WATTLEADDR_KEY=your_secret_key bash address.sh
set -euo pipefail
API="https://api.wattleaddr.com.au"
AUTH="Authorization: Bearer $WATTLEADDR_KEY"
# One session per address. Reuse it for every keystroke and the final retrieve.
SESSION="$(uuidgen 2>/dev/null || cat /proc/sys/kernel/random/uuid)"
# a. Suggestions as the person types.
SUGGESTIONS=$(curl -sS --fail-with-body -G -H "$AUTH" \
--data-urlencode "q=1 martin place sydney" \
--data-urlencode "session=$SESSION" \
"$API/v1/addresses/autocomplete") || { echo "Request failed: $SUGGESTIONS"; exit 1; }
echo "$SUGGESTIONS" | jq -r '.suggestions[] | "\(.id) \(.formatted)"'
# b. The one they picked. This is the charged call.
ID=$(echo "$SUGGESTIONS" | jq -r '.suggestions[0].id // empty')
[ -n "$ID" ] || { echo "No suggestions"; exit 1; }
ADDRESS=$(curl -sS --fail-with-body -G -H "$AUTH" \
--data-urlencode "session=$SESSION" \
"$API/v1/addresses/$(jq -rn --arg id "$ID" '$id|@uri')") || { echo "Request failed: $ADDRESS"; exit 1; }
echo "$ADDRESS" | jq '{formatted, postcode: .components.postcode, geo, billed}'
Step 5: What you pay, limits and errors
You pay per lookup. Send the same session with each autocomplete keystroke and the final retrieve, and the whole session counts as one lookup. Default autocomplete on its own is not billed. Full-detail autocomplete is billed differently, as described under Full detail in one call. A retrieve or verify with no session is always charged, so always send one. A verify that finds no match is not charged. Suburb and postcode search is billed differently. See Suburb, state and postcode.
Plan allowances and prices are on the pricing page. When the monthly quota is used up, the Free plan, plans bought through the Shopify app, and a paid plan you have cancelled return 402 quota_exceeded on charged calls. Other paid plans keep working and bill overage at the rate on the pricing page, up to a ceiling where they also return 402.
Rate limits and speed
Each live key has a requests-per-second limit set by its plan. A key can send that many requests at once, then continue at that rate. Over it, the API returns 429 rate_limited with a Retry-After header saying how many seconds to wait. Nothing is queued. A refused request is not counted or charged.
| Plan | Requests per second, per key | Live keys per workspace |
|---|---|---|
| Free | 5 | 2 |
| Starter | 15 | 10 |
| Growth | 40 | 25 |
| Enterprise | 200 | 1,000 |
There is no separate concurrency limit. Parallel requests are fine within the per-second rate. Each live key has its own limit, so use one key per system. If one system needs more than its plan’s rate, talk to us instead of spreading it across keys. Limits above the published ones are set by agreement. Test keys have a separate, smaller allowance. On Enterprise, test keys share one rate of 5 requests per second across the workspace by default. We can set a different rate for your workspace. Monthly volume is set by the plan’s quota (above). The monthly allowance is shared by all keys in a workspace, and each key only has its own requests-per-second limit.
Speed. Measured from a data centre in Melbourne over the internet, typing 200 addresses the way a shopper does: autocomplete answered in a median of 36 ms, and 95% of 2,155 searches within 139 ms. That includes the network time. Opening a new HTTPS connection added about 35 ms more, so keep connections open. Requests are normally served from Sydney, so from further away expect more network time. Your speed will vary with your network, your location and other factors. Last checked 3 November 2026 at 3:18 pm AEDT. Measured inside the API in September 2026, verify takes 35 to 100 ms once a query is warm, and up to about 600 ms on the first call for a large block of units. Repeated prefixes are served from an in-memory cache. Live availability and the G-NAF release being served are on the status page.
How it runs. The full G-NAF release is loaded into OpenSearch by the open-source Addressr loader, which we host. Our API queries it directly: the exact query first, and a spelling-tolerant one only when that finds nothing. The same API handles keys, metering, scoring and the corrections described below. Keys, usage and billing are in Postgres. Sydney is primary and Melbourne is a warm standby. Quarterly G-NAF releases are loaded in place with no downtime.
Common errors
Every error is JSON: { "error": { "code", "message", "docs" } }. Switch on code, which does not change. The message may change. The docs link points at the matching row of the full error reference, which lists every code. These are the ones you are most likely to see first:
| Status | code | What happened | What to do |
|---|---|---|---|
| 401 | unauthorized | No API key was sent. | Add an Authorization: Bearer YOUR_KEY header (secret key), or ?key= for a publishable key in the browser. |
| 401 | invalid_key | The key is wrong, has been revoked, or has a typo. | Copy it again from the console, or create a new key. Revoked keys never come back. |
| 402 | quota_exceeded | This month’s lookups are used up and your plan does not run over (Free, Shopify, a cancelled plan, a paid plan with a spending cap set at your request, or a paid plan whose owner chose to stop at the allowance in Settings), or a paid plan has reached the overage ceiling of five times its included lookups. The message says which. A call with detail=full is refused here whenever the workspace’s billable requests are refused, even if its session was already billed. That message starts with “Nothing was charged.” | Wait for the period to roll over. On the Free plan, upgrade in the console under Billing. If the message says the workspace is set to stop at its allowance, the owner can allow overage under Settings. If the message says the overage ceiling was reached, contact support to lift it; a plan change only takes effect next period. Address autocomplete without detail=full keeps working. Suburb and postcode autocomplete is refused too, because it can be charged. |
| 402 | test_mode_expired | A test key was used after the free test period (15 days from account creation). On Enterprise, we can switch on test keys that do not expire for a workspace by written agreement. That is the exception. Where we have not switched that option on for a workspace, the 15-day rule applies. | Create a Live key in the console. Live keys work on every plan, including Free. The one exception is the suburb and postcode API, which needs a paid plan on a live key. |
| 403 | full_detail_off | Nothing was charged. A call with detail=full was sent while full-detail autocomplete is switched off for the workspace. The message reads: “Nothing was charged. Full-detail autocomplete is switched off for this workspace. An owner or admin can switch it on in the console under Settings. Autocomplete without `detail=full` still works.” | An owner or admin signs in to the console, opens Settings and switches on Full-detail autocomplete. Or leave detail=full out and use autocomplete and retrieve as before. |
| 403 | forbidden_referrer | A publishable key was used from a domain that is not on its allowed list. | Edit the key in the console and add the host the page is served from to Allowed domains, such as shop.com.au. Add a port only to limit the key to that port. |
| 429 | rate_limited | Too many requests per second on one key. Test keys on an Enterprise workspace share one rate across the workspace by default. We can set a different rate for your workspace. | Wait the number of seconds in the Retry-After header, then retry. Debounce keystrokes in the browser. |
Not an error: 200 with "suggestions": [] and a notice. See PO Boxes below.
Reference
Keys and authentication
There are two key types, both created in the console. Never expose a secret key in the browser.
| Key | Prefix | Where | Secured by |
|---|---|---|---|
| Secret | waddr_sk_live_… | Server-side | Authorization: Bearer + optional IP allowlist |
| Publishable | waddr_pk_live_… | Browser (autocomplete and retrieve only) | The website domains you list + rate limits |
Either type can be made in test mode (waddr_sk_test_…, waddr_pk_test_…). Test keys use real data, are never charged, and work for the first 15 days of an account, or, on Enterprise, without expiry for test keys covered by your agreement. Responses from a test key carry "test": true. Enterprise teams setting up SIT, UAT or training environments can follow test and UAT environments.
Keys are how your application signs in. How your team signs in to the console is separate. On Enterprise plans you can connect the console to your own identity provider over OpenID Connect, and require it. See single sign-on setup.
Endpoints
Base URL https://api.wattleaddr.com.au/v1. JSON only. Australian addresses only.
| Method | Path | Purpose |
|---|---|---|
GET | /v1/addresses/autocomplete | Type-ahead suggestions for a partial query (not charged by default; with detail=full, charged once per session, on the first suggestion) |
GET | /v1/addresses/{id} | Full structured record for a chosen suggestion (charged) |
GET | /v1/addresses/reverse | The nearest addresses to a latitude and longitude, nearest first (charged when at least one address comes back, secret keys only). Step by step guide |
POST | /v1/addresses/verify | Match free text to its official G-NAF form, with a verdict for each field (charged on a match) |
POST | /v1/addresses/verify/batch | Verify up to 100 addresses in one call (charged on each match, secret keys only) |
POST | /v1/batch-jobs | Start a job for a CSV file of up to 100,000 rows (charged on each match as it runs, secret keys only) |
GET | /v1/batch-jobs/{id} | Status and progress of a job |
GET | /v1/batch-jobs/{id}/results | Download the results of a job, as CSV or JSON |
DELETE | /v1/batch-jobs/{id} | Delete a job and its files now |
GET | /v1/localities/autocomplete | Suburb or postcode suggestions (charged once per session, on the first suggestion) |
GET | /v1/localities/{id} | One suburb, state and postcode pair (free inside a session already charged) |
POST | /v1/localities/verify | Check that a suburb, state and postcode belong together (charged when there is a match) |
GET | /v1/usage | Your usage by day or by customer reference (secret keys only, not charged) |
GET | /v1/status | Service health, current G-NAF release and the number of address records |
Every parameter and response schema is in the interactive reference.
Have a location and need the address? See reverse geocoding, or the step by step guide for beginners.
Verify an address you already hold
There is a plain-language overview of verification, and what it is not, on the verification page.
verify takes free text you already hold. It returns the best match in its official G-NAF form, plus an assessment of how well it answers what you sent. Branch on verdict.
-H "Authorization: Bearer YOUR_KEY" \
-H "Content-Type: application/json" \
-d '{"address": "23 wakool ave deer park", "session": "demo-2"}'
"matched": true,
"match": { /* the full record, same shape as retrieve */ },
"verdict": "corrected",
"match_score": 75,
"match_level": "premise",
"elements": { "street_number": "verified", …, "postcode": "missing" },
"changed_elements": [],
… plus alternatives, source, gnaf_release, billed and, on a test key, test
}
verdict | Meaning | Handling |
|---|---|---|
verified | Every element you supplied agrees, and no other candidate fits | Accept |
corrected | Agrees as far as it goes. You abbreviated or left something out. With extended_corrections: true it can also mean we fixed one part that the rest of the address backs up, named in changed_elements | Accept the official form, or ask again for the missing elements you need. If changed_elements is not empty, we fixed that part, so show the official form to the person or review it. A street suffix left out (“Station St” for Station St West) also reads corrected. missing means not supplied, not required: a house has no unit |
ambiguous | An element was contradicted, input was discarded, a runner-up fits equally well, or you gave a building address and the building has units (the alternatives list them) | Review. Never accept automatically. If your data is deliberately at building level, accept on match_level: premise and check alternatives |
unverified | Nothing matched, or the match scored too low to rely on. If reaching the candidate meant contradicting or discarding part of what you sent, no record is returned (matched: false, match: null) and the lookup is not billed. elements, match_score and dropped_tokens still say why. A short input that contradicts nothing (a suburb and postcode, say) still returns its locality-level record | Reject and flag |
elements gives every field its own status (verified, changed or missing). A checkout can then ask again for the one wrong field, not the whole address. match_level says how precisely we identified it: subpremise a unit, premise a building, thoroughfare the street only, locality the suburb only. It is independent of the verdict. When you supply no unit or level, verify prefers the building over its units. Supply the unit to get subpremise.
We publish no accept or reject score threshold. The right line depends on what a wrong address costs you. The older top-level confidence field on a verify response is deprecated. Branch on verdict. A verified address exists in G-NAF and we know where it is. That is not a promise that mail can be delivered to it. There is a worked example of verifying on the server, without paying twice, in the Next.js guide.
To verify a whole file, or up to 100 addresses in one call, see bulk address verification (overview: bulk address verification for Australia).
Typos, misspellings and units
Matching is fuzzy but not phonetic. A word of three to five letters may have one character wrong, missing, extra or swapped. A longer word may have two. A word of one or two letters must be exact. That applies to the street name and the suburb alike, with one exception: the last word typed is treated as a prefix and gets no tolerance. So 589 Beems Rd Carseldine and 589 Beams Rd Carsledine QLD both find 589 Beams Rd, but a suburb misspelt at the very end of the query matches nothing on its own. How often the right address comes back for a misspelt suburb or street is measured and published on the match accuracy page.
When nothing matches, the search is retried with something dropped. Verify reports what it discarded in dropped_tokens and scores the match lower. The street number goes first if the street and suburb you named exist and only the number does not. You then get the nearest street numbers, with a street_number_not_found notice (no exact match for the number in the area searched). Verify refuses that match and does not answer with a different number. Otherwise the trailing words (suburb, state, postcode) are dropped one at a time. A retry is never answered in a state or postcode your query contradicts. Suggestions appear once the query names a street or suburb. A bare unit, level or small street number on its own returns an empty list.
Verify never corrects a street number. A number that disagrees with the record is marked changed, not swapped. If the number had to be discarded to find anything at all, verify refuses. It will not answer about the house next door.
Autocomplete is looser, in this order. A one- or two-digit number is matched exactly, so if no premise carries it the suggestions are sub-dwellings that do (8 Beams Rd returns Unit 8 of the blocks on Beams Rd). A number of three or more digits gets the same one-character tolerance as a word, which can bring up a neighbour. Only when neither finds anything does the number itself get dropped. That means the street and suburb exist but there is no exact match for that number. You then get that street’s nearest numbers, with a street_number_not_found notice saying so. If you type a unit and the building matches in your suburb but has no exact match for that unit, the building leads the list with a unit_not_found notice. When you type a number and no unit, the premise with that number on that street comes before anybody’s units. A building normally comes before its own units, even when the block is large. Type the unit (3/589, unit 3 589) to get the unit.
Some buildings are recorded under a number range, and some streets cross a suburb line inside one postcode. When you type a number, a street and a suburb or postcode, and the suggestions have nothing with that number on that street, autocomplete can add, after them and only if the list has room, the official address that covers it: the same number in another suburb with the same postcode, or the range on the same side of the street that contains it. 100 Kent St, Sydney 2000 adds 96-108 Kent St, Millers Point NSW 2000. It always shows the address as G-NAF holds it, never a number we made up. It only adds to the list and never changes the ones above it. With extended corrections on, verify also uses it to find the range, or the neighbouring suburb, that holds the number. It never takes the nearest-number rows. The 20 October 2026 search changes are described in the release post.
Verify tells you what it changed. elements marks each part verified, changed or missing. changed_elements lists the corrected ones, and the corrected values are in match.components. A corrected street name lowers match_score and gives an unverified or ambiguous verdict, never verified. So a misspelt street reaches you as the right record flagged for review, not as an automatic accept. A building address on a block with units matches the building with an ambiguous verdict and some of its units in alternatives.
Spellings. Verify reads common spellings the way you meant them: Mt for Mount, Mc Lachlan for McLachlan, apt or flat for unit, Nth for North after the street name (Third Av Nth), a street type you have only part typed, and a flat written G16/12. A misspelt suburb also counts when you typed a state or postcode that leaves one record. Plain ones read verified. Looser ones read corrected. A misspelt suburb shows as corrected in elements. No element is marked changed and changed_elements stays empty for any of these. A compass letter in front of the street name (N St for North St) is not read this way: with extended corrections it is a street name written another way, and without them it stays unverified.
One-part corrections, opt in. Send extended_corrections: true and verify also fixes one wrong part when every other part points to a single record: a neighbouring suburb with the same postcode, a wrong street type, a wrong postcode on the right suburb, a street number inside a range on the same side of the street (124 for 124-134), a flat typed without its letter when the building has only one such flat, or a street name written another way (Bay View for Bayview, Mac for Mc, a misspelt north, south, east or west). The verdict is then corrected, the part is marked changed in elements and named in changed_elements, and match_score is lower than for a verified match. Verify never fixes a state, never fixes two parts at once, and fixes nothing when another record, in any suburb or state, fits what you sent as well. The same field works on the batch call, and on a bulk job as the query parameter extended_corrections. The console has a checkbox, Allow one-part corrections.
Change on 1 February 2027. From that date a request that does not say will get one-part corrections. If you need corrected to keep meaning only abbreviated or left out, send extended_corrections: false. A false value is always honoured. If you accept corrected automatically, check changed_elements first.
PO Boxes & postal addresses
PO Boxes are not supported, because G-NAF holds physical addresses only. It has no PO Boxes, GPO Boxes, Locked Bags or Private Bags. A query for one returns 200 with an empty suggestions array and a notice. Your form can then ask for a street address, or take the PO Box in a separate field. verify returns the same notice with matched: false and billed: false. A query the dataset cannot answer is never charged. To validate PO Boxes you need a product licensed for Australia Post’s PAF. AMAS and PAF vs G-NAF explains the difference.
"code": "postal_address_unsupported",
"kind": "PO Box",
"message": "PO Box addresses aren’t in the G-NAF dataset…"
} }
Australian reverse geocoding API
New to APIs? Read the step by step guide. This section is the reference.
Reverse geocoding turns a point on a map into the nearest addresses. Use it when you have a driver’s or technician’s location, a map pin or a phone’s GPS position, and you need the street address.
It needs a secret key, so call it from your server. A mobile app or a web page sends the position to your own server, and your server calls WattleAddr. A publishable key gets 403 forbidden_key_type. It works on every plan, including Free.

The request
"https://api.wattleaddr.com.au/v1/addresses/reverse?lat=-33.99168126&lng=150.80123469&radius=100&limit=3"
The response lists the nearest addresses first.
{
"addresses": [
{
"id": "GANSW720007107",
"formatted": "35 Bergin Cct, Leppington NSW 2179",
"components": {
"flat_number": null, "level_number": null,
"street_number": "35", "street_name": "Bergin", "street_type": "Circuit", "street_suffix": null,
"locality": "Leppington", "state": "NSW", "postcode": "2179"
},
"geo": { "lat": -33.99168126, "lng": 150.80123469 },
"confidence": "high",
"distance_m": 0
},
{
"id": "GANSW720006300",
"formatted": "37 Bergin Cct, Leppington NSW 2179",
"components": { … },
"geo": { "lat": -33.99155496, "lng": 150.80129962 },
"confidence": "high",
"distance_m": 15.3
},
{
"id": "GANSW720684251",
"formatted": "33a Bergin Cct, Leppington NSW 2179",
"components": { … },
"geo": { "lat": -33.99188327, "lng": 150.80122153 },
"confidence": "high",
"distance_m": 22.5
}
],
"source": "gnaf",
"gnaf_release": "2026-08",
"billed": true
}Each address is the same record that retrieve returns, with one extra field, distance_m. The two shortened components objects have the same fields as the first.
| Parameter | What it is |
|---|---|
lat | Required. Latitude in decimal degrees, from -90 to 90. |
lng | Required. Longitude in decimal degrees, from -180 to 180. |
radius | Optional. How far to look, in metres, from 1 to 2000. The default is 100. |
limit | Optional. How many addresses to return, a whole number from 1 to 10. The default is 1. |
session | Optional. A token you choose. A retrieve in the same session within an hour of a billed reverse call is normally not billed again. |
ref | Optional. Your own ID for a customer, as on the other endpoints. You can send it as the X-WattleAddr-Ref header instead. |
A value outside its range returns 400 bad_request. We do not adjust it for you.
| Field | What it is |
|---|---|
addresses | The nearest addresses, nearest first. Empty when we find no address within the radius. Units often share their building’s coordinate, so the base address comes first when two are the same distance. |
distance_m | The distance from your point, in metres, to one decimal place. |
gnaf_release | The quarterly G-NAF release that answered. It is not proof that an address is current. |
billed | Whether this call used one lookup from your plan. false on a test key, on an empty result, or when we could not check your usage. |
test | Present, and true, only on a test key. |
How reverse geocoding is billed
Every call that returns at least one address is one lookup, from the same monthly allowance as the other endpoints. A call that returns no address is never billed. A session does not stop a repeat reverse call from being billed. A retrieve in the same session within an hour of a billed reverse call is normally not billed again. Test keys are never billed. If you retry after your own timeout, the retry can be billed as another lookup.
What the result does and does not tell you
- Nearest is the nearest address point. It means the nearest G-NAF address point. A neighbour’s point can be nearer than the property someone is standing on, so the result is not proof of where a person is. Addresses that G-NAF places only at the middle of their street or suburb are left out, because G-NAF has no point for the property itself.
- The data is a release. Results come from the G-NAF release we serve. An address that G-NAF has since retired can still appear.
- The coordinate is the G-NAF geocode. It is usually the property centroid. It is not a promise that mail can be delivered, or that it is the building’s door.
Privacy
We do not keep the coordinates, or the address we find, in usage records or search logs. The usage record keeps the type of call, the time, the key and session, how many addresses came back, how long it took, the status code, the G-NAF release and whether it was billed. If a request fails at our web server, the request line, including the coordinates, can appear in that server’s error log. We keep that log for no longer than 16 days. See the Privacy Policy.
Errors
These are the codes reverse geocoding can return. If the address data cannot be reached, it returns 503 engine_unavailable and nothing is charged.
| Status | code | What happened | What to do |
|---|---|---|---|
| 400 | bad_request | The query (q) or address is under 3 characters, or over the length limit. For suburb and postcode search the minimum is 2 characters, and session is required. Suburb verify needs at least two of suburb, state and postcode. On reverse geocoding, lat, lng, radius or limit is missing, is not a plain number, or is outside its range. The values are not adjusted. With detail=full, session is missing or longer than 200 characters. Those messages start with “Nothing was charged.” | Wait until the person has typed 3 characters before calling address search, or 2 for suburb and postcode search. Trim very long input. With detail=full, and on suburb and postcode search, add session to the URL query string (for example &session=abc123), not a header. It can be up to 200 characters. For reverse geocoding, send lat from -90 to 90, lng from -180 to 180, radius from 1 to 2000 and limit from 1 to 10. |
| 400 | invalid_ref | The customer reference (the X-WattleAddr-Ref header or the ref query parameter) is longer than 64 characters or has a character other than letters, digits and . _ : - (so no @ and no spaces). Nothing was charged. | Send your own ID for the customer, not a name or an email address. Or leave the reference out: it is optional. |
| 401 | unauthorized | No API key was sent. | Add an Authorization: Bearer YOUR_KEY header (secret key), or ?key= for a publishable key in the browser. |
| 401 | invalid_key | The key is wrong, has been revoked, or has a typo. | Copy it again from the console, or create a new key. Revoked keys never come back. |
| 402 | quota_exceeded | This month’s lookups are used up and your plan does not run over (Free, Shopify, a cancelled plan, a paid plan with a spending cap set at your request, or a paid plan whose owner chose to stop at the allowance in Settings), or a paid plan has reached the overage ceiling of five times its included lookups. The message says which. A call with detail=full is refused here whenever the workspace’s billable requests are refused, even if its session was already billed. That message starts with “Nothing was charged.” | Wait for the period to roll over. On the Free plan, upgrade in the console under Billing. If the message says the workspace is set to stop at its allowance, the owner can allow overage under Settings. If the message says the overage ceiling was reached, contact support to lift it; a plan change only takes effect next period. Address autocomplete without detail=full keeps working. Suburb and postcode autocomplete is refused too, because it can be charged. |
| 402 | test_mode_expired | A test key was used after the free test period (15 days from account creation). On Enterprise, we can switch on test keys that do not expire for a workspace by written agreement. That is the exception. Where we have not switched that option on for a workspace, the 15-day rule applies. | Create a Live key in the console. Live keys work on every plan, including Free. The one exception is the suburb and postcode API, which needs a paid plan on a live key. |
| 403 | forbidden_referrer | A publishable key was used from a domain that is not on its allowed list. | Edit the key in the console and add the host the page is served from to Allowed domains, such as shop.com.au. Add a port only to limit the key to that port. |
| 403 | forbidden_key_type | A publishable (browser) key was used to call verify (address or suburb), reverse geocoding or the usage endpoint. Publishable keys can only call autocomplete and retrieve. | Call verify or reverse geocoding from your server with a secret key. If a person is typing the address, use autocomplete and retrieve with the publishable key. Verify is for addresses you already hold. Usage is for your server too. |
| 403 | forbidden_ip | A secret key was used from an IP address that is not on its allowed list. | Edit the key in the console and add the address to Allowed IPs / CIDRs, or clear the list to allow any IP. |
| 429 | rate_limited | Too many requests per second on one key. Test keys on an Enterprise workspace share one rate across the workspace by default. We can set a different rate for your workspace. | Wait the number of seconds in the Retry-After header, then retry. Debounce keystrokes in the browser. |
| 503 | service_unavailable | We cannot reach our own database, so we cannot check this key or your usage right now. GET /v1/usage returns it too when usage cannot be read, including usage by customer reference before that is available on the server. Nothing was charged for a request that stops here. This is never a 401: the key may be fine. If it happens part way through a batch, the response lists the rows already processed, and billed shows which of them were charged. | Wait the number of seconds in the Retry-After header (30), then retry. Do not create a new key. After a batch that stopped part way, retry only the rows that were not returned, and any returned with engine_error. |
| 503 | engine_unavailable | The suburb and postcode data or the address data is not available on this server. Nothing was charged. With detail=full, the same code means the records for the suggestions could not be read: “Nothing was charged. Address details are not available right now. Try again in 30 seconds.” | Wait a few seconds and retry. If it keeps happening, check wattleaddr.com.au/status. |
Tested code for this call is in the Python, Node.js and PHP guides.
Suburb, state and postcode
Three endpoints suggest suburbs and postcodes as someone types, and check that a suburb, state and postcode belong together. You can use them instead of building your own postcode list. They are included on Starter, Growth and Enterprise with a live key. On Free, test keys can use them during your account’s first 15 days. On Enterprise, test keys covered by your agreement do not expire. There is a shorter overview on the postcode API page.
-H "Authorization: Bearer YOUR_KEY"
"session": "demo-3",
"query": "north parra",
"suggestions": [{
"id": "NSW1234-2151",
"formatted": "North Parramatta NSW 2151",
"suburb": "North Parramatta",
"state": "NSW",
"postcode": "2151"
}]
}
This is an example. The id is made up, and real ids can change between G-NAF releases. A query of digits only searches postcodes. state and limit are optional. session is required, and without it you get 400 bad_request. Each suggestion already holds the suburb, state and postcode, so you do not need a second call to read them. Suburb search forgives a typo, but only when the first letter is right.


A suggestion carries the suburb, state and postcode, so filling a form needs no second call. There is no SDK helper for suburbs and postcodes, so call the endpoint with fetch. Use a publishable key in the browser, and one session for each search box.
async function suggest(q) {
if (q.trim().length < 2) return [];
const url = `https://api.wattleaddr.com.au/v1/localities/autocomplete?q=${encodeURIComponent(q)}&session=${session}`;
const res = await fetch(url, { headers: { Authorization: "Bearer YOUR_PUBLISHABLE_KEY" } });
if (!res.ok) return []; // a 402 means a Free live key or quota reached: fall back to a free-text field
return (await res.json()).suggestions;
}
// When the person picks a suggestion:
function onPick(s) {
form.suburb.value = s.suburb;
form.state.value = s.state;
form.postcode.value = s.postcode;
}
Try it, with no key
/v1/localities/autocompletesearch a suburb or a postcode/v1/localities/verifydo these belong together?No key needed. This uses our own demo key, so nothing is billed to you.
How suburb and postcode lookups are billed
- One suburb search session is one lookup. It is billed the first time the session returns at least one suggestion, whether or not anything is selected.
- This is different from addresses with default autocomplete, where an abandoned address search is not billed.
- A search that returns no suggestions is not billed. Keystrokes within a session are fair use.
- Retrieving or verifying in a session billed within the last hour is not billed again. Verify is billed only when
matchis notnull. - A billed suburb lookup costs the same as an address lookup and uses the same monthly quota.
- With a publishable key, each new session that returns a suggestion is billed, so use one session per search box and keep it for the whole search.
If you get a 402
A live key on the Free plan gets 402 feature_unavailable with the message “Nothing was charged. Suburb and postcode lookups need a paid plan on a live key. Test keys can use them during your account’s first 15 days.” A cancelled plan moves the workspace to Free when its paid period ends, and the same error appears from then. Treat a 402 as a signal to fall back to a free-text suburb field.
Verify a suburb, state and postcode
POST /v1/localities/verify takes at least two of suburb, state and postcode, and an optional session. It needs a secret key. A publishable key gets 403 forbidden_key_type. The response is { matched, billed, verdict, match, elements, alternatives }. match has the same shape as a retrieve response without billed, or is null. Each entry in elements is verified, changed or missing. “Canberra” on its own is ambiguous with match: null. With a postcode it is still ambiguous when more than one suburb at that postcode fits, and alternatives lists them. “Canberra City” with 2601 resolves to City.
verdict | When | match | Billed |
|---|---|---|---|
verified | Everything supplied agrees, exactly one pair fits, and it is not a low-count pair | Set | Yes |
corrected | It agrees, and a missing field was filled from the only fitting pair | Set | Yes |
ambiguous | One pair fits but a supplied element was contradicted (marked changed), or the pair is a low-count one | Set | Yes |
ambiguous | Several pairs fit, and alternatives lists them | null | No |
unverified | Nothing fits | null | No |
What the data is
G-NAF has no postcode list. We build each suburb, state and postcode pair from the current G-NAF addresses that carry it. Suburb and postcode pairs are derived by WattleAddr from G-NAF address records.
- Postcodes are as recorded on G-NAF addresses and can differ from Australia Post’s.
- A postcode used only for PO Boxes, Locked Bags or large mail receivers is not included, because G-NAF holds physical addresses only.
- A suburb with no G-NAF addresses yet, such as a new estate, is not included.
- This is not Australia Post’s postcode list, and we never fill gaps from it.
- A verified suburb, state and postcode is not a check that mail can be delivered.
Show this attribution where your users can see it, as set out under Attribution: “Incorporates or developed using G-NAF © Geoscape Australia licensed by the Commonwealth of Australia under the Open Geo-coded National Address File (G-NAF) End User Licence Agreement.” If you change the pairs, say so.
Usage per customer (for platforms)
If you build software that uses WattleAddr on behalf of your own customers, you can tag each call with your ID for that customer and see usage per customer. Use it to pass costs on, or to spot one customer using far more than the rest. It is optional. A call without it works exactly as before.
curl -H "Authorization: Bearer YOUR_SECRET_KEY" \
-H "X-WattleAddr-Ref: cust_8841" \
"https://api.wattleaddr.com.au/v1/addresses/autocomplete?q=1+martin+pl&session=demo-1"
# or as a query parameter (for a browser, where a header is awkward)
"https://api.wattleaddr.com.au/v1/addresses/autocomplete?q=1+martin+pl&session=demo-1&ref=cust_8841"
- Format. 1 to 64 characters: letters, digits and
. _ : -. No spaces and no@. Anything else is refused with400 invalid_refand nothing is charged. - No personal information. Use your own customer ID. Do not put names, email addresses, phone numbers or street addresses in it.
- Where it works. Address autocomplete, retrieve and verify, the same three for suburb and postcode, and the synchronous batch (
/v1/addresses/verify/batch). Reverse geocoding takes a reference too. If you use the browser widget, pass{ ref: 'cust_8841' }as an option when you create it. A reference sent from a browser can be changed by anyone using the page, so for costs you pass on, send it from your server. - It changes nothing else. Billing, sessions, quotas and rate limits work the same with or without it. It is counted per day. It is not kept in the search log. References and their daily counts are kept for up to 400 days. Calls made with a test key are counted together with live calls in the reference counts.
See the counts. In the console, the Usage page has a “By customer reference” table for the current period (the 50 busiest), and plans with CSV export can download every reference for a month. From code, call the usage endpoint with a secret key. Dates are the same days billing uses, a range can be up to 92 days, and the default is the current billing period.
"https://api.wattleaddr.com.au/v1/usage?from=2026-10-01&to=2026-10-31&group_by=ref"
# { "totals": { "billable_lookups": 1240, "requests": 9310 },
# "rows": [ { "ref": "cust_8841", "billable_lookups": 310, "requests": 2204 }, … ] }
group_by=day (the default) returns one row per day. totals is your whole workspace for the range, so it also includes calls that carried no reference. If you send a very large number of different references in one day, the later ones are counted together under the reference ~other. Counts start from the day this feature was released. The usage endpoint is not charged. See the interactive reference for every field.
Building with a coding agent
If you use Claude Code, Cursor, Copilot or similar, give it our agent skill. It covers what an assistant otherwise gets wrong: session tokens and what they cost, which key belongs in the browser, PO Boxes not being in G-NAF, reading a verify verdict, and how to store the address components. It is one markdown file with no telemetry.
curl -o WATTLEADDR.md https://wattleaddr.com.au/skills/wattleaddr/SKILL.md
# Claude Code: drop it in as a skill
mkdir -p .claude/skills/wattleaddr && curl -o .claude/skills/wattleaddr/SKILL.md \
https://wattleaddr.com.au/skills/wattleaddr/SKILL.md
It also ships inside @wattleaddr/js, at node_modules/@wattleaddr/js/skills/wattleaddr/SKILL.md. An agent working in a project that already uses the SDK can find it without downloading anything.
Words we use
| Word | Meaning |
|---|---|
| endpoint | One URL the API answers on. The address endpoints are autocomplete, retrieve, reverse, verify and status. |
| autocomplete | The call that returns suggestions as someone types. Never charged by default. With detail=full it is billed once per session. |
| retrieve | The call that returns the full record for one suggestion. Charged once per session. |
| verify | The call that matches free text you already hold to its official form. Charged on a match. |
| lookup | The unit you are charged in. One lookup is one address a person actually picked (retrieve) or one free-text address matched (verify). With detail=full, one search session that shows a suggestion is also one lookup. The Free plan includes 5,000 a month. |
| session | Any string you choose that ties the keystrokes for one address to the final retrieve. Shared session means one lookup. No session means every retrieve is a lookup. |
| quota | The lookups included in your plan each month. When they are used up, charged calls return 402 on plans that do not run over. |
| rate limit | How many requests per second one key may make. Over it, the API returns 429 with Retry-After. |
| secret key | waddr_sk_…. For your server, sent as Authorization: Bearer. Never in a web page. |
| publishable key | waddr_pk_…. For the browser. Safe in a web page once you lock it to your domains, because other websites then can’t use it. |
| test key | waddr_sk_test_… or waddr_pk_test_…. Real data, never charged. Time limited, except Enterprise test keys covered by your agreement. |
| G-NAF | The Geocoded National Address File: the open register of every physical address in Australia, published quarterly by Geoscape. WattleAddr is built on it. It has no PO Boxes. |
| locality | G-NAF’s word for suburb or town. |
| verdict | Verify’s answer on what to do with a match: verified, corrected, ambiguous or unverified. Branch on this, not on confidence. |
| notice | A note on a successful response explaining why it is empty. Not an error. |
Data & privacy
Your end users’ input never goes to an offshore address provider such as Google Places, and the request path stays onshore. The data-residency attestation has the detail.
Reverse geocoding is different. We do not keep the coordinates, or the address we find, in usage records or search logs. The usage record keeps the type of call, the time, the key and session, how many addresses came back, how long it took, the status code, the G-NAF release and whether it was billed. See reverse geocoding.
Autocomplete queries, including suburb and postcode searches, and the addresses they match are recorded in a search log for each workspace, for usage, debugging and support. In the console you choose what it keeps:
| Mode | What it stores |
|---|---|
full (default) | Query and matched-address text, in full, until the retention period ends. |
hashed | Each query as a salted keyed hash. Matched-address text is dropped. This is pseudonymisation, not anonymisation: we hold the key. |
none | No query or matched-address text at all. Only counts, timing and billing. |
You set how long logs are kept (7–365 days, by plan). Old query text is deleted automatically. You can also apply a privacy mode to logs already stored, in one click. Why hashing an address is pseudonymisation explains the difference. See the FAQ and Privacy Policy for detail.
Attribution
WattleAddr is built on the open Geocoded National Address File. The G-NAF licence requires attribution. Show this text in a reasonable place for where the addresses appear, for example next to the address field or on an about, legal or data-sources page your users can reach from your product. If you build WattleAddr into a product for your own customers, this line in your product covers their use of it there. If you pass Address Data on to them, pass on the licence’s disclaimer and mail restriction too.
licensed under the Open G-NAF End User Licence Agreement.
Modified by [your product] for search and display.
Try every endpoint live in the interactive reference. Questions? hello@wattleaddr.com.au