# Taiwan MOPS Company Announcements Scraper (`automation-lab/taiwan-mops-company-announcements-scraper`) Actor

Track Taiwan MOPS company announcements from the public TWSE OpenAPI with clean date, company, keyword, and clause filters.

- **URL**: https://apify.com/automation-lab/taiwan-mops-company-announcements-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Business
- **Stats:** 2 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

## Taiwan MOPS Company Announcements Scraper

Track Taiwan MOPS material company announcements from the public TWSE OpenAPI. This Apify Actor turns the official Traditional Chinese disclosure feed into clean English-keyed dataset records with date, company, keyword, clause, and volume filters.

Use it to monitor listed-company material events, corporate-governance updates, tender offers, dividend announcements, board changes, market status notices, and other disclosures published through Taiwan's Market Observation Post System (MOPS).

### What does Taiwan MOPS Company Announcements Scraper do?

The actor fetches the TWSE/MOPS public announcements OpenAPI and emits one dataset item per announcement.

It normalizes the source fields into stable English aliases while preserving the original context:

- 🏢 Company stock code and company name
- 📅 Announcement date, announcement time, report date, and event date
- 🧾 Announcement title and MOPS clause
- 📝 Full announcement description/details
- 🔗 Human source page and source API URL
- 🕒 Scrape timestamp for monitoring pipelines
- 🇹🇼 Optional raw Traditional Chinese source fields

### Who is it for?

This actor is useful for teams that need repeatable Taiwan disclosure monitoring.

- 📈 Equity researchers tracking listed Taiwan companies
- 🌏 APAC market-intelligence teams covering exchange disclosures
- 🧑‍⚖️ Corporate-governance and compliance analysts
- 📰 Financial news monitors looking for material-event signals
- 🏦 Investor-relations teams watching peer-company announcements
- 🤖 Data engineers building alerts, dashboards, or LLM workflows

### Why use this actor?

The official endpoint is public, but raw MOPS records use Traditional Chinese field names, ROC dates, and source-specific whitespace. This actor packages the feed for repeatable automation.

Benefits:

- No login required
- No browser required
- No proxy required
- Low-cost HTTP/API execution
- Stable English output aliases
- Raw fields available when needed
- Works well for scheduled monitoring runs

### Source coverage

The actor uses the public TWSE OpenAPI endpoint:

`https://openapi.twse.com.tw/v1/opendata/t187ap04_L`

The feed is maintained by TWSE/MOPS and contains listed-company announcement records. Availability and historical depth are controlled by the public source.

### Data you can extract

| Field | Description |
| --- | --- |
| `companyCode` | Taiwan listed-company stock code |
| `companyName` | Company name from MOPS |
| `announcementDate` | Announcement date converted to ISO format |
| `announcementTime` | Announcement time in `HH:mm:ss` |
| `eventDate` | Fact/event date converted to ISO format |
| `reportDate` | Source report date converted to ISO format |
| `title` | Material announcement title |
| `clause` | MOPS clause/category value |
| `description` | Full announcement detail text |
| `sourceUrl` | Human MOPS search page |
| `sourceApiUrl` | Public API endpoint used by the actor |
| `scrapedAt` | Time when the actor saved the record |
| `raw` | Optional raw Traditional Chinese source object |

### How much does it cost to scrape Taiwan MOPS announcements?

This actor uses pay-per-event pricing:

- A small start event is charged once per run.
- A per-announcement event is charged only for records saved to the dataset.

The actor is HTTP/API-only and does not use paid proxies, so it is designed for inexpensive scheduled monitoring. Exact live prices are shown on the Apify Store page after launch.

### Input options

You can run the actor broadly or with focused monitoring filters.

#### Date filters

Use `startDate` and `endDate` to keep only announcements in a date range.

Accepted formats:

- ISO date: `2026-06-30`
- ROC date: `1150630`

#### Company filters

Use `companyCodes` to monitor specific listed companies.

Examples:

- `2330` — TSMC
- `2317` — Hon Hai / Foxconn
- `2454` — MediaTek

#### Keyword filters

Use `titleKeyword` to match the announcement title or description.

Examples:

- `股利`
- `董事`
- `併購`
- `tender offer`

#### Clause filter

Use `announcementType` when you need an exact MOPS clause such as `第14款`.

#### Run limit

Use `maxItems` to control the maximum number of announcements saved.

### Example input: monitor dividend announcements

