# SEC S-1 IPO Filings Scraper (`automation-lab/sec-s1-ipo-filings-scraper`) Actor

📄 Monitor SEC EDGAR S-1 and S-1/A IPO registration filings. Extract company, CIK, accession, dates, filing index, and document URLs.

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

## Pricing

Pay per event

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## SEC S-1 IPO Filings Scraper

Monitor SEC EDGAR S-1 and S-1/A registration statements and turn recent IPO filing activity into structured data.

### What does SEC S-1 IPO Filings Scraper do?

This Apify actor reads SEC EDGAR Atom feeds for current S-1 and S-1/A filings.

It follows each filing index page to extract the accession number, company name, CIK, filing dates, file size, and primary document URL.

It is designed for IPO pipeline monitoring rather than broad EDGAR crawling.

Use it when you need a clean spreadsheet or API feed of companies preparing to go public.

### Who is it for?

Investment researchers use it to watch new IPO registration statements.

Equity capital markets teams use it to track pipeline activity.

Investment banks use it to identify issuers and amendments quickly.

IR and PR agencies use it to spot companies entering public-market workflows.

Sales teams use it to find timely trigger events for outreach.

Data teams use it to populate dashboards and alerting systems.

### Why use this actor?

✅ Focused S-1 and S-1/A coverage.

✅ No browser automation required.

✅ SEC-compliant descriptive User-Agent support.

✅ Primary document links included.

✅ Optional filing document text extraction.

✅ Simple pay-per-event pricing.

✅ API-ready output for alerts, CRMs, spreadsheets, and warehouses.

### What data can you extract?

| Field | Description |
| --- | --- |
| `formType` | SEC form type such as S-1 or S-1/A |
| `companyName` | Issuer name parsed from EDGAR |
| `cik` | SEC Central Index Key |
| `accessionNumber` | SEC accession number |
| `filedDate` | Filing date |
| `filedAt` | Filing timestamp when available |
| `updatedAt` | Atom feed update timestamp |
| `fileSize` | SEC-reported file size |
| `filingIndexUrl` | SEC filing detail page |
| `primaryDocumentUrl` | Main filing document URL |
| `primaryDocumentType` | Primary document form type |
| `primaryDocumentDescription` | SEC description of the document |
| `secArchiveUrl` | SEC archive directory URL |
| `title` | Original feed title |
| `summary` | SEC feed summary |
| `scrapeTimestamp` | Time the record was scraped |
| `primaryDocumentText` | Optional cleaned filing text |

### How much does it cost to scrape SEC S-1 IPO filings?

The actor uses pay-per-event pricing.

There is a small start event for each run: `$0.005`.

There is a per-filing item event for each saved filing record.

| Plan tier | Price per filing |
| --- | --- |
| Free | $0.000076402 |
| Starter / Bronze | $0.000066437 |
| Scale / Silver | $0.000051821 |
| Business / Gold | $0.000039862 |
| Platinum | $0.000026575 |
| Diamond | $0.000018602 |

A 100-filing monitoring run costs about `$0.0126` on the Free tier including the start event.

Keep the default `maxItems` at 100 for a balanced first run.

Disable document text extraction unless you need filing body text.

### How to use this SEC S-1 scraper

1. Open the actor on Apify.

2. Choose form types, usually `S-1` and `S-1/A`.

3. Set `maxItems` to the number of filing records you need.

4. Optionally filter by company name or CIK.

5. Keep the default SEC User-Agent or replace it with your own contact string.

6. Run the actor.

7. Export the dataset as JSON, CSV, Excel, or via API.

### Input options

`formTypes` controls which EDGAR form feeds to read.

`maxItems` controls the maximum number of records saved.

`mode` selects current filings or date-range filtering.

`startDate` filters saved records on or after a date.

`endDate` filters saved records on or before a date.

`companyQuery` filters company names.

`cik` restricts results to one SEC issuer identifier.

`includePrimaryDocumentText` fetches and stores filing text.

`secUserAgent` identifies your application to SEC EDGAR.

`requestDelayMs` controls conservative delay between SEC requests.

### Example input

```json
{
  "formTypes": ["S-1", "S-1/A"],
  "maxItems": 100,
  "mode": "current",
  "includePrimaryDocumentText": false,
  "requestDelayMs": 200
}
````

### Example output

```json
{
  "formType": "S-1",
  "companyName": "Example Holdings Inc.",
  "cik": "1234567",
  "accessionNumber": "0001234567-26-000001",
  "filedDate": "2026-07-03",
  "filingIndexUrl": "https://www.sec.gov/Archives/edgar/data/...-index.htm",
  "primaryDocumentUrl": "https://www.sec.gov/Archives/edgar/data/.../forms-1.htm",
  "scrapeTimestamp": "2026-07-03T00:00:00.000Z"
}
```

### Tips for best results

Use `S-1` and `S-1/A` together for both initial registrations and amendments.

Use a CIK filter when monitoring a known issuer.

Use company name filtering for lightweight keyword watchlists.

Keep document text disabled for high-volume monitoring.

Enable document text for summarization and diligence workflows.

Use scheduled runs for daily IPO pipeline monitoring.

### Integrations

Send new S-1 records to Slack for IPO alerts.

Load the dataset into Google Sheets for analyst review.

Push records into a CRM as financing or public-market intent signals.

Store records in BigQuery, Snowflake, or Postgres for trend analysis.

Combine with LLM summarization to extract risk factors and use of proceeds.

Trigger sales outreach when a target account files or amends an S-1.

### 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-s1-ipo-filings-scraper').call({
  formTypes: ['S-1', 'S-1/A'],
  maxItems: 100
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient('APIFY_TOKEN')
run = client.actor('automation-lab/sec-s1-ipo-filings-scraper').call(run_input={
    'formTypes': ['S-1', 'S-1/A'],
    'maxItems': 100,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### API usage with cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~sec-s1-ipo-filings-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"formTypes":["S-1","S-1/A"],"maxItems":100}'
```

