# Corporate.AI Company Registry Scraper (`automation-lab/corporate-ai-company-registry-scraper`) Actor

🔎 Search Corporate.AI’s public US registry and export legal names, filing numbers, entity status, formation dates, jurisdiction, addresses, and canonical source links.

- **URL**: https://apify.com/automation-lab/corporate-ai-company-registry-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Lead generation
- **Stats:** 2 total users, 1 monthly users, 80.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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## Corporate.AI Company Registry Scraper

Search Corporate.AI's public US company registry and turn company matches into structured, export-ready records.

Use a company name, keyword, or saved Corporate.AI search URL. Add state, entity-type, and status filters. Optionally enrich each match with jurisdiction, filing type, and public address details.

The Actor is designed for repeatable KYB research, compliance screening, B2B enrichment, legal research, and registry monitoring—not one-off copy and paste.

### What does Corporate.AI Company Registry Scraper do?

It automates the public company-search workflow on Corporate.AI.

- 🔎 Searches by company name or keyword
- 🎯 Applies state, entity-type, and status filters
- 📄 Follows bounded result pagination
- 🏢 Enriches public entity detail pages
- 🧹 Removes duplicate companies
- 🔗 Preserves canonical source URLs
- 🕐 Adds a scrape timestamp to every row
- 📦 Exports JSON, CSV, Excel, XML, and RSS through Apify datasets

Search records remain useful even when an optional detail page has sparse fields.

Officer and registered-agent fields are nullable because they are not present for every source record.

### Who is it for?

#### KYB and compliance teams

Build a first-pass registry dataset before enhanced due diligence.

Use filing numbers and source URLs to retain an auditable trail.

#### B2B sales and enrichment teams

Discover companies matching a brand, industry keyword, or naming pattern.

Schedule the same query to refresh prospect lists.

#### Legal and investigative researchers

Compare legal names, jurisdictions, statuses, formation dates, and filing identifiers.

Open the canonical source URL when a record needs manual verification.

#### Journalists and analysts

Collect structured company matches for research notebooks, spreadsheets, and reproducible investigations.

### Why use this Actor?

Manual registry research is slow and difficult to repeat consistently.

This Actor provides:

- predictable JSON fields
- automatic pagination
- deterministic deduplication
- optional detail enrichment
- configurable extraction limits
- retries and request timeouts
- integrations with the Apify API, webhooks, schedules, and cloud storage

No Corporate.AI account or paid API key is required for the public surfaces used by this Actor.

### What company data can I extract?

| Field | Description |
|---|---|
| `sourceId` | Corporate.AI internal entity identifier |
| `query` | Company query that produced the match |
| `legalName` | Registered legal name |
| `state` | Filing state code |
| `filingNumber` | State filing identifier |
| `entityType` | Corporation, LLC, LP, or another source type |
| `status` | Public registry status |
| `formationDate` | Formation date when available |
| `dissolutionDate` | Dissolution date when available |
| `sourceUrl` | Canonical Corporate.AI entity page |
| `rank` | Source relevance rank |
| `jurisdiction` | Enriched jurisdiction |
| `filingType` | Enriched filing type |
| `principalAddress` | Public principal address object |
| `mailingAddress` | Public mailing address object |
| `officerNames` | Nullable list when available |
| `agentName` | Nullable registered-agent name |
| `detailsIncluded` | Whether enrichment was requested |
| `scrapedAt` | UTC extraction timestamp |

### How to scrape Corporate.AI company records

1. Open the Actor input page.
2. Add one or more company queries.
3. Optionally choose a two-letter state code.
4. Optionally add entity type or status.
5. Set a conservative maximum company count.
6. Keep detail enrichment enabled when you need addresses.
7. Click **Start**.
8. Review the dataset preview.
9. Export the records or connect an integration.

The prefilled example searches `ZEBRA` in New York and completes quickly.

### Input options

#### `queries`

A list of company names or keywords.

Example:

