How to Scrape the Australia Business Register (ABN/ABR)

If you have ever tried to build an Australian B2B prospect list, you know the register itself is public but almost impossible to use in bulk. The ASIC Business Names register holds roughly 3.27 million records, and the official lookup site — abr.business.gov.au — is built for one ABN at a time. There is no “download all consulting firms in NSW” button. This guide covers what data the register actually exposes, how the underlying open-data API works, and how to pull clean, filterable business records at scale without touching a headless browser.

What’s worth extracting

The Australian Government publishes the Business Names register as open data on data.gov.au through its CKAN datastore API. Every record maps to a small but useful set of fields. For each business you can extract:

• businessName — the registered business name (source field BN_NAME).
• abn — the 11-digit Australian Business Number (BN_ABN), the stable join key for enrichment.
• status — registration status: Registered, Cancelled or Deregistered (BN_STATUS).
• registeredDate — when the name was registered (BN_REG_DT, formatted DD/MM/YYYY).
• cancelledDate — cancellation date when present (BN_CANCEL_DT).
• stateOfRegistration — the state or territory: NSW, VIC, QLD, WA, SA, TAS, ACT, NT (BN_STATE_OF_REG).
• stateNumber — the state registration number (BN_STATE_NUM).
• register — the register name (REGISTER_NAME), which is “BUSINESS NAMES”.
• abrUrl — a ready-made deep link to the ABR lookup page for that ABN.
• scrapedAt — an ISO 8601 run timestamp.

That is 10 fields per record. Note what is not here: the Business Names register does not publish email addresses or phone numbers. What it gives you is a clean, authoritative identity layer — name, ABN, status, state, dates — that you then enrich with contact data from other sources using the ABN as the key.

How the source actually works

The register lives behind CKAN, the open-source data portal software that powers data.gov.au. CKAN exposes a datastore_search endpoint that accepts a resource ID, a free-text query, and filters, and returns JSON rows. Conceptually a query looks like this:

GET https://data.gov.au/data/api/3/action/datastore_search
  ?resource_id=<current-business-names-resource>
  &q=consulting                 # free-text search across the record
  &filters={"BN_STATUS":"Registered","BN_STATE_OF_REG":"NSW"}
  &limit=100
  &offset=0

The actor wraps this cleanly. You give it plain filters and it handles the CKAN mechanics: it maps query to CKAN’s q, maps status and state to the underlying BN_STATUS / BN_STATE_OF_REG filters, paginates with limit/offset, de-duplicates by record id, and normalizes each raw CKAN row into the 10-field schema above. Because CKAN is a plain JSON HTTP API, no headless browser is involved — there is no DOM to walk and no JavaScript challenge to solve.

One important detail from the README: government open-data resources occasionally get republished under a new resource ID. The actor verifies the register resource is live on each run and auto-discovers the current CKAN resource if the ID has moved, so a run doesn’t silently break when data.gov.au rotates the dataset.

Here is a realistic input — registered consulting businesses in New South Wales:

{
  "query": "consulting",
  "status": "Registered",
  "state": "NSW",
  "maxResults": 2000
}

The query field is a keyword match; status set to Registered filters to live business names (best for outreach); state scopes to a territory; maxResults caps the run. Every field is optional, so you can run it broad or laser-targeted.

▶ Open the Australia Business Register Scraper on Apify — one run returns thousands of businesses with ABN, status, state and an ABR lookup link per row. No API key, no login. Export to CSV, JSON or Excel.

The access reality

The register is genuinely open — no key, no login, no captcha — so the friction here is not anti-bot defenses. It’s pagination depth and volume math. CKAN caps very deep offsets: you cannot simply request offset 1,000,000 and walk the entire 3.27M-record register in one pass. The datastore is tuned for reasonable queries, not full-table exports over HTTP.

The practical consequence, straight from the README: to approximate the whole register, split your run by state and/or by query keyword and combine the datasets. A single broad run returns the first slice up to your maxResults. Segmented runs — one per state, or one per industry keyword — reach deeper because each starts its own shallow pagination window. This is the standard pattern for pulling a large targeted segment out of a capped datastore.

A useProxy toggle routes traffic through Apify Proxy (datacenter by default). Because data.gov.au is open, you can turn proxy off, but the README recommends keeping it on for stable, consistent runs.