```json
{
  "startDate": "2026-06-01",
  "endDate": "2026-06-30",
  "titleKeyword": "股利",
  "maxItems": 100,
  "includeRawFields": false
}
````

### Example input: monitor specific companies

```json
{
  "companyCodes": ["2330", "2317", "2454"],
  "maxItems": 100,
  "includeRawFields": true
}
```

### Example output

```json
{
  "companyCode": "2330",
  "companyName": "台積電",
  "announcementDate": "2026-06-30",
  "announcementTime": "14:30:00",
  "eventDate": "2026-06-30",
  "reportDate": "2026-06-30",
  "title": "公告本公司...",
  "clause": "第14款",
  "description": "1.事實發生日...",
  "sourceUrl": "https://mops.twse.com.tw/mops/web/t05sr01_1",
  "sourceApiUrl": "https://openapi.twse.com.tw/v1/opendata/t187ap04_L",
  "scrapedAt": "2026-06-30T04:30:00.000Z"
}
```

### How to run

1. Open the actor on Apify.
2. Enter optional date, company, keyword, or clause filters.
3. Choose a `maxItems` limit.
4. Run the actor.
5. Export the dataset as JSON, CSV, Excel, or via API.

### Scheduling and monitoring

For disclosure monitoring, schedule the actor to run daily or hourly. Use a narrow keyword/company filter for alerting workflows, or run broadly and filter downstream in your warehouse.

Common schedules:

- Daily market-monitoring snapshot
- Hourly corporate-event alerting
- Weekly APAC disclosure archive refresh

### Integration ideas

- Send matching announcements to Slack or Teams.
- Load datasets into BigQuery, Snowflake, or PostgreSQL.
- Trigger an Apify webhook when a new disclosure appears.
- Feed records into an LLM summarizer for English briefs.
- Combine with financial statement or SEC filing actors for cross-market monitoring.

### API usage with JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/taiwan-mops-company-announcements-scraper').call({
  companyCodes: ['2330', '2317'],
  maxItems: 100,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items[0]);
```

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/taiwan-mops-company-announcements-scraper').call(
    run_input={
        'titleKeyword': '股利',
        'maxItems': 100,
    }
)
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items[0])
```

### API usage with cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~taiwan-mops-company-announcements-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"companyCodes":["2330"],"maxItems":50}'
```

### MCP usage

Use the Apify MCP server to call this actor from Claude Desktop, Claude Code, or other MCP clients.

MCP URL:

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

Claude Code setup:

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

Claude Desktop JSON config:

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

Example prompts:

- "Run the Taiwan MOPS announcements scraper for company code 2330 and summarize new governance disclosures."
- "Find dividend-related Taiwan MOPS announcements from the latest feed."
- "Monitor MOPS announcements with the keyword 董事 and return the most important items."

### Data quality notes

- Dates are converted from ROC year format to ISO dates.
- Source line breaks are preserved where they carry meaning.
- Extra spaces and repeated blank lines are normalized.
- Raw fields can be included for auditability.
- The actor does not translate Traditional Chinese text; it preserves source language.

### Troubleshooting

#### I received fewer records than expected

The public OpenAPI feed may only expose the currently available set of announcements. Broaden your date range, remove company filters, or increase `maxItems`.

#### My company code returned no results

Check that the company has announcements in the current public feed. Use the actor without `companyCodes` first, then add the code once you confirm it appears.

#### Keyword matching missed an item

The keyword filter matches the title and description exactly as text. Try a shorter Traditional Chinese term or run without the keyword and filter downstream.

### Limitations

- Coverage depends on the public TWSE/MOPS OpenAPI feed.
- Historical depth is limited by the source endpoint.
- The actor does not scrape private pages or login-only data.
- The actor does not provide legal, investment, or trading advice.

### Legality and responsible use

This actor uses a public OpenAPI endpoint and saves publicly available company disclosure data. You are responsible for using the data in accordance with applicable laws, platform terms, and your organization's compliance requirements.

### Related scrapers

Explore related Automation Lab actors for financial and regulatory workflows:

- ASX announcements scraper: `https://apify.com/automation-lab/asx-announcements-scraper`
- SEC filings scraper: `https://apify.com/automation-lab/sec-filings-scraper`
- SEC litigation releases scraper: `https://apify.com/automation-lab/sec-litigation-releases-scraper`
- Financial statements scraper: `https://apify.com/automation-lab/financial-statements-scraper`

### FAQ

#### Does this actor require a proxy?

