# Australia Federal Register of Legislation Scraper (`parseforge/australia-legislation-register-scraper`) Actor

Tap the Australian Federal Register of Legislation for Acts, legislative instruments, and other titles. Returns title ID, name, making date, collection, principal flag, and in force status. Filter by name or collection for legal research, compliance tracking, and policy monitoring.

- **URL**: https://apify.com/parseforge/australia-legislation-register-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Developer tools, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $19.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
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 Federal Register of Legislation Scraper

> 🚀 **Export Australian legislation in seconds.** Pull Acts, legislative instruments, and other titles from the official Federal Register of Legislation, complete with title IDs, making dates, and in-force status.

> 🕒 **Last updated:** 2026-06-08 · **📊 Up to 14 fields** per record · official OData API · whole-register coverage

Turn the Australian Federal Register of Legislation into clean, structured records you can drop into a compliance tracker, a legal research database, or a policy monitoring dashboard. Search by title name, restrict to a single collection, or list the entire register, and get every matching title with its ID, making date, collection, principal flag, and current status.

Coverage is the complete public register as the Australian Government Office of Parliamentary Counsel publishes it: Acts, legislative instruments, notifiable instruments, the Constitution, continued law, gazettes, and more. Data is read live from the official `api.prod.legislation.gov.au` OData endpoint, so every run reflects the register at run time.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Legal researchers and law librarians | Build and refresh a searchable legislation index |
| Compliance and governance teams | Track which instruments are in force |
| Policy analysts and government affairs | Monitor new and amended titles by collection |
| RegTech and legal-tech builders | Seed an app with structured legislation data |

### 📋 What the Australia Legislation Register Scraper does

This Actor queries the official Federal Register of Legislation OData API and returns one clean record per title that matches your input:

- **Search** the title name for a keyword such as `Privacy` or `Migration`, or leave it empty to list the whole register.
- **Filter by collection** to restrict results to Acts, legislative instruments, notifiable instruments, and more.
- **Advanced OData filter** for power users who want raw `$filter` expressions like `isPrincipal eq true` or `year eq 2024`.
- **Sort** by title ID (roughly chronological, since the ID is year-encoded) or by name.

You control how many records come back, and every record carries a `scrapedAt` timestamp.

### 🎬 Full Demo (_🚧 Coming soon_)

### ⚙️ Input

| Field | Type | Description |
|---|---|---|
| `search` | string | Free text matched against the title name, for example `Privacy` or `Migration`. Returns every title whose name contains this text. Leave empty to list all titles. |
| `collection` | select | Restrict results to one collection: `Act`, `LegislativeInstrument`, `NotifiableInstrument`, `AdministrativeArrangementsOrder`, `Constitution`, `ContinuedLaw`, `Gazette`, or `PrerogativeInstrument`. Empty returns all collections. |
| `filter` | string | Optional raw OData `$filter` expression for advanced queries, for example `isPrincipal eq true`. Combined with the search and collection using AND. |
| `orderBy` | select | Sort order: `id desc`, `id asc`, `name asc`, or `name desc`. Defaults to `id desc` (newest first). |
| `maxItems` | integer | How many records to return. Free plan is capped at 10. |

