# SEC EDGAR Filing Monitor (`bytehavenstudios/sec-edgar-filing-monitor`) Actor

Change-detection over the live SEC EDGAR filing stream. Maintain a watchlist (CIKs/tickers) and form-type filter (8-K, 4, SC 13D/13G, S-1, 10-K/10-Q); each run emits one record per newly-appeared accession, joined to issuer metadata and event-classified. Keyless. Not endorsed by the SEC.

- **URL**: https://apify.com/bytehavenstudios/sec-edgar-filing-monitor.md
- **Developed by:** [ByteHaven Studios](https://apify.com/bytehavenstudios) (community)
- **Categories:** Developer tools, News
- **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.

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 EDGAR Filing Monitor

**First-seen change-detection over the live SEC EDGAR filing stream.** Give it a watchlist (CIKs
and/or tickers) plus a form-type filter (8-K, 4, SC 13D/13G, S-1, 10-K/10-Q, 424B); each run emits
one normalized record per **newly-appeared accession**, joined to issuer metadata (name, ticker,
CIK, SIC, state) and classified for high-value events (new 13D/13G ownership stakes, Form 4 insider
buys/sells, 8-K material events), with a **new-since-last-run** high-water-mark mode across scheduled
runs.

Clean REST/JSON — no browser, no proxy, no login, no API key required.
**Data source: SEC EDGAR (U.S. federal, public domain, 17 U.S.C. §105).**

> This product uses data from the U.S. Securities and Exchange Commission's EDGAR system, but is not
> endorsed or certified by the SEC.

> **Status: scaffold (v0.1, in progress).** This Actor is being built in slices; the runtime logic
> (`src/edgar.js`, `src/filters.js`, `src/main.js`) is landing incrementally. This README documents
> the intended product surface. See `CHANGELOG.md` for what's implemented so far.

---

### What it does

For each run it resolves the watchlist (tickers → CIKs via SEC's `company_tickers.json`), queries
the **per-issuer submissions feed** `GET https://data.sec.gov/submissions/CIK##########.json`
(zero-padded 10-digit CIK) and the **cross-issuer full-text search**
`GET https://efts.sec.gov/LATEST/search-index?q=&forms=&startdt=&enddt=&from=&hits=`, applies your
form-type filter, keeps only accessions accepted after the last-run high-water-mark, dedupes on the
**accession number** (`adsh`), and pushes one dataset item per filing.

- **First-seen change-detection** (the moat): farms bulk-download filings; this instead watches the
  live stream and emits each accession the first run it appears, normalized and issuer-joined.
- **Watchlist + form filter**: monitor specific CIKs/tickers and/or specific form families.
- **Event classification**: new 13D/13G stakes, Form 4 insider trades, 8-K material events.
- **New-filing monitor**: `monitorNewOnly` persists the max acceptance-datetime seen (in the Actor's
  key-value store) and, on the next scheduled run, emits only accessions accepted after it.

### Inputs

| Input | Type | Notes |
|---|---|---|
| `ciks` | string[] | CIKs to watch (any form; normalized to 10-digit). Empty = market-wide by form only |
| `tickers` | string[] | Tickers to watch, resolved to CIKs via `company_tickers.json` |
| `forms` | string[] | Form types (`8-K`, `4`, `SC 13D`, `S-1`, `10-K`…). Empty = all |
| `since` | string | `startdt` delta cursor (YYYY-MM-DD). Empty = recent trailing window |
| `until` | string | Optional `enddt` upper bound (YYYY-MM-DD). Empty = up to today |
| `query` | string | Optional full-text `q` (phrase in quotes). Empty = match all (`q=*`) |
| `monitorNewOnly` | boolean | Emit only accessions after the stored acceptance-datetime high-water-mark |
| `maxResults` | integer | Cap total filings returned (0 = no cap) |
| `proxyConfiguration` | object | Optional; the API is open and needs no proxy. Default: none |

### Output — one record per filing (intended shape)

```json
{
  "adsh": "0001437749-12-001697",
  "cik": "0000320193",
  "issuerName": "Apple Inc.",
  "tickers": ["AAPL"],
  "form": "8-K",
  "rootForm": "8-K",
  "filingDate": "2026-07-09",
  "acceptanceDateTime": "2026-07-09T16:31:12.000Z",
  "primaryDocument": "aapl-20260709.htm",
  "primaryDocumentUrl": "https://www.sec.gov/Archives/edgar/data/320193/000143774912001697/aapl-20260709.htm",
  "periodOfReport": "2026-07-09",
  "sic": "3571",
  "sicDescription": "Electronic Computers",
  "stateOfIncorp": "CA",
  "bizState": "CA",
  "fileNumber": "001-36743",
  "eventType": "material-event",
  "isNew": true,
  "attribution": "This product uses data from the U.S. Securities and Exchange Commission's EDGAR system, but is not endorsed or certified by the SEC.",
  "fetchedAt": "2026-07-10T14:00:00.000Z"
}
````

`adsh` (accession number) is the dedupe key. `cik` is the zero-padded 10-digit issuer key.
`isNew` is `true` when an accession was not seen in a previous run (only meaningful with
`monitorNewOnly`). Every record carries the required SEC no-endorsement `attribution` string.

#### Control records (not charged)

Two non-filing records may be pushed to signal run state. Neither triggers a `filing-returned`
charge:

| Record | When | Shape |
|---|---|---|
| `_noData` | No filings matched the watchlist/form/window | `{ "_noData": true, "filters": {...}, "message": "...", "fetchedAt": "..." }` |
| `_error` | The fetch failed after retries, or normalization threw | `{ "_error": true, "filters": {...}, "message": "...", "fetchedAt": "..." }` |

`_noData` keeps a zero-result run green and auditable rather than pushing a silent empty dataset.

### Pricing (pay-per-event)

One **`filing-returned`** event is charged per filing record pushed to the dataset. Cost scales with
results, not runtime. Use `ciks` / `tickers` / `forms` / `maxResults` / `monitorNewOnly` to keep
spend proportional to signal. (Live price shown on the Store page; see `docs/PRICING.md`, lands in a
later slice.)

### Data source & attribution

SEC EDGAR data is U.S.-government public domain (17 U.S.C. §105). Per SEC's Website Dissemination
policy: *"Information presented on sec.gov is considered public information and may be copied or
further distributed by users of the web site without the SEC's permission."* No API key is required.
This Actor surfaces a no-endorsement attribution string on every record and in the listing:
*"This product uses data from the U.S. Securities and Exchange Commission's EDGAR system, but is not
endorsed or certified by the SEC."* Full compliance record: `COMPLIANCE.md` (lands in a later slice).

> EDGAR relays filer-submitted data; filings may be corrected, amended, or refiled. This Actor
> relays the data as published; it does not certify accuracy.

### Maintenance notes (scaffold — carried into the API layer, slice 2)

- **Mandatory descriptive `User-Agent`.** SEC fair-access requires a declared UA on every request;
  undeclared tools get an "Undeclared Automated Tool" error. Wire this exact constant into the API
  layer (`src/edgar.js`):
  **`ByteHaven Studios EDGAR Monitor developer@bytehavenstudios.com`**
- **Rate limit** — stay under SEC's **10 requests/second** fair-access ceiling; throttle + back off
  on `403`/`429`.
- **Zero-pad CIK** to 10 digits for `data.sec.gov/submissions/CIK##########.json`.
- **EFTS coverage/cap** — full-text search covers 2001-present only and returns **≤10,000 hits per
  query**; window/paginate by date (`startdt`/`enddt`, `from`/`hits`) to stay under it.
- **Form taxonomy drift** — match on both `form` and `root_forms`; new form variants appear.
- **Ticker map refresh** — re-fetch `company_tickers.json` periodically for new listings/renames.
- **Trademark caveat** — text reference to "EDGAR" is fine, but do NOT use the SEC seal or EDGAR
  marks in the product NAME/branding.
- **`/cgi-bin` is robots-disallowed** — never use `browse-edgar`/`getcurrent`; the JSON hosts
  (`data.sec.gov`, `efts.sec.gov`) and `/Archives/edgar/`, `/files/` are the sanctioned paths.

# Actor input Schema

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

SEC Central Index Keys to monitor. Accepts any form — bare number ("320193"), zero-padded ("0000320193"), or with the CIK prefix; normalized to a 10-digit CIK internally. Combined with 'Tickers' as one watchlist. Empty watchlist = market-wide monitoring by form type only (use with care — high volume).

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

Stock tickers to monitor, e.g. "AAPL", "MSFT". Resolved to CIKs via SEC's company\_tickers.json map. Combined with 'CIKs' as one watchlist. Empty watchlist = market-wide monitoring by form type only.

## `forms` (type: `array`):

Restrict to these EDGAR form types, e.g. "8-K", "4", "SC 13D", "SC 13G", "S-1", "10-K", "10-Q", "424B". Matched against both the exact `form` and the `root_forms` family. Empty = all form types.

## `since` (type: `string`):

Only fetch filings accepted at or after this date — maps to the EDGAR full-text search `startdt` (YYYY-MM-DD). Accepts YYYY-MM-DD. Leave empty to default to a recent trailing window. Ignored if 'Only new since last run' is on (the stored high-water-mark drives the cursor instead).

## `until` (type: `string`):

Optional upper bound on filing date (maps to EDGAR full-text search `enddt`, YYYY-MM-DD). Leave empty for no upper bound (up to today).

## `query` (type: `string`):

Optional keyword / phrase to pass to EDGAR full-text search (`q`), e.g. "material agreement". Wrap a phrase in double quotes. Empty = match all filings (`q=*`) for the watchlist / form filter.

## `monitorNewOnly` (type: `boolean`):

Persist the max acceptance-datetime high-water-mark seen (in the Actor's key-value store) and, on the next run, emit only accessions accepted after it. Turns this Actor into a first-seen new-filing monitor across scheduled runs.

## `maxResults` (type: `integer`):

Cap the total number of filings returned. 0 = no cap (page until the window is exhausted, honoring EDGAR's 10,000-hit-per-query ceiling by windowing dates).

## `proxyConfiguration` (type: `object`):

Optional. The SEC EDGAR endpoints are clean, open, public JSON and need NO proxy. You may enable Apify Proxy only to distribute requests if you run very large historical pulls (stay under SEC's 10 req/s fair-access limit). Default: no proxy.

## Actor input object example

```json
{
  "ciks": [],
  "tickers": [],
  "forms": [],
  "since": "2026-07-01",
  "until": "2026-07-10",
  "query": "material agreement",
  "monitorNewOnly": false,
  "maxResults": 0,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `filings` (type: `string`):

One SEC EDGAR filing matched by the watchlist, form, and date window. Rendered as the Filings table (see the dataset schema).

# 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 = {
    "ciks": [],
    "tickers": [],
    "forms": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("bytehavenstudios/sec-edgar-filing-monitor").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 = {
    "ciks": [],
    "tickers": [],
    "forms": [],
}

# Run the Actor and wait for it to finish
run = client.actor("bytehavenstudios/sec-edgar-filing-monitor").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 '{
  "ciks": [],
  "tickers": [],
  "forms": []
}' |
apify call bytehavenstudios/sec-edgar-filing-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=bytehavenstudios/sec-edgar-filing-monitor",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "SEC EDGAR Filing Monitor",
        "description": "Change-detection over the live SEC EDGAR filing stream. Maintain a watchlist (CIKs/tickers) and form-type filter (8-K, 4, SC 13D/13G, S-1, 10-K/10-Q); each run emits one record per newly-appeared accession, joined to issuer metadata and event-classified. Keyless. Not endorsed by the SEC.",
        "version": "0.1",
        "x-build-id": "WqkQvJxSXvXNBz6qF"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/bytehavenstudios~sec-edgar-filing-monitor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-bytehavenstudios-sec-edgar-filing-monitor",
                "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/bytehavenstudios~sec-edgar-filing-monitor/runs": {
            "post": {
                "operationId": "runs-sync-bytehavenstudios-sec-edgar-filing-monitor",
                "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/bytehavenstudios~sec-edgar-filing-monitor/run-sync": {
            "post": {
                "operationId": "run-sync-bytehavenstudios-sec-edgar-filing-monitor",
                "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": {
                    "ciks": {
                        "title": "CIKs to watch",
                        "type": "array",
                        "description": "SEC Central Index Keys to monitor. Accepts any form — bare number (\"320193\"), zero-padded (\"0000320193\"), or with the CIK prefix; normalized to a 10-digit CIK internally. Combined with 'Tickers' as one watchlist. Empty watchlist = market-wide monitoring by form type only (use with care — high volume).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "tickers": {
                        "title": "Tickers to watch",
                        "type": "array",
                        "description": "Stock tickers to monitor, e.g. \"AAPL\", \"MSFT\". Resolved to CIKs via SEC's company_tickers.json map. Combined with 'CIKs' as one watchlist. Empty watchlist = market-wide monitoring by form type only.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "forms": {
                        "title": "Form types",
                        "type": "array",
                        "description": "Restrict to these EDGAR form types, e.g. \"8-K\", \"4\", \"SC 13D\", \"SC 13G\", \"S-1\", \"10-K\", \"10-Q\", \"424B\". Matched against both the exact `form` and the `root_forms` family. Empty = all form types.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "since": {
                        "title": "Filed since (delta cursor)",
                        "type": "string",
                        "description": "Only fetch filings accepted at or after this date — maps to the EDGAR full-text search `startdt` (YYYY-MM-DD). Accepts YYYY-MM-DD. Leave empty to default to a recent trailing window. Ignored if 'Only new since last run' is on (the stored high-water-mark drives the cursor instead)."
                    },
                    "until": {
                        "title": "Filed until (optional upper bound)",
                        "type": "string",
                        "description": "Optional upper bound on filing date (maps to EDGAR full-text search `enddt`, YYYY-MM-DD). Leave empty for no upper bound (up to today)."
                    },
                    "query": {
                        "title": "Full-text query (optional)",
                        "type": "string",
                        "description": "Optional keyword / phrase to pass to EDGAR full-text search (`q`), e.g. \"material agreement\". Wrap a phrase in double quotes. Empty = match all filings (`q=*`) for the watchlist / form filter."
                    },
                    "monitorNewOnly": {
                        "title": "Only new since last run",
                        "type": "boolean",
                        "description": "Persist the max acceptance-datetime high-water-mark seen (in the Actor's key-value store) and, on the next run, emit only accessions accepted after it. Turns this Actor into a first-seen new-filing monitor across scheduled runs.",
                        "default": false
                    },
                    "maxResults": {
                        "title": "Max filings per run",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Cap the total number of filings returned. 0 = no cap (page until the window is exhausted, honoring EDGAR's 10,000-hit-per-query ceiling by windowing dates).",
                        "default": 0
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional. The SEC EDGAR endpoints are clean, open, public JSON and need NO proxy. You may enable Apify Proxy only to distribute requests if you run very large historical pulls (stay under SEC's 10 req/s fair-access limit). Default: no proxy.",
                        "default": {
                            "useApifyProxy": 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```