# ASIC Australian Companies - ACN/ABN Lookup & New Registrations (`jpopendata/au-asic-companies`) Actor

Australian companies from ASIC's weekly Company Dataset on data.gov.au: search by name, ACN/ARBN or ABN, or list new registrations and deregistrations by date. Status, type, class, ABN, registration dates, former names. Official CKAN API; CC BY 3.0 AU. Unofficial; not affiliated with ASIC.

- **URL**: https://apify.com/jpopendata/au-asic-companies.md
- **Developed by:** [JP Open Data](https://apify.com/jpopendata) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## ASIC Australian Companies – ACN/ABN Lookup & New Registrations

Get Australian company records from **ASIC's Company Dataset** — the official weekly snapshot of the ASIC company register (about 4.45 million name records, every registered company plus companies deregistered in the last year), published by the Australian Securities and Investments Commission on **data.gov.au** under CC BY 3.0 AU.

- **New registrations**: companies registered (or deregistered) in a date window — by default the 7 days up to the latest weekly extract, newest first.
- **Search**: look companies up by **name keywords** (current or former names), **ACN/ARBN** or **ABN** — up to 2,000 numbers per run.
- **Filters**: status (registered, deregistered, external administration, strike-off…), type (proprietary, public, foreign, registered body), class, sub class, previous state of registration, and "changed in the latest weekly extract".
- **One row per company**: current name, all former names, ACN, ABN, type, class, sub class, status (codes **and** ASIC's descriptions), registration and deregistration dates, previous state of registration, and the extract date the row comes from.

It reads the data through data.gov.au's documented CKAN API (the DataStore query interface that ASIC's own help file for this dataset recommends). No browser, no login, no API key, no proxy.

### Quick start — verified input

Newest companies registered in the last week (this is also what an empty input `{}` does):

```json
{
  "mode": "recent",
  "dateField": "registered",
  "lastDays": 7,
  "maxItems": 100
}
```

Search by name (whole words; former names count too):

```json
{
  "mode": "search",
  "companyNames": ["Woolworths"],
  "maxItems": 50
}
```

Look up a list of company numbers:

```json
{
  "mode": "search",
  "acns": ["004 085 616", "000 000 019"],
  "abns": ["53 004 085 616"]
}
```

### Input

| Field | What it does |
|---|---|
| `mode` | `recent` (default): companies registered/deregistered in a date window. `search`: look up by name, ACN/ARBN or ABN. Entering ACNs/ABNs switches to `search` automatically. |
| `companyNames` | Name keywords, e.g. `"Woolworths"`, `"bp australia"`, `"mining*"`. Every word must be a whole word of one name (any order); `*` matches the start of a word. In `recent` mode they narrow the new registrations. |
| `acns` | ACNs or ARBNs (9 digits; spaces and "ACN" labels are fine). Numbers that fail the check digit are skipped and listed in `RUN_SUMMARY.invalidNumbers`. |
| `abns` | ABNs (11 digits). This dataset holds companies only — no sole traders, partnerships or trusts. |
| `dateField` | `registered` (default) or `deregistered` (ASIC keeps deregistered companies here for one year). |
| `lastDays` | `recent` mode: the N days up to and including the latest weekly extract (1–366, default 7). |
| `dateFrom`, `dateTo` | Optional window, `YYYY-MM-DD` (also `DD/MM/YYYY`, `1-Jul-2026`, `today`, `-30d`). Up to 3,660 days in `recent` mode; any range in `search` mode. |
| `statuses` | `REGD`, `DRGD`, `EXAD`, `SOFF`, `NOAC`, `NRGD`, `PROV`, `DISS`, `DIV3`, `PEND`, `CNCL` — or names like `"registered"`, `"liquidation"`, `"strike off"`. |
| `types` | `APTY` (proprietary), `APUB` (public), `FNOS` (foreign company), `RACN` (registered Australian body). |
| `classes`, `subClasses` | ASIC class codes (`LMSH`, `LMGT`, `LMSG`, `NLIA`, `UNLM`, `NONE`) and sub class codes (`LIST`, `ULST`, `PROP`, `PSTC`, `PNPC`, `HUNT`, …). |
| `previousStates` | `NSW`, `VIC`, `QLD`, `SA`, `WA`, `TAS`, `ACT`, `NT` — the state an older company was originally registered in (before 1991). |
| `onlyChangedThisWeek` | Only companies that are new or whose name, type, class, sub class or status changed since the previous weekly extract. With `statuses: ["EXAD"]` you get this week's companies entering external administration. |
| `includeFormerNameMatches` | Return companies whose **former** name matches a keyword (default `true`). |
| `maxItems` | Maximum companies (default 100, up to 100,000). Raised automatically to cover an ACN/ABN list. |
| `maxApiRequests` | Hard request budget (default 30, up to 500). |

### Output

One item per company:

```json
{
  "companyName": "B P AUSTRALIA PTY LTD",
  "acn": "004085616",
  "abn": "53004085616",
  "type": "APTY",
  "typeDescription": "Australian proprietary company",
  "class": "LMSH",
  "classDescription": "Limited by shares",
  "subClass": "PROP",
  "subClassDescription": "Proprietary other",
  "status": "REGD",
  "statusDescription": "Registered",
  "registrationDate": "1920-08-25",
  "deregistrationDate": null,
  "previousStateOfRegistration": "VIC",
  "stateRegistrationNumber": "C0007382M",
  "currentNameStartDate": "2002-03-26",
  "previousNames": ["B P AUSTRALIA LIMITED", "THE COMMONWEALTH OIL REFINERIES LIMITED"],
  "modifiedSinceLastReport": false,
  "matchedBy": "acn",
  "matchedTerm": "004085616",
  "datasetExtractDate": "2026-10-13",
  "datasetLastModified": "2026-10-12T13:53:24Z",
  "source": "ASIC Company Dataset (Australian Securities and Investments Commission), published on data.gov.au",
  "sourceUrl": "https://data.gov.au/data/dataset/asic-companies",
  "license": "Attribution: Australian Securities and Investments Commission (ASIC), Commonwealth of Australia, ASIC - Company Dataset, sourced on 2026-10-13, https://data.gov.au/data/dataset/asic-companies. Licensed under Creative Commons Attribution 3.0 Australia (https://creativecommons.org/licenses/by/3.0/au/). Changed by this tool: ...",
  "retrievedAt": "2026-10-13T00:05:00.000Z"
}
```

- `acn` is the 9-digit number from the dataset's ACN column (for type `RACN`, ASIC's data dictionary says it is the ARBN).
- `abn` is `null` when the company has no ABN (ASIC publishes `0`); brand-new companies often have none yet.
- `matchedBy`: `name`, `formerName`, `acn`, `abn`, `dateWindow` or `filters`.
- `datasetExtractDate`: the day of the weekly ASIC extract the row comes from (Sydney time).
- A run summary (window, counts, numbers not found, requests used, `complete`) is saved as `RUN_SUMMARY` in the key-value store.