**Example 1 — every privacy-related title, newest first**
```json
{
    "search": "Privacy",
    "orderBy": "id desc",
    "maxItems": 50
}
````

**Example 2 — principal Acts only**

```json
{
    "collection": "Act",
    "filter": "isPrincipal eq true",
    "maxItems": 100
}
```

> ⚠️ **Good to Know:** Title IDs are year-encoded, so sorting by `id desc` returns the most recent titles first. The upstream API rejects sorting by making date when a filter is present, which is why only ID and name ordering are offered.

### 📊 Output

Each record looks like this:

| Field | Description |
|---|---|
| 📌 `title` | Title name |
| 🏷 `id` | Federal Register title ID |
| 🔗 `url` | Direct link to the title on legislation.gov.au |
| 📊 `status` | Lifecycle status of the title |
| 🗂 `collection` | Register collection (Act, LegislativeInstrument, etc.) |
| 🗃 `subCollection` | Subcollection where applicable |
| 📅 `makingDate` | Date the title was made |
| ⭐ `isPrincipal` | Whether this is a principal (not amending) title |
| ✅ `isInForce` | Whether the title is currently in force |
| 📆 `year` | Year of the title |
| #️⃣ `number` | Title number |
| 📚 `seriesType` | Series type |
| 🔢 `optionalSeriesNumber` | Optional series number |
| 🗓 `asMadeRegisteredAt` | When the as-made version was registered |
| 📜 `originatingBillUri` | Originating bill URI where available |
| 🕒 `scrapedAt` | Collection timestamp |
| ❌ `error` | Null on success |

**Real sample — an Act**

```json
{
    "title": "Privacy Act 1988",
    "id": "C2004A03712",
    "url": "https://www.legislation.gov.au/C2004A03712",
    "status": "InForce",
    "collection": "Act",
    "subCollection": "Act",
    "makingDate": "1988-12-14",
    "isPrincipal": true,
    "isInForce": true,
    "year": 1988,
    "number": 119,
    "seriesType": "Act",
    "optionalSeriesNumber": null,
    "asMadeRegisteredAt": "2004-08-23T00:00:00",
    "originatingBillUri": null,
    "scrapedAt": "2026-06-08T17:09:21.000Z",
    "error": null
}
```

**Real sample — a legislative instrument**

```json
{
    "title": "Migration Regulations 1994",
    "id": "C2004A04791",
    "url": "https://www.legislation.gov.au/C2004A04791",
    "status": "InForce",
    "collection": "LegislativeInstrument",
    "subCollection": "Regulation",
    "makingDate": "1994-08-25",
    "isPrincipal": true,
    "isInForce": true,
    "year": 1994,
    "number": 268,
    "seriesType": "LegislativeInstrument",
    "optionalSeriesNumber": null,
    "asMadeRegisteredAt": "2005-03-01T00:00:00",
    "originatingBillUri": null,
    "scrapedAt": "2026-06-08T17:09:21.000Z",
    "error": null
}
```

### ✨ Why choose this Actor

- Reads the official Federal Register of Legislation OData API, not a scraped HTML page.
- One clean, flat record per title that maps straight onto a database schema.
- Principal and in-force flags let you filter to exactly the law you care about.
- Search, collection, and raw OData filters combine for precise queries.
- No account, no key, and no login required.

### 📈 How it compares to alternatives

| Approach | Effort | Structured fields | In-force flag | Maintenance |
|---|---|---|---|---|
| This Actor | One run | Yes | Yes | None on your side |
| Copying from the register by hand | Hours | Inconsistent | Manual | Constant |
| Writing your own OData client | Days | Depends | Manual | You own the upkeep |

### 🚀 How to use

1. Create a free Apify account using [this sign-up link](https://console.apify.com/sign-up?fpr=vmoqkp).
2. Open the Australia Federal Register of Legislation Scraper.
3. Enter a `search` term or pick a `collection` (or leave both empty for the whole register).
4. Set `maxItems` to the number of records you want.
5. Click **Start** and grab your results when the run finishes.

### 💼 Business use cases

#### Legal research

| Goal | How this helps |
|---|---|
| Build a searchable legislation index | Pull titles by name or collection with IDs and links |
| Find principal instruments fast | Filter with `isPrincipal eq true` |

#### Compliance and governance

| Goal | How this helps |
|---|---|
| Track what is in force | Use the `isInForce` flag on every record |
| Audit a regulatory area | Search by keyword across all collections |

#### Policy monitoring

| Goal | How this helps |
|---|---|
| Watch for new titles | Sort by `id desc` and snapshot on a schedule |
| Group law by collection | Use the `collection` and `subCollection` fields |

#### Legal-tech and RegTech

| Goal | How this helps |
|---|---|
| Seed an app database | Export structured titles to CSV, JSON, or Excel |
| Keep links current | Every record carries a canonical register URL |

### 🔌 Automating Australia Legislation Register Scraper

Connect runs to the tools you already use:

- **Make** and **Zapier** to trigger runs and route records into sheets or databases.
- **Slack** to post a summary when new titles appear.
- **Airbyte** to load results into a warehouse.
- **GitHub** Actions to schedule periodic snapshots.
- **Google Drive** to archive each run's output.

### 🌟 Beyond business use cases

- **Research:** study how a body of law grows and changes over time.
- **Personal:** track legislation relevant to your own situation.
- **Non-profit:** power a free community legal-information resource.
- **Experimentation:** prototype a legal-search app without writing a scraper.

### 🤖 Ask an AI assistant

Paste your results into [ChatGPT](https://chat.openai.com), [Claude](https://claude.ai), [Perplexity](https://www.perplexity.ai), or [Microsoft Copilot](https://copilot.microsoft.com) and ask it to summarise an Act, group titles by collection, or flag which instruments are no longer in force.

### ❓ Frequently Asked Questions

**Do I need an account or API key?**
No. The Actor reads the public Federal Register of Legislation OData API, which needs no login or key.

**Which collections can I pull?**
Acts, legislative instruments, notifiable instruments, administrative arrangements orders, the Constitution, continued law, gazettes, and prerogative instruments.

**Can I search by name?**
Yes. The `search` field matches any title whose name contains your text.

**What is the advanced OData filter for?**
It lets power users pass a raw `$filter` expression, such as `year eq 2024`, that is combined with the search and collection using AND.

**Why can't I sort by making date?**
The upstream API rejects making-date ordering when a filter is present. Title IDs are year-encoded, so sorting by ID is roughly chronological.

**How do I know if a title is current?**
Each record includes an `isInForce` flag and a `status` field.

**How fresh is the data?**
Every run reads live from the official API, so it reflects the register at run time.

**Can I export to Excel or CSV?**
Yes. Apify lets you download the dataset as CSV, Excel, JSON, or XML.

**Can I schedule this?**
Yes. Use Apify Schedules to snapshot the register on any cadence.

**Is this affiliated with the Australian Government?**
No. This is an independent tool that reads only publicly available data.

### 🔌 Integrate with any app

Results are available through the Apify API, so you can pull them into any app, database, or workflow you already run.

### 🔗 Recommended Actors

- [UK The Gazette Statutory Notices Scraper](https://apify.com/parseforge)
- [Ukraine Prozorro Tenders Scraper](https://apify.com/parseforge)
- More government and reference data Actors in the [ParseForge collection](https://apify.com/parseforge)

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge).

**🆘 Need Help?** [Open our contact form](https://tally.so/r/BzdKgA)

> **⚠️ Disclaimer:** independent tool, not affiliated with the Australian Government or the Office of Parliamentary Counsel. Only publicly available data is collected.

# Actor input Schema

## `search` (type: `string`):

Free text matched against the title name, for example 'Privacy' or 'Migration'. Returns every title whose name contains this text. Leave empty to list all titles.

## `collection` (type: `string`):

Restrict results to one collection of the register. 'Any collection' returns titles across all collections.

## `filter` (type: `string`):

Optional raw OData $filter expression for advanced queries, for example "isPrincipal eq true" or "year eq 2024". Combined with the search and collection above using AND. Leave empty if not needed.

## `orderBy` (type: `string`):

Order in which titles are returned. Title ID is encoded with the year, so sorting by it groups titles roughly oldest to newest.

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

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

## Actor input object example

```json
{
  "collection": "",
  "orderBy": "id desc",
  "maxItems": 10
}
```

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

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/australia-legislation-register-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 }

# Run the Actor and wait for it to finish
run = client.actor("parseforge/australia-legislation-register-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
}' |
apify call parseforge/australia-legislation-register-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Australia Federal Register of Legislation Scraper",
        "description": "Tap the Australian Federal Register of Legislation for Acts, legislative instruments, and other titles. Returns title ID, name, making date, collection, principal flag, and in force status. Filter by name or collection for legal research, compliance tracking, and policy monitoring.",
        "version": "0.1",
        "x-build-id": "qZEpHurabvbbWXdrc"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~australia-legislation-register-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-australia-legislation-register-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-legislation-register-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-australia-legislation-register-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-legislation-register-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-australia-legislation-register-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": {
                    "search": {
                        "title": "Search title name",
                        "type": "string",
                        "description": "Free text matched against the title name, for example 'Privacy' or 'Migration'. Returns every title whose name contains this text. Leave empty to list all titles."
                    },
                    "collection": {
                        "title": "Collection",
                        "enum": [
                            "",
                            "Act",
                            "LegislativeInstrument",
                            "NotifiableInstrument",
                            "AdministrativeArrangementsOrder",
                            "Constitution",
                            "ContinuedLaw",
                            "Gazette",
                            "PrerogativeInstrument"
                        ],
                        "type": "string",
                        "description": "Restrict results to one collection of the register. 'Any collection' returns titles across all collections.",
                        "default": ""
                    },
                    "filter": {
                        "title": "Advanced OData filter",
                        "type": "string",
                        "description": "Optional raw OData $filter expression for advanced queries, for example \"isPrincipal eq true\" or \"year eq 2024\". Combined with the search and collection above using AND. Leave empty if not needed."
                    },
                    "orderBy": {
                        "title": "Sort order",
                        "enum": [
                            "id desc",
                            "id asc",
                            "name asc",
                            "name desc"
                        ],
                        "type": "string",
                        "description": "Order in which titles are returned. Title ID is encoded with the year, so sorting by it groups titles roughly oldest to newest.",
                        "default": "id desc"
                    },
                    "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"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
