# Australia Open Data (data.gov.au) Scraper (`parseforge/australia-data-gov-au-scraper`) Actor

Export Australian government open datasets from data.gov.au. Browse 70k+ datasets across federal, state, and territory agencies. Pull dataset metadata, resources, organization, license, tags, and update frequency. Catalog mode lists all; dataset mode fetches one by ID.

- **URL**: https://apify.com/parseforge/australia-data-gov-au-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Business, Other, Education
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $15.00 / 1,000 result items

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 🦘 Australia Open Data (data.gov.au) Scraper

> 🚀 **Export the Australian open data catalog in seconds.** Pull **70,000+ datasets** spanning federal, state, and territory agencies, including AEMO power market data, transport feeds, environmental records, and census tables. No API key, no manual CSV stitching, no portal click-through.

> 🕒 **Last updated:** 2026-05-22 · **📊 13 fields** per record · **🦘 70,000+ datasets** · **🏛️ Federal + 8 states/territories** · **⚡ AEMO, ABS, BoM and more**

The **Australia Open Data Scraper** taps the official data.gov.au catalog and returns **13 structured fields per dataset**, including title, description, organization, license, resource files (CSV, GeoJSON, XLSX, ZIP, NetCDF), tags, and creation/modification timestamps. The portal aggregates publications from the Australian Bureau of Statistics, Australian Energy Market Operator, Bureau of Meteorology, Geoscience Australia, Department of Climate Change, and every state and territory government.

The catalog covers **federal datasets, all eight states and territories, and major statutory authorities**, with consistent licensing fields and downloadable resources. This Actor turns it into a clean dataset downloadable as CSV, Excel, JSON, or XML in under a minute. Filters and pagination run server-side, so you skip the parser engineering entirely.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| ANZ researchers, fintech analysts, climate scientists, civic-tech builders, GIS engineers, journalists, NGOs | Open-data discovery, energy market analysis, climate research, regional dataset inventory, license auditing, ML training data |

---

### 📋 What the Australia Open Data Scraper does

Two collection workflows in a single run:

- 🦘 **Catalog walk.** Paginate the full Australian dataset registry, optionally filtered by a search query.
- 🎯 **Single dataset fetch.** Retrieve one dataset by UUID or slug for targeted enrichment.
- 📁 **Resource expansion.** Every dataset includes its file resources with name, format, URL, language, size, and last-modified timestamp.
- 🏷️ **Tag merge.** All publication keywords consolidated into one clean list.
- 🏛️ **Organization attribution.** Publishing department, state agency, or statutory authority captured for every record.

Each record includes identifiers (UUID, slug), descriptive metadata (title, notes, tags), governance (organization, license, frequency), and a full list of downloadable resources.

> 💡 **Why it matters:** Australia's open data portal pools data from every level of government, but the portal UI is built for browsing one dataset at a time. This Actor turns it into a single downloadable spreadsheet so you can audit license terms, sort by recency, or build a research inventory in minutes.

---

### 🎬 Full Demo

_🚧 Coming soon: a 3-minute walkthrough showing how to go from sign-up to a downloaded dataset._

---

### ⚙️ Input

<table>
<thead>
<tr><th>Input</th><th>Type</th><th>Default</th><th>Behavior</th></tr>
</thead>
<tbody>
<tr><td><code>maxItems</code></td><td>integer</td><td><code>10</code></td><td>Records to return. Free plan caps at 10, paid plan at 1,000,000.</td></tr>
<tr><td><code>mode</code></td><td>enum</td><td><code>"catalog"</code></td><td><code>catalog</code> walks the registry, <code>dataset</code> fetches one record by ID.</td></tr>
<tr><td><code>datasetId</code></td><td>string</td><td>empty</td><td>UUID or slug of a single dataset. Required in dataset mode.</td></tr>
<tr><td><code>searchQuery</code></td><td>string</td><td>empty</td><td>Optional keyword filter applied in catalog mode.</td></tr>
</tbody>
</table>

**Example: catalog walk of 100 datasets matching "energy".**

```json
{
    "maxItems": 100,
    "mode": "catalog",
    "searchQuery": "energy"
}
````

**Example: fetch one dataset by slug.**

```json
{
    "mode": "dataset",
    "datasetId": "aemo-nem-dispatch-data"
}
```

> ⚠️ **Good to Know:** dataset frequency, license, and tag completeness vary by publishing agency. ABS and AEMO datasets are richly tagged; smaller council or local-authority datasets sometimes leave frequency blank. The Actor always returns the official portal URL so you can cross-check anything ambiguous.

***

### 📊 Output

Each dataset record contains up to **13 fields**. Download the dataset as CSV, Excel, JSON, or XML.

#### 🧾 Schema

| Field | Type | Example |
|---|---|---|
| 🆔 `id` | string | `"d4b1f0fa-a5e8-4b9b-9d7a-1f3c5e6b1c2d"` |
| 🏷️ `name` | string | `"aemo-nem-dispatch-data"` |
| 📰 `title` | string | `"AEMO National Electricity Market Dispatch Data"` |
| 📝 `notes` | string | `"5-minute dispatch prices and volumes..."` |
| 🏛️ `organization` | string | `"Australian Energy Market Operator"` |
| ⚖️ `license` | string | `"Creative Commons Attribution 4.0"` |
| 🏷️ `tags` | array | `["electricity","NEM","dispatch","wholesale"]` |
| 📁 `resourcesCount` | number | `5` |
| 📦 `resources` | array | `[{name, format, url, language, size, lastModified}]` |
| 🕒 `metadataCreated` | ISO 8601 | `"2018-09-12T01:14:22.000Z"` |
| 🔁 `metadataModified` | ISO 8601 | `"2026-05-21T22:00:00.000Z"` |
| 📅 `frequency` | string | null | `"hourly"` |
| 🔗 `portalUrl` | string | `"https://data.gov.au/dataset/..."` |
| 🕒 `scrapedAt` | ISO 8601 | `"2026-05-22T00:00:00.000Z"` |

#### 📦 Sample records

<details>
<summary><strong>⚡ AEMO National Electricity Market dispatch</strong></summary>

```json
{
    "id": "d4b1f0fa-a5e8-4b9b-9d7a-1f3c5e6b1c2d",
    "name": "aemo-nem-dispatch-data",
    "title": "AEMO National Electricity Market Dispatch Data",
    "notes": "5-minute dispatch prices, generator output, and demand across the National Electricity Market.",
    "organization": "Australian Energy Market Operator",
    "license": "Creative Commons Attribution 4.0",
    "tags": ["electricity", "NEM", "dispatch", "wholesale", "energy-market"],
    "resourcesCount": 5,
    "resources": [
        {
            "name": "NEM dispatch (CSV)",
            "format": "CSV",
            "url": "https://nemweb.com.au/.../dispatch.csv",
            "language": "en",
            "size": null,
            "lastModified": "2026-05-21T22:00:00.000Z"
        }
    ],
    "metadataCreated": "2018-09-12T01:14:22.000Z",
    "metadataModified": "2026-05-21T22:00:00.000Z",
    "frequency": "hourly",
    "portalUrl": "https://data.gov.au/dataset/aemo-nem-dispatch-data",
    "scrapedAt": "2026-05-22T00:00:00.000Z"
}
```

</details>

<details>
<summary><strong>🌦️ Bureau of Meteorology rainfall observations</strong></summary>

```json
{
    "id": "f1a2b3c4-d5e6-4f7a-8b9c-1d2e3f4a5b6c",
    "name": "bom-rainfall-observations",
    "title": "Daily Rainfall Observations",
    "notes": "Daily rainfall totals from Bureau of Meteorology weather stations across Australia.",
    "organization": "Bureau of Meteorology",
    "license": "Creative Commons Attribution 3.0 Australia",
    "tags": ["rainfall", "weather", "climate", "observations"],
    "resourcesCount": 3,
    "resources": [
        {
            "name": "Daily rainfall (CSV)",
            "format": "CSV",
            "url": "http://www.bom.gov.au/.../rainfall_daily.csv",
            "language": "en",
            "size": null,
            "lastModified": "2026-05-21T03:00:00.000Z"
        }
    ],
    "metadataCreated": "2015-04-08T11:42:18.331Z",
    "metadataModified": "2026-05-21T03:00:00.000Z",
    "frequency": "daily",
    "portalUrl": "https://data.gov.au/dataset/bom-rainfall-observations",
    "scrapedAt": "2026-05-22T00:00:00.000Z"
}
```

</details>

<details>
<summary><strong>🚦 NSW Traffic Volume Counts</strong></summary>

```json
{
    "id": "9a2b3c4d-5e6f-7a8b-9c1d-2e3f4a5b6c7d",
    "name": "nsw-traffic-volume-viewer",
    "title": "NSW Traffic Volume Counts",
    "notes": "Average annual daily traffic volumes on the NSW classified road network.",
    "organization": "Transport for NSW",
    "license": "Creative Commons Attribution",
    "tags": ["traffic", "transport", "NSW", "roads"],
    "resourcesCount": 4,
    "resources": [
        {
            "name": "Traffic counts (CSV)",
            "format": "CSV",
            "url": "https://opendata.transport.nsw.gov.au/.../traffic.csv",
            "language": "en",
            "size": null,
            "lastModified": "2026-04-30T00:00:00.000Z"
        }
    ],
    "metadataCreated": "2017-11-23T08:00:00.000Z",
    "metadataModified": "2026-04-30T00:00:00.000Z",
    "frequency": "annually",
    "portalUrl": "https://data.gov.au/dataset/nsw-traffic-volume-viewer",
    "scrapedAt": "2026-05-22T00:00:00.000Z"
}
```

</details>

***

### ✨ Why choose this Actor

| | Capability |
|---|---|
| 🦘 | **All-of-government coverage.** Federal, state, territory, and statutory authority datasets in one feed. |
| 🎯 | **Two-mode workflow.** Bulk catalog walk for inventory, single-dataset fetch for enrichment. |
| 📁 | **Resource expansion.** Each record carries its downloadable files (CSV, GeoJSON, ZIP, NetCDF) with size and last-modified date. |
| ⚡ | **Energy-market ready.** AEMO dispatch, demand, and forecast datasets surface in standard catalog mode. |
| 🌦️ | **Climate-research ready.** BoM and CSIRO observation datasets included with resource links. |
| 🔁 | **Always fresh.** Every run pulls the latest catalog state, no caching. |
| 🚫 | **No authentication.** Works on public open data. No API key needed. |

> 📊 data.gov.au is the most comprehensive single source of free Australian government data. This Actor makes the entire registry queryable in minutes.

***

### 📈 How it compares to alternatives

| Approach | Cost | Coverage | Refresh | Filters | Setup |
|---|---|---|---|---|---|
| **⭐ Australia Open Data Scraper** *(this Actor)* | $5 free credit, then pay-per-use | **70,000+** Australian datasets | **Live per run** | Search keyword, single ID | ⚡ 2 min |
| Hand-built CKAN client | Free | Up to you | Manual | Up to you | 🐢 Days |
| Commercial data marketplaces | $$$ | Curated subset | Variable | Vendor-defined | ⏳ Hours |
| Manual portal browsing | Free | One at a time | Manual | UI search | 🕒 Endless |

Pick this Actor when you want a clean structured dataset of the entire Australian open data registry without writing a CKAN client.

***

### 🚀 How to use

1. 📝 **Sign up.** [Create a free account with $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp) (takes 2 minutes).
2. 🌐 **Open the Actor.** Go to the Australia Open Data Scraper page on the Apify Store.
3. 🎯 **Set input.** Pick catalog mode for a full walk or dataset mode with an ID, plus `maxItems`.
4. 🚀 **Run it.** Click **Start** and let the Actor collect your data.
5. 📥 **Download.** Grab your results in the **Dataset** tab as CSV, Excel, JSON, or XML.

> ⏱️ Total time from signup to downloaded dataset: **3-5 minutes.** No coding required.

***

### 💼 Business use cases

<table>
<tr>
<td width="50%" valign="top">

#### ⚡ Energy & Utilities Analytics

- Pull AEMO NEM and gas market datasets
- Track wholesale price publications
- Build forecasting inputs from official feeds
- Inventory renewable-energy publication coverage

</td>
<td width="50%" valign="top">

#### 🌦️ Climate & Environment Research

- Source BoM and CSIRO observation datasets
- Layer environmental files into GIS dashboards
- Build climate-impact studies with cited data
- Monitor air-quality and emissions publications

</td>
</tr>
<tr>
<td width="50%" valign="top">

#### 📰 Journalism & Civic Tech

- Audit which agencies publish what
- Track open-data publishing commitments
- Discover lesser-known transparency releases
- Surface licensing terms across jurisdictions

</td>
<td width="50%" valign="top">

#### 🏛️ Policy, Fintech & Research

- Aggregate ABS economic indicator publications
- Build cross-state analytics with citations
- Pull regulatory and reporting datasets
- Source baseline data for policy proposals

</td>
</tr>
</table>

***

### 🔌 Automating Australia Open Data Scraper

Control the scraper programmatically for scheduled runs and pipeline integrations:

- 🟢 **Node.js.** Install the `apify-client` NPM package.
- 🐍 **Python.** Use the `apify-client` PyPI package.
- 📚 See the [Apify API documentation](https://docs.apify.com/api/v2) for full details.

The [Apify Schedules feature](https://docs.apify.com/platform/schedules) lets you trigger this Actor on any cron interval. Weekly or monthly refreshes keep downstream catalogs in sync automatically.

***

### 🌟 Beyond business use cases

Data like this powers more than commercial workflows. The same structured records support research, education, civic projects, and personal initiatives.

<table>
<tr>
<td width="50%">

#### 🎓 Research and academia

- Public-policy theses with reproducible data citations
- Climate-science publications using official observations
- Cross-jurisdiction open-government comparisons
- Course exercises on Australian data discovery

</td>
<td width="50%">

#### 🎨 Personal and creative

- Dataviz portfolios sourced from ANZ data
- Indie civic dashboards and search interfaces
- Hobby projects on local transit or weather
- Content research for explainer blogs

</td>
</tr>
<tr>
<td width="50%">

#### 🤝 Non-profit and civic

- NGO research on environmental and social files
- Civic-tech open-data discovery tools
- Investigative journalism around state releases
- Community map layers from official sources

</td>
<td width="50%">

#### 🧪 Experimentation

- Train ML models on Australian government data
- Prototype agents that resolve dataset slugs
- Validate civic-tech product ideas with real metadata
- Build dataset search experiences over open feeds

</td>
</tr>
</table>

***

### 🤖 Ask an AI assistant about this scraper

Open a ready-to-send prompt about this ParseForge actor in the AI of your choice:

- 💬 [**ChatGPT**](https://chat.openai.com/?q=How%20do%20I%20use%20the%20Australia%20Open%20Data%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🧠 [**Claude**](https://claude.ai/new?q=How%20do%20I%20use%20the%20Australia%20Open%20Data%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🔍 [**Perplexity**](https://perplexity.ai/search?q=How%20do%20I%20use%20the%20Australia%20Open%20Data%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🅒 [**Copilot**](https://copilot.microsoft.com/?q=How%20do%20I%20use%20the%20Australia%20Open%20Data%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)

***

### ❓ Frequently Asked Questions

#### 🧩 How does it work?

Configure your mode (catalog walk or single dataset) and optional keyword filter, click Start, and the Actor paginates the data.gov.au catalog server-side and emits one clean structured record per dataset.

#### 🦘 How many datasets are in the catalog?

More than 70,000 datasets across federal, state, territory, and statutory agencies. The exact count changes as agencies publish, update, or retire records.

#### 🔁 How often is the catalog refreshed?

Agencies publish on their own schedules (some hourly, some annually). Every run of this Actor fetches the latest catalog state in real time.

#### 📁 Do I get the actual files or just the links?

You get the resource metadata for every file (name, format, URL, language, size, last-modified). Download the files themselves directly from the URLs in the `resources` field.

#### ⚡ Can I get AEMO and BoM datasets through this Actor?

Yes. AEMO, Bureau of Meteorology, ABS, Geoscience Australia, CSIRO, and all state and territory agencies that publish to data.gov.au are in scope.

#### ⏰ Can I schedule regular runs?

Yes. Use Apify Schedules to run this Actor on any cron interval (daily, weekly, monthly) and keep a downstream dataset inventory in sync.

#### ⚖️ Is this data legal to use?

data.gov.au datasets are typically published under permissive Creative Commons licenses. Always review the per-dataset `license` field returned by this Actor before commercial reuse.

#### 💼 Can I use this data commercially?

Most datasets allow commercial use under Creative Commons Attribution. A small number carry restrictions, which you can read in the `license` field for each record.

#### 💳 Do I need a paid Apify plan to use this Actor?

No. The free Apify plan is enough for testing and small runs (10 records per run). A paid plan lifts the limit and gives you access to scheduling, higher concurrency, and larger datasets.

#### 🔁 What happens if a run fails or gets interrupted?

Apify automatically retries transient errors. If a run still fails, you can inspect the log in the Runs tab, fix the input, and re-run. Partial datasets from failed runs are preserved so you never lose progress.

#### 🆘 What if I need help?

Our support team is here to help. Contact us through the Apify platform or use the Tally form linked below.

***

### 🔌 Integrate with any app

Australia Open Data Scraper connects to any cloud service via [Apify integrations](https://apify.com/integrations):

- [**Make**](https://docs.apify.com/platform/integrations/make) - Automate multi-step workflows
- [**Zapier**](https://docs.apify.com/platform/integrations/zapier) - Connect with 5,000+ apps
- [**Slack**](https://docs.apify.com/platform/integrations/slack) - Get run notifications in your channels
- [**Airbyte**](https://docs.apify.com/platform/integrations/airbyte) - Pipe dataset metadata into your warehouse
- [**GitHub**](https://docs.apify.com/platform/integrations/github) - Trigger runs from commits and releases
- [**Google Drive**](https://docs.apify.com/platform/integrations/drive) - Export datasets straight to Sheets

You can also use webhooks to trigger downstream actions when a run finishes. Push new datasets into your product backend, or alert your team in Slack.

***

### 🔗 Recommended Actors

- [**🍁 Canada Open Data Scraper**](https://apify.com/parseforge/canada-open-data-scraper) - Canadian federal open dataset catalog
- [**🏢 ABR Australian Business Register Scraper**](https://apify.com/parseforge/abr-australian-business-register-scraper) - 7M+ Australian business records
- [**📈 Indexmundi Scraper**](https://apify.com/parseforge/indexmundi-scraper) - Global demographic and economic indicators
- [**🗺️ Nominatim OSM Scraper**](https://apify.com/parseforge/nominatim-osm-scraper) - Geocode addresses via OpenStreetMap
- [**✈️ OurAirports Scraper**](https://apify.com/parseforge/ourairports-scraper) - Global airport, heliport, and airfield dataset

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for more reference-data scrapers.

***

**🆘 Need Help?** [**Open our contact form**](https://tally.so/r/BzdKgA) to request a new scraper, propose a custom data project, or report an issue.

***

> **⚠️ Disclaimer:** this Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by data.gov.au, the Australian Government, or any state or territory agency. All trademarks mentioned are the property of their respective owners. Only publicly available open government data is collected.

# Actor input Schema

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

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

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

Catalog walks all datasets. Dataset fetches a single dataset by ID.

## `datasetId` (type: `string`):

Dataset ID (UUID or slug). Required in dataset mode.

## `searchQuery` (type: `string`):

Optional substring filter applied to dataset IDs in catalog mode. Leave blank to walk all datasets.

## Actor input object example

```json
{
  "maxItems": 10,
  "mode": "catalog"
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# 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 = {
    "maxItems": 10,
    "mode": "catalog"
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/australia-data-gov-au-scraper").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 = {
    "maxItems": 10,
    "mode": "catalog",
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/australia-data-gov-au-scraper").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 '{
  "maxItems": 10,
  "mode": "catalog"
}' |
apify call parseforge/australia-data-gov-au-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=parseforge/australia-data-gov-au-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Australia Open Data (data.gov.au) Scraper",
        "description": "Export Australian government open datasets from data.gov.au. Browse 70k+ datasets across federal, state, and territory agencies. Pull dataset metadata, resources, organization, license, tags, and update frequency. Catalog mode lists all; dataset mode fetches one by ID.",
        "version": "1.0",
        "x-build-id": "iLCJvAJOKAtfZedso"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~australia-data-gov-au-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-australia-data-gov-au-scraper",
                "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/parseforge~australia-data-gov-au-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-australia-data-gov-au-scraper",
                "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/parseforge~australia-data-gov-au-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-australia-data-gov-au-scraper",
                "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": {
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    },
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "catalog",
                            "dataset"
                        ],
                        "type": "string",
                        "description": "Catalog walks all datasets. Dataset fetches a single dataset by ID."
                    },
                    "datasetId": {
                        "title": "Dataset ID",
                        "type": "string",
                        "description": "Dataset ID (UUID or slug). Required in dataset mode."
                    },
                    "searchQuery": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Optional substring filter applied to dataset IDs in catalog mode. Leave blank to walk all datasets."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