Example output

A single record looks like this:

{
  "businessName": "HOOLIHAN PROPERTY CONSULTING",
  "abn": "47151666812",
  "status": "Registered",
  "registeredDate": "06/01/2011",
  "cancelledDate": null,
  "stateOfRegistration": "NSW",
  "stateNumber": "BN98545970",
  "register": "BUSINESS NAMES",
  "abrUrl": "https://abr.business.gov.au/ABN/View?abn=47151666812",
  "scrapedAt": "2026-07-06T00:00:00.000Z"
}

The abrUrl is the field that turns a spreadsheet into a workflow: click it and you land on the official ABR record for that ABN, no manual copy-paste of the number into the lookup form.

Single-ABN lookup

Beyond bulk search, the actor has a single-ABN lookup mode. Pass an exact 11-digit ABN and it resolves that one business to its official register fields:

{ "abn": "47151666812" }

This is handy for verification and enrichment jobs — you already have a list of ABNs from a CRM or an invoice system and you want to confirm the registered name and status against the official source.

Typical use cases

What people actually do with this data:

• B2B lead generation — build targeted Australian prospect lists by keyword and state, each row carrying an ABN and an ABR link, then enrich contact details from other sources.
• Sales prospecting — filter status = Registered by state to surface live, active businesses worth approaching, skipping cancelled and deregistered names.
• Market research — count and profile businesses by keyword, state and registration date to size a segment or measure how fast an industry is forming in a region.
• KYC, compliance and due diligence — verify business names, ABNs and registration/cancellation status against the authoritative register.
• Competitor mapping — pull every business name matching an industry keyword within a state and benchmark their status and registration age.
• CRM enrichment — resolve records by ABN or name and append official register fields plus the ABR URL to rows you already hold.

Cost and effort math

Building this yourself is deceptively fiddly. CKAN’s datastore_search is documented, but you’d still write and maintain: the filter-mapping logic (human labels to BN_* field names), offset pagination with the deep-offset cap handled gracefully, de-duplication by record id, resource-ID discovery for when data.gov.au republishes the dataset, and output normalization into a stable schema. None of it is hard individually; together it’s a small project plus ongoing babysitting whenever the government moves the resource.

The managed actor collapses that to a form you fill in. Pricing is pay-per-result — you pay a fraction of a cent per business row returned, plus a tiny per-run start fee, with no separate platform-compute bill to reason about. For a lead-gen pull of a few thousand registered businesses in a state, the cost lands in the low single-digit dollars. There are no residential-proxy bills to worry about, because an open government API doesn’t need residential IPs.

Common pitfalls

A few things specific to this source that will bite you if you don’t plan for them:

• Date format is DD/MM/YYYY, not ISO. registeredDate comes through as 06/01/2011 (6 January), Australian order. Parse it explicitly; do not let a US-locale parser read it as June 1.
• Deep pagination is capped. One broad run will not return all 3.27M records. Segment by state and/or keyword and union the datasets — this is the intended pattern, not a workaround.
• No contact fields exist. The register carries name, ABN, status, dates and state only. If you need email or phone, use the ABN to enrich from another source; the actor cannot invent fields the register doesn’t publish.
• Status matters for outreach. A “Cancelled” or “Deregistered” name is a dead lead. Always filter to Registered for prospecting, and store the status so you can re-filter later.
• cancelledDate is usually null. It’s only populated for names that have actually been cancelled — an expected null on active records, not missing data.
• ABN vs. business name is one-to-many. A single ABN (a legal entity) can hold several registered business names. De-dup on the record id, and decide whether you want unique ABNs or unique names for your use case.

Wrapping up

The Australian Business Names register is a high-quality, fully open dataset trapped behind a one-record-at-a-time lookup UI. If you only need to check a handful of ABNs, the official site is fine. If you need a filterable, exportable slice — every registered consulting firm in NSW, every active cafe in Victoria — the managed actor turns the CKAN datastore into a clean CSV without you writing a single API call.

▶ Run the Australia Business Register Scraper on Apify — filter by name, status, state or single ABN; get thousands of official ABR-linked business records per run. No key, no captcha. Start on Apify’s free monthly credit.