# ASX Company Announcements Scraper (`automation-lab/asx-company-announcements-scraper`) Actor

Monitor ASX company announcements by ticker and export disclosure metadata, price-sensitive flags, PDF links, pages, and file sizes.

- **URL**: https://apify.com/automation-lab/asx-company-announcements-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Business
- **Stats:** 3 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

## ASX Company Announcements Scraper

Extract structured ASX company announcements and disclosure PDF links by ticker.

Use this actor to monitor Australian Securities Exchange announcements for investor research, compliance review, market-data enrichment, and investor-relations workflows.

### What does ASX Company Announcements Scraper do?

ASX Company Announcements Scraper collects public company disclosure records from ASX announcement pages.

It accepts one or more ASX ticker codes.

It returns release dates, release times, titles, price-sensitive flags, document URLs, page counts, and file sizes.

It can optionally download each PDF into the run key-value store.

The default mode is metadata-first so monitoring runs stay fast and inexpensive.

### Who is it for?

#### Finance researchers

Track company disclosures by ticker without manually opening ASX pages.

#### Compliance teams

Archive market disclosures and document evidence for review workflows.

#### Investor-relations teams

Watch peer announcements, investor presentations, leadership updates, and results materials.

#### Market-data products

Feed clean announcement metadata into dashboards, alerts, databases, or downstream enrichment jobs.

#### Analysts and funds

Monitor multiple ASX codes on a schedule and export announcement links for deeper research.

### Why use this ASX announcements extractor?

- 📈 Ticker-based monitoring for listed Australian companies.
- 📄 Direct PDF/display links for each announcement.
- 🕒 Release date and time fields for alerting and time-series workflows.
- 🚩 Price-sensitive flag extraction when ASX marks the row.
- 🧾 Page count and file size metadata for triage.
- 🔁 Works well as a scheduled monitor.
- ⚙️ HTTP-first implementation with no browser overhead.

### Data you can extract

| Field | Description |
| --- | --- |
| `asxCode` | Requested ASX ticker code. |
| `companyName` | Company name shown by ASX. |
| `announcementTitle` | Announcement headline. |
| `releaseDate` | Release date. |
| `releaseTime` | Release time where available. |
| `releasedAt` | ISO-like timestamp with Australian offset where parseable. |
| `priceSensitive` | Whether the ASX row indicates price sensitivity. |
| `documentUrl` | ASX PDF/display URL. |
| `pdfUrl` | Same document URL, provided for export compatibility. |
| `pages` | Number of pages shown by ASX. |
| `fileSize` | File size label shown by ASX. |
| `fileSizeBytes` | Parsed file size in bytes when possible. |
| `sourceUrl` | Listing page URL used for extraction. |
| `searchPeriod` | Search period label shown by ASX. |
| `documentKey` | Key-value store PDF key when PDF saving is enabled. |
| `scrapedAt` | Timestamp when the record was scraped. |

### How much does it cost to scrape ASX company announcements?

This actor uses pay-per-event pricing.

There is a small start charge per run.

There is a per-announcement charge for each saved disclosure record.

For the cheapest scheduled monitoring run, keep PDF downloading disabled and set `maxItems` to the number of records you need.

PDF storage is optional because documents are larger than metadata and can increase storage and bandwidth usage.

### Input options

#### `asxCodes`

A list of ASX ticker codes.

Examples: `BHP`, `CBA`, `RIO`, `WBC`, `NAB`.

#### `period`

The ASX lookback period requested from the source endpoint.

Supported values are `D`, `W`, `M`, `M3`, `M6`, and `Y`.

#### `startDate`

Optional ISO date filter in `YYYY-MM-DD` format.

Records before this date are skipped after fetching.

#### `endDate`

Optional ISO date filter in `YYYY-MM-DD` format.

Records after this date are skipped after fetching.

#### `maxItems`

Maximum announcement records to save across all supplied ticker codes.

#### `savePdfDocuments`

When enabled, each announcement PDF is downloaded to the default key-value store and `documentKey` is populated.

Leave it disabled for fast monitoring runs.

### Example input

