# ASIC Bulk Company Register (Australia) (`knotty_mistveil/asic-company-register`) Actor

Australian companies from ASIC's official Company Register open data (data.gov.au): ACN, ABN, status, type, registration date. Not a scrape of paid ASIC Connect

- **URL**: https://apify.com/knotty_mistveil/asic-company-register.md
- **Developed by:** [Jason](https://apify.com/knotty_mistveil) (community)
- **Categories:** Business, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$1.00 / 1,000 company returneds

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 Bulk Company Register (Australia)

Every company on Australia's official corporate register, straight from ASIC's (Australian Securities and Investments Commission) own bulk open-data extract on data.gov.au - not a scrape of the paid, CAPTCHA-protected ASIC Connect search. The Actor streams the ~400 MB national file (verified 2026-09-21: 399,800,168 bytes / 4,010,895 companies), resolves each company's current name from ASIC's own former-name/current-name rows, and delivers clean, flat JSON with the ACN, ABN, type, status, registration date and full name history - filtered by registration date, status, company type, previous state of registration and name keywords.

### What you get

One record per company (`id` = ACN):

| Field | Description |
| --- | --- |
| `id` | ACN (Australian Company Number), also `acn` |
| `source` | Always `data.gov.au/asic` |
| `url` | The dataset page (`https://data.gov.au/data/dataset/asic-companies`) - ASIC does not publish a stable per-company URL in this open file; see "Data source and licence" |
| `fetchedAt` | ISO timestamp of the run |
| `companyName` | Current registered name, resolved from ASIC's name-history rows (see below) |
| `acn` | 9-digit Australian Company Number (an ARBN when `type` is `RACN`, per ASIC's own data dictionary) |
| `type` / `typeDescription` | Raw ASIC code (`APTY`, `APUB`, `FNOS`, `RACN`, `CCIV`) and its decoded label |
| `class` / `classDescription` | Liability class code and label (e.g. `LMSH` = Limited by shares) |
| `subClass` / `subClassDescription` | Sub-class code and label (e.g. `PROP` = Proprietary company, other) |
| `status` / `statusDescription` | Status code and label (e.g. `REGD` = Registered, `DRGD` = Deregistered) |
| `dateOfRegistration` | ISO date |
| `dateOfDeregistration` | ISO date, or `null` while still registered (published by ASIC since 11 March 2025) |
| `previousStateOfRegistration` | State the company was first registered in before the national scheme, e.g. `NSW` - populated for ~5% of companies (see "Limits and freshness") |
| `stateRegistrationNumber` | That state's own registration number, where applicable |
| `modifiedSinceLastReport` | `true` when ASIC's record changed since the previous weekly file |
| `abn` | Australian Business Number, or `null` when the company has none (ASIC publishes `0`; the Actor converts it) |
| `formerNames` | Earlier names on record (array), in ASIC's own row order - not guaranteed chronological. Empty if never renamed |
| `currentNameStartDate` | ISO date the current name took effect, or `null` if never renamed |
| `datasetLastModified` | Last-modified timestamp of the source file at fetch time |

### Input

| Input | Type | Default | Description |
| --- | --- | --- | --- |
| `allDates` | boolean | `true` | The file is **not** sorted by registration date (verified 2026-09-21), so any date filter forces a full scan of the ~400 MB file. Default `true` keeps the Store "Try it" run cheap: it reads from the start of the file and stops as soon as `maxItems` companies match. Set to `false`, or supply `dateFrom`/`dateTo` (either does this automatically), to filter by date. |
| `daysBack` | integer | `7` | Used only when the date filter is active. The file refreshes weekly, so a narrow window can land almost entirely after the newest data - see "Limits and freshness". |
| `dateFrom` | string | - | Earliest `Date of Registration`, `YYYY-MM-DD`. Setting this (or `dateTo`) switches the date filter on. Overrides `daysBack`. |
| `dateTo` | string | today | Latest `Date of Registration`, `YYYY-MM-DD`. |
| `statuses` | array | `["REGD"]` | ASIC status codes to keep (see the legend above). Empty list = every status, including deregistered and struck-off companies. |
| `types` | array | `[]` | ASIC type codes to keep (`APTY`, `APUB`, `FNOS`, `RACN`, `CCIV`). Empty = all (99.0% of the register is `APTY`). |
| `previousStates` | array | `[]` | Filter on `previousStateOfRegistration`. Honestly, this only ever matches ~5% of companies - those first registered under a state's own corporate law before the 1990s national scheme; every company registered since then has this field empty, so it does not usefully narrow a "recent companies" search. |
| `keywords` | array | `[]` | Case-insensitive substrings; a company is kept when its current name contains any of them (OR). |
| `maxItems` | integer | `500` | Stop after this many companies (you are charged per result). Kept at the standard default because the *cost* is capped by `maxItems` regardless of file size - the compute *time* is a separate, documented trade-off (see "Limits and freshness"). |

Default input (cheapest possible run - no date filter, currently-registered companies, first 500 found from the start of the file):

```json
{ "allDates": true, "statuses": ["REGD"], "maxItems": 500 }
```

Companies newly registered in the last 30 days in mining/finance-adjacent names (accepts the full-scan cost):

```json
{ "allDates": false, "daysBack": 30, "keywords": ["mining", "resources", "capital"], "maxItems": 2000 }
```

Every foreign company on the register, regardless of status:

```json
{ "allDates": true, "types": ["FNOS"], "statuses": [], "maxItems": 5000 }
```

### Output example

A real record from the 2026-09-14 file (run 2026-09-21, `keywords: ["nippon life"]`, `statuses: []`) - a company renamed three times:

```json
{
  "id": "000000402",
  "source": "data.gov.au/asic",
  "url": "https://data.gov.au/data/dataset/asic-companies",
  "fetchedAt": "2026-09-21T03:01:04.146Z",
  "companyName": "NIPPON LIFE INSURANCE AUSTRALIA AND NEW ZEALAND LIMITED",
  "acn": "000000402",
  "type": "APUB",
  "typeDescription": "Australian public company",
  "class": "LMSH",
  "classDescription": "Limited by shares",
  "subClass": "ULST",
  "subClassDescription": "Unlisted public company",
  "status": "REGD",
  "statusDescription": "Registered",
  "dateOfRegistration": "1886-12-31",
  "dateOfDeregistration": null,
  "previousStateOfRegistration": "NSW",
  "stateRegistrationNumber": "00020825",
  "modifiedSinceLastReport": false,
  "abn": "90000000402",
  "formerNames": ["MLC LIFE LTD", "MLC LIMITED", "THE MUTUAL LIFE & CITIZENS' ASSURANCE CO LTD"],
  "currentNameStartDate": "2025-09-26",
  "datasetLastModified": "2026-09-14T14:53:34.014830"
}
```

### Pricing

Pay per result: **US$0.001 per company returned**, i.e. **US$1 per 1,000 companies**. Nothing is charged for a run that returns no companies (verified: every edge-case run below with zero matches logged `pushed: 0` and no charge attempt). Apify platform usage (compute, storage) is billed separately by Apify; the free plan limits how much compute a run may use, so a full-file scan (see below) may need a paid plan for very large `maxItems` values.

### Data source and licence

- Source: "ASIC - Company Dataset", published by the Australian Securities and Investments Commission on data.gov.au: <https://data.gov.au/data/dataset/asic-companies>. The Actor resolves the current CSV resource at run time via the CKAN `package_show` API rather than hard-coding a filename, because the published file is renamed every week (e.g. `company_202609.csv`); verified 2026-09-21 that the resource id itself (`5c3914e6-...`) stays stable across weekly refreshes.
- Format: despite the `.csv` extension the file is **TAB-delimited** with a UTF-8 BOM (confirmed directly against ASIC's own "Company Dataset - Help File", 11/07/2025, and against a live download). No comma-CSV quoting is used or needed.
- Licence: **Creative Commons Attribution 3.0 Australia** (CC BY 3.0 AU), <http://creativecommons.org/licenses/by/3.0/au/>, read directly from the dataset page's licence badge and schema markup on 2026-09-21. This permits commercial reuse with attribution. Suggested credit: "Source: ASIC (Australian Securities and Investments Commission) via data.gov.au, licensed under CC BY 3.0 AU."
- Not a scrape: several competing Store listings scrape ASIC Connect (ASIC's own paid, login/CAPTCHA-gated search service - "Accessing some information may attract a fee", per ASIC's help file). This Actor only reads ASIC's own bulk open-data extract; no login, no CAPTCHA, no paid ASIC Connect calls.
- Personal data: this file lists **companies**, not individuals or sole traders (sole traders/partnerships are on ASIC's separate Business Names register, not covered here). Checked the full `Type` legend against 4,445,221 live rows (2026-09-21): the only values are `APTY`, `APUB`, `FNOS`, `RACN` and `CCIV`, all body-corporate types - none represent an individual. A company's registered name can occasionally itself be a person's name (e.g. a namesake proprietary company), but no personal address or contact field is published in this dataset.

### Limits and freshness

- **Size and volume** (measured 2026-09-21 against the live file): 399,800,168 bytes (399.8 MB / 381.3 MiB), last modified by ASIC 2026-09-14. 4,445,221 data rows resolve to **4,010,895 companies** after dedup. 332,447 companies (8.3%) have been renamed at least once (up to 14 names for the most-renamed company found); the rest (3,678,448) have a single row.
- **Former-name dedup**: ASIC publishes one row per historical name plus one row for the current name, marked `Current Name Indicator = Y`. The Actor keeps exactly one output record per ACN: the `Y`-marked row when present, or (10 companies out of 4,010,895, 0.0002%, all found in a full scan) the true current name recovered from the `Current Name` column that ASIC still publishes on every historical row when no row is explicitly marked `Y` - verified against the live file rather than assumed. Every company's rows are contiguous in the file (verified by comparing a full row-by-row grouping against a full-file distinct-ACN count: both equal 4,010,895), so streaming needs only a tiny per-company buffer, never the whole file.
- **Not sorted by date**: registration dates are not monotonic through the file (measured: 66,486 date decreases across a 2.3M-row slice) - only loosely correlated with ACN order. A date-filtered run must therefore scan the whole file. Measured full-scan times on this machine, 2026-09-21 (no matches, so no early exit): **11.2s, 12.6s and 12.7s** across three runs, peaking at ~130 MB RSS. An **unfiltered** run (default `allDates: true`) instead stops as soon as `maxItems` matches are found from the start of the file - measured at 0.1-0.9 seconds for `maxItems` 2-500.
- **Weekly refresh, narrow-window risk**: the file is republished every Tuesday per ASIC's help file (this copy: Monday 2026-09-14). A `daysBack: 7` run executed on 2026-09-21 - i.e. right before the historically-typical refresh - matched **zero** companies in a real full-scan test, because the file's newest data (14 Sep) barely overlapped the 7-day lookback window measured from the run date (21 Sep). Widen `daysBack`, set an explicit `dateFrom`, or use `allDates: true` if a narrow window returns nothing.
- **Default run bias**: because the file is grouped by ACN (roughly, but not exactly, oldest-first) rather than by date, the default unfiltered run's first matches skew toward long-established companies (some over a century old) rather than recent registrations. Use a date filter (accepting the full-scan cost above) to get recent registrations specifically.
- **Status mix** (deduped company counts, 2026-09-21): REGD 3,721,706 (92.8%), DRGD 209,828 (5.2%), SOFF 46,789 (1.2%), EXAD 32,237 (0.8%), NOAC 295, CNCL 39, DISS 1.
- **ABN coverage**: 1,631,200 companies (40.7%) have no ABN on record (ASIC publishes `0`; returned here as `null`).
- No documented rate limit: this is a single static file download, not a paginated API. `fetchWithRetry` retries transient network errors and 5xx/429s with backoff.

### Use cases

- New-company lead lists: recently registered companies (accept the full-scan cost) filtered by name keyword or company type, for sales prospecting or supplier onboarding.
- KYC and compliance checks: confirm an ACN's status, registration date, ABN and full name history before dealing with a counterparty.
- Market and competitor research: track foreign company registrations (`types: ["FNOS"]`) or deregistrations/strike-offs (`statuses: ["DRGD","SOFF"]`) over time.

### Support

Open an issue on the Actor's Issues tab on Apify Store; replies within 14 days. Please include your run ID and input.

# Actor input Schema

## `allDates` (type: `boolean`):

Default true. The ~400 MB national file is NOT sorted by registration date, so applying any date filter forces a full streamed scan of the whole file (see 'Limits and freshness' in the README for measured timing). Leaving this ticked keeps the default 'Try it' run cheap: it reads from the start of the file and stops as soon as 'Max results' matching companies are found. Untick it, or set 'Registered from' / 'Registered to' / 'Days back' (any of which also switches this off automatically), to filter by registration date at the cost of the full scan.

## `daysBack` (type: `integer`):

Used only when the date filter is active (see 'All dates'). Keep companies registered within this many days before today (or before 'Registered to'). The file refreshes weekly, so a narrow window can land almost entirely after the newest data depending on when in the week you run - widen it or set an explicit range if you get zero results.

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

Earliest registration date to include (inclusive). Setting this (or 'Registered to') switches the date filter on regardless of 'All dates'. Overrides 'Days back'. The register holds companies registered as far back as the 1800s.

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

Latest registration date to include (inclusive). Defaults to today.

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

Exact ASIC status codes to keep. Default REGD (currently registered) only - the register also lists deregistered/administration companies (see the README for the full legend). Empty list = every status.

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

ASIC 'Type' codes to keep. Empty = all types. 99% of the register is APTY (Australian proprietary company).

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

Keep only companies whose 'Previous State of Registration' matches one of these. This field is populated almost exclusively for companies first registered under a State corporate law BEFORE the national Corporations Law scheme (pre-1990s) - about 5% of all companies; every company registered since then has this field empty, so filtering on it does not usefully narrow a 'newly registered' search. Empty list = no filter (default).

## `keywords` (type: `array`):

Case-insensitive substrings; a company is kept when its current name contains any of them (OR). Empty = no name filter.

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

Stop after this many companies. You are charged per result returned. The full register holds about 4 million companies in one ~400 MB file; 500 keeps the default run's cost capped at US$0.50 regardless of how much of the file has to be scanned.

## Actor input object example

```json
{
  "allDates": true,
  "daysBack": 7,
  "statuses": [
    "REGD"
  ],
  "types": [],
  "previousStates": [],
  "keywords": [],
  "maxItems": 100
}
```

# Actor output Schema

## `results` (type: `string`):

All records returned by the run, one JSON object each. Append ?format=csv or ?format=xlsx to download a spreadsheet.

## `summary` (type: `string`):

Counts, the date window used, source freshness and any per-source warnings, written at the end of the run.

# 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 = {
    "allDates": true,
    "daysBack": 7,
    "statuses": [
        "REGD"
    ],
    "types": [],
    "previousStates": [],
    "keywords": [],
    "maxItems": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("knotty_mistveil/asic-company-register").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 = {
    "allDates": True,
    "daysBack": 7,
    "statuses": ["REGD"],
    "types": [],
    "previousStates": [],
    "keywords": [],
    "maxItems": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("knotty_mistveil/asic-company-register").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 '{
  "allDates": true,
  "daysBack": 7,
  "statuses": [
    "REGD"
  ],
  "types": [],
  "previousStates": [],
  "keywords": [],
  "maxItems": 100
}' |
apify call knotty_mistveil/asic-company-register --silent --output-dataset

```

## MCP server setup

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

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/DZyfltJwFX6aJrB4v/builds/92xMs4Uqblz1scrHq/openapi.json