# SEC Form N-PORT Mutual Fund Holdings Scraper (`automation-lab/sec-form-nport-mutual-fund-holdings-scraper`) Actor

Extract SEC EDGAR N-PORT/NPORT-P mutual fund holdings by CIK or ticker with identifiers, balances, USD values, and filing URLs.

- **URL**: https://apify.com/automation-lab/sec-form-nport-mutual-fund-holdings-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Other
- **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

## SEC Form N-PORT Mutual Fund Holdings Scraper

Extract structured mutual fund portfolio holdings from public SEC EDGAR N-PORT and NPORT-P filings. Provide fund tickers or CIKs and get a flat dataset of securities, identifiers, balances, values, classifications, and source filing metadata.

### What does this actor do?

This actor turns SEC N-PORT filings into analysis-ready holding rows. It resolves fund tickers through SEC ticker maps, reads each registrant's submissions JSON, filters NPORT filings, downloads the raw SEC submission document, and parses each `invstOrSec` holding.

### Who is it for?

- 🧾 Compliance teams monitoring mutual fund portfolio disclosures.
- 📈 Fund analysts comparing disclosed holdings across report periods.
- 🏦 Fintech data teams enriching security master or portfolio databases.
- 🔎 Researchers who need repeatable EDGAR extraction without hand-opening filings.
- 🤖 Automation builders feeding BI, alerts, or data warehouses.

### Why use it?

SEC N-PORT filings are public, but the raw XML is nested and inconsistent enough to slow down analysts. This actor provides a polite API-first workflow and returns a normalized table suitable for CSV, JSON, API, or scheduled exports.

### Data you can extract

| Field group | Examples |
| --- | --- |
| Filing | CIK, form type, accession number, filing date, report date, raw filing URL |
| Fund | registrant name, series name, series ID, class ID, ticker |
| Security | name, title, LEI, CUSIP, ISIN |
| Position | balance, units, currency, exchange rate, value USD, percent value |
| Classification | payoff profile, asset category, issuer category, issuer country, restricted flag |

### How much does it cost to scrape SEC Form N-PORT mutual fund holdings?

The actor uses pay-per-event pricing: a small start event and a per-holding result event. SEC data is public and HTTP-based, so runs are designed to be low-cost. Use `maxHoldings` and `maxFilingsPerCik` to control run size.

### Input options

- `tickers` — mutual fund/share-class tickers such as `LACAX`.
- `ciks` — SEC registrant CIKs with or without leading zeros.
- `startDate` / `endDate` — filing date range filters.
- `formTypes` — defaults to `NPORT-P` and `NPORT-EX`.
- `maxFilingsPerCik` — recent matching filings per registrant.
- `maxHoldings` — maximum dataset rows for cost control.
- `requestDelayMs` — polite delay between SEC requests.
- `userAgent` — SEC-compliant descriptive User-Agent.

### Example input

```json
{
  "tickers": ["LACAX"],
  "ciks": ["0000002110"],
  "startDate": "2025-01-01",
  "formTypes": ["NPORT-P"],
  "maxFilingsPerCik": 2,
  "maxHoldings": 100,
  "requestDelayMs": 350
}
````

### Example output

```json
{
  "cik": "0000002110",
  "ticker": "LACAX",
  "formType": "NPORT-P",
  "accessionNumber": "0001410368-26-055109",
  "filingDate": "2026-05-28",
  "registrantName": "COLUMBIA ACORN TRUST",
  "seriesName": "Columbia Acorn International Select",
  "securityName": "adidas AG",
  "cusip": "000000000",
  "isin": "DE000A1EWWW0",
  "balance": 15472,
  "units": "NS",
  "currency": "EUR",
  "valueUsd": 2504247.42,
  "percentValue": 1.35812107416,
  "assetCategory": "EC",
  "issuerCountry": "DE",
  "rawFilingUrl": "https://www.sec.gov/Archives/..."
}
```

### How to run it

1. Open the actor input page.
2. Enter one or more fund tickers or CIKs.
3. Set a filing date range if needed.
4. Choose the maximum filings and holdings.
5. Run the actor.
6. Export the dataset as CSV, JSON, Excel, or via API.

### SEC fair access

The actor sends a descriptive User-Agent and includes a configurable request delay. Keep concurrency low and avoid unnecessary repeat runs against the same filings. For scheduled monitoring, prefer daily or weekly cadence unless your workflow requires more frequent updates.

### Ticker resolution

Mutual fund tickers are resolved through `company_tickers_mf.json`. If a ticker is not found there, the actor also checks the standard SEC company ticker map. You can always bypass ticker resolution by providing a CIK directly.

### Filing selection

The actor reads `data.sec.gov/submissions/CIK##########.json`, then filters recent filings by form type and filing date. It downloads the raw `.txt` submission for each selected accession because that file contains the original N-PORT XML data.

### Output quality notes

N-PORT filings can vary by registrant and period. Some securities may not have every identifier, and some derivatives or non-standard positions may omit fields such as ISIN or CUSIP. Missing upstream values are left blank rather than guessed.

