# SEC Form D Scraper (`automation-lab/sec-form-d-scraper`) Actor

Scrape SEC EDGAR Form D private-offering filings for issuer, offering amount, investor count, related persons, addresses, and source URLs.

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

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## SEC Form D Scraper

Extract SEC EDGAR Form D private-offering filings into structured datasets for startup funding intelligence, private-market monitoring, compliance review, and issuer enrichment.

This Apify Actor monitors the latest SEC Form D feed or targets specific accession numbers, CIKs, and EDGAR filing URLs. It uses SEC public endpoints with a compliant User-Agent and saves one clean dataset row per filing.

### What does SEC Form D Scraper do?

SEC Form D Scraper turns public Form D filings into analysis-ready records.

It collects issuer names, CIKs, accession numbers, filing dates, offering amounts, amount sold, investor counts, industry groups, issuer addresses, related persons, and SEC source links.

Use it when you need repeatable private-offering data without manually opening EDGAR filing pages.

### Who is it for?

- 💼 Investors tracking new private offerings and startup funding signals.
- 🧲 Sales teams building issuer and fund lead lists.
- ⚖️ Compliance and legal teams monitoring exempt offerings.
- 📊 Data teams enriching private-market databases.
- 🏢 Service providers looking for newly active issuers.

### Why use this actor?

SEC EDGAR is public, but Form D data is split across feeds, index pages, and XML primary documents.

This actor handles discovery, XML parsing, field normalization, polite request pacing, and dataset output in one repeatable workflow.

### Key features

- ✅ Latest SEC Form D current-feed mode.
- ✅ Exact accession-number mode.
- ✅ Issuer CIK mode using SEC submissions JSON.
- ✅ SEC filing index URL mode.
- ✅ Compliant User-Agent input.
- ✅ Offering amounts and investor counts.
- ✅ Related persons with relationship labels.
- ✅ Direct SEC index and XML source URLs.

### Data extracted

| Field | Description |
| --- | --- |
| issuerName | Issuer or fund name |
| cik | SEC Central Index Key |
| accessionNumber | Filing accession number |
| filingDate | Filing date when available |
| industryGroup | SEC Form D industry group |
| offeringAmountUsd | Total offering amount |
| amountSoldUsd | Amount already sold |
| amountRemainingUsd | Remaining amount |
| totalInvestors | Number of investors |
| relatedPersons | Directors, promoters, executives, and other related people |
| sourceIndexUrl | EDGAR filing index page |
| primaryDocumentUrl | Parsed SEC XML document |

### How much does it cost to scrape SEC Form D filings?

The actor uses pay-per-event pricing.

- Start event: $0.005 per run.
- Filing scraped event: tiered per Form D filing saved to the dataset.
- BRONZE per-filing price: $0.000036462, with lower prices on higher Apify subscription tiers.

Small tests are inexpensive because the default input saves only a limited number of filings.

### Input overview

The input is designed around the way analysts search SEC Form D filings.

Choose a source mode, set a maximum number of filings, and optionally provide specific accession numbers, CIKs, or SEC filing URLs.

### Input fields

| Input | Type | Purpose |
| --- | --- | --- |
| mode | string | `current`, `accessions`, `ciks`, or `urls` |
| maxItems | integer | Maximum filings to save |
| feedCount | integer | SEC current-feed entries to scan |
| accessionNumbers | string array | Exact Form D accession numbers |
| ciks | string array | Issuer CIKs to scan for recent Form D filings |
| startUrls | request list | SEC EDGAR filing index pages |
| includeRelatedPersons | boolean | Include nested people records |
| delayMs | integer | Polite delay between SEC requests |
| userAgent | string | SEC-compliant User-Agent with contact info |

### Example input: latest Form D filings

```json
{
  "mode": "current",
  "maxItems": 20,
  "feedCount": 40,
  "includeRelatedPersons": true,
  "delayMs": 150,
  "userAgent": "Your Company Form D monitor contact: data@example.com"
}
````

### Example input: accession numbers

```json
{
  "mode": "accessions",
  "accessionNumbers": ["0002132077-26-000001"],
  "maxItems": 1
}
```

### Example input: CIK monitoring

```json
{
  "mode": "ciks",
  "ciks": ["2132077"],
  "maxItems": 10,
  "feedCount": 40
}
```

### Output example

```json
{
  "issuerName": "Example Fund LP",
  "cik": "0000000000",
  "accessionNumber": "0000000000-26-000001",
  "filingDate": "2026-07-02",
  "industryGroup": "Pooled Investment Fund",
  "offeringAmountUsd": 5000000,
  "amountSoldUsd": 1250000,
  "totalInvestors": 4,
  "issuerCity": "NEW YORK",
  "issuerStateOrCountry": "NEW YORK",
  "relatedPersonCount": 2,
  "sourceIndexUrl": "https://www.sec.gov/Archives/...-index.htm",
  "primaryDocumentUrl": "https://www.sec.gov/Archives/.../primary_doc.xml"
}
```

### How to run

1. Choose the input mode.
2. Keep the default User-Agent or replace it with your organization contact.
3. Set `maxItems` for the number of filings you need.
4. Start the run.
5. Export the dataset as JSON, CSV, Excel, XML, or via API.

### Tips for best results

- Use `current` mode for daily monitoring.
- Use `ciks` mode when tracking known issuers or funds.
- Use accession mode for deterministic re-processing of known filings.
- Keep `delayMs` non-zero for SEC fair-access behavior.
- Store your own contact email in `userAgent` for production workflows.

### Integrations

Use this actor in workflows such as:

- Daily Form D lead alerts into a CRM.
- Private-market deal database enrichment.
- Compliance monitoring dashboards.
- Investor watchlists by issuer CIK.
- Legal research exports for exempt offerings.

### API usage with Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/sec-form-d-scraper').call({
  mode: 'current',
  maxItems: 20,
  feedCount: 40,
});
console.log(run.defaultDatasetId);
```