No. The source is a public OpenAPI endpoint, so the actor runs as an HTTP/API integration without paid proxies.

#### Does this actor translate Traditional Chinese announcements?

No. It normalizes field names and dates but keeps the official announcement text unchanged.

#### Can I monitor only one company?

Yes. Put one or more Taiwan stock codes in `companyCodes`.

#### Can I use this for alerts?

Yes. Schedule the actor and connect dataset or run-finished webhooks to your alerting system.

#### Can I export to Excel?

Yes. Apify datasets can be exported as JSON, CSV, Excel, XML, RSS, or HTML.

### Support

If the public MOPS endpoint changes, report an issue on Apify with the input you used and a link to the failed run. Include whether the failure happened for all inputs or only a specific date/company filter.

# Actor input Schema

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

Earliest announcement date to include. Use ISO date (2026-06-01) or ROC date (1150601). Leave empty for the current OpenAPI feed.

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

Latest announcement date to include. Use ISO date (2026-06-30) or ROC date (1150630). Leave empty for no upper limit.

## `companyCodes` (type: `array`):

Optional Taiwan listed-company stock codes to monitor, for example 2330 for TSMC or 2317 for Hon Hai. Empty means all companies.

## `titleKeyword` (type: `string`):

Optional Traditional Chinese or English keyword to match against the announcement title and description, such as 股利, 董事, or merger.

## `announcementType` (type: `string`):

Optional exact MOPS clause value, for example 第14款. Leave empty to include every announcement type.

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

Maximum dataset records to save. Keep this low for a quick smoke test; increase for monitoring or archival runs.

## `includeRawFields` (type: `boolean`):

Attach the original TWSE/MOPS JSON object to each output item for auditability and downstream translation workflows.

## Actor input object example

```json
{
  "companyCodes": [],
  "maxItems": 20,
  "includeRawFields": 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 = {
    "startDate": "",
    "endDate": "",
    "companyCodes": [],
    "titleKeyword": "",
    "maxItems": 20,
    "includeRawFields": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/taiwan-mops-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 = {
    "startDate": "",
    "endDate": "",
    "companyCodes": [],
    "titleKeyword": "",
    "maxItems": 20,
    "includeRawFields": False,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/taiwan-mops-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 '{
  "startDate": "",
  "endDate": "",
  "companyCodes": [],
  "titleKeyword": "",
  "maxItems": 20,
  "includeRawFields": false
}' |
apify call automation-lab/taiwan-mops-company-announcements-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Taiwan MOPS Company Announcements Scraper",
        "description": "Track Taiwan MOPS company announcements from the public TWSE OpenAPI with clean date, company, keyword, and clause filters.",
        "version": "0.1",
        "x-build-id": "R3vu5ftNOggGOJ5dG"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~taiwan-mops-company-announcements-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-taiwan-mops-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~taiwan-mops-company-announcements-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-taiwan-mops-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~taiwan-mops-company-announcements-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-taiwan-mops-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",
                "properties": {
                    "startDate": {
                        "title": "Start announcement date",
                        "type": "string",
                        "description": "Earliest announcement date to include. Use ISO date (2026-06-01) or ROC date (1150601). Leave empty for the current OpenAPI feed."
                    },
                    "endDate": {
                        "title": "End announcement date",
                        "type": "string",
                        "description": "Latest announcement date to include. Use ISO date (2026-06-30) or ROC date (1150630). Leave empty for no upper limit."
                    },
                    "companyCodes": {
                        "title": "Company stock codes",
                        "type": "array",
                        "description": "Optional Taiwan listed-company stock codes to monitor, for example 2330 for TSMC or 2317 for Hon Hai. Empty means all companies.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "titleKeyword": {
                        "title": "Title or description keyword",
                        "type": "string",
                        "description": "Optional Traditional Chinese or English keyword to match against the announcement title and description, such as 股利, 董事, or merger."
                    },
                    "announcementType": {
                        "title": "MOPS clause / announcement type",
                        "type": "string",
                        "description": "Optional exact MOPS clause value, for example 第14款. Leave empty to include every announcement type."
                    },
                    "maxItems": {
                        "title": "Maximum announcements",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum dataset records to save. Keep this low for a quick smoke test; increase for monitoring or archival runs.",
                        "default": 20
                    },
                    "includeRawFields": {
                        "title": "Include raw Traditional Chinese fields",
                        "type": "boolean",
                        "description": "Attach the original TWSE/MOPS JSON object to each output item for auditability and downstream translation workflows.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```