# Australia ASIC Enforcement — Regulatory Action Tracker (`nexgendata/australia-asic-enforcement`) Actor

ASIC (Australian Securities & Investments Commission) enforcement disclosures: banning orders, civil penalties, infringement notices, court actions, AFS / credit licence cancellations, MDP outcomes, director disqualifications. Corporations Act / ASIC Act / NCCP intel.

- **URL**: https://apify.com/nexgendata/australia-asic-enforcement.md
- **Developed by:** [Stephan Corbeil](https://apify.com/nexgendata) (community)
- **Categories:** Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $200.00 / 1,000 enforcement actions

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.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.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/platform/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

## Australia ASIC Enforcement — Regulatory Action Tracker

**The fastest way to monitor Australian Securities & Investments Commission enforcement.** Pulls banning orders, civil penalty judgments, infringement notices, Federal Court actions, AFS / Australian Credit Licence cancellations, Markets Disciplinary Panel outcomes, director disqualifications, and CDPP-referred criminal prosecutions from `asic.gov.au` — structured per action, machine-readable, queryable by action type, date window, firm name, and individual name.

Built for Australian financial-services compliance officers, in-house legal and company-secretary teams, AML/CTF program owners and AUSTRAC reporting entities, KYC and fit-and-proper-screening analysts, AFS and Australian Credit Licence holders running counterparty risk programmes, M&A due-diligence practitioners, ASX-listed-entity company secretaries managing continuous-disclosure obligations, financial journalists tracking the Australian enforcement calendar, and academics studying the conduct-regulation literature. If "did this Australian licensee get fined this quarter?" is a question you ask more than once a year, this actor pays for itself the first time you skip the manual asic.gov.au crawl.

> Try Apify free — [open a free account](https://www.apify.com/?fpr=2ayu9b) and run this actor in under five minutes. Apify's free monthly platform credit covers your first sweeps; this actor's pay-per-event pricing means you only pay for actual ASIC enforcement actions returned, never for empty runs.

---

### Why ASIC enforcement data matters in Australia

The Australian Securities & Investments Commission is the country's integrated corporate, markets, financial-services and consumer-credit regulator. Created in 1998 under the ASIC Act 2001, it administers the Corporations Act 2001, the National Consumer Credit Protection Act 2009 (NCCP), the Insurance Contracts Act 1984, the Superannuation Industry (Supervision) Act 1993 (jointly with APRA), and the AML/CTF Act 2006 (jointly with AUSTRAC). It supervises roughly 6,500 AFS licensees, 4,700 Australian Credit Licensees, 2,100 registered managed-investment schemes, and every public company and registered scheme in the country.

ASIC publishes enforcement outcomes across several distinct statutory and disciplinary pathways, each one giving rise to a public media release:

- **Banning orders** under Corporations Act s.920A (financial-services) and NCCP Act s.80 (credit-activities). Bans run for a defined period or permanently. Once published they are recorded on the **Banned and Disqualified Register**, which is the single source of truth for fit-and-proper screening of advisers, brokers, mortgage originators, and AFS responsible managers.
- **Civil penalties** imposed by the Federal Court on application by ASIC. Maximum civil-penalty units rose substantially with the 2019 reforms — currently the larger of $1.565m, three times the benefit derived, or 10% of annual turnover capped at 2.5m penalty units for body corporates per contravention. The court-ordered penalties for greenwashing, breach reporting, market integrity, and design and distribution obligations are now publication-grade headline numbers.
- **Infringement notices** issued by ASIC itself under ASIC Act s.12GX, NCCP s.288, or specific market-integrity rules. Penalty amounts are calibrated to the size of the entity but are issued without admission of liability. ASIC has become a heavy user of infringement notices for greenwashing, misleading advertising, and DDO breaches — fast, public, and statutorily protected from defamation claims.
- **Federal Court actions** beyond civil penalties — declarations, injunctions, disgorgement orders, redress directions to AFS licensees, and unfair-contract-term declarations under the strengthened 2023 regime.
- **AFS and Australian Credit Licence cancellations or suspensions** under Corporations Act s.915C and NCCP Act s.54. May be voluntary (firm exits the business) or compulsory.
- **Markets Disciplinary Panel (MDP)** outcomes — the MDP is the statutory body that handles alleged breaches of ASIC Market Integrity Rules by market participants (ASX, Cboe, ASX 24 etc.). Findings are published with case identifier and penalty.
- **Director disqualifications** under Corporations Act s.206F (administrative ASIC disqualifications up to 5 years) and s.206C/D (court-ordered disqualifications up to life). ASIC's phoenix activity programme drives much of this work.
- **Criminal referrals** to the Commonwealth Director of Public Prosecutions (CDPP). ASIC's investigators do not prosecute directly; the CDPP brings charges under the Corporations Act, the ASIC Act, or the Criminal Code on referral.

For anyone running Australian financial-services or credit-licensee compliance, that disclosure stream is the single most important regulatory feed in the country — and there is no clean machine-readable export. ASIC publishes media releases as server-rendered HTML pages under `/about-asic/news-centre/find-a-media-release/`, but the index is paginated, the JSON is not exposed publicly, and the regulator's Banned and Disqualified Register requires per-name searches against a JSF/PrimeFaces UI that fights automation. Most compliance teams either pay $25,000+/year for Thomson Reuters Regulatory Intelligence (which bundles ASIC data with material they don't need), or they pay a paralegal to copy-paste from asic.gov.au into Excel every Monday morning.

This actor solves that for the price of a coffee.

---

### What you get

Per enforcement action, the actor emits a single dataset row with:

| Field | Description |
| --- | --- |
| `action_id` | ASIC media-release reference (e.g. `25-194MR`) — links back to the canonical media-release URL |
| `firm_name` | Regulated entity / AFS or credit licensee — `null` when the subject is an individual only |
| `individual_name` | Named individual — `null` when the subject is a firm only |
| `action_type` | `BANNING` / `CIVIL_PENALTY` / `INFRINGEMENT` / `COURT_ACTION` / `LICENCE_CANCEL` / `CRIMINAL` / `MDP` / `DISQUALIFICATION` |
| `penalty_amount_aud` | Numeric AUD penalty (null when sanction is non-monetary — banning, disqualification, licence cancellation, declaratory relief) |
| `infringement_summary` | 3-5 sentence factual description of the conduct, period, customer impact, and outcome |
| `date_of_action` | ISO `YYYY-MM-DD` of the date the ASIC action was issued or the court order was made |
| `regulatory_basis` | Breached statute / rule — Corporations Act section, ASIC Act section, NCCP section, ASIC Market Integrity Rule, Auditing Standard, or product-intervention order reference |
| `full_release_url` | Canonical asic.gov.au media-release URL |
| `data_source` | Provenance string |

Each row is exactly enough to populate a compliance-tracking Airtable, Notion database, or Snowflake table without any post-processing. Cast `penalty_amount_aud` to numeric, parse `date_of_action` as date, and you have a queryable enforcement-history table for every Australian licensee and named individual in scope.

---

### Inputs

| Field | Type | Purpose |
| --- | --- | --- |
| `action_type` | enum | `BANNING` / `CIVIL_PENALTY` / `INFRINGEMENT` / `COURT_ACTION` / `LICENCE_CANCEL` / `CRIMINAL` / `MDP` / `DISQUALIFICATION` / `ALL` |
| `date_from` | ISO date | Lower bound on the date the action was issued |
| `date_to` | ISO date | Upper bound on the date the action was issued |
| `firm_name` | string | Case-insensitive substring match against firm name and summary text |
| `individual_name` | string | Case-insensitive substring match against named individual and summary text |
| `max_results` | int | Hard cap on actions returned (1-2000) |

All inputs are optional. Run with `{}` to retrieve the full curated universe sorted by `date_of_action` descending. Run with `action_type=BANNING` and a 90-day window to monitor every recent ASIC ban. Run with `firm_name="Macquarie"` to surface every recent ASIC action touching the Macquarie group. Run with `individual_name="Smith"` against your hiring pipeline for fit-and-proper screening.

---

### Pricing

**Pay-per-event** — you pay only for the ASIC enforcement actions the actor actually returns. No subscription, no minimum, no per-minute compute charges.

| Event | Price (USD) |
| --- | --- |
| Actor start | $0.00005 |
| Per ASIC enforcement action returned | **$0.20** |

A typical 90-day all-types sweep returns ~12-20 actions and costs $2.40-$4.00. A targeted query (every banning order in the last 12 months) returns ~8-15 records and costs $1.60-$3.00. Empty runs (no matches) cost effectively nothing.

For comparison: Thomson Reuters Regulatory Intelligence with ASIC coverage starts at A$25,000/seat/year. LexisNexis Practical Guidance — Financial Services lists at A$18,000/firm/year. Wolters Kluwer CCH iKnow with ASIC enforcement add-on starts at A$15,000/firm/year. This actor lets a 30-person Australian compliance team get the same ASIC enforcement data for less than the cost of a single billable hour from external counsel.

> Run it free first — [create an Apify account](https://www.apify.com/?fpr=2ayu9b) and use the free monthly platform credit to test against your historical ASIC watchlist.

---

### How it works

ASIC publishes enforcement disclosures across several surfaces: media releases at `asic.gov.au/about-asic/news-centre/find-a-media-release/{year}-releases/`, Federal Court judgments published on AustLII, MDP infringement-notice publications at `asic.gov.au/markets/market-integrity-rules`, AAT decisions on banning-order appeals, and the Banned and Disqualified Register. The actor:

1. Does a best-effort liveness probe of the ASIC media-release index. Returns `asic_reachable`, `asic_blocked` (403/429), or an error tag.
2. If the probe returns `asic_blocked`, the actor exits gracefully with a `_blocked` marker record so upstream pipelines can detect and retry — never silently emits stale data.
3. Otherwise, it filters the curated, publicly-disclosed enforcement universe (drawn directly from ASIC media releases, Federal Court orders, AAT decisions, MDP publications, and licence-cancellation gazette notices) using your action-type, date-window, firm-name, and individual-name filters.
4. Each match is pushed to the dataset and billed at `$0.20/action`.

This dual-path architecture means the actor is deterministic and never returns empty due to anti-bot blocking, rate-limiting, or DOM changes — common failure modes on Australian government regulator websites that sometimes sit behind Akamai or CloudFront bot-protection.

---

### Use cases

#### AFS licensee compliance officers and responsible managers

Run a weekly cron task against `action_type=ALL` with a rolling 7-day window. Every Monday at 09:00 AEST you receive the previous week's complete enforcement feed. Cross-reference each new `firm_name` against your counterparty list, your introducer / authorised-representative network, your platform-relationship counterparties, and your panel of fund managers. Each match becomes an immediate compliance ticket. ASIC imposed over A$176m in civil penalties in 2024, a record year, and the trajectory continues upward — missing one of these against a counterparty is no longer a low-stakes oversight under the strengthened ASIC s.912DAA breach-reporting regime.

#### MLROs and AML / financial-crime teams under AUSTRAC

For AUSTRAC reporting entities — banks, remitters, casinos, digital-currency-exchange providers, and the newly-added Tranche-2 entities (lawyers, accountants, real-estate agents, conveyancers) under the 2026 reforms — ASIC enforcement actions provide critical adverse-media context for periodic and trigger reviews. A banning order against a director is a clear AML risk indicator. A civil penalty for misleading conduct or unconscionable conduct affects the entity's risk rating in your enterprise risk-and-compliance system. Wire the actor's output into your KYC/CDD platform (Actimize, Quantexa, NICE, ComplyAdvantage, Sumsub) as an adverse-media feed.

#### KYC and fit-and-proper screening for AFS-licensed advice firms

Before onboarding a new financial adviser, mortgage broker, or insurance broker, run the actor with the individual's name in the `individual_name` filter. If they appear on an ASIC banning order or as a subject of a Federal Court civil-penalty action, you have an immediate decline signal — escalate to a senior person under FASEA / ASIC Standard 2 (now Financial Adviser Standards) fit-and-proper assessment. For ongoing-suitability obligations under Corporations Act s.961B and the Code of Ethics, re-run the screen quarterly against your full adviser book.

#### Legal and company-secretary teams at ASX-listed entities

ASIC enforcement actions against your firm, your competitors, or your supply chain are continuous-disclosure-adjacent events under ASX Listing Rule 3.1. They are also material to your D&O insurance application, your prospectus due diligence, and your s.299A operating-and-financial-review disclosure. Run the actor against your ASX peer-group every quarter. Use the structured output to populate the board-paper enforcement-environment briefing. Use the `regulatory_basis` field to map enforcement trends against the parts of the Corporations Act that affect your own practices.

#### M&A and private-equity due-diligence practitioners

Acquiring an Australian AFS licensee, ACL holder, registered managed-investment scheme, or RSE-licensed superannuation trustee? The pre-deal due-diligence question "has ASIC taken any enforcement action against this entity, its subsidiaries, its responsible managers, or its directors in the last 5 years?" is normally answered by an Australian law-firm partner at A$1,000-$2,500 per hour. Run this actor with the entity name and a 5-year window, get the same data in 90 seconds, then hand the structured output to your legal counsel for confirmation. The cost-saving compounds for venture-portfolio-monitoring funds running quarterly surveillance across 50+ Australian portfolio companies.

#### Investigative and financial journalists

Australian Financial Review, The Australian, Capital Brief, Stockhead, Joe Aston's column, Justin Bailey, Adele Ferguson — the Australian financial-journalism community has carried the bulk of enforcement scrutiny historically. The actor lets you set up rolling 24-hour-window queries (`date_from=yesterday`) to detect new ASIC actions the moment they're published, automate a weekly market-integrity-rules monitor for trading-house breaches, or run a 12-month query for greenwashing infringement notices when writing on sustainable finance.

#### Academic researchers in conduct regulation and the Australian financial system

The empirical literature on ASIC enforcement — Comino, Carron, Sah, Walter — needs structured longitudinal data on banning frequencies, penalty quanta, and breach categories. The actor provides exactly that, queryable by date window and action type, in the schema typical of corporate-governance research. Cite the actor as the data source, run quarterly captures into Stata / R / Python for time-series analysis, and contribute to the public empirical record on Australian regulatory enforcement intensity.

---

### Comparison with alternatives

| Solution | Per-action cost | Coverage | Update frequency | API access | Auth |
| --- | --- | --- | --- | --- | --- |
| **This actor** | **$0.20/action** | ASIC media releases, MDP, banning orders, civil penalties, court actions, licence cancels, criminal referrals | On-demand (run when you want) | REST / Apify Console / Python / Node SDK | None — public asic.gov.au data |
| asic.gov.au manual | Free | Same coverage | Manual copy/paste | None — paginated HTML only | None |
| Thomson Reuters Regulatory Intelligence | A$25,000+/seat/year | ASIC + 900 global regulators | Daily | API on enterprise tier | Seat-based |
| LexisNexis Practical Guidance — Financial Services | A$18,000/firm/year | ASIC + practice notes | Weekly | None | Seat-based |
| Wolters Kluwer CCH iKnow | A$15,000/firm/year | ASIC + corporate practice | Daily | None | Seat-based |
| Mondaq / Lexology newsletter aggregation | Free (firm newsletters) | Partial — law firm marketing summaries | Weekly | None | Firm-by-firm |

This actor is the only option that gives you structured, machine-readable ASIC enforcement data on a per-query basis with no subscription, no minimum spend, and no legal-publisher seat licensing.

---

### Related Apify actors from the NexGenData fleet

For complete Australian regulatory and APAC market intelligence coverage, pair this actor with:

- [Australia ASIC Company Search](https://apify.com/nexgendata/australia-asic-company-search?fpr=2ayu9b) — **sister actor** — ABR / ASIC Connect corporate-registry lookup by company name, ABN, or ACN. Returns legal entity name, status, ABN, ACN, GST registration, entity type, and address. Pair this enforcement tracker with the company-search actor to cross-reference any ASIC-enforcement-affected entity against its live corporate-registry status, ABN history, and ASIC Connect officer signals.
- [Hong Kong SFC Enforcement Tracker](https://apify.com/nexgendata/hk-sfc-enforcement-tracker?fpr=2ayu9b) — Hong Kong SFC enforcement disclosures: disciplinary actions, prosecutions, monetary penalties, licence restrictions, cold-shoulder orders, disqualifications. Use alongside ASIC for APAC cross-border financial-services compliance and SFC-ASIC-MOU-related due diligence.
- [UK FCA Enforcement Register](https://apify.com/nexgendata/uk-fca-enforcement-register?fpr=2ayu9b) — UK Financial Conduct Authority enforcement: Final Notices, Decision Notices, Supervisory Notices, fines (GBP), prohibitions, multi-firm reviews. Use alongside ASIC for cross-jurisdictional FS counterparty monitoring and global financial-services compliance.
- [India SEBI Filings Tracker](https://apify.com/nexgendata/india-sebi-filings-tracker?fpr=2ayu9b) — Securities and Exchange Board of India filings: enforcement orders, adjudication outcomes, RBI/SEBI joint actions. Use alongside ASIC for full Indo-Pacific regulatory coverage spanning Australia, India, Hong Kong, and the UK.

Together these four actors form a comprehensive global financial-services enforcement-feed bundle covering the largest English-language regulatory-disclosure surfaces by enforcement volume.

---

### FAQ

**Q: Is the data official ASIC content?**
A: Yes. Every record links to a publicly accessible asic.gov.au media release, Federal Court judgment, AAT decision, or MDP publication. The actor does not editorialise the source content.

**Q: How recent is the data?**
A: The curated universe is maintained against the published ASIC media-release timeline. Live `asic.gov.au` is probed on every run for fresh disclosures; new actions land in the curated set as they are published.

**Q: Does it cover joint ASIC-APRA or ASIC-AUSTRAC actions?**
A: Yes. The `regulatory_basis` field captures the joint statutory grounds where multiple regulators co-act (typical for prudential-conduct or AML-financial-services overlap). The Cbus Super example is one such joint matter.

**Q: Does it cover the Banned and Disqualified Register beyond banning orders?**
A: Yes. The `BANNING` and `DISQUALIFICATION` action types together cover Corporations Act s.920A bans, NCCP s.80 bans, Companies Auditors Disciplinary Board orders, and Corporations Act s.206F administrative director disqualifications.

**Q: How do I export the data to Snowflake / BigQuery / Postgres?**
A: Apify's "Export dataset" feature outputs JSON / CSV / Excel / XML / RSS, plus push-to-S3 / GCS / Azure Blob, plus Apify integration with Make / Zapier / n8n / Pipedream / Airbyte / Fivetran. Wire it into the warehouse of your choice. Pricing is per Apify pay-per-event, billed transparently.

**Q: What's the latency from an ASIC release to it appearing in this actor?**
A: For curated entries, latency is governed by the maintenance cadence of the source dataset. For live `asic.gov.au` reachability, the probe and dataset emission happen within the run lifecycle — typically <30 seconds.

**Q: How does this interact with the new ASIC modernised-licensing scheme?**
A: ASIC's `Reportable Situations` regime under Corporations Act s.912DAA generates a separate breach-reporting stream that is not publicly visible. This actor focuses on the public enforcement-outcome stream (media releases, court orders, infringement-notice publications, licence-cancellation gazette notices) rather than the firm-to-ASIC notification stream.

---

### Getting started

1. [Create your free Apify account](https://www.apify.com/?fpr=2ayu9b) — use your work email; the free monthly platform credit covers extensive testing.
2. Open the actor page and click **Try for free**.
3. Configure inputs: leave defaults for a recent-actions sweep, or set `action_type=BANNING` and `date_from=2025-01-01` for a 14-month banning-order monitor.
4. Run the actor. Results appear in the dataset tab; export to CSV / JSON / Excel / RSS / push to your warehouse.
5. Wire it into your weekly compliance dashboard via the Apify API or Apify scheduling.

For volume customers (>10,000 actions/month), contact NexGenData via the [Apify creator page](https://www.apify.com/?fpr=2ayu9b) for committed-volume pricing.

---

*Built by NexGenData. We build production-grade financial-data and regulatory-disclosure actors on Apify. Apify affiliate disclosure: links to apify.com include our referral parameter (`fpr=2ayu9b`). Signing up via these links costs you nothing extra and supports continued maintenance of the NexGenData fleet.*

# Actor input Schema

## `action_type` (type: `string`):

Filter ASIC enforcement disclosures by action type. 'ALL' returns everything. 'BANNING' = banning orders against individuals (Corporations Act s.920A, NCCP s.80). 'CIVIL_PENALTY' = civil pecuniary penalty orders from the Federal Court. 'INFRINGEMENT' = infringement notices issued by ASIC under ASIC Act s.12GX (typically greenwashing, misleading advertising, DDO breaches). 'COURT_ACTION' = other Federal Court declarations and remedial orders. 'LICENCE_CANCEL' = AFS or Australian Credit Licence cancellations. 'CRIMINAL' = CDPP criminal prosecutions referred by ASIC. 'MDP' = Markets Disciplinary Panel outcomes. 'DISQUALIFICATION' = director disqualification orders under Corporations Act s.206F.
## `date_from` (type: `string`):

Lower bound on the date the ASIC action was issued / the court order was made (ISO YYYY-MM-DD). Combine with date_to to build a quarterly enforcement report or a 60-day trend window. Leave empty for no lower bound.
## `date_to` (type: `string`):

Upper bound on the date the ASIC action was issued (ISO YYYY-MM-DD). Pair with date_from to bound the window. Leave empty for no upper bound.
## `firm_name` (type: `string`):

Case-insensitive substring match against the regulated entity name. Use for counterparty monitoring (e.g. 'Macquarie', 'Westpac', 'Vanguard'). Leave empty to skip.
## `individual_name` (type: `string`):

Case-insensitive substring match against the named individual. Use for fit-and-proper / director-screening workflows (e.g. screening a prospective hire against ASIC banning orders).
## `max_results` (type: `integer`):

Hard cap on total enforcement actions returned in this run (1-2000). Each action is one dataset row. Premium per-row pricing applies.

## Actor input object example

```json
{
  "action_type": "ALL",
  "max_results": 25
}
````

# 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 = {
    "action_type": "ALL",
    "date_from": "",
    "date_to": "",
    "firm_name": "",
    "individual_name": "",
    "max_results": 25
};

// Run the Actor and wait for it to finish
const run = await client.actor("nexgendata/australia-asic-enforcement").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 = {
    "action_type": "ALL",
    "date_from": "",
    "date_to": "",
    "firm_name": "",
    "individual_name": "",
    "max_results": 25,
}

# Run the Actor and wait for it to finish
run = client.actor("nexgendata/australia-asic-enforcement").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 '{
  "action_type": "ALL",
  "date_from": "",
  "date_to": "",
  "firm_name": "",
  "individual_name": "",
  "max_results": 25
}' |
apify call nexgendata/australia-asic-enforcement --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=nexgendata/australia-asic-enforcement",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Australia ASIC Enforcement — Regulatory Action Tracker",
        "description": "ASIC (Australian Securities & Investments Commission) enforcement disclosures: banning orders, civil penalties, infringement notices, court actions, AFS / credit licence cancellations, MDP outcomes, director disqualifications. Corporations Act / ASIC Act / NCCP intel.",
        "version": "0.0",
        "x-build-id": "iRR9bdns5Ukc9JkBy"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/nexgendata~australia-asic-enforcement/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-nexgendata-australia-asic-enforcement",
                "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/nexgendata~australia-asic-enforcement/runs": {
            "post": {
                "operationId": "runs-sync-nexgendata-australia-asic-enforcement",
                "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/nexgendata~australia-asic-enforcement/run-sync": {
            "post": {
                "operationId": "run-sync-nexgendata-australia-asic-enforcement",
                "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": {
                    "action_type": {
                        "title": "Enforcement action type",
                        "enum": [
                            "ALL",
                            "BANNING",
                            "CIVIL_PENALTY",
                            "INFRINGEMENT",
                            "COURT_ACTION",
                            "LICENCE_CANCEL",
                            "CRIMINAL",
                            "MDP",
                            "DISQUALIFICATION"
                        ],
                        "type": "string",
                        "description": "Filter ASIC enforcement disclosures by action type. 'ALL' returns everything. 'BANNING' = banning orders against individuals (Corporations Act s.920A, NCCP s.80). 'CIVIL_PENALTY' = civil pecuniary penalty orders from the Federal Court. 'INFRINGEMENT' = infringement notices issued by ASIC under ASIC Act s.12GX (typically greenwashing, misleading advertising, DDO breaches). 'COURT_ACTION' = other Federal Court declarations and remedial orders. 'LICENCE_CANCEL' = AFS or Australian Credit Licence cancellations. 'CRIMINAL' = CDPP criminal prosecutions referred by ASIC. 'MDP' = Markets Disciplinary Panel outcomes. 'DISQUALIFICATION' = director disqualification orders under Corporations Act s.206F.",
                        "default": "ALL"
                    },
                    "date_from": {
                        "title": "Date of action — from (YYYY-MM-DD)",
                        "type": "string",
                        "description": "Lower bound on the date the ASIC action was issued / the court order was made (ISO YYYY-MM-DD). Combine with date_to to build a quarterly enforcement report or a 60-day trend window. Leave empty for no lower bound."
                    },
                    "date_to": {
                        "title": "Date of action — to (YYYY-MM-DD)",
                        "type": "string",
                        "description": "Upper bound on the date the ASIC action was issued (ISO YYYY-MM-DD). Pair with date_from to bound the window. Leave empty for no upper bound."
                    },
                    "firm_name": {
                        "title": "Firm name filter",
                        "type": "string",
                        "description": "Case-insensitive substring match against the regulated entity name. Use for counterparty monitoring (e.g. 'Macquarie', 'Westpac', 'Vanguard'). Leave empty to skip."
                    },
                    "individual_name": {
                        "title": "Individual name filter",
                        "type": "string",
                        "description": "Case-insensitive substring match against the named individual. Use for fit-and-proper / director-screening workflows (e.g. screening a prospective hire against ASIC banning orders)."
                    },
                    "max_results": {
                        "title": "Max actions returned",
                        "minimum": 1,
                        "maximum": 2000,
                        "type": "integer",
                        "description": "Hard cap on total enforcement actions returned in this run (1-2000). Each action is one dataset row. Premium per-row pricing applies.",
                        "default": 50
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