```json
["APPLE", "HOLDINGS"]
````

#### `startUrls`

Public Corporate.AI search URLs.

Example:

```json
[{ "url": "https://corporate.ai/search?q=APPLE&state=CA" }]
```

Only `corporate.ai/search` URLs are accepted. Other hosts and paths fail closed.

#### `state`

An optional two-letter state code such as `CA`, `NY`, or `TX`.

#### `entityType`

An optional source entity type such as `Corporation`, `LLC`, or `LP`.

#### `status`

An optional source status such as `Active` or `Dissolved`.

#### `includeDetails`

Fetch public entity pages for additional registration and address fields.

#### `maxItems`

The maximum unique companies saved across all queries.

#### `pageSize`

The number of search records requested per page, up to 100.

#### `maxConcurrency`

The maximum simultaneous detail requests, up to 10.

### Input example

```json
{
  "queries": ["APPLE"],
  "state": "CA",
  "status": "Active",
  "includeDetails": true,
  "maxItems": 20,
  "pageSize": 50,
  "maxConcurrency": 5
}
```

You may combine queries and saved search URLs. Duplicate companies are emitted once.

### Output example

```json
{
  "sourceId": "02f90184-6138-4b4d-8cda-6c9fc2fbc74f",
  "query": "APPLE",
  "legalName": "APPLE-EATERS, INC.",
  "state": "CA",
  "filingNumber": "2464892",
  "entityType": "Corporation",
  "status": "Active",
  "formationDate": "2002-08-28T00:00:00.000Z",
  "dissolutionDate": null,
  "sourceUrl": "https://corporate.ai/entity/ca/2464892/apple-eaters-inc",
  "rank": 0.12158542,
  "jurisdiction": "California",
  "filingType": "Domestic",
  "principalAddress": {
    "streetAddress": "200 PARK AVENUE SOUTH 8TH FLOOR",
    "locality": "NY",
    "region": "NY",
    "country": "United States",
    "formatted": "200 PARK AVENUE SOUTH 8TH FLOOR · NY, NY · United States"
  },
  "mailingAddress": {
    "formatted": "200 PARK AVENUE SOUTH 8TH FLOOR · NY, NY · United States"
  },
  "officerNames": null,
  "agentName": null,
  "detailsIncluded": true,
  "scrapedAt": "2026-07-21T00:00:00.000Z"
}
```

### How much does it cost to scrape company registry records?

This Actor uses pay-per-event pricing.

You pay a small run-start fee and a per-company-record fee.

Apify plan tiers receive progressively lower per-record prices. The live pricing table on the Actor page is authoritative.

To control cost:

- set a low `maxItems` for initial tests
- disable details when search-level fields are enough
- avoid overlapping queries
- use state and status filters
- review a small dataset before scaling

The Actor stops once it reaches your maximum.

### Pagination and limits

Corporate.AI search results are fetched with offset pagination.

The Actor stops when:

- `maxItems` is reached
- the source returns no records
- the source reports `hasMore=false`

`maxItems` applies across all queries, not separately to each query.

### Detail enrichment

When `includeDetails` is enabled, each company page may add:

- jurisdiction
- filing type
- principal address
- mailing address

The source may omit fields for some companies or states.

A failed optional detail request does not discard a valid search record.

### Data quality and coverage

Corporate.AI describes its registry as a US company dataset sourced from state filings.

Coverage and freshness can vary by state and record.

This Actor reports what the public source returns at run time. It does not make a blanket guarantee about all 50 states, officer availability, or official legal completeness.

For consequential decisions, verify the record using its source URL and the relevant Secretary of State.

### Tips for reliable company searches

- Start with the distinctive part of a legal name.
- Use uppercase or lowercase; the source handles text matching.
- Add a state when a name is common.
- Use multiple focused queries instead of one overly broad keyword.
- Keep concurrency conservative for stable scheduled runs.
- Store filing number plus state as a durable external key.
- Retain `scrapedAt` when comparing changes over time.

### Scheduling a registry monitor

Use an Apify schedule to repeat the same input daily, weekly, or monthly.

A common workflow is:

1. Run a focused company search.
2. Export filing number, status, and source URL.
3. Compare the latest dataset with the previous dataset.
4. Notify your team when new entities or status changes appear.

Connect a webhook to trigger downstream automation after each successful run.

### Integrations

#### Google Sheets

Send new company records to a sheet used by compliance or sales operations.

#### Make

Trigger enrichment, approval, or CRM workflows from completed datasets.

#### Zapier

Create alerts or lead records when a scheduled registry run finishes.

#### Slack

Post newly discovered companies to a research or compliance channel.

#### Webhooks

Notify your own endpoint and fetch the default dataset through the Apify API.

#### Cloud storage

Export JSON or CSV to your preferred storage and analytics stack.

### Use with the Apify API

#### JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/corporate-ai-company-registry-scraper').call({
  queries: ['APPLE'],
  state: 'CA',
  includeDetails: true,
  maxItems: 20,
});
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/corporate-ai-company-registry-scraper').call(run_input={
    'queries': ['APPLE'],
    'state': 'CA',
    'includeDetails': True,
    'maxItems': 20,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

#### cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~corporate-ai-company-registry-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"queries":["APPLE"],"state":"CA","includeDetails":true,"maxItems":20}'
```

