# Australian Financial Advisers Register Search (ASIC FAR) (`scrapeworks/australian-financial-advisers-register`) Actor

Bulk-search the official ASIC Financial Advisers Register (88,000+ records) by adviser name, adviser number, AFS licence number or ABN, or sweep current advisers by state. Status, AFSL licensee, qualifications and advice areas as clean JSON. Free government data, no API key.

- **URL**: https://apify.com/scrapeworks/australian-financial-advisers-register.md
- **Developed by:** [Nicolas van Arkens](https://apify.com/scrapeworks) (community)
- **Categories:** Lead generation, Business, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $6.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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use 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

## Australian Financial Advisers Register Search (ASIC FAR Lookup)

Search the **official ASIC Financial Advisers Register** in bulk — **88,000+
adviser records** covering every person authorised to give personal financial
advice to retail clients in Australia. Search by **adviser name**, **adviser
number**, **AFS licence number** or **ABN**, filter to **current advisers by
state**, and get clean, structured JSON. No API key, no login, no fragile page
scraping: this actor reads the government open-data feed on **data.gov.au**
directly.

Give it a list of searches and it paginates the register for each one — or give
it **no searches at all** and sweep the whole register with filters (e.g. every
current adviser in NSW), pulling thousands of records in a single run.

### What you can do with it

- **Adviser verification (compliance / AML-KYC)** — confirm a person is a
  currently authorised financial adviser, which AFSL they operate under, and
  whether their registration has ceased.
- **Lead lists of advisers and licensees** — every current adviser in a state,
  with suburb/postcode, licensee (AFSL), qualifications and memberships.
- **Recruitment & market mapping** — find advisers by qualification, designation
  (CFP, CA, CPA) or professional body membership; map who controls which licence.
- **Licensee due diligence** — list all advisers appointed under a given AFS
  licence number or licensee ABN, past and present.
- **Advice-capability screening** — each row decodes what the adviser can advise
  on: superannuation, SMSFs, securities, derivatives, life products, margin
  lending and more, plus whether they can provide tax (financial) advice.

### Data fields you get

| Field | Description |
|---|---|
| `adviserName` | The adviser's full name as registered |
| `adviserNumber` | The adviser's unique ASIC register number |
| `role` / `subType` | Register role (e.g. Financial Adviser, Time-share Adviser) |
| `roleStatus` | `Current` (authorised now) or `Ceased` |
| `overallRegistrationStatus` | `Registered` / `Not Registered` under the adviser-registration requirement |
| `firstProvidedAdvice` | Year the adviser first provided advice |
| `startDate` / `endDate` | When this authorisation started / ended (DD/MM/YYYY) |
| `licenceName` / `licenceNumber` / `licenceAbn` | The AFS licensee the adviser operates under |
| `licenceControlledBy` | Who controls the licensee, when recorded |
| `appointedBy` / `appointedByNumber` / `appointedByAbn` | The authorised representative that appointed the adviser |
| `suburb` / `state` / `postcode` / `country` | The adviser's registered business address locality |
| `canProvideTaxAdvice` | `true` if registered to provide tax (financial) advice services |
| `adviceAreas` | Plain-language list of what they may advise on (e.g. `Superannuation`, `Securities`, `Self-managed superannuation funds`) |
| `adviceAreaCodes` | The raw register flag codes behind `adviceAreas` |
| `qualifications` | List of qualifications and training on record |
| `memberships` | Professional body memberships (e.g. CA ANZ, FAAA) |
| `cpdFailureYear` | Year of any recorded CPD (continuing professional development) failure |
| `furtherRestrictions` | Any further restrictions noted on the register |
| `licenceAbnLookupUrl` | Deep link to the official ABN Lookup page for the licensee |
| `matchType` | `name`, `number`, `abn` or `sweep` — how this row was matched |
| `query` | The input search that produced this row |

### Input

`queries` is a list. A **number up to 9 digits** is treated as an **adviser
number or AFS licence number** (zero-padded automatically), an **11-digit
number** as an **ABN**. Anything else runs a **full-text search** (adviser
names, licensee names, suburbs, qualifications). Leave `queries` **empty** to
sweep the whole register using only the filters.

```json
{
    "queries": ["SMITH", "000221137", "25005620824"],
    "maxResultsPerQuery": 100,
    "statusFilter": "Current",
    "stateFilter": "NSW"
}
````

- **`queries`** — names, adviser/licence numbers and/or ABNs. Each is searched separately. Empty = filtered sweep of the full register.
- **`maxResultsPerQuery`** — cap on rows per search (1–10000). The actor paginates automatically.
- **`statusFilter`** — `all`, `Current` (active advisers only), or `Ceased` only.
- **`stateFilter`** — `all` or one of `NSW, VIC, QLD, WA, SA, TAS, ACT, NT`.

### Output sample

Each result is one row in the dataset:

```json
{
    "query": "SMITH",
    "matchType": "name",
    "adviserName": "FRANK MATTHEW SMITH",
    "adviserNumber": "000299549",
    "role": "Financial Adviser",
    "subType": "Financial Adviser",
    "roleStatus": "Current",
    "firstProvidedAdvice": "1995",
    "startDate": "15/03/2006",
    "endDate": null,
    "licenceName": "SMITH COFFEY PTY LTD",
    "licenceNumber": "000237972",
    "overallRegistrationStatus": "Registered",
    "suburb": "Subiaco",
    "state": "WA",
    "postcode": "6008",
    "country": "Australia",
    "canProvideTaxAdvice": true,
    "adviceAreas": ["Life products - investment life insurance", "Life products - life risk insurance", "Superannuation", "Securities"],
    "qualifications": ["1993 - Bachelor of Commerce - Degree - University of Western Australia"],
    "memberships": ["Chartered Accountants Australia and New Zealand (CA ANZ)"],
    "cpdFailureYear": null,
    "licenceAbnLookupUrl": null
}
```

### Pricing

Pay per result — you are billed only for each adviser record returned. Searches
that return no matches are **not** charged.

### FAQ

**Where does the data come from?** The ASIC Financial Advisers Dataset published
as open data on data.gov.au (the Australian Government open-data portal),
licensed Creative Commons Attribution 3.0 Australia. ASIC refreshes it
regularly; it is the same data behind the Moneysmart Financial Advisers
Register.

**Does it include ceased advisers?** Yes — the register keeps historical
records. Use `statusFilter: "Current"` to get only advisers authorised today.

**Can I get all advisers under one licensee?** Yes — search the AFS licence
number (e.g. `237972`) or the licensee's 11-digit ABN and you get every adviser
record linked to it.

**Do I need an API key or login?** No. This source is fully public.

**Is this the company register?** No — this is the **people** register
(financial advisers). For companies and business names, see the companion
actors *Australian Company Register Search* and *Australian Business Register
Search*.

# Actor input Schema

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

One entry per search. A plain keyword runs a full-text search over the register - adviser names, licensee (AFSL) names, suburbs, qualifications (e.g. 'SMITH', 'MACQUARIE', 'CFP'). A number up to 9 digits is treated as an adviser number or AFS licence number (zero-padded automatically, e.g. '221137'). An 11-digit number is treated as an ABN. Add as many as you like - each is searched and paginated independently. LEAVE EMPTY to sweep the whole register using only the status/state filters below (e.g. every Current adviser in NSW).

## `maxResultsPerQuery` (type: `integer`):

Maximum number of adviser records to return for EACH search above (or for the whole filtered sweep when no searches are given). The actor paginates the register automatically until it reaches this number or runs out of matches. Range 1-10000. Higher = more rows = higher cost (you are billed per result row).

## `statusFilter` (type: `string`):

Limit results by adviser role status. 'all' returns everything; 'Current' returns only advisers currently authorised to give advice; 'Ceased' returns only advisers whose authorisation has ended.

## `stateFilter` (type: `string`):

Limit results to advisers whose registered address is in one Australian state or territory. 'all' does not filter. Note: many Ceased advisers have no address on record, so state filtering works best together with 'Current' status.

## Actor input object example

```json
{
  "queries": [
    "SMITH",
    "MACQUARIE",
    "221137",
    "25005620824"
  ],
  "maxResultsPerQuery": 100,
  "statusFilter": "all",
  "stateFilter": "all"
}
```

# 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": [
        "SMITH",
        "000221137"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapeworks/australian-financial-advisers-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 = { "queries": [
        "SMITH",
        "000221137",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("scrapeworks/australian-financial-advisers-register").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": [
    "SMITH",
    "000221137"
  ]
}' |
apify call scrapeworks/australian-financial-advisers-register --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=scrapeworks/australian-financial-advisers-register",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Australian Financial Advisers Register Search (ASIC FAR)",
        "description": "Bulk-search the official ASIC Financial Advisers Register (88,000+ records) by adviser name, adviser number, AFS licence number or ABN, or sweep current advisers by state. Status, AFSL licensee, qualifications and advice areas as clean JSON. Free government data, no API key.",
        "version": "0.1",
        "x-build-id": "4w7bxNbSLh9HQbjaL"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapeworks~australian-financial-advisers-register/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapeworks-australian-financial-advisers-register",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/scrapeworks~australian-financial-advisers-register/runs": {
            "post": {
                "operationId": "runs-sync-scrapeworks-australian-financial-advisers-register",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/scrapeworks~australian-financial-advisers-register/run-sync": {
            "post": {
                "operationId": "run-sync-scrapeworks-australian-financial-advisers-register",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "queries": {
                        "title": "Searches (adviser names, adviser/licence numbers, ABNs)",
                        "type": "array",
                        "description": "One entry per search. A plain keyword runs a full-text search over the register - adviser names, licensee (AFSL) names, suburbs, qualifications (e.g. 'SMITH', 'MACQUARIE', 'CFP'). A number up to 9 digits is treated as an adviser number or AFS licence number (zero-padded automatically, e.g. '221137'). An 11-digit number is treated as an ABN. Add as many as you like - each is searched and paginated independently. LEAVE EMPTY to sweep the whole register using only the status/state filters below (e.g. every Current adviser in NSW).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResultsPerQuery": {
                        "title": "Max results per search",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of adviser records to return for EACH search above (or for the whole filtered sweep when no searches are given). The actor paginates the register automatically until it reaches this number or runs out of matches. Range 1-10000. Higher = more rows = higher cost (you are billed per result row).",
                        "default": 100
                    },
                    "statusFilter": {
                        "title": "Adviser status",
                        "enum": [
                            "all",
                            "Current",
                            "Ceased"
                        ],
                        "type": "string",
                        "description": "Limit results by adviser role status. 'all' returns everything; 'Current' returns only advisers currently authorised to give advice; 'Ceased' returns only advisers whose authorisation has ended.",
                        "default": "all"
                    },
                    "stateFilter": {
                        "title": "State / territory",
                        "enum": [
                            "all",
                            "NSW",
                            "VIC",
                            "QLD",
                            "WA",
                            "SA",
                            "TAS",
                            "ACT",
                            "NT"
                        ],
                        "type": "string",
                        "description": "Limit results to advisers whose registered address is in one Australian state or territory. 'all' does not filter. Note: many Ceased advisers have no address on record, so state filtering works best together with 'Current' status.",
                        "default": "all"
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