```json
{
  "asxCodes": ["BHP", "CBA", "RIO", "WBC", "NAB"],
  "period": "M6",
  "maxItems": 100,
  "savePdfDocuments": false
}
````

### Example output

```json
{
  "asxCode": "BHP",
  "companyName": "BHP GROUP LIMITED",
  "announcementTitle": "BHP Executive Leadership Team Update",
  "releaseDate": "2026-06-26",
  "releaseTime": "1:49 pm",
  "releasedAt": "2026-06-26T13:49:00+10:00",
  "priceSensitive": false,
  "documentUrl": "https://www.asx.com.au/asx/v2/statistics/displayAnnouncement.do?display=pdf&idsId=03108312",
  "pdfUrl": "https://www.asx.com.au/asx/v2/statistics/displayAnnouncement.do?display=pdf&idsId=03108312",
  "pages": 2,
  "fileSize": "108.5KB",
  "fileSizeBytes": 111104,
  "sourceUrl": "https://www.asx.com.au/asx/v2/statistics/announcements.do?by=asxCode&asxCode=BHP&timeframe=D&period=M6",
  "searchPeriod": "Released between 29/12/2025 and 29/06/2026",
  "documentKey": null,
  "scrapedAt": "2026-06-29T05:00:00.000Z"
}
```

### How to run the ASX announcements scraper

1. Add one or more ASX ticker codes.
2. Choose a lookback period.
3. Set `maxItems` for your monitoring budget.
4. Optionally add date filters.
5. Run the actor.
6. Export the dataset as JSON, CSV, Excel, or via API.

### Tips for best results

Use several ticker codes in one run when you want a daily disclosure digest.

Use `period: "D"` for scheduled daily monitoring.

Use `period: "M6"` or `period: "Y"` for backfills.

Keep `savePdfDocuments` off unless you need copies of the underlying PDFs.

Use `documentUrl` to fetch PDFs later in your own document pipeline.

### Integrations

#### Scheduled disclosure monitor

Run the actor daily and send new dataset rows to Slack, email, Google Sheets, or a database.

#### Compliance archive

Enable PDF storage and export `documentKey` values for evidence retention workflows.

#### Market-data enrichment

Join announcement metadata with prices, fundamentals, or internal issuer identifiers.

#### Analyst dashboard

Load the dataset into BI tools and filter by ticker, date, price-sensitive flag, or title keywords.

### API usage with Node.js

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/asx-company-announcements-scraper').call({
  asxCodes: ['BHP', 'CBA', 'RIO'],
  period: 'M6',
  maxItems: 100,
});
console.log(run.defaultDatasetId);
```

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/asx-company-announcements-scraper').call(run_input={
    'asxCodes': ['BHP', 'CBA', 'RIO'],
    'period': 'M6',
    'maxItems': 100,
})
print(run['defaultDatasetId'])
```

### API usage with cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~asx-company-announcements-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"asxCodes":["BHP","CBA","RIO"],"period":"M6","maxItems":100}'
```

### MCP integration

Use the Apify MCP server with Claude Code or Claude Desktop.

MCP URL:

```text
https://mcp.apify.com/?tools=automation-lab/asx-company-announcements-scraper
```

Add it in Claude Code:

```bash
claude mcp add apify-asx-announcements https://mcp.apify.com/?tools=automation-lab/asx-company-announcements-scraper
```

Claude Desktop JSON configuration:

```json
{
  "mcpServers": {
    "apify-asx-announcements": {
      "url": "https://mcp.apify.com/?tools=automation-lab/asx-company-announcements-scraper"
    }
  }
}
```

Example prompts:

- "Run the ASX announcements scraper for BHP and summarize price-sensitive updates."
- "Monitor CBA, NAB, WBC, and ANZ disclosures from the last week."
- "Fetch ASX announcement PDF links for RIO and save the dataset as CSV."

### Automation patterns

#### Daily ASX alerting

Schedule `period: "D"` every trading day.

Deduplicate by `documentUrl` in your downstream system.

Send only new price-sensitive rows to analysts.

#### Earnings-season monitoring

Use a larger ticker list and `period: "M"`.

Filter titles for results, presentations, dividends, and guidance updates.

#### Backfill workflow

Use `period: "Y"` and a higher `maxItems` value.

Disable PDF saving for the first pass.

Download selected PDFs later if needed.

### FAQ

#### Can I monitor multiple ASX tickers in one run?

Yes. Add multiple ticker codes to `asxCodes` and set `maxItems` high enough for the expected disclosure volume.

#### Does the actor extract full PDF text?

The default dataset focuses on reliable announcement metadata and PDF URLs. Enable PDF storage when you need raw document copies for a separate text extraction pipeline.

### Troubleshooting

#### I received fewer records than expected

The ASX endpoint only returns records available for the selected ticker and period.

Increase the period, add more ticker codes, or raise `maxItems`.

#### PDF documents were not saved

Check that `savePdfDocuments` is enabled.

If ASX temporarily fails a PDF request, the metadata record is still saved and `documentKey` remains null.

#### A ticker returned no records

Confirm the ASX code is valid and currently listed.

Try a longer lookback period.

### Legality

This actor extracts public ASX announcement pages.

Use the data in accordance with ASX terms, applicable laws, and your own compliance requirements.