### Use with MCP and AI agents

Connect through [Apify MCP](https://mcp.apify.com/?tools=automation-lab/corporate-ai-company-registry-scraper).

#### Claude Code setup

Add the hosted MCP server with the exact command below:

```bash
claude mcp add --transport http apify "https://mcp.apify.com/?tools=automation-lab/corporate-ai-company-registry-scraper"
```

Then authenticate when prompted and ask Claude to run the Actor with a bounded input.

Example prompt:

> Search Corporate.AI for active New York companies matching ZEBRA, enrich the first 20 records, and summarize entity types.

#### Claude Desktop setup

Add this server block to the Claude Desktop MCP configuration:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com/?tools=automation-lab/corporate-ai-company-registry-scraper"
    }
  }
}
```

#### Cursor setup

Open **Cursor Settings → MCP**, add a remote server, and use the same `mcpServers` JSON block and URL shown above.

#### VS Code setup

Open the MCP configuration in VS Code, add an HTTP server named `apify`, and use the same Corporate.AI Actor tool URL shown above.

Example prompt for Desktop, Cursor, or VS Code:

> Build a CSV-ready list of active NY LLCs matching HOLDINGS with filing numbers and source links.

Always specify a `maxItems` limit in agent-driven workflows.

### Error handling

Search requests use timeouts, retries, and exponential backoff.

Unexpected search response shapes fail the run instead of returning misleading success.

Invalid start URL hosts or paths fail closed.

Individual detail failures are logged, while valid search records remain available with nullable detail fields.

### Troubleshooting

#### Why did my query return no companies?

Try a broader name fragment, remove optional filters, or verify the query directly on Corporate.AI.

#### Why are address or officer fields null?

Public detail coverage differs by record and state. Officer and agent data are intentionally nullable rather than fabricated.

#### Why did a search URL fail validation?

Only public `https://corporate.ai/search?...` URLs are accepted. Entity URLs and third-party URLs are outside this input route.

#### Why did I receive fewer records than `maxItems`?

`maxItems` is a ceiling, not a promise. The source may have fewer matching records after filters.

### Legal and responsible use

This Actor accesses publicly reachable registry search and entity pages.

You are responsible for your use of the data and for complying with applicable laws, source terms, privacy rules, and contractual obligations.

Do not use registry data for harassment, discrimination, spam, or unsupported automated decisions.

Public registry information is not legal advice. Verify consequential facts with the official state registry.

### Related scrapers