### Use with AI agents via MCP

SEC S-1 IPO Filings Scraper is available as a tool for AI assistants that support the Model Context Protocol (MCP).

Add the Apify MCP server to your AI client — this gives you access to Apify actors, including this one.

Setup for Claude Code:

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/sec-s1-ipo-filings-scraper"
```

Setup for Claude Desktop, Cursor, or VS Code:

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

Your AI assistant will authenticate with your Apify account on first use.

Example prompts:

- "Run the SEC S-1 IPO Filings Scraper and summarize new issuers."

- "Find recent S-1/A amendments and group them by company."

- "Extract S-1 filings and prepare a sales trigger list."

### Scheduling and monitoring

Run this actor daily to monitor the IPO pipeline.

Use Apify schedules to run before your team starts work.

Send the dataset to webhooks or integrations for automated alerts.

Compare consecutive runs by accession number to detect newly filed records.

### Legality: is it legal to scrape SEC S-1 IPO filings?

SEC EDGAR data is public.

SEC asks automated tools to use a descriptive User-Agent.

This actor uses conservative request pacing.

Do not use scraped data for unlawful spam, deception, or securities-law violations.

Review SEC terms and fair-access guidance for your use case.

### FAQ

**How fast is the SEC S-1 IPO Filings Scraper?**

A 100-filing metadata run usually completes in about one minute with the default SEC-friendly delay.

**How much does a typical monitoring run cost?**

A 100-filing run is about one cent on the Free tier, including the run start event.

**Does this replace the official SEC EDGAR website?**

No. It turns public EDGAR S-1 filing pages into structured API-ready data for monitoring and workflow automation.

**Why did some primary document URLs return null?**

SEC occasionally returns temporary 403 responses for individual filing index pages. The actor still saves feed and master-index metadata for those filings.

**Why are results empty?**

Remove restrictive `companyQuery`, `cik`, or date filters, then run again. Current feeds may contain fewer filings on quiet market days.

### Troubleshooting

If a run returns fewer records than expected, increase `maxItems`, enable quarterly index fallback, or remove filters.

If a company filter returns nothing, try the issuer CIK instead of a partial name.

If SEC returns a temporary error, rerun later with the default request delay.

If you enable document text, expect longer runs and larger datasets.

### Related scrapers

Explore related automation-lab actors for SEC Form 4, 13F, Form ADV, investor alerts, and other public-market workflows.

Use them together when you need a broader capital markets data pipeline.

### Output quality

Records are typed and include source URLs.

The actor does not infer IPO status beyond S-1 registration activity.

The actor does not download attachments unless document text is requested.

The actor saves feed metadata even if an individual filing index page has a temporary issue.

### Limits

EDGAR current feeds expose recent filings, not the entire historical archive.

For very old filings, use a specific CIK workflow or a separate historical EDGAR product.

The actor caps `maxItems` at 500 to keep runs predictable and respectful.

### Changelog

Initial version: focused SEC EDGAR S-1 and S-1/A filing metadata extractor.

# Actor input Schema

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

SEC registration statement form types to monitor. Use S-1 for IPO registrations and S-1/A for amendments.

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

Maximum number of filing records to save across all selected form types.

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

Use current filings for broad IPO monitoring. Date range filtering is applied after SEC feed retrieval.

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

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

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

Only save filings filed on or before this date (YYYY-MM-DD).

## `companyQuery` (type: `string`):

Optional case-insensitive company name filter, for example 'Holdings' or 'Inc.'.

## `cik` (type: `string`):

Optional SEC Central Index Key to restrict results to one company.

## `includePrimaryDocumentText` (type: `boolean`):

Fetch and save cleaned text from the primary S-1 filing document. Leave disabled for fast metadata monitoring.

## `includeHistoricalFallback` (type: `boolean`):

When current EDGAR feeds contain fewer filings than maxItems, fetch recent SEC quarterly master indexes to reach larger monitoring volumes.

## `secUserAgent` (type: `string`):

Descriptive User-Agent sent to SEC EDGAR. SEC requests identifying contact information.

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

Conservative delay to respect SEC EDGAR fair-access guidance. Minimum 100 ms.

## Actor input object example

```json
{
  "formTypes": [
    "S-1",
    "S-1/A"
  ],
  "maxItems": 20,
  "mode": "current",
  "includePrimaryDocumentText": false,
  "includeHistoricalFallback": true,
  "secUserAgent": "AutomationLab SEC S-1 IPO Filings Scraper contact@automation-lab.ai",
  "requestDelayMs": 200
}
```

# 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 = {
    "formTypes": [
        "S-1",
        "S-1/A"
    ],
    "maxItems": 20,
    "mode": "current",
    "startDate": "",
    "endDate": "",
    "companyQuery": "",
    "cik": "",
    "includePrimaryDocumentText": false,
    "includeHistoricalFallback": true,
    "secUserAgent": "AutomationLab SEC S-1 IPO Filings Scraper contact@automation-lab.ai",
    "requestDelayMs": 200
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/sec-s1-ipo-filings-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 = {
    "formTypes": [
        "S-1",
        "S-1/A",
    ],
    "maxItems": 20,
    "mode": "current",
    "startDate": "",
    "endDate": "",
    "companyQuery": "",
    "cik": "",
    "includePrimaryDocumentText": False,
    "includeHistoricalFallback": True,
    "secUserAgent": "AutomationLab SEC S-1 IPO Filings Scraper contact@automation-lab.ai",
    "requestDelayMs": 200,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/sec-s1-ipo-filings-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 '{
  "formTypes": [
    "S-1",
    "S-1/A"
  ],
  "maxItems": 20,
  "mode": "current",
  "startDate": "",
  "endDate": "",
  "companyQuery": "",
  "cik": "",
  "includePrimaryDocumentText": false,
  "includeHistoricalFallback": true,
  "secUserAgent": "AutomationLab SEC S-1 IPO Filings Scraper contact@automation-lab.ai",
  "requestDelayMs": 200
}' |
apify call automation-lab/sec-s1-ipo-filings-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "SEC S-1 IPO Filings Scraper",
        "description": "📄 Monitor SEC EDGAR S-1 and S-1/A IPO registration filings. Extract company, CIK, accession, dates, filing index, and document URLs.",
        "version": "0.1",
        "x-build-id": "34tzJeCN2hSJVPdcS"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~sec-s1-ipo-filings-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-sec-s1-ipo-filings-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-s1-ipo-filings-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-sec-s1-ipo-filings-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-s1-ipo-filings-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-sec-s1-ipo-filings-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": [
                    "formTypes",
                    "maxItems"
                ],
                "properties": {
                    "formTypes": {
                        "title": "Form types",
                        "type": "array",
                        "description": "SEC registration statement form types to monitor. Use S-1 for IPO registrations and S-1/A for amendments.",
                        "default": [
                            "S-1",
                            "S-1/A"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Maximum filings",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of filing records to save across all selected form types.",
                        "default": 20
                    },
                    "mode": {
                        "title": "Collection mode",
                        "enum": [
                            "current",
                            "dateRange"
                        ],
                        "type": "string",
                        "description": "Use current filings for broad IPO monitoring. Date range filtering is applied after SEC feed retrieval.",
                        "default": "current"
                    },
                    "startDate": {
                        "title": "Start filed date",
                        "type": "string",
                        "description": "Only save filings filed on or after this date (YYYY-MM-DD)."
                    },
                    "endDate": {
                        "title": "End filed date",
                        "type": "string",
                        "description": "Only save filings filed on or before this date (YYYY-MM-DD)."
                    },
                    "companyQuery": {
                        "title": "Company name contains",
                        "type": "string",
                        "description": "Optional case-insensitive company name filter, for example 'Holdings' or 'Inc.'."
                    },
                    "cik": {
                        "title": "Company CIK",
                        "type": "string",
                        "description": "Optional SEC Central Index Key to restrict results to one company."
                    },
                    "includePrimaryDocumentText": {
                        "title": "Include primary document text",
                        "type": "boolean",
                        "description": "Fetch and save cleaned text from the primary S-1 filing document. Leave disabled for fast metadata monitoring.",
                        "default": false
                    },
                    "includeHistoricalFallback": {
                        "title": "Use quarterly SEC index fallback",
                        "type": "boolean",
                        "description": "When current EDGAR feeds contain fewer filings than maxItems, fetch recent SEC quarterly master indexes to reach larger monitoring volumes.",
                        "default": true
                    },
                    "secUserAgent": {
                        "title": "SEC User-Agent",
                        "type": "string",
                        "description": "Descriptive User-Agent sent to SEC EDGAR. SEC requests identifying contact information.",
                        "default": "AutomationLab SEC S-1 IPO Filings Scraper contact@automation-lab.ai"
                    },
                    "requestDelayMs": {
                        "title": "Delay between SEC requests (ms)",
                        "minimum": 100,
                        "maximum": 2000,
                        "type": "integer",
                        "description": "Conservative delay to respect SEC EDGAR fair-access guidance. Minimum 100 ms.",
                        "default": 200
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```