### Freshness

ASIC uploads a new extract **every Tuesday** (Australian time). Each row says which extract it comes from. For real-time details of a single company use ASIC Connect (ASIC's own search, some products are paid).

### Common input mistakes

| You entered | What happens / what to enter |
|---|---|
| `companyNames: ["Woolw"]` | Words must be whole words. Use `"woolw*"` for the start of a word. |
| `companyNames: ["004 085 616"]` | Recognised as an ACN and searched as one (a warning says so). |
| `acns: ["4085616"]` (zeros lost in a spreadsheet) | Padded back to `004085616`. A number that fails the check digit is skipped and reported. |
| `mode: "search"` with no names or numbers | The run stops at once and explains what to enter. Use `mode: "recent"` to list new registrations. |
| `previousStates: ["Sydney"]` | Accepted as `NSW`, but note this is the pre-1991 state of registration, not the office location (the dataset has no address). |
| `dateField: "deregistered"` with a window older than one year | ASIC keeps deregistered companies here for one year only; older ones are not in the dataset. |

### Empty results?

- A keyword that is not a whole word of any company name (try `*` or fewer words).
- Filters that exclude everything (e.g. a status plus a type plus a previous state).
- A very short window on a weekend or holiday.
- ACNs/ABNs of companies deregistered more than a year ago (listed in `RUN_SUMMARY.notFoundAcns` / `notFoundAbns`).

A run that finds nothing still succeeds (0 items, `complete: true`) and logs why it may be empty.

### Run time and resources

| Job | Requests | Typical time |
|---|---|---|
| Quick start (100 newest companies) | 2 | 5–10 s |
| One name search | 2–3 | 5–10 s |
| 1,000 ACNs | 11 | about 30–40 s |
| 5,000 companies from a window | 6 | about 20–30 s |

Requests are sent one at a time, at least 2 seconds apart. The Actor runs in 256 MB with no proxy, so platform usage per run is a small fraction of a compute unit.

### What is not included

- No officeholders, shareholders, contact details or addresses — the ASIC dataset does not contain them, and this Actor adds none.
- No registered office or postcode: "previous state of registration" is the only state field (older companies only).
- Companies deregistered more than one year ago are not in the dataset.

### Attribution and licence

The data is © Commonwealth of Australia (ASIC), licensed under [Creative Commons Attribution 3.0 Australia](https://creativecommons.org/licenses/by/3.0/au/). data.gov.au asks for this form of attribution: *Organisation name, jurisdiction, title of dataset, date the content was sourced, dataset URL* — every item carries it in `license`, for example:

> Attribution: Australian Securities and Investments Commission (ASIC), Commonwealth of Australia, ASIC - Company Dataset, sourced on 2026-10-13, https://data.gov.au/data/dataset/asic-companies.

If you republish the data, keep that attribution, say what you changed, and do not suggest that ASIC or data.gov.au endorses you.

### Disclaimer

- **Unofficial**: this Actor is not affiliated with or endorsed by ASIC, data.gov.au or the Commonwealth of Australia.
- It uses only public data from the official open-data portal, through its documented API.
- You are responsible for using the data lawfully and in line with the source's terms and the licence.
- GDPR and privacy: the output contains company-level register data only. Some company names include a person's name; treat such data according to the privacy laws that apply to you.

# Actor input Schema

## `mode` (type: `string`):

recent (default) = companies registered (or deregistered) in a date window — by default the 7 days up to the latest weekly ASIC extract, newest first. search = look up companies by name keywords, ACN/ARBN or ABN (no date limit unless you set Date from / Date to). If you enter ACNs or ABNs the run switches to search automatically.

## `companyNames` (type: `array`):

Optional. Words of the company name, any case, e.g. "Woolworths", "bp australia", "mining\*". Every word must appear as a whole word of the name (any order); end a word with \* to match its start ("woolw\*"). A company matches if ANY entry matches. Former names count too (see Match former names). In mode recent they narrow the new registrations; in mode search they search the whole register.

## `acns` (type: `array`):

Optional (mode search). Australian Company Numbers or Australian Registered Body Numbers: 9 digits, spaces and labels allowed, e.g. "004 085 616", "ACN 000 000 019". Up to 2,000 per run (100 per request). Numbers that fail the check digit are skipped and listed in RUN_SUMMARY.invalidNumbers.

## `abns` (type: `array`):

Optional (mode search). Australian Business Numbers of companies: 11 digits, spaces allowed, e.g. "53 004 085 616". Only companies are in this dataset (no sole traders, partnerships or trusts). Numbers that fail the ABN check are skipped.

## `dateField` (type: `string`):

registered (default) = date of registration; deregistered = date of deregistration (ASIC keeps deregistered companies in this dataset for one year only).

## `lastDays` (type: `integer`):

Mode recent: the N days up to and including the latest weekly ASIC extract (1..366). The extract is published every Tuesday, so the window ends on that day, not today. Ignored when Date from is set. Australia registers roughly 4,000-6,000 companies a week.

## `dateFrom` (type: `string`):

Optional. First day of the window, YYYY-MM-DD, e.g. "2026-07-01". DD/MM/YYYY (day first), "1-Jul-2026", "today", "yesterday" and "-30d" (30 days before today, Sydney time) also work. In mode recent the window can be at most 3,660 days; in mode search any range works together with names or numbers.

## `dateTo` (type: `string`):

Optional. Last day of the window (inclusive), same formats as Date from. Defaults to the latest weekly extract date.

## `statuses` (type: `array`):

Optional. ASIC status codes or names: REGD (Registered), DRGD (Deregistered), EXAD (External administration - receivership/liquidation), SOFF (Strike-off action in progress), NOAC (Not active), NRGD (Not registered), PROV, DISS, DIV3, PEND, CNCL. "registered", "deregistered", "liquidation", "strike off" also work. Empty = all.

## `types` (type: `array`):

Optional. APTY (Australian proprietary company), APUB (Australian public company), FNOS (foreign company registered in Australia), RACN (registered Australian body). "proprietary", "public", "foreign" also work. Empty = all.

## `classes` (type: `array`):

Optional. LMSH (limited by shares), LMGT (limited by guarantee), LMSG (shares and guarantee), NLIA (no liability), UNLM (unlimited), NONE. Empty = all.

## `subClasses` (type: `array`):

Optional. ASIC sub class codes, e.g. LIST (listed public company), ULST (unlisted public company), PROP (proprietary other), PSTC (proprietary superannuation trustee company), PNPC (proprietary non-profit), HUNT (home unit company), NLTD, ULSN, ULSS, LISN, LISS, EXPT, NEXT, PUBF, RACA, RACO, STFI, NONE. Empty = all.

## `previousStates` (type: `array`):

Optional. NSW, VIC, QLD, SA, WA, TAS, ACT, NT (or the full names). This is the state in which an older company was originally registered (before national registration in 1991); newer companies have none, and the dataset has no registered office address.

## `onlyChangedThisWeek` (type: `boolean`):

Only companies whose name, type, class, sub class or status changed (or that are new) since the previous weekly extract — ASIC's "Modified since last report" flag. Combine with Statuses = EXAD to get this week's companies entering external administration.

## `includeFormerNameMatches` (type: `boolean`):

When a keyword matches only a former name of a company, still return the company (matchedBy = formerName). Turn off to match current names only.

## `maxItems` (type: `integer`):

Maximum companies to return (1..100000). Companies come newest first (highest ACN first). When you list ACNs/ABNs it is raised to cover the list. You are charged per company.

## `maxApiRequests` (type: `integer`):

Hard budget of requests to the data.gov.au API for the whole run (1..500). Requests go one at a time at least 2 seconds apart; one request returns up to 1,000 name records (100 numbers per request for ACN/ABN lists). If the budget runs out the run still succeeds with what it found (complete=false in RUN_SUMMARY).

## `proxyConfiguration` (type: `object`):

Optional and normally not needed: the data.gov.au API answers Apify datacenter IPs. If set, one sticky session is used for the whole run (never rotation).

## Actor input object example

```json
{
  "mode": "recent",
  "companyNames": [],
  "acns": [],
  "abns": [],
  "dateField": "registered",
  "lastDays": 7,
  "dateFrom": "",
  "dateTo": "",
  "statuses": [],
  "types": [],
  "classes": [],
  "subClasses": [],
  "previousStates": [],
  "onlyChangedThisWeek": false,
  "includeFormerNameMatches": true,
  "maxItems": 100,
  "maxApiRequests": 30,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `records` (type: `string`):

One row per company from ASIC's Company Dataset (data.gov.au), with the CC BY 3.0 AU attribution (source, sourceUrl, license, retrievedAt) on every item.

# 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 = {
    "mode": "recent",
    "companyNames": [],
    "acns": [],
    "abns": [],
    "dateField": "registered",
    "lastDays": 7,
    "dateFrom": "",
    "dateTo": "",
    "statuses": [],
    "types": [],
    "classes": [],
    "subClasses": [],
    "previousStates": [],
    "onlyChangedThisWeek": false,
    "includeFormerNameMatches": true,
    "maxItems": 100,
    "maxApiRequests": 30,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("jpopendata/au-asic-companies").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 = {
    "mode": "recent",
    "companyNames": [],
    "acns": [],
    "abns": [],
    "dateField": "registered",
    "lastDays": 7,
    "dateFrom": "",
    "dateTo": "",
    "statuses": [],
    "types": [],
    "classes": [],
    "subClasses": [],
    "previousStates": [],
    "onlyChangedThisWeek": False,
    "includeFormerNameMatches": True,
    "maxItems": 100,
    "maxApiRequests": 30,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("jpopendata/au-asic-companies").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "mode": "recent",
  "companyNames": [],
  "acns": [],
  "abns": [],
  "dateField": "registered",
  "lastDays": 7,
  "dateFrom": "",
  "dateTo": "",
  "statuses": [],
  "types": [],
  "classes": [],
  "subClasses": [],
  "previousStates": [],
  "onlyChangedThisWeek": false,
  "includeFormerNameMatches": true,
  "maxItems": 100,
  "maxApiRequests": 30,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call jpopendata/au-asic-companies --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,jpopendata/au-asic-companies"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/9iNfNaPtFMbHokDTZ/builds/he9rFoue2I8TRcMgS/openapi.json