# ✉️ SEC Comment Letter & Correspondence Monitor (`nexgendata/sec-comment-letter-monitor`) Actor

SEC staff comment letters (UPLOAD) and responses (CORRESP)

- **URL**: https://apify.com/nexgendata/sec-comment-letter-monitor.md
- **Developed by:** [NexGenData](https://apify.com/nexgendata) (community)
- **Categories:** Business
- **Stats:** 4 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 products

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 Comment Letter & Correspondence Monitor

Track **SEC staff comment letters** (form type `UPLOAD`) and registrant responses (`CORRESP`) the moment they hit EDGAR's full-text search index — the early-warning channel where the SEC's Division of Corporation Finance privately challenges a company's filings on revenue recognition, non-GAAP metrics, segment reporting, going-concern, crypto disclosure, and dozens of other accounting and disclosure issues. These letters routinely surface accounting risk **months before** it shows up in a restatement, an 8-K, or a stock move. This actor pulls them as structured JSON — company, ticker, form type, filed date, and a direct document link — filtered by date window and optional keyword.

> **One actor. One token. The accounting-risk early-warning feed that forensic-accounting and short-research desks build by hand from EDGAR — delivered as pay-per-record JSON.**

### Why use this

- **Earliest public signal of accounting scrutiny.** A `UPLOAD` letter is the SEC staff formally questioning a filing. By the time the market reacts to a restatement, this channel flagged the issue quarters earlier.
- **Keyword targeting across the letter index.** Pass a `query` phrase (e.g. `revenue recognition`, `going concern`, `non-GAAP`) and AND it with the form filter to isolate the specific accounting topic you cover.
- **Direct document links.** Every record carries a `documentUrl` to the letter itself, so your analysts (or your NLP pipeline) go straight from alert to source text.
- **Date-window or lookback control.** Use `daysBack` for a rolling monitor or explicit `startDate`/`endDate` for a historical sweep of a coverage universe.
- **Official source, ETL-ready.** Reads SEC EDGAR full-text search. Stable flat JSON loads straight into Snowflake, BigQuery, Postgres, or a Slack alerting workflow.

### What you get

Each record represents one comment-letter or correspondence filing matching your filters. Core fields:

- `companyName` — the registrant the letter concerns
- `ticker` — the company's stock ticker (when resolvable)
- `formType` — the SEC form type (`UPLOAD` = SEC staff comment letter)
- `filedDate` — the date the letter was filed on EDGAR
- `documentUrl` — direct link to the comment-letter document

A typical monitoring workflow keys off `companyName` + `filedDate` for dedupe and routes the `documentUrl` to a reader or NLP step.

### Use cases

- **Forensic-accounting / short research** — Run a daily monitor with `query="revenue recognition"` or `query="going concern"` and route every new `UPLOAD` to your analyst queue. SEC staff comments are a leading indicator of restatement risk that short desks weaponize before the broader market notices.
- **Audit-committee & controller risk monitoring** — Track comment letters across your industry peer set to see which accounting topics the SEC staff is pressing this cycle (e.g. crypto-asset disclosure, supplier-finance arrangements, segment changes) and get ahead of the same questions on your own filings.
- **Securities litigation sourcing** — Plaintiff and defense firms screen for `UPLOAD` letters on a coverage universe to identify disclosure disputes that may foreshadow securities-fraud claims.
- **Event-driven / credit research** — A comment letter challenging going-concern language or non-GAAP add-backs is a tradeable signal for event-driven equity and distressed-credit desks.
- **Compliance benchmarking** — Corporate IR and reporting teams study the SEC's live comment themes to calibrate their own MD&A and non-GAAP disclosures before filing.
- **Academic / policy research** — Aggregate comment-letter volume and topics over time for studies on SEC enforcement priorities and disclosure-quality trends.

### How the comment-letter process works (and why the timing is the edge)

When a company files a 10-K, 10-Q, S-1, or registration statement, the SEC's Division of Corporation Finance may **review it and send a private comment letter** challenging specific disclosures — how revenue is recognized, how a non-GAAP metric is reconciled, whether a going-concern qualification is warranted, how a segment is defined, or how a novel area (crypto-assets, SPAC accounting, supplier-finance programs) is presented. The company responds in writing; the staff may issue follow-ups. **The entire exchange is made public on EDGAR after the review concludes** — and that publication is the moment this actor catches.

The reason this feed is valuable is sequencing. A disclosure problem typically travels: *comment letter → company response → possible amendment/restatement → 8-K → market reaction.* By the time the last step prints, the `UPLOAD` letter was searchable quarters earlier. Monitoring `UPLOAD` filings on a keyword and a coverage universe puts you at the front of that chain rather than the back of it.

### Common monitoring recipes

- **Going-concern early warning:** `{"forms": "UPLOAD", "query": "going concern", "daysBack": 7}` on a daily schedule — surfaces companies the SEC staff is pressing on viability.
- **Revenue-recognition scrutiny:** `{"forms": "UPLOAD", "query": "revenue recognition", "daysBack": 30}` — the single most common high-impact comment theme.
- **Non-GAAP pushback:** `{"forms": "UPLOAD", "query": "non-GAAP", "daysBack": 30}` — tracks the SEC's recurring focus on adjusted-metric prominence and add-backs.
- **Historical sweep of a window:** `{"forms": "UPLOAD", "startDate": "2026-01-01", "endDate": "2026-06-30", "maxResults": 500}` — build a back-test set of letters for a coverage universe.

### Sample output

```json
{
  "companyName": "EXAMPLE TECHNOLOGIES INC",
  "ticker": "EXTC",
  "formType": "UPLOAD",
  "filedDate": "2026-06-18",
  "documentUrl": "https://www.sec.gov/Archives/edgar/data/0001234567/000000000026000123/filename.htm"
}
````

### Input parameters

| Parameter | What it does |
|-----------|--------------|
| `forms` | SEC comment-letter form type. `UPLOAD` = SEC staff comment letters. Note: `CORRESP` currently errors on the SEC full-text search backend. |
| `query` | Optional exact-phrase keyword to AND with the form filter (e.g. `revenue recognition`, `non-GAAP`, `going concern`). |
| `daysBack` | Look back this many days from today (ignored if explicit dates are set). |
| `startDate` | Override start of the window (`YYYY-MM-DD`). |
| `endDate` | Override end of the window (`YYYY-MM-DD`). |
| `maxResults` | Maximum number of filings to return. |
| `userAgentContact` | SEC requires a User-Agent with contact info; supply your contact string here. |

### How to use

#### Python (apify-client)

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")

run = client.actor("nexgendata/sec-comment-letter-monitor").call(run_input={
    "forms": "UPLOAD",
    "query": "revenue recognition",
    "daysBack": 30,
    "maxResults": 200,
    "userAgentContact": "Your Name your@email.com",
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["filedDate"], item["companyName"], item["ticker"], item["documentUrl"])
```

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/nexgendata~sec-comment-letter-monitor/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "forms": "UPLOAD",
    "query": "going concern",
    "startDate": "2026-01-01",
    "endDate": "2026-06-30",
    "maxResults": 500,
    "userAgentContact": "Your Name your@email.com"
  }'
```

#### No-code (Zapier / Make)

Use the Apify "Run actor and get dataset items" action with actor ID `nexgendata/sec-comment-letter-monitor`, schedule it daily, and fire a Slack message or CRM task whenever a new `UPLOAD` matching your keyword appears — mapping `companyName`, `filedDate`, and `documentUrl` into the alert.

### Pricing

This actor runs on Apify's **pay-per-event (PPE)** model — **$0.10 per result** (one charge per comment-letter record returned), plus a sub-cent actor-start event. No subscription, no seat licence, no minimum.

Worked example:

- A daily monitor returning 15 new letters → **$1.50**
- A monthly keyword sweep returning 200 letters → **$20.00**
- A historical coverage-universe pull returning 500 letters → **$50.00**

Because billing is per result, a quiet day with no matching letters costs effectively nothing.

### How this compares to Bloomberg Terminal

Bloomberg's terminal surfaces SEC correspondence inside a **~$24,000-per-seat-per-year** workspace, and dedicated comment-letter analytics products (Audit Analytics, Intelligize, Ideagen Disclosure) run on **enterprise contracts** that price most individual researchers and small funds out entirely. Those platforms add taxonomies, full-text analytics, and curated alerting you may still want at scale. But if your workflow is a **keyword-targeted monitor on a coverage universe** — "tell me every new SEC comment letter mentioning going concern" — you do not need a Bloomberg seat to get the company, date, and document link. You need this actor, queryable from your own code at a fraction of the cost, with the document URL ready for your own NLP.

### FAQ

**Q: What exactly is an `UPLOAD` filing?**
A: `UPLOAD` is the EDGAR form type for a comment letter sent by the SEC's Division of Corporation Finance staff to a registrant, questioning aspects of a filing. `CORRESP` is the registrant's written response. Both are made public on EDGAR after the review concludes.

**Q: Why does `CORRESP` sometimes error?**
A: The SEC full-text search backend currently returns errors for `CORRESP` form queries in some cases. The `UPLOAD` (staff letters) path is the reliable one and is where the accounting-risk signal originates. Track `UPLOAD` and follow links to the related `CORRESP` on the company's EDGAR page when needed.

**Q: How fresh are the results?**
A: Comment letters become searchable when the SEC publishes them on EDGAR (typically after the review process closes). Each run queries the live index; schedule daily for an early-warning monitor.

**Q: Do I need the `userAgentContact`?**
A: Yes. The SEC requires every automated request to identify itself with a contact (name + email). Supply yours so the SEC can reach the request's operator per its fair-access policy.

**Q: Can I get the letter's full text?**
A: This actor returns the `documentUrl` to each letter. Follow the link (or pipe it into a downstream fetch/NLP step) to retrieve and analyze the full letter text.

### Schema stability & versioning

This actor follows NexGenData's **additive-only schema** contract. New fields may be added over time (appearing as new JSON keys, defaulting to `null` for older runs), but existing fields are never renamed or removed without a major-version bump and advance notice. Field semantics — date formats, value-sets — are never silently changed. Build production pipelines on this output with confidence.

### Compliance & legal

- This actor reformats **public SEC EDGAR data**. It is not affiliated with, endorsed by, or sponsored by the SEC.
- Comment letters and correspondence are official public filings. Nothing here is legal or investment advice.
- For any regulated decision — securities research, litigation, compliance — **verify against the primary EDGAR filing** and consult qualified counsel.
- Requests identify themselves to the SEC per its fair-access User-Agent policy. You are responsible for compliant downstream use.

### Related NexGenData actors

Part of NexGenData's **SEC / Disclosure intelligence** cluster — pair this actor with:

- [SEC Form 8-K Event Monitor](https://apify.com/nexgendata/sec-8k-event-monitor?fpr=2ayu9b)
- [SEC Executive Compensation Proxy Tracker](https://apify.com/nexgendata/sec-exec-comp-proxy-tracker?fpr=2ayu9b)
- [SEC XBRL Financial Frames](https://apify.com/nexgendata/sec-xbrl-financial-frames?fpr=2ayu9b)
- [SEC Form 4 Insider Monitor](https://apify.com/nexgendata/sec-form-4-insider-monitor?fpr=2ayu9b)
- [SEC Delisting & Deregistration Tracker](https://apify.com/nexgendata/sec-delisting-deregistration-tracker?fpr=2ayu9b)
- [SEC Going-Private Tracker](https://apify.com/nexgendata/sec-going-private-tracker?fpr=2ayu9b)

Browse the full 200+ actor catalog at **https://apify.com/nexgendata?fpr=2ayu9b**.

# Actor input Schema

## `forms` (type: `string`):

SEC comment-letter form (UPLOAD = SEC staff letters). Note: CORRESP currently errors on SEC FTS.

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

Optional exact-phrase to AND with the form filter.

## `daysBack` (type: `integer`):

Look back this many days (ignored if dates set).

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

Override start (YYYY-MM-DD).

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

Override end (YYYY-MM-DD).

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

Maximum filings to return.

## `userAgentContact` (type: `string`):

SEC requires a UA with contact info.

## Actor input object example

```json
{
  "forms": "UPLOAD",
  "daysBack": 120,
  "maxResults": 300
}
```

# 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 = {
    "forms": "UPLOAD"
};

// Run the Actor and wait for it to finish
const run = await client.actor("nexgendata/sec-comment-letter-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 = { "forms": "UPLOAD" }

# Run the Actor and wait for it to finish
run = client.actor("nexgendata/sec-comment-letter-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 '{
  "forms": "UPLOAD"
}' |
apify call nexgendata/sec-comment-letter-monitor --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "✉️ SEC Comment Letter & Correspondence Monitor",
        "description": "SEC staff comment letters (UPLOAD) and responses (CORRESP)",
        "version": "0.0",
        "x-build-id": "udyBwDXLVHnf2VcrQ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/nexgendata~sec-comment-letter-monitor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-nexgendata-sec-comment-letter-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/nexgendata~sec-comment-letter-monitor/runs": {
            "post": {
                "operationId": "runs-sync-nexgendata-sec-comment-letter-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/nexgendata~sec-comment-letter-monitor/run-sync": {
            "post": {
                "operationId": "run-sync-nexgendata-sec-comment-letter-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": {
                    "forms": {
                        "title": "Form types",
                        "type": "string",
                        "description": "SEC comment-letter form (UPLOAD = SEC staff letters). Note: CORRESP currently errors on SEC FTS.",
                        "default": "UPLOAD"
                    },
                    "query": {
                        "title": "Keyword (optional)",
                        "type": "string",
                        "description": "Optional exact-phrase to AND with the form filter."
                    },
                    "daysBack": {
                        "title": "Days back",
                        "minimum": 1,
                        "maximum": 3650,
                        "type": "integer",
                        "description": "Look back this many days (ignored if dates set).",
                        "default": 120
                    },
                    "startDate": {
                        "title": "Start date",
                        "type": "string",
                        "description": "Override start (YYYY-MM-DD)."
                    },
                    "endDate": {
                        "title": "End date",
                        "type": "string",
                        "description": "Override end (YYYY-MM-DD)."
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum filings to return.",
                        "default": 300
                    },
                    "userAgentContact": {
                        "title": "SEC User-Agent contact",
                        "type": "string",
                        "description": "SEC requires a UA with contact info."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