### API usage with Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/sec-form-d-scraper').call({
    'mode': 'current',
    'maxItems': 20,
    'feedCount': 40,
})
print(run['defaultDatasetId'])
```

### API usage with cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~sec-form-d-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"mode":"current","maxItems":20,"feedCount":40}'
```

### MCP integration

Connect the actor to Claude Desktop or Claude Code through Apify MCP.

Use the MCP server URL with the actor tool selected:

```text
https://mcp.apify.com/?tools=automation-lab/sec-form-d-scraper
```

Add the MCP server in Claude Code:

```bash
claude mcp add apify-sec-form-d --url "https://mcp.apify.com/?tools=automation-lab/sec-form-d-scraper"
```

Claude Desktop JSON configuration:

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

MCP example prompts:

```text
Use automation-lab/sec-form-d-scraper to run the latest 50 Form D filings and summarize the largest offerings.
```

```text
Use the SEC Form D MCP tool to scrape Form D filings for this CIK list and extract issuer addresses.
```

```text
Run automation-lab/sec-form-d-scraper every morning and identify new pooled investment funds.
```

### SEC compliance notes

SEC public endpoints require respectful access patterns.

This actor uses a descriptive User-Agent, no login, no browser automation, and a default delay between filing requests.

Users should set their own organization contact in the User-Agent field for sustained production monitoring.

### Legality

This actor extracts public SEC EDGAR filing data and does not bypass logins or access controls.

### Legal considerations

This actor extracts public SEC EDGAR data.

You are responsible for using the output lawfully, respecting SEC fair-access policies, and complying with applicable privacy, securities, and data-processing rules.

### FAQ

#### Can I use this for daily funding lead monitoring?

Yes. Use `current` mode with a schedule and export new dataset rows to your CRM or database.

#### Does this actor need proxies?

No. It uses public SEC endpoints directly with a compliant User-Agent.

### Troubleshooting: no results

Check that the selected mode matches your input.

For accession mode, accession numbers must look like `0000000000-26-000001`.

For URL mode, provide SEC filing index URLs ending in `-index.htm`.

### Troubleshooting: SEC access errors

If SEC returns an access error, set a more specific User-Agent with your company name and email, increase `delayMs`, and reduce `maxItems`.

### Related scrapers

Explore other automation-lab actors for finance and lead generation workflows:

- https://apify.com/automation-lab/website-contact-finder
- https://apify.com/automation-lab/google-maps-lead-finder
- https://apify.com/automation-lab/company-website-scraper

### Dataset exports

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

Use CSV for spreadsheet workflows, JSON for enrichment pipelines, and API access for scheduled monitoring.

### Scheduling

Schedule this actor daily or hourly to monitor new Form D filings.

Use `current` mode with a small `maxItems` for frequent monitoring, or CIK mode for focused issuer watchlists.

### Data quality

The actor parses SEC's primary XML documents rather than relying only on rendered HTML.

Some Form D fields are optional. Missing SEC values are returned as `null` while arrays remain arrays.

### Versioning

Output field names are designed to remain stable after publication.

Future versions may add optional fields, but existing field names should remain compatible for downstream integrations.

# Actor input Schema

## `mode` (type: `string`):

Choose how to find Form D filings. Current feed monitors latest SEC Form D filings; accessions, CIKs, and URLs target specific filings or issuers.

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

Maximum Form D filing records to save to the dataset.

## `feedCount` (type: `integer`):

How many Form D candidates to collect from SEC EDGAR when using current-feed or CIK modes. The actor paginates the SEC feed when needed.

## `accessionNumbers` (type: `array`):

Optional SEC accession numbers, e.g. 0002132077-26-000001. Used when Source mode is Accession numbers.

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

Optional issuer CIKs to scan through SEC submissions JSON for recent Form D filings.

## `startUrls` (type: `array`):

Optional SEC EDGAR filing index URLs ending in -index.htm. Used when Source mode is SEC filing index URLs.

## `includeRelatedPersons` (type: `boolean`):

Include directors, promoters, executives, and other related people listed on each Form D filing.

## `delayMs` (type: `integer`):

Polite delay between filing requests. Keep this non-zero to respect SEC EDGAR fair-access limits.

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

SEC requires a descriptive User-Agent with contact information. Replace with your organization/contact email for production monitoring.

## Actor input object example

```json
{
  "mode": "current",
  "maxItems": 20,
  "feedCount": 40,
  "accessionNumbers": [
    "0002132077-26-000001"
  ],
  "ciks": [
    "2132077"
  ],
  "startUrls": [
    {
      "url": "https://www.sec.gov/Archives/edgar/data/2132077/000213207726000001/0002132077-26-000001-index.htm"
    }
  ],
  "includeRelatedPersons": true,
  "delayMs": 150,
  "userAgent": "automation-lab SEC Form D Scraper contact: support@automation-lab.com"
}
```

# 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 = {
    "mode": "current",
    "maxItems": 20,
    "feedCount": 40,
    "accessionNumbers": [
        "0002132077-26-000001"
    ],
    "ciks": [
        "2132077"
    ],
    "startUrls": [
        {
            "url": "https://www.sec.gov/Archives/edgar/data/2132077/000213207726000001/0002132077-26-000001-index.htm"
        }
    ],
    "includeRelatedPersons": true,
    "delayMs": 150,
    "userAgent": "automation-lab SEC Form D Scraper contact: support@automation-lab.com"
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/sec-form-d-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 = {
    "mode": "current",
    "maxItems": 20,
    "feedCount": 40,
    "accessionNumbers": ["0002132077-26-000001"],
    "ciks": ["2132077"],
    "startUrls": [{ "url": "https://www.sec.gov/Archives/edgar/data/2132077/000213207726000001/0002132077-26-000001-index.htm" }],
    "includeRelatedPersons": True,
    "delayMs": 150,
    "userAgent": "automation-lab SEC Form D Scraper contact: support@automation-lab.com",
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/sec-form-d-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 '{
  "mode": "current",
  "maxItems": 20,
  "feedCount": 40,
  "accessionNumbers": [
    "0002132077-26-000001"
  ],
  "ciks": [
    "2132077"
  ],
  "startUrls": [
    {
      "url": "https://www.sec.gov/Archives/edgar/data/2132077/000213207726000001/0002132077-26-000001-index.htm"
    }
  ],
  "includeRelatedPersons": true,
  "delayMs": 150,
  "userAgent": "automation-lab SEC Form D Scraper contact: support@automation-lab.com"
}' |
apify call automation-lab/sec-form-d-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "SEC Form D Scraper",
        "description": "Scrape SEC EDGAR Form D private-offering filings for issuer, offering amount, investor count, related persons, addresses, and source URLs.",
        "version": "0.1",
        "x-build-id": "N5d1WMIV6MqZpJhrQ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~sec-form-d-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-sec-form-d-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/automation-lab~sec-form-d-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-sec-form-d-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/automation-lab~sec-form-d-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-sec-form-d-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "mode": {
                        "title": "Source mode",
                        "enum": [
                            "current",
                            "accessions",
                            "ciks",
                            "urls"
                        ],
                        "type": "string",
                        "description": "Choose how to find Form D filings. Current feed monitors latest SEC Form D filings; accessions, CIKs, and URLs target specific filings or issuers.",
                        "default": "current"
                    },
                    "maxItems": {
                        "title": "Maximum filings",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum Form D filing records to save to the dataset.",
                        "default": 20
                    },
                    "feedCount": {
                        "title": "SEC feed count",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "How many Form D candidates to collect from SEC EDGAR when using current-feed or CIK modes. The actor paginates the SEC feed when needed.",
                        "default": 40
                    },
                    "accessionNumbers": {
                        "title": "Accession numbers",
                        "type": "array",
                        "description": "Optional SEC accession numbers, e.g. 0002132077-26-000001. Used when Source mode is Accession numbers.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "ciks": {
                        "title": "Issuer CIKs",
                        "type": "array",
                        "description": "Optional issuer CIKs to scan through SEC submissions JSON for recent Form D filings.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "SEC filing index URLs",
                        "type": "array",
                        "description": "Optional SEC EDGAR filing index URLs ending in -index.htm. Used when Source mode is SEC filing index URLs.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "includeRelatedPersons": {
                        "title": "Include related persons",
                        "type": "boolean",
                        "description": "Include directors, promoters, executives, and other related people listed on each Form D filing.",
                        "default": true
                    },
                    "delayMs": {
                        "title": "Delay between SEC requests (ms)",
                        "minimum": 0,
                        "maximum": 2000,
                        "type": "integer",
                        "description": "Polite delay between filing requests. Keep this non-zero to respect SEC EDGAR fair-access limits.",
                        "default": 150
                    },
                    "userAgent": {
                        "title": "SEC-compliant User-Agent",
                        "type": "string",
                        "description": "SEC requires a descriptive User-Agent with contact information. Replace with your organization/contact email for production monitoring.",
                        "default": "automation-lab SEC Form D Scraper contact: support@automation-lab.com"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```