# ABN Lookup & Bulk Enrichment (`au_actorfactory/abn-lookup-enricher`) Actor

Bulk ABN lookup & GST status checker. Validate ABNs, ACNs & business names against the official ABR. Clean CRMs & lead lists at $5 per 1,000.

- **URL**: https://apify.com/au\_actorfactory/abn-lookup-enricher.md
- **Developed by:** [AU Actor Factory](https://apify.com/au_actorfactory) (community)
- **Categories:** E-commerce, Lead generation, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$5.00 / 1,000 enriched business records

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## ABN Lookup & Bulk Enrichment — validate ABNs, ACNs & business names in bulk

**Bulk ABN lookup** against the official Australian Business Register (ABR): paste a list of ABNs, ACNs, or business names and get back verified entity details — ABN status, entity type, **GST registration status**, registered business names, state and postcode — as a clean dataset you can export to CSV, Excel, or JSON. Built for CRM cleanup, supplier verification, and lead-list validation at **$5.00 per 1,000 results**.

### What you can do with it

- **Bulk ABN validation** — check hundreds or thousands of ABNs in one run, with local checksum validation before any API call (invalid numbers never waste a lookup)
- **Check GST registration status** for a supplier list before issuing invoices (`gstRegistered: true/false` plus the registration date)
- **Business name to ABN lookup** — resolve company names to their ABN with the ABR's relevance score, keeping only matches above your threshold
- **ACN to ABN lookup** — company numbers resolve to full entity details
- **Clean a CRM or lead list** — dedupe and enrich Australian B2B records with authoritative government data
- **Verify entity type** — distinguish sole traders, companies, trusts, and partnerships before a deal

### Why this actor

- **Official data.** Results for valid ABNs, ACNs, and business-name matches come live from the Australian Business Register's own web services — not a stale copy. (Numbers that fail checksum are rejected locally and marked in your results without an API call.)
- **Transparent pricing.** $5.00 per 1,000 results, period. 5,000 results cost $25. No compute-unit surprises.
- **Fast and light.** Pure HTTP, no browsers, polite rate-limiting. A 1,000-entry ABN/ACN list finishes in ~4-7 minutes (business-name queries make up to 4 API calls each, so they run slower); up to 5,000 queries per run.
- **Actively maintained.** Automated regression testing; issues answered fast.
- **Agent-ready.** Compact structured output (<1KB per item) works cleanly via the Apify MCP server and API.

### Pricing

| Job | Results | Cost |
|---|---|---|
| Validate a 200-supplier list | 200 | $1.00 |
| Clean a 5,000-entry CRM | 5,000 | $25.00 |
| Enrich 20,000 leads | 20,000 | $100.00 |

You pay only for results returned (pay-per-result) — note a business-name query returns up to 3 matched results by default, each billed as one result. Data-level failures (invalid checksum, no name match, ABR errors) return an item with an `error` field explaining why. The one exception: an invalid access key terminates the run with a clear error message instead of producing error items.

### Quick start

1. **Get your free ABR key (one-time, ~5 minutes).** The official ABN Lookup web services are free but each user needs their own access key (GUID). Register at [abr.business.gov.au/Tools/WebServices](https://abr.business.gov.au/Tools/WebServices) — the GUID arrives by email.
2. Paste the GUID into the **ABR GUID** field (stored encrypted).
3. Paste your ABNs / ACNs / business names into **queries** — mixed lists are fine, each entry is auto-detected.
4. Run. Export the dataset as CSV/Excel/JSON, or fetch it via API.

### Example output

```json
{
  "query": "49 004 028 077",
  "queryType": "abn",
  "abn": "49004028077",
  "abnStatus": "Active",
  "abnStatusEffectiveFrom": "1999-11-01",
  "entityName": "BHP GROUP LIMITED",
  "entityTypeCode": "PUB",
  "entityTypeName": "Australian Public Company",
  "gstRegistered": true,
  "gstRegisteredFrom": "2000-07-01",
  "businessNames": ["BHP", "BHP GROUP"],
  "state": "NSW",
  "postcode": "2000",
  "matchScore": null,
  "error": null,
  "retrievedAt": "2026-07-22T10:15:00.000Z"
}
```

### Input options

| Field | Default | What it does |
|---|---|---|
| `queries` | 2 sample queries | ABNs (11 digits), ACNs (9 digits), or business names — auto-detected |
| `abrGuid` | — | Your free ABR web-services GUID (encrypted) |
| `nameMatchLimit` | 3 | Max candidates enriched per name query |
| `minNameScore` | 80 | Drop name matches below this ABR relevance score (0–100) |
| `requestDelayMs` |  200 | Politeness delay between API calls |

### FAQ

**What if I run it without a GUID?**
The run finishes instantly with setup instructions in the log — **no results are produced and nothing is charged.**

**Is the GUID really free?**
Yes. The Australian Business Register issues web-services access keys free of charge — registration takes about five minutes and the GUID is emailed to you. This actor uses *your* key, so your usage stays within your own ABR agreement.

**Is this official, current data?**
Yes — every valid query hits the ABR's live web services at query time; checksum-invalid numbers are flagged locally without a call. Nothing is cached or resold from a stale database.

**What does `gstRegistered` mean?**
Whether the entity is currently registered for GST, with `gstRegisteredFrom` giving the effective date. Useful for checking whether a supplier's invoice should include GST.

**How accurate is business-name matching?**
The ABR returns a relevance score (0–100) per candidate. By default only matches scoring 80+ are enriched (top 3 per name); tune `minNameScore` and `nameMatchLimit` to be stricter or broader. Exact registered names typically score 95+.

**Can I run huge lists?**
Up to 5,000 queries per run, processed sequentially with a politeness delay (5,000 ABN/ACN lookups ≈ 25-35 minutes with defaults; business-name queries take roughly 4x longer each). For larger jobs, split the list into multiple runs.

**What happens if a lookup fails?**
For data-level failures (invalid ABN checksum, no name match above threshold, ABR error message) you get an item with the `error` field populated, so reconciliation against your source list is trivial. An invalid access key instead terminates the run with a clear message.

**Are these "business names" or "trading names"?**
The `businessNames` field carries what the ABR's service returns for the entity — its registered business names. Note the ABR **stopped collecting trading names in May 2012**; historical trading names have no legal status and cannot be relied on for business identity (ABR's own guidance). Use `entityName` (the legal entity name) for identity purposes.

**Which ABR interface does this use?**
The official ABN Lookup JSON services (ABN, ACN and name search) — the exact scope the ABR provides in JSON — under your own free GUID registration.

**Can AI agents use this?**
Yes — the actor works through the Apify API and MCP server, and the compact JSON output is designed to be agent-friendly.

### Support & maintenance

This actor is covered by automated regression tests against the live ABR service. Found a problem or need a field added? Open an issue on the **Issues** tab — it gets a response fast.

***

### Disclaimer

Data is retrieved as-is from the Australian Business Register at query time. **Verify outputs before relying on them** for invoicing, tax, compliance, or business decisions — you are responsible for how you use the data and for confirming it against official sources where it matters. This actor provides data lookup only; it does not provide professional, tax, legal, or financial advice, and no warranty of accuracy or completeness is given.

*Data sourced live from the Australian Business Register under your own free ABR web-services registration. Use business data responsibly — this actor is not intended for collecting personal information.*

# Actor input Schema

## `queries` (type: `array`):

One entry per lookup (max 5,000 per run). 11-digit ABNs, 9-digit ACNs, or business names are auto-detected. Spaces in numbers are fine.

## `abrGuid` (type: `string`):

Your free ABN Lookup web services GUID. Register in ~5 minutes at https://abr.business.gov.au/Tools/WebServices — the GUID is emailed to you. Without it, the run outputs setup instructions instead of data.

## `nameMatchLimit` (type: `integer`):

For business-name queries: how many top candidates to enrich (each counts as one result).

## `minNameScore` (type: `integer`):

ABR relevance score threshold (0-100) below which name matches are dropped.

## `requestDelayMs` (type: `integer`):

Politeness delay between calls to the ABR service.

## Actor input object example

```json
{
  "queries": [
    "49 004 028 077",
    "qantas airways"
  ],
  "nameMatchLimit": 3,
  "minNameScore": 80,
  "requestDelayMs": 200
}
```

# Actor output Schema

## `enrichedEntities` (type: `string`):

One item per resolved entity: ABN, status, entity name/type, GST registration, business names, location, match score, per-item error.

## `setupInstructions` (type: `string`):

Present only when the run had no ABR GUID: how to get the free key. Such runs produce no dataset items and are not charged.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "queries": [
        "49 004 028 077",
        "qantas airways"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("au_actorfactory/abn-lookup-enricher").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "queries": [
        "49 004 028 077",
        "qantas airways",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("au_actorfactory/abn-lookup-enricher").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "queries": [
    "49 004 028 077",
    "qantas airways"
  ]
}' |
apify call au_actorfactory/abn-lookup-enricher --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=au_actorfactory/abn-lookup-enricher",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/RS6hb02yeH8lHxIFw/builds/DmApe8f81haxaPpeE/openapi.json