### Tips for best results

- Start with one ticker and `maxHoldings` around 100 to confirm the target fund.
- Use CIKs for production workflows when you already know the registrant.
- Increase `maxFilingsPerCik` for historical comparisons.
- Keep `requestDelayMs` at 350 ms or higher for polite EDGAR access.
- Export CSV when analysts need quick spreadsheet review.

### Integrations

- 📊 Send results to Google Sheets or a BI warehouse.
- 🧠 Feed holdings into portfolio analytics or risk classification systems.
- 🔔 Schedule recurring runs and alert when a fund discloses new holdings.
- 🧾 Archive source filing URLs for compliance evidence.

### API usage: Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/sec-form-nport-mutual-fund-holdings-scraper').call({
  tickers: ['LACAX'],
  maxFilingsPerCik: 2,
  maxHoldings: 100
});
console.log(run.defaultDatasetId);
```

### API usage: Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/sec-form-nport-mutual-fund-holdings-scraper').call(run_input={
    'tickers': ['LACAX'],
    'maxFilingsPerCik': 2,
    'maxHoldings': 100,
})
print(run['defaultDatasetId'])
```

### API usage: cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~sec-form-nport-mutual-fund-holdings-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"tickers":["LACAX"],"maxFilingsPerCik":2,"maxHoldings":100}'
```

### MCP usage

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

Claude Code setup:

```bash
claude mcp add apify https://mcp.apify.com/?tools=automation-lab/sec-form-nport-mutual-fund-holdings-scraper
```

Claude Desktop JSON config:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com/?tools=automation-lab/sec-form-nport-mutual-fund-holdings-scraper"
    }
  }
}
```

Direct MCP URL:

```text
https://mcp.apify.com/?tools=automation-lab/sec-form-nport-mutual-fund-holdings-scraper
```

Example prompts:

- "Run the SEC N-PORT holdings scraper for LACAX and summarize the top holdings by value."
- "Compare the latest two NPORT-P filings for CIK 0000002110."
- "Export mutual fund holdings with CUSIP and ISIN fields for compliance review."

### Scheduling and monitoring

Create an Apify task with your preferred tickers, date window, and row limit. Schedule it monthly or quarterly to track new disclosures. The raw filing URL in every row makes it easy to audit where a value came from.

### FAQ

#### Can I scrape all holdings for a fund?

Yes. Increase `maxHoldings` high enough for the target filing. Large diversified funds may contain hundreds or thousands of rows.

### Common troubleshooting

#### Why did my ticker return no filings?

Some tickers map to a class or series whose registrant may not have recent NPORT filings in the selected date range. Try providing the registrant CIK directly or widening the date window.

#### Why are some identifiers blank?

The actor only returns identifiers present in the SEC filing. Some holdings omit ISIN, LEI, CUSIP, currency, or fair-value fields.

#### Why should I provide a User-Agent?

SEC fair-access guidance asks automated clients to identify themselves. The actor includes a default User-Agent, but organizations may prefer to include their own contact string.

### Legality

This actor reads public SEC EDGAR data. You are responsible for using the data in compliance with SEC terms, Apify terms, and any rules that apply to your organization or jurisdiction.

### Related scrapers

- https://apify.com/automation-lab/sec-edgar-company-filings-scraper
- https://apify.com/automation-lab/sec-form-144-restricted-stock-sales-tracker
- https://apify.com/automation-lab/fixed-income-fund-tracker
- https://apify.com/automation-lab/earnings-transcripts

### Changelog

- 0.1 — Initial SEC EDGAR N-PORT holdings extraction by ticker/CIK.

### Support

If a run fails or a filing parses unexpectedly, share the run ID, input, and target CIK/ticker so the issue can be reproduced.

### Output field reference

- `cik`
- `ticker`
- `formType`
- `accessionNumber`
- `filingDate`
- `reportDate`
- `registrantName`
- `seriesName`
- `seriesId`
- `classId`
- `securityName`
- `securityTitle`
- `lei`
- `cusip`
- `isin`
- `balance`
- `units`
- `currency`
- `exchangeRate`
- `valueUsd`
- `percentValue`
- `payoffProfile`
- `assetCategory`
- `issuerCategory`
- `issuerCountry`
- `isRestrictedSecurity`
- `fairValueLevel`
- `rawFilingUrl`
- `scrapedAt`

# Actor input Schema

## `tickers` (type: `array`):

Mutual fund/share-class tickers to resolve through SEC company\_tickers\_mf.json, for example LACAX or VFIAX.

## `ciks` (type: `array`):

SEC registrant CIKs. Use this when you already know the fund registrant CIK.

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

Only include filings filed on or after this date (YYYY-MM-DD).

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

Only include filings filed on or before this date (YYYY-MM-DD). Leave empty for latest filings.

## `formTypes` (type: `array`):

SEC forms to include. NPORT-P is the standard monthly portfolio holdings form.

## `maxFilingsPerCik` (type: `integer`):

Maximum recent matching filings to download for each CIK.

## `maxHoldings` (type: `integer`):

Maximum holding rows to save across the whole run. Increase for full portfolio exports.

## `requestDelayMs` (type: `integer`):

Polite delay to respect SEC fair-access guidance. Keep at least 100 ms; 350 ms is a safe default.

## `userAgent` (type: `string`):

Descriptive User-Agent sent to SEC endpoints. SEC recommends including an app/contact identifier.

## Actor input object example

```json
{
  "tickers": [
    "LACAX"
  ],
  "ciks": [
    "0000002110"
  ],
  "startDate": "2025-01-01",
  "formTypes": [
    "NPORT-P"
  ],
  "maxFilingsPerCik": 2,
  "maxHoldings": 20,
  "requestDelayMs": 350,
  "userAgent": "Automation-Lab SEC N-PORT Scraper/0.1 (contact: support@automation-lab.example)"
}
```

# 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 = {
    "tickers": [
        "LACAX"
    ],
    "ciks": [
        "0000002110"
    ],
    "startDate": "2025-01-01",
    "formTypes": [
        "NPORT-P"
    ],
    "maxFilingsPerCik": 2,
    "maxHoldings": 20,
    "requestDelayMs": 350,
    "userAgent": "Automation-Lab SEC N-PORT Scraper/0.1 (contact: support@automation-lab.example)"
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/sec-form-nport-mutual-fund-holdings-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 = {
    "tickers": ["LACAX"],
    "ciks": ["0000002110"],
    "startDate": "2025-01-01",
    "formTypes": ["NPORT-P"],
    "maxFilingsPerCik": 2,
    "maxHoldings": 20,
    "requestDelayMs": 350,
    "userAgent": "Automation-Lab SEC N-PORT Scraper/0.1 (contact: support@automation-lab.example)",
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/sec-form-nport-mutual-fund-holdings-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 '{
  "tickers": [
    "LACAX"
  ],
  "ciks": [
    "0000002110"
  ],
  "startDate": "2025-01-01",
  "formTypes": [
    "NPORT-P"
  ],
  "maxFilingsPerCik": 2,
  "maxHoldings": 20,
  "requestDelayMs": 350,
  "userAgent": "Automation-Lab SEC N-PORT Scraper/0.1 (contact: support@automation-lab.example)"
}' |
apify call automation-lab/sec-form-nport-mutual-fund-holdings-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=automation-lab/sec-form-nport-mutual-fund-holdings-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "SEC Form N-PORT Mutual Fund Holdings Scraper",
        "description": "Extract SEC EDGAR N-PORT/NPORT-P mutual fund holdings by CIK or ticker with identifiers, balances, USD values, and filing URLs.",
        "version": "0.1",
        "x-build-id": "exwlHNtqejWDSb1Fh"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~sec-form-nport-mutual-fund-holdings-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-sec-form-nport-mutual-fund-holdings-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~sec-form-nport-mutual-fund-holdings-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-sec-form-nport-mutual-fund-holdings-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~sec-form-nport-mutual-fund-holdings-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-sec-form-nport-mutual-fund-holdings-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": {
                    "tickers": {
                        "title": "Fund tickers",
                        "type": "array",
                        "description": "Mutual fund/share-class tickers to resolve through SEC company_tickers_mf.json, for example LACAX or VFIAX.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "ciks": {
                        "title": "CIKs",
                        "type": "array",
                        "description": "SEC registrant CIKs. Use this when you already know the fund registrant CIK.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startDate": {
                        "title": "Start filing date",
                        "type": "string",
                        "description": "Only include filings filed on or after this date (YYYY-MM-DD)."
                    },
                    "endDate": {
                        "title": "End filing date",
                        "type": "string",
                        "description": "Only include filings filed on or before this date (YYYY-MM-DD). Leave empty for latest filings."
                    },
                    "formTypes": {
                        "title": "Form types",
                        "type": "array",
                        "description": "SEC forms to include. NPORT-P is the standard monthly portfolio holdings form.",
                        "items": {
                            "type": "string"
                        },
                        "default": [
                            "NPORT-P",
                            "NPORT-EX"
                        ]
                    },
                    "maxFilingsPerCik": {
                        "title": "Max filings per CIK",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum recent matching filings to download for each CIK.",
                        "default": 3
                    },
                    "maxHoldings": {
                        "title": "Max holdings",
                        "minimum": 1,
                        "maximum": 50000,
                        "type": "integer",
                        "description": "Maximum holding rows to save across the whole run. Increase for full portfolio exports.",
                        "default": 20
                    },
                    "requestDelayMs": {
                        "title": "Delay between SEC requests (ms)",
                        "minimum": 100,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Polite delay to respect SEC fair-access guidance. Keep at least 100 ms; 350 ms is a safe default.",
                        "default": 350
                    },
                    "userAgent": {
                        "title": "SEC User-Agent",
                        "type": "string",
                        "description": "Descriptive User-Agent sent to SEC endpoints. SEC recommends including an app/contact identifier."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```