# Australian Energy Plans - Electricity, Gas & Solar FiT (`crawlplant/au-energy-plans`) Actor

Every electricity and gas plan from 42 Australian retailers, ~19,000 plans, by postcode: supply charge, time-of-use rates, solar feed-in tariff, controlled load, discounts, plus an estimated annual bill for your usage and a daily plan-change feed. Consumer Data Right data, refreshed nightly.

- **URL**: https://apify.com/crawlplant/au-energy-plans.md
- **Developed by:** [Piotr Zimniak](https://apify.com/crawlplant) (community)
- **Categories:** Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.25 / 1,000 plan rows

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

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

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

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

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

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

# README

## Australian Energy Plans - Electricity, Gas & Solar FiT

*Independent tool, not affiliated with any energy retailer, the AER or Energy Made Easy. It reads only the public plan data
retailers publish under the Consumer Data Right.*

Every electricity and gas plan published by **42 Australian energy retailers**: about **19,000 plans**, with daily supply
charges, usage and time-of-use rates, solar feed-in tariffs, controlled load, discounts and contract terms, **for any postcode**,
plus an **estimated annual bill** for your usage and a **daily plan-change feed**. Ask "what is the cheapest electricity plan in
3000 for 5,000 kWh a year?" or "which retailers pay the most for solar in Brisbane?" and get a ranked answer in about 3 seconds.

### Why this one

- **The whole market for your postcode.** Every plan from every retailer that publishes Consumer Data Right plan data, filtered
  to the plans actually sold at your postcodes.
- **An annual bill, not just rates.** Time-of-use bands, summer and winter prices, stepped rates and daily supply charges are
  combined into one comparable number (GST included), with a credit for your solar exports.
- **Clean fields.** Supply charge, single / peak / shoulder / off-peak rates, controlled load, best feed-in tariff, demand charges,
  GreenPower, discounts and incentives, in the same fields for every retailer.
- **Plan changes, every day.** Price rises and cuts, new and withdrawn plans, since we started tracking on 27 September 2026.
- **Fast and reliable.** Runs are answered from our nightly snapshot of all ~19,000 plans in about 3 seconds. See [Reliability](#reliability).
- **The only Apify Actor with Australian Consumer Data Right energy plans** (September 2026).
- **See it live.** A bill calculator, tonight's best feed-in tariffs and a day on a time-of-use plan: [crawlplant.com/au-energy-plans](https://crawlplant.com/au-energy-plans/).

### What can you use it for?

- **Comparison sites, brokers and switching services**: a daily feed of every plan with its postcode coverage.
- **Solar and battery installers**: the best feed-in tariffs and time-of-use plans in an area, for customer quotes.
- **Property managers and businesses**: the cheapest small-business plans for each site's postcode.
- **Analysts and journalists**: price changes after the annual default market offer reset, retailer by retailer.
- **AI agents**: "find the cheapest plan for my postcode" (see [Use with AI agents](#use-with-ai-agents)).

### Quick start

1. Click **Try for free** (or **Start**): the 100 cheapest residential electricity plans in postcode **2000** for 4,000 kWh a
   year. It finishes in about 3 seconds and costs $0.20 on the Free plan.
2. Change **Postcodes**, **Electricity use per year** and, if you have panels, **Solar export per year**.
3. Download JSON, CSV or Excel, or save the input as a **task** to reuse or schedule it.

#### Copy to your AI assistant

Paste this into ChatGPT, Claude or any agent so it knows how to use the Actor:

```
crawlplant/au-energy-plans on Apify: every electricity and gas plan published by 42 Australian retailers (~19,000 plans,
Consumer Data Right data, refreshed nightly), by postcode, with an estimated annual bill. Modes (field "mode"): cheapest (default:
plans at the postcodes ranked by estimated annual bill), plans (every matching plan, any sortBy), changes (plan changes since
changedSince: a date or "last-run"; empty = last 7 days), brands (retailers covered). Inputs: postcodes (4-digit strings, default
["2000"]), fuelTypes (ELECTRICITY default, GAS, DUAL; exact match), customerType (RESIDENTIAL default, BUSINESS), planTypes
(MARKET, STANDING, REGULATED), brands (a word of the retailer's name, e.g. "agl"), features (solar, controlledLoad, timeOfUse,
singleRate, greenPower, noDemandCharges; default ["noDemandCharges"]), annualKwh (default 4000), peakShare/shoulderShare/
offPeakShare (0.35/0.25/0.4), solarExportKwh (0), gasAnnualMj (25000), sortBy (estimate_asc default, supply_asc, usage_rate_asc,
fit_desc, brand), maxItems (100). Each plan row: brandName, displayName, fuelType, planType, pricingModel, postcodes,
distributors, estimatedAnnualCost {total, supply, usage, solarCredit, incGst: true, approximate, reasons}, dailySupplyCharge and
rates {single, peak, shoulder, offPeak} in $/kWh ex-GST, controlledLoadRate, solarFeedInTariff, seasonal, hasDemandCharges, gas,
greenPower, discounts, incentives, scrapedAt, source, rank. Cost: $2.00 per 1,000 rows (Free plan) down to $1.25; change rows
+$3.00 per 1,000; $0.00005 per run. Runs take ~3 s. Tracking since 2026-09-27.
```

### Modes

| Mode | What you get |
|---|---|
| `cheapest` (default) | Plans at your postcodes, ranked by the estimated annual bill |
| `plans` | Every matching plan, sorted as you like, for full exports |
| `changes` | Plan changes since a date or since your last run: old and new supply charge, rates and feed-in tariff |
| `brands` | The retailers covered, with logo, ABN and website |

### Ready-to-use examples

**1. Cheapest electricity plans in Sydney CBD**

```json
{ "mode": "cheapest", "postcodes": ["2000"], "annualKwh": 4000 }
```

**2. Cheapest plans for a home with solar in Melbourne**

```json
{ "mode": "cheapest", "postcodes": ["3000"], "features": ["solar", "noDemandCharges"], "annualKwh": 5000, "solarExportKwh": 3000 }
```

**3. Best solar feed-in tariffs in Brisbane**

```json
{ "mode": "plans", "postcodes": ["4000"], "features": ["solar"], "sortBy": "fit_desc", "maxItems": 50 }
```

**4. Cheapest gas plans in Adelaide**

```json
{ "mode": "cheapest", "postcodes": ["5000"], "fuelTypes": ["GAS"], "gasAnnualMj": 30000 }
```

**5. Time-of-use plans for charging an EV overnight**

```json
{ "mode": "cheapest", "postcodes": ["2150"], "features": ["timeOfUse", "noDemandCharges"], "annualKwh": 7000, "peakShare": 0.2, "shoulderShare": 0.2, "offPeakShare": 0.6 }
```

**6. Plans with controlled load (off-peak hot water)**

```json
{ "mode": "cheapest", "postcodes": ["2250"], "features": ["controlledLoad", "noDemandCharges"] }
```

**7. Small-business electricity plans across several sites**

```json
{ "mode": "cheapest", "postcodes": ["2000", "3000", "4000"], "customerType": "BUSINESS", "annualKwh": 20000, "maxItems": 300 }
```

**8. Every AGL and Origin plan in one postcode**

```json
{ "mode": "plans", "postcodes": ["2000"], "brands": ["agl", "origin"], "sortBy": "brand", "maxItems": 1000 }
```

**9. Standing (default) offers only**

```json
{ "mode": "plans", "postcodes": ["2000"], "planTypes": ["STANDING"] }
```

**10. Price changes in my postcode since my last run (schedule it weekly)**

```json
{ "mode": "changes", "postcodes": ["3000"], "changedSince": "last-run" }
```

**11. Plan changes since a date**

```json
{ "mode": "changes", "postcodes": ["2000", "3000"], "changedSince": "2026-09-27" }
```

**12. The list of retailers covered**

```json
{ "mode": "brands", "maxItems": 200 }
```

### How to…

#### Find the cheapest electricity plan for your postcode

Mode `cheapest` with your postcode and yearly use (example 1). `estimatedAnnualCost.total` ranks the plans; your latest bill
shows your yearly kWh.

#### Compare solar feed-in tariffs

Mode `plans`, `features: ["solar"]`, `sortBy: "fit_desc"` (example 3). To rank by the whole bill instead, add
`solarExportKwh` in `cheapest` mode (example 2).

#### Find a plan for EV charging or off-peak use

Set your own `peakShare` / `shoulderShare` / `offPeakShare` and keep `timeOfUse` (example 5): plans with cheap off-peak rates rise to the top.

#### Get the cheapest gas plan

`fuelTypes: ["GAS"]` and your yearly use in MJ from your gas bill (example 4).

#### Get alerts when energy prices change

Schedule example 10 and add an email, Slack or webhook integration on "run succeeded": each run returns only the plans whose
prices changed since the previous run.

#### Export every energy plan in Australia

Mode `plans`, leave `features` empty (`[]`), list the postcodes you need and set `maxItems` high.

### How the bill estimate works

`estimatedAnnualCost.total` = daily supply charge × 365 + your usage priced at the plan's rates, **plus 10% GST**, minus your solar
export × the plan's best feed-in tariff (feed-in credits carry no GST). Rate fields in the output are the plan's published prices,
before GST (`pricesIncludeGst: false`); the estimate includes GST.

- **Time of use**: your kWh are split with `peakShare` / `shoulderShare` / `offPeakShare`; bands a plan doesn't have share their part
  with the others.
- **Seasons**: plans with summer and winter prices are priced season by season, weighted by days.
- **Stepped rates** (e.g. the first 11 kWh a day at one price) are priced block by block.
- **Guaranteed discounts** (a percentage off usage or off the whole bill, no conditions) are included.
- **Left out**: demand charges, controlled-load usage and conditional discounts (pay-on-time, direct debit). Plans where this
  matters get `approximate: true` with the reasons.
- **Demand-charge plans are hidden by default** (`features: ["noDemandCharges"]`), so every ranked plan is compared on its full
  price. Set `features` to `[]` to include them, marked `hasDemandCharges: true`.

It is an estimate to rank plans, not a quote: check the retailer's offer before switching.

### Input options

| Option | Default | Description |
|---|---|---|
| `mode` | `cheapest` | `cheapest`, `plans`, `changes`, `brands` |
| `postcodes` | `["2000"]` | 4-digit postcodes |
| `fuelTypes` | `["ELECTRICITY"]` | `ELECTRICITY`, `GAS`, `DUAL` (exact match) |
| `customerType` | `RESIDENTIAL` | `RESIDENTIAL` or `BUSINESS` |
| `planTypes` | `[]` | `MARKET`, `STANDING`, `REGULATED` |
| `brands` | `[]` | Retailer names (a word of the name) or ids from mode `brands` |
| `features` | `["noDemandCharges"]` | `solar`, `controlledLoad`, `timeOfUse`, `singleRate`, `greenPower`, `noDemandCharges`; `[]` includes demand-charge plans |
| `annualKwh` | `4000` | Your electricity use per year |
| `peakShare`, `shoulderShare`, `offPeakShare` | `0.35`, `0.25`, `0.4` | How your use splits across time-of-use bands |
| `solarExportKwh` | `0` | Solar exported to the grid per year |
| `gasAnnualMj` | `25000` | Your gas use per year (gas plans) |
| `sortBy` | `estimate_asc` | `estimate_asc`, `supply_asc`, `usage_rate_asc`, `fit_desc`, `brand` |
| `maxItems` | `100` | Maximum rows |
| `changedSince` | - | For `changes`: a date or `last-run`; empty = last 7 days |
| `maxAgeHours` | `36` | Data older than this still comes back, with a note in the run summary |
| `includeRaw` | `false` | Add the plan's original Consumer Data Right JSON |

### Example output

```json
{
  "type": "plan",
  "planId": "AMB1139004MRE1@EME",
  "brandId": "aer:amber",
  "brandName": "Amber Electric",
  "displayName": "Battery + Solar: Variable Wholesale Prices (estimate)",
  "fuelType": "ELECTRICITY",
  "planType": "MARKET",
  "customerType": "RESIDENTIAL",
  "pricingModel": "SINGLE_RATE",
  "postcodes": [
    "2000"
  ],
  "distributors": [
    "Ausgrid"
  ],
  "estimatedAnnualCost": {
    "total": 1196.34,
    "supply": 426.34,
    "usage": 770,
    "solarCredit": 0,
    "incGst": true,
    "approximate": false,
    "reasons": []
  },
  "dailySupplyCharge": 1.061856,
  "rates": {
    "single": 0.175,
    "peak": null,
    "shoulder": null,
    "offPeak": null
  },
  "solarFeedInTariff": 0.1226,
  "isFixed": false,
  "seasonal": false,
  "hasDemandCharges": false,
  "pricesIncludeGst": false,
  "scrapedAt": "2026-09-27T12:51:36.366Z",
  "source": "cache",
  "rank": 1
}
```

### Output fields

| Field | Description |
|---|---|
| `type` | `plan`, `change` or `brand` |
| `planId`, `displayName` | The plan's id and name |
| `brandId`, `brand`, `brandName` | The retailer |
| `fuelType`, `planType`, `customerType` | Electricity / gas / dual; market / standing / regulated; residential / business |
| `pricingModel` | e.g. `SINGLE_RATE`, `TIME_OF_USE`, `SINGLE_RATE_CONT_LOAD` |
| `postcodes` | Which of your postcodes the plan is sold in |
| `distributors` | Network areas the plan is sold in |
| `estimatedAnnualCost` | `{ total, supply, usage, solarCredit, incGst, approximate, reasons }` for your usage |
| `dailySupplyCharge` | $/day before GST (first season) |
| `rates` | `{ single, peak, shoulder, offPeak }` in $/kWh before GST (first season) |
| `controlledLoadRate` | $/kWh for controlled load, before GST |
| `solarFeedInTariff` | Best feed-in tariff the retailer pays a new customer, $/kWh (closed government / premium schemes excluded) |
| `isFixed`, `seasonal`, `hasDemandCharges` | Fixed-price contract; prices vary by season; demand charges apply |
| `gas` | Gas prices for gas and dual-fuel plans (same shape, $/MJ) |
| `greenPower`, `discounts`, `incentives` | GreenPower option; discount and incentive descriptions |
| `effectiveFrom`, `effectiveTo`, `planLastUpdated` | Plan validity and the retailer's last update |
| `firstSeenAt`, `detailFetchedAt`, `scrapedAt` | When we first saw it, last downloaded it, and last checked the retailer's list |
| `source` | `cache` (our nightly snapshot) |
| `rank` | Position in `cheapest` mode |
| `event`, `oldDailySupplyCharge`, `newDailySupplyCharge`, `oldRates`, `newRates`, `observedAt` | Change rows (`changes` mode) |

### Run it through the API

JavaScript:

```js
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: 'YOUR_TOKEN' });
const run = await client.actor('crawlplant/au-energy-plans').call({ postcodes: ['3000'], annualKwh: 5000, solarExportKwh: 2000 });
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.slice(0, 5).map((p) => `${p.rank}. ${p.brandName} ${p.displayName}: $${p.estimatedAnnualCost?.total}/yr`));
```

Python:

```python
from apify_client import ApifyClient
client = ApifyClient("YOUR_TOKEN")
run = client.actor("crawlplant/au-energy-plans").call(run_input={"postcodes": ["4000"], "features": ["solar"], "sortBy": "fit_desc"})
for p in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(p["brandName"], p["displayName"], p["solarFeedInTariff"])
```

### Use with AI agents

The Actor works as a tool in the [Apify MCP server](https://mcp.apify.com) for Claude, ChatGPT, Cursor and others:

```
https://mcp.apify.com?tools=crawlplant/au-energy-plans
```

Try *"what's the cheapest electricity plan in 2000 for 6,000 kWh a year?"* or *"which retailers pay the most for solar exports in 4000?"*.

### Pricing

Pay per result: platform usage is included, and the bill estimate comes with every plan.

| Event | Free plan | Starter | Scale | Business and up |
|---|---|---|---|---|
| Plan or retailer row (per 1,000) | $2.00 | $1.60 | $1.40 | $1.25 |
| Plan change row (per 1,000, `changes` mode, on top of the row price) | $3.00 | $3.00 | $3.00 | $3.00 |
| Actor start (per run) | $0.00005 | $0.00005 | $0.00005 | $0.00005 |

| Example on the Free plan | Rows | Cost |
|---|---|---|
| Default run: 100 cheapest plans in one postcode | 100 | $0.20 |
| Top 20 solar plans in two postcodes | 20 | $0.04 |
| Every residential plan in one postcode (electricity and gas) | ~750-1,500 | ~$1.50-3.00 |
| 300 business plans across three sites | 300 | $0.60 |
| Weekly watch with `changedSince: "last-run"` | only the changes | often $0.00 |

Set a **maximum cost per run** in the run options to stop a large run at your budget.

### Reliability

- Every run is answered from our nightly snapshot of all ~19,000 plans, so it doesn't depend on retailer data being reachable at
  that moment: results in about 3 seconds.
- Automated checks test the Actor, the data and its freshness every 3 hours, around the clock.

### Data freshness

We read every retailer's plan list every night (Australian time) and re-download a plan when it changed, and at least weekly.
`scrapedAt` is when the retailer's list was last checked. Plan history is kept since 27 September 2026.

### Troubleshooting

- **No plans for a postcode**: plan data covers the national electricity and gas markets (NSW, ACT, VIC, QLD, SA and TAS); the
  Northern Territory and most of Western Australia have their own arrangements.
- **An estimate is `null`**: the plan has no usage prices (for example export-only plans), or usage for that fuel is 0.
- **An estimate is marked `approximate`**: see its `reasons` (controlled load, stepped time-of-use blocks).

### FAQ

#### What is the cheapest electricity plan for my postcode?

Run example 1 with your postcode and yearly use: every plan sold there, ranked by the estimated annual bill.

#### How much does it cost?

$2.00 per 1,000 plans on the Free plan, down to $1.25 on higher plans, plus $0.00005 per run. The default run costs $0.20.
See [Pricing](#pricing).

#### Where does the data come from?

From the public plan data every Australian energy retailer must publish under the Consumer Data Right. No logins, no personal data.

#### Does the estimate include GST?

Yes. The estimate includes 10% GST; the rate fields show the published prices before GST.

#### How far back does the price history go?

To 27 September 2026, when tracking started; every change since is kept.

#### Is this advice?

No. It is published plan data and an estimate to compare plans; check the retailer's offer before switching.

### Privacy

Only public plan data is collected. Each run sends the developer anonymous feature-usage statistics (the mode and which options
were used, never your postcodes or usage values); your Apify account id is replaced by a one-way hash on arrival.

# Actor input Schema

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

cheapest = plans available at your postcodes, ranked by the estimated annual bill; plans = every matching plan; changes = price changes since a date or your last run; brands = the retailers we cover.

## `postcodes` (type: `array`):

Australian postcodes (4 digits, e.g. 2000, 3000, 0800). A plan is returned once with every requested postcode it serves.

## `fuelTypes` (type: `array`):

Electricity, gas, or dual-fuel plans (exact match).

## `customerType` (type: `string`):

Residential (home) or small-business plans.

## `planTypes` (type: `array`):

Market offers, standing offers (default offer) or regulated plans. Empty = all.

## `brands` (type: `array`):

Only these retailers: a word of the name ("agl", "origin", "red") or a retailer id from mode "brands".

## `features` (type: `array`):

Keep only plans with all of these. "No demand charges" is on by default because the bill estimate cannot price demand charges; remove it to see those plans too.

## `annualKwh` (type: `number`):

About 4,000 kWh for a typical 2-3 person home; your bill shows your own.

## `peakShare` (type: `number`):

Share of your electricity used in peak hours (time-of-use plans). Peak + shoulder + off-peak should be 1.

## `shoulderShare` (type: `number`):

Share of your electricity used in shoulder hours (time-of-use plans).

## `offPeakShare` (type: `number`):

Share of your electricity used off-peak (time-of-use plans).

## `solarExportKwh` (type: `number`):

Electricity your panels send to the grid; credited at the plan's best feed-in tariff.

## `gasAnnualMj` (type: `number`):

For gas plans. Around 25,000 MJ for a home with gas heating and hot water; 0 = no gas estimate.

## `sortBy` (type: `string`):

How to order the plans. cheapest mode ranks by the estimated annual bill by default.

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

Stop after this many rows.

## `changedSince` (type: `string`):

Mode "changes": a date (2026-09-01) or "last-run". Empty = last 7 days.

## `maxAgeHours` (type: `integer`):

We refresh every plan daily. Older data is still served, with a warning in the run summary.

## `includeRaw` (type: `boolean`):

Add the plan's original CDR JSON (large).

## Actor input object example

```json
{
  "mode": "cheapest",
  "postcodes": [
    "2000"
  ],
  "fuelTypes": [
    "ELECTRICITY"
  ],
  "customerType": "RESIDENTIAL",
  "planTypes": [],
  "brands": [],
  "features": [
    "noDemandCharges"
  ],
  "annualKwh": 4000,
  "peakShare": 0.35,
  "shoulderShare": 0.25,
  "offPeakShare": 0.4,
  "solarExportKwh": 0,
  "gasAnnualMj": 25000,
  "sortBy": "estimate_asc",
  "maxItems": 100,
  "maxAgeHours": 36,
  "includeRaw": false
}
```

# Actor output Schema

## `results` (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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlplant/au-energy-plans").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("crawlplant/au-energy-plans").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{}' |
apify call crawlplant/au-energy-plans --silent --output-dataset

```

## MCP server setup

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

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

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/89KbcbvGR8KuPvpdw/builds/oPNg8advbi8dImaev/openapi.json