Explore other public-data and business-intelligence tools from [automation-lab](https://apify.com/automation-lab).

Combine registry records with website, lead, or company-enrichment Actors when your workflow needs additional public context.

### FAQ

#### Does the Actor require a Corporate.AI API key?

No. It uses the anonymous public search endpoint and public entity pages.

#### Can I search several company names in one run?

Yes. Add multiple values to `queries`; the global `maxItems` covers the whole run.

#### Can I use a saved search URL?

Yes. Add a Corporate.AI `/search` URL to `startUrls`.

#### Are duplicate companies removed?

Yes. The Actor deduplicates by source ID, with state plus filing number as the conceptual fallback.

#### Does it return every officer and registered agent?

No. Those fields remain null where Corporate.AI does not expose them.

#### Can I export to Excel or CSV?

Yes. Open the dataset and choose the desired export format.

#### Can I run it on a schedule?

Yes. Use Apify schedules and optionally attach a webhook.

#### Is this an official government registry?

No. Corporate.AI is the public source surface. Follow the canonical links and official state sources for final verification.

# Actor input Schema

## `queries` (type: `array`):

Company names or keywords to search. Add one query per line.

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

Optional public Corporate.AI /search URLs. Filters in each URL override the global filters.

## `state` (type: `string`):

Optional two-letter US state filter, for example CA or NY.

## `entityType` (type: `string`):

Optional Corporate.AI entity type filter, such as Corporation, LLC, or LP.

## `status` (type: `string`):

Optional status filter, such as Active or Dissolved.

## `includeDetails` (type: `boolean`):

Fetch each public entity page for jurisdiction, filing type, and available addresses.

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

Maximum unique company records saved across all queries.

## `pageSize` (type: `integer`):

Records requested per search API page.

## `maxConcurrency` (type: `integer`):

Maximum concurrent detail-page requests. Keep this conservative for source stability.

## Actor input object example

```json
{
  "queries": [
    "ZEBRA"
  ],
  "startUrls": [
    {
      "url": "https://corporate.ai/search?q=ZEBRA&state=NY"
    }
  ],
  "state": "NY",
  "includeDetails": true,
  "maxItems": 20,
  "pageSize": 50,
  "maxConcurrency": 5
}
```

# 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 = {
    "queries": [
        "ZEBRA"
    ],
    "startUrls": [
        {
            "url": "https://corporate.ai/search?q=ZEBRA&state=NY"
        }
    ],
    "state": "NY",
    "includeDetails": true,
    "maxItems": 20,
    "pageSize": 50,
    "maxConcurrency": 5
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/corporate-ai-company-registry-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 = {
    "queries": ["ZEBRA"],
    "startUrls": [{ "url": "https://corporate.ai/search?q=ZEBRA&state=NY" }],
    "state": "NY",
    "includeDetails": True,
    "maxItems": 20,
    "pageSize": 50,
    "maxConcurrency": 5,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/corporate-ai-company-registry-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 '{
  "queries": [
    "ZEBRA"
  ],
  "startUrls": [
    {
      "url": "https://corporate.ai/search?q=ZEBRA&state=NY"
    }
  ],
  "state": "NY",
  "includeDetails": true,
  "maxItems": 20,
  "pageSize": 50,
  "maxConcurrency": 5
}' |
apify call automation-lab/corporate-ai-company-registry-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Corporate.AI Company Registry Scraper",
        "description": "🔎 Search Corporate.AI’s public US registry and export legal names, filing numbers, entity status, formation dates, jurisdiction, addresses, and canonical source links.",
        "version": "0.1",
        "x-build-id": "L5YIFk0oecnkhHBgO"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~corporate-ai-company-registry-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-corporate-ai-company-registry-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~corporate-ai-company-registry-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-corporate-ai-company-registry-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~corporate-ai-company-registry-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-corporate-ai-company-registry-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": {
                    "queries": {
                        "title": "🔎 Company queries",
                        "type": "array",
                        "description": "Company names or keywords to search. Add one query per line.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Corporate.AI search URLs",
                        "type": "array",
                        "description": "Optional public Corporate.AI /search URLs. Filters in each URL override the global filters.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "state": {
                        "title": "State code",
                        "pattern": "^[A-Za-z]{2}$",
                        "type": "string",
                        "description": "Optional two-letter US state filter, for example CA or NY."
                    },
                    "entityType": {
                        "title": "Entity type",
                        "type": "string",
                        "description": "Optional Corporate.AI entity type filter, such as Corporation, LLC, or LP."
                    },
                    "status": {
                        "title": "Company status",
                        "type": "string",
                        "description": "Optional status filter, such as Active or Dissolved."
                    },
                    "includeDetails": {
                        "title": "Enrich company details",
                        "type": "boolean",
                        "description": "Fetch each public entity page for jurisdiction, filing type, and available addresses.",
                        "default": true
                    },
                    "maxItems": {
                        "title": "Maximum companies",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum unique company records saved across all queries.",
                        "default": 20
                    },
                    "pageSize": {
                        "title": "Search page size",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Records requested per search API page.",
                        "default": 50
                    },
                    "maxConcurrency": {
                        "title": "Detail concurrency",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Maximum concurrent detail-page requests. Keep this conservative for source stability.",
                        "default": 5
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
