# SEC Comment Letters Scraper (`automation-lab/sec-comment-letters-scraper`) Actor

Extract SEC staff comment letters and company responses from EDGAR by ticker or CIK for compliance, due diligence, and disclosure monitoring.

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

## Pricing

Pay per event + usage

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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 Comment Letters Scraper

Extract SEC staff comment letters and company responses from EDGAR by ticker or CIK.

The actor focuses on the SEC forms that matter for disclosure-review workflows:

- `UPLOAD` — SEC staff comment letters
- `CORRESP` — company response letters

It resolves tickers to CIKs, reads the SEC submissions API, follows older archive shards when requested, and returns normalized document rows with direct EDGAR URLs.

---

### What does SEC Comment Letters Scraper do?

SEC Comment Letters Scraper helps you collect public SEC correspondence records without manually searching EDGAR company pages.

It can:

- Resolve company tickers such as `AAPL`, `MSFT`, or `AMZN` to CIKs
- Read public SEC submissions JSON
- Filter filings to `UPLOAD` and `CORRESP`
- Include recent filings and older SEC archive shards
- Return direct document and filing-detail URLs
- Optionally fetch cleaned text previews from HTML/text documents
- Label each row as a staff letter or company response
- Save everything to an Apify dataset for export or automation

### Who is it for?

#### Securities lawyers

Use it to review how the SEC staff has commented on an issuer's disclosures before drafting, diligence, or transaction work.

#### Compliance teams

Monitor staff comments and responses for companies you track, competitors, or portfolio entities.

#### Investor relations teams

Find historical correspondence that may explain disclosure changes, risk-factor emphasis, accounting questions, or SEC review timelines.

#### Investors and analysts

Collect due-diligence signals from SEC review correspondence and compare comment histories across issuers.

#### Data teams

Build recurring EDGAR correspondence pipelines without writing ticker resolution, submissions pagination, and archive URL logic yourself.

### Why use it?

SEC EDGAR is public, but comment-letter workflows are repetitive:

- You must know the CIK or resolve a ticker
- You must inspect the submissions JSON
- You must filter form types correctly
- You may need older archive shards
- You need stable URLs for documents and filing detail pages
- You need clean rows for spreadsheets, CRMs, dashboards, or internal research tools

This actor packages those steps into a repeatable Apify run.

### What data can I extract?

| Field | Description |
| --- | --- |
| `cik` | SEC Central Index Key, zero padded to 10 digits |
| `ticker` | Resolved ticker when available |
| `companyName` | SEC company name |
| `form` | `UPLOAD` or `CORRESP` |
| `filingDate` | SEC filing date |
| `reportDate` | SEC report date when present |
| `accessionNumber` | SEC accession number |
| `primaryDocument` | Primary document filename |
| `documentDescription` | SEC primary document description when present |
| `documentUrl` | Direct EDGAR document URL |
| `filingDetailUrl` | EDGAR filing detail page URL |
| `submissionsUrl` | SEC submissions JSON URL |
| `archiveFile` | Older submissions shard name when used |
| `isStaffLetter` | `true` for SEC staff `UPLOAD` letters |
| `isCompanyResponse` | `true` for issuer `CORRESP` responses |
| `documentType` | `html`, `pdf`, `text`, or `unknown` |
| `documentText` | Optional cleaned text preview |
| `scrapedAt` | Extraction timestamp |

### How much does it cost to scrape SEC comment letters?

This actor uses pay-per-event pricing.

- A small start fee is charged once per run.
- A per-record fee is charged for each SEC comment-letter row produced.
- You control spend with `maxItems`, date filters, and company list size.

For most workflows, start with a few tickers and a date range. Increase `maxItems` only after confirming the output matches your needs.

### Input options

#### `companies`

Required list of tickers or CIKs.

Examples:

- `AAPL`
- `MSFT`
- `AMZN`
- `0000320193`

#### `startDate`

Only include filings on or after this date.

Example:

`2021-01-01`

#### `endDate`

Only include filings on or before this date.

Leave empty for no upper bound.

#### `maxItems`

Global output cap across all companies.

Use this to control cost and runtime.

#### `includeArchiveShards`

When enabled, the actor follows older SEC submissions shard files.

Disable it for a fast recent-filings-only run.

#### `includeDocumentText`

When enabled, the actor downloads each primary document and saves a cleaned text preview for HTML/text documents.

PDF documents keep the URL but may not include text.

#### `maxDocumentTextChars`

Maximum characters of document preview stored per row.

#### `requestDelayMs`

Delay between SEC requests.

The default is conservative to respect SEC fair-access guidance.

### Example input

```json
{
  "companies": ["AAPL", "MSFT", "AMZN"],
  "startDate": "2021-01-01",
  "maxItems": 100,
  "includeArchiveShards": true,
  "includeDocumentText": false,
  "requestDelayMs": 150
}
````

### Example output

```json
{
  "cik": "0000320193",
  "ticker": "AAPL",
  "companyName": "Apple Inc.",
  "form": "CORRESP",
  "filingDate": "2024-04-29",
  "accessionNumber": "0000320193-24-000061",
  "primaryDocument": "filename1.htm",
  "documentUrl": "https://www.sec.gov/Archives/edgar/data/320193/000032019324000061/filename1.htm",
  "isStaffLetter": false,
  "isCompanyResponse": true,
  "documentType": "html",
  "source": "sec-edgar-submissions"
}
```

### How to run it

1. Open the actor on Apify.
2. Add tickers or CIKs to `companies`.
3. Choose a date range.
4. Set `maxItems`.
5. Decide whether to include archive shards.
6. Run the actor.
7. Export the dataset as JSON, CSV, Excel, XML, or RSS.

### Tips for best results

- Use tickers for convenience.
- Use CIKs for exact entity matching.
- Keep `includeArchiveShards` enabled for historical due diligence.
- Disable document text for faster URL-only monitoring.
- Enable document text for legal-review samples or LLM workflows.
- Increase `requestDelayMs` if the SEC returns rate-limit errors.
- Use `startDate` to avoid collecting old correspondence you do not need.

### SEC fair-access behavior

The actor uses direct SEC HTTP endpoints and a descriptive User-Agent.

It intentionally avoids high concurrency.

SEC can rate-limit abusive traffic. If you run very large company lists, use a larger delay and reasonable item limits.

### Integrations

#### Compliance dashboard

Schedule the actor daily or weekly and send new rows to your dashboard.

#### Due-diligence data room

Export comment letters and response URLs to CSV for deal teams.

#### Legal research workflow

Enable document text previews, then send rows to an internal review or summarization pipeline.

#### Investor monitoring

Track peer companies and alert when new `UPLOAD` or `CORRESP` filings appear.

#### Data warehouse

Use Apify webhooks or the API to load dataset rows into Snowflake, BigQuery, Postgres, or an internal lake.

### 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-comment-letters-scraper').call({
  companies: ['AAPL', 'MSFT'],
  startDate: '2021-01-01',
  maxItems: 50,
});

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

#### Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/sec-comment-letters-scraper').call(run_input={
    'companies': ['AAPL', 'MSFT'],
    'startDate': '2021-01-01',
    'maxItems': 50,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~sec-comment-letters-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"companies":["AAPL","MSFT"],"startDate":"2021-01-01","maxItems":50}'
```

### MCP usage

You can use this actor from MCP-enabled tools through Apify MCP.

MCP URL:

`https://mcp.apify.com/?tools=automation-lab/sec-comment-letters-scraper`

Claude Code add command:

```bash
claude mcp add apify-sec-comment-letters https://mcp.apify.com/?tools=automation-lab/sec-comment-letters-scraper
```

Claude Desktop MCP server configuration:

```json
{
  "mcpServers": {
    "apify-sec-comment-letters": {
      "url": "https://mcp.apify.com/?tools=automation-lab/sec-comment-letters-scraper"
    }
  }
}
```

Example prompts showing MCP usage:

Claude Desktop prompt:

> Use the SEC Comment Letters Scraper MCP tool to collect Apple and Microsoft comment letters since 2021, then summarize recurring disclosure topics.

Claude Code prompt:

> Run automation-lab/sec-comment-letters-scraper through MCP for AAPL, MSFT, and AMZN. Save the dataset as a CSV and identify company responses filed after staff uploads.

Example compliance prompt:

> Monitor my issuer watchlist with the SEC comment letter scraper and return new EDGAR correspondence URLs grouped by company.

### Related scrapers

Explore related Automation Lab actors:

- https://apify.com/automation-lab/sec-form-4-insider-trading-scraper
- https://apify.com/automation-lab/sec-13f-filings-scraper
- https://apify.com/automation-lab/sec-form-d-scraper
- https://apify.com/automation-lab/sec-litigation-releases

### Legality

This actor uses publicly available SEC EDGAR data.

You are responsible for using the data lawfully, respecting SEC fair-access policies, and complying with your organization's legal and compliance requirements.

Do not use the output as legal advice. Have qualified counsel review legal conclusions.

### Troubleshooting

#### Why did I get zero rows?

The company may not have recent `UPLOAD` or `CORRESP` filings in your date range. Try widening the date range, enabling archive shards, or checking the CIK.

#### Why is document text empty?

Some primary documents are PDFs. The actor preserves the PDF URL but does not OCR PDFs. HTML and text documents are best for previews.

#### Why did SEC return an error?

SEC may rate-limit high-volume runs. Increase `requestDelayMs`, reduce the company list, or lower `maxItems`.

#### Why are staff letters and company responses mixed together?

They are related correspondence records and share the same schema. Use `form`, `isStaffLetter`, or `isCompanyResponse` to filter them.

### FAQ

#### Can I scrape by ticker?

Yes. The actor resolves tickers with the SEC company ticker file.

#### Can I scrape by CIK?

Yes. Enter a CIK with or without leading zeros.

#### Does it require an SEC API key?

No. The actor uses public SEC endpoints.

#### Does it use a browser?

No. It is an HTTP/API actor.

#### Can it monitor new letters?

Yes. Schedule recurring runs and compare new dataset rows by accession number.

#### Can it fetch full document text?

It can include cleaned previews for HTML/text documents. PDF OCR is not included.

#### Can it collect more than 100 records?

Yes. Increase `maxItems` and include more companies or wider date ranges.

#### What forms are included?

Only `UPLOAD` and `CORRESP`, which correspond to SEC staff letters and company responses.

### Changelog

#### 0.1

Initial private build for SEC comment letter and correspondence extraction.

# Actor input Schema

## `companies` (type: `array`):

Enter stock tickers (AAPL, MSFT) or 10-digit CIKs. The actor resolves tickers with the SEC company ticker file.

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

Only include comment-letter filings on or after this date (YYYY-MM-DD). Leave empty for no lower bound.

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

Only include filings on or before this date (YYYY-MM-DD). Leave empty for no upper bound.

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

Maximum dataset rows to emit across all companies.

## `includeArchiveShards` (type: `boolean`):

Read older submissions shard files referenced by SEC submissions JSON. Turn off for a faster recent-filings-only run.

## `includeDocumentText` (type: `boolean`):

Fetch each primary document and include a cleaned text preview when the document is HTML or text. PDF rows keep URLs but usually have no text preview.

## `maxDocumentTextChars` (type: `integer`):

Maximum cleaned document text characters to store per row when document previews are enabled.

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

Conservative delay used to respect SEC fair-access guidance. Increase if you see SEC rate-limit errors.

## Actor input object example

```json
{
  "companies": [
    "AAPL",
    "MSFT",
    "AMZN"
  ],
  "startDate": "2021-01-01",
  "maxItems": 20,
  "includeArchiveShards": true,
  "includeDocumentText": false,
  "maxDocumentTextChars": 0,
  "requestDelayMs": 150
}
```

# 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 = {
    "companies": [
        "AAPL",
        "MSFT",
        "AMZN"
    ],
    "startDate": "2021-01-01",
    "maxItems": 20,
    "includeArchiveShards": true,
    "includeDocumentText": false,
    "maxDocumentTextChars": 0,
    "requestDelayMs": 150
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/sec-comment-letters-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 = {
    "companies": [
        "AAPL",
        "MSFT",
        "AMZN",
    ],
    "startDate": "2021-01-01",
    "maxItems": 20,
    "includeArchiveShards": True,
    "includeDocumentText": False,
    "maxDocumentTextChars": 0,
    "requestDelayMs": 150,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/sec-comment-letters-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 '{
  "companies": [
    "AAPL",
    "MSFT",
    "AMZN"
  ],
  "startDate": "2021-01-01",
  "maxItems": 20,
  "includeArchiveShards": true,
  "includeDocumentText": false,
  "maxDocumentTextChars": 0,
  "requestDelayMs": 150
}' |
apify call automation-lab/sec-comment-letters-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "SEC Comment Letters Scraper",
        "description": "Extract SEC staff comment letters and company responses from EDGAR by ticker or CIK for compliance, due diligence, and disclosure monitoring.",
        "version": "0.1",
        "x-build-id": "wjzkzOl6f1wPSpf1a"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~sec-comment-letters-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-sec-comment-letters-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-comment-letters-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-sec-comment-letters-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-comment-letters-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-sec-comment-letters-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "companies"
                ],
                "properties": {
                    "companies": {
                        "title": "Tickers or CIKs",
                        "minItems": 1,
                        "type": "array",
                        "description": "Enter stock tickers (AAPL, MSFT) or 10-digit CIKs. The actor resolves tickers with the SEC company ticker file.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startDate": {
                        "title": "Start date",
                        "type": "string",
                        "description": "Only include comment-letter filings on or after this date (YYYY-MM-DD). Leave empty for no lower bound."
                    },
                    "endDate": {
                        "title": "End date",
                        "type": "string",
                        "description": "Only include filings on or before this date (YYYY-MM-DD). Leave empty for no upper bound."
                    },
                    "maxItems": {
                        "title": "Maximum comment-letter records",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum dataset rows to emit across all companies.",
                        "default": 20
                    },
                    "includeArchiveShards": {
                        "title": "Include older SEC archive shards",
                        "type": "boolean",
                        "description": "Read older submissions shard files referenced by SEC submissions JSON. Turn off for a faster recent-filings-only run.",
                        "default": true
                    },
                    "includeDocumentText": {
                        "title": "Download document text preview",
                        "type": "boolean",
                        "description": "Fetch each primary document and include a cleaned text preview when the document is HTML or text. PDF rows keep URLs but usually have no text preview.",
                        "default": false
                    },
                    "maxDocumentTextChars": {
                        "title": "Maximum document text characters",
                        "minimum": 0,
                        "maximum": 50000,
                        "type": "integer",
                        "description": "Maximum cleaned document text characters to store per row when document previews are enabled.",
                        "default": 0
                    },
                    "requestDelayMs": {
                        "title": "Delay between SEC requests (ms)",
                        "minimum": 100,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Conservative delay used to respect SEC fair-access guidance. Increase if you see SEC rate-limit errors.",
                        "default": 150
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