Do not overload the source website.

The actor uses bounded requests and conservative defaults.

### Related scrapers

Explore other Automation Lab actors for market, financial, and compliance data workflows:

- https://apify.com/automation-lab/sec-edgar-8k-filings-scraper
- https://apify.com/automation-lab/company-news-scraper
- https://apify.com/automation-lab/website-contact-finder

### Changelog

#### 0.1

Initial private build for ASX company announcements monitoring.

### Support

If you need an additional output field, more exchanges, or a custom workflow, open an issue on the actor page.

### Output quality notes

ASX display URLs are included exactly as provided by the source endpoint.

Date and time parsing is best effort.

The original text fields are preserved so users can audit records against ASX.

### Performance notes

This is an HTTP actor.

It does not launch a browser.

Metadata-only runs are designed to be fast.

PDF-saving runs perform extra document downloads.

### Data retention notes

Dataset records are stored in the run dataset.

Optional PDFs are stored in the run key-value store.

Export or retain data according to your Apify storage settings.

# Actor input Schema

## `asxCodes` (type: `array`):

One or more ASX company codes, for example BHP, CBA, RIO, WBC, NAB.

## `period` (type: `string`):

Lookback window requested from the ASX legacy announcements endpoint. Date filters below are applied after fetching.

## `startDate` (type: `string`):

Optional ISO date filter (YYYY-MM-DD). Announcements before this date are skipped.

## `endDate` (type: `string`):

Optional ISO date filter (YYYY-MM-DD). Announcements after this date are skipped.

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

Maximum announcement records to save across all ASX codes.

## `savePdfDocuments` (type: `boolean`):

When enabled, the actor downloads each announcement PDF and stores it in the run key-value store. Leave off for cheaper metadata monitoring runs.

## Actor input object example

```json
{
  "asxCodes": [
    "BHP",
    "CBA",
    "RIO",
    "WBC",
    "NAB"
  ],
  "period": "M6",
  "maxItems": 20,
  "savePdfDocuments": false
}
```

# 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 = {
    "asxCodes": [
        "BHP",
        "CBA",
        "RIO",
        "WBC",
        "NAB"
    ],
    "period": "M6",
    "maxItems": 20,
    "savePdfDocuments": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/asx-company-announcements-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 = {
    "asxCodes": [
        "BHP",
        "CBA",
        "RIO",
        "WBC",
        "NAB",
    ],
    "period": "M6",
    "maxItems": 20,
    "savePdfDocuments": False,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/asx-company-announcements-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 '{
  "asxCodes": [
    "BHP",
    "CBA",
    "RIO",
    "WBC",
    "NAB"
  ],
  "period": "M6",
  "maxItems": 20,
  "savePdfDocuments": false
}' |
apify call automation-lab/asx-company-announcements-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=automation-lab/asx-company-announcements-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "ASX Company Announcements Scraper",
        "description": "Monitor ASX company announcements by ticker and export disclosure metadata, price-sensitive flags, PDF links, pages, and file sizes.",
        "version": "0.1",
        "x-build-id": "F8MJ1Kw7DXHCQSoSm"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~asx-company-announcements-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-asx-company-announcements-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/automation-lab~asx-company-announcements-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-asx-company-announcements-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/automation-lab~asx-company-announcements-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-asx-company-announcements-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",
                "required": [
                    "asxCodes"
                ],
                "properties": {
                    "asxCodes": {
                        "title": "ASX ticker codes",
                        "minItems": 1,
                        "type": "array",
                        "description": "One or more ASX company codes, for example BHP, CBA, RIO, WBC, NAB.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "period": {
                        "title": "ASX lookback period",
                        "enum": [
                            "D",
                            "W",
                            "M",
                            "M3",
                            "M6",
                            "Y"
                        ],
                        "type": "string",
                        "description": "Lookback window requested from the ASX legacy announcements endpoint. Date filters below are applied after fetching.",
                        "default": "M6"
                    },
                    "startDate": {
                        "title": "Start date",
                        "type": "string",
                        "description": "Optional ISO date filter (YYYY-MM-DD). Announcements before this date are skipped."
                    },
                    "endDate": {
                        "title": "End date",
                        "type": "string",
                        "description": "Optional ISO date filter (YYYY-MM-DD). Announcements after this date are skipped."
                    },
                    "maxItems": {
                        "title": "Maximum announcements",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum announcement records to save across all ASX codes.",
                        "default": 20
                    },
                    "savePdfDocuments": {
                        "title": "Save PDF documents to key-value store",
                        "type": "boolean",
                        "description": "When enabled, the actor downloads each announcement PDF and stores it in the run key-value store. Leave off for cheaper metadata monitoring runs.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
