How fast is the DingoFind address API?

DingoFind returns autocomplete results in under 10ms p99. 85% of requests are served from an in-memory cache in under 1ms. Cache misses hit the Tantivy search index in 5-15ms.

Is there a free tier for the Australian address API?

Yes. DingoFind offers a free trial with 100,000 requests in your first month. A credit card is required to activate (no charge during trial). After your trial, paid plans start at $29/month.

Australian Address Search
for Developers

Add typo-tolerant address autocomplete to any Australian app in minutes. Rust-powered. Sub-10ms. 15.8M addresses from the official GNAF dataset.

Live demo - real data, real API. No signup needed.

15.8M

Australian addresses

<10ms

p99 response time

100K

Free trial requests

100%

Hosted in Australia

Built for production

Everything you need to ship reliable Australian address input in your app.

Sub-10ms responses

Tantivy full-text search with mmap'd index and in-process Moka cache. No Redis. No round-trips. 85% of requests served from cache in under 1ms. The remaining 15% hit the index in 5–15ms.

Typo tolerant

"colins st melbn" returns Collins Street Melbourne. Fuzzy matching (Levenshtein distance), phonetic normalisation, and abbreviation expansion (St → Street, Rd → Road, Ave → Avenue) are built in.

Official GNAF data

Built on the Geocoded National Address File - the same dataset used by Australia Post, the ABS, and all state governments. Covers all states, territories, rural addresses, and indigenous communities. Updated quarterly.

Lat/lon geocoordinates

Every result includes latitude and longitude accurate to the parcel centroid - no second lookup needed. Growth tier adds reverse geocoding: find the nearest addresses for any lat/lon point.

Address parsing

Decompose any freeform Australian address into unit, level, street number, street name, street type, suburb, state, and postcode. Handles complex formats: unit/lot numbers, ranges, building names.

Simple integration

Standard Bearer token auth. CORS enabled. Gzip compressed. One endpoint for autocomplete, one for validation, one for parsing. Works from any language, framework, or platform.

Who uses DingoFind

Any product that handles Australian addresses benefits from fast, accurate autocomplete.

E-commerce checkout

Autocomplete shipping and billing addresses. Reduce form abandonment. Validate addresses before charging customers.

Field service apps

Tradies, delivery drivers, inspectors - fast address lookup that works even in areas with unusual or new addresses.

SaaS & CRM

Keep address data clean at the point of entry. Parse addresses into structured fields for databases, mailing lists, and analytics.

Property & real estate

Property listings, inspections, rental applications. Add SA1 codes and LGA names for demographic enrichment on Growth tier.

Integrate in minutes

One endpoint. Standard Bearer auth. Returns JSON with addresses and coordinates.

# Autocomplete - returns matching addresses with geocoordinates
curl "https://www.dingofind.com/v1/autocomplete?q=1+george+st+sydney&limit=5" \
  -H "Authorization: Bearer YOUR_API_KEY"

# Response
{
  "suggestions": [
    {
      "full_address": "1 George St Sydney NSW 2000",
      "gnaf_pid":    "GANSW703882303",
      "suburb":      "Sydney",
      "state":       "NSW",
      "postcode":    "2000",
      "latitude":    -33.8688,
      "longitude":   151.2093
    }
  ]
}

// Debounced address autocomplete - drop into any form
async function searchAddress(query) {
  const res = await fetch(
    `https://www.dingofind.com/v1/autocomplete?q=${encodeURIComponent(query)}&limit=5`,
    { headers: { Authorization: `Bearer ${YOUR_API_KEY}` } }
  );
  const { suggestions } = await res.json();
  return suggestions;
}

// Each suggestion: full_address, suburb, state, postcode, latitude, longitude
const results = await searchAddress("1 george st syd");
console.log(results[0].full_address); // "1 George St Sydney NSW 2000"
console.log(results[0].latitude);    // -33.8688

import requests

def autocomplete(query: str, api_key: str, limit: int = 5) -> list:
    r = requests.get(
        "https://www.dingofind.com/v1/autocomplete",
        params={"q": query, "limit": limit},
        headers={"Authorization": f"Bearer {api_key}"}
    )
    r.raise_for_status()
    return r.json()["suggestions"]

results = autocomplete("1 george st sydney", "YOUR_API_KEY")
for addr in results:
    print(f"{addr['full_address']} ({addr['latitude']}, {addr['longitude']})")
# 1 George St Sydney NSW 2000 (-33.8688, 151.2093)

See full endpoint reference in the API docs →

Simple pricing

Start with a free trial. Scale as you grow. No setup fees, no contracts.

Monthly Annual 2 months free

Start your free trial

100,000 requests in your first 30 days. Credit card required - no charge during trial.

Create account →

Free Trial

$0_{/30 days}

100,000 requests total

Autocomplete
Address validation (GNAF)
Lat/lon geocoordinates
Address parsing
Enrichment (SA1, LGA)
Reverse geocode
Batch processing

Card required · No charge · Upgrade anytime

Create account →

Frequently asked questions

Everything you need to know before integrating.

What Australian address data does DingoFind use?

DingoFind is built on the Geocoded National Address File (GNAF) - Australia's authoritative address dataset, maintained by PSMA Australia and published under the Open G-NAF licence. It covers all states and territories including rural, remote, and indigenous community addresses. The data is updated quarterly from official government sources. GNAF is the same dataset used by Australia Post, the Australian Bureau of Statistics, and every state government for addressing purposes.

How fast is the API really?

The API is written in Rust using the Axum web framework and the Tantivy search engine. All address data is stored in a memory-mapped Tantivy index on the server (no database queries on the hot path). In production: 85% of autocomplete requests are served from an in-memory Moka cache in under 1ms. The remaining 15% hit the Tantivy index directly and return in 5–15ms. The p99 latency is consistently under 15ms on our Oracle Cloud Sydney hardware.

How does typo tolerance work?

DingoFind uses multiple techniques at query time: fuzzy term matching with Levenshtein distance 1 (catches one-character typos), prefix matching for partially-typed words, and an abbreviation expansion table (St → Street, Rd → Road, Ave → Avenue, Hwy → Highway, etc.). Common Australian suburb abbreviations are also expanded. This means a query like "1 colins st melbn" correctly returns "1 Collins Street Melbourne VIC 3000".

What is address enrichment?

Growth and Pro tier responses include additional spatial fields attached to each address: Mesh Block code (ABS 2021 census mesh block), SA1 code (Statistical Area Level 1), LGA name (Local Government Area), and Federal electorate. These are resolved at query time via an in-memory R-tree spatial index - no extra API call required.

Can I validate an address before using it?

Yes. The /v1/validate endpoint checks whether a freeform address string matches a record in the GNAF dataset and returns a confidence score between 0 and 1. A score of 0.80 or above is considered valid. This works for the vast majority of Australian street addresses.

Important: Validation is against GNAF — Australia's official government address dataset. DingoFind is not connected to Australia Post's proprietary delivery database (PAF/DPID). This means PO Boxes, Locked Bags, and CMB addresses won't validate, and the result doesn't guarantee postal deliverability. For most use cases (e-commerce checkout, CRM data cleansing, user-entered addresses) GNAF validation is accurate and sufficient. If your specific use case requires absolute postal delivery confirmation, you'll need to supplement this with an AusPost integration.

What counts as a "request"? How many requests does one address lookup use?

One request = one HTTP call to the API. Not one address lookup by your end user.

An autocomplete field fires a new API call on (roughly) each keystroke. A user typing "1 George Street Sydney" will typically trigger somewhere between 4 and 10 requests depending on how your integration is built — your debounce delay, minimum query length, and whether you cache recent results all affect this. There is no hard upper bound we can guarantee; a worst-case unoptimised integration could send more.

As a practical planning guide: with a 100–150ms debounce (the right choice for a sub-10ms API — longer debounces are only needed to mask slow servers) and a 3-character minimum, expect roughly 3–5 requests per completed address lookup. Without any debounce, expect 10–20.

Your daily limit applies to total HTTP requests from your API key. We recommend monitoring your usage dashboard in the first week after launch to understand your real consumption rate. See our API docs for debouncing best practices and our Terms of Service §7 for the full definition.

Is there a free tier?

Yes - DingoFind offers a free trial with 100,000 requests in your first 30 days. A credit card is required to activate your trial, but you won't be charged anything during the trial period. After your trial ends, choose a paid plan starting at $29/month to continue. Free trial includes autocomplete, address validation, and geocoordinates on every result.

Where is the data hosted? Is it Australian?

Yes. DingoFind runs entirely on Oracle Cloud Infrastructure in the Melbourne region (ap-melbourne-1). All address data remains on Australian infrastructure. No data leaves Australian territory.

Can I use this in a commercial product?

Yes. All plans allow commercial use. The underlying GNAF data is published by Geoscape Australia under the Creative Commons Attribution 4.0 International (CC BY 4.0) licence, which explicitly permits commercial use. If your product displays GNAF-derived address data to end users, you should include an attribution to Geoscape Australia as the source. DingoFind's Terms of Service include the full attribution notice required under CC BY 4.0. See the official GNAF dataset for more details.

Australian Address Searchfor Developers