# Rhode Island Secretary of State Business Search Scraper (`crawlerbros/rhode-island-sos-business-search-scraper`) Actor

Search Rhode Island's free public business entity database by entity name, officer name, ID number, filing number, registered agent, address, NAICS code, or purpose. Get entity type, status, formation date, address, and registered agent details.

- **URL**: https://apify.com/crawlerbros/rhode-island-sos-business-search-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Automation, Lead generation, Agents
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

## Rhode Island Secretary of State Business Search Scraper

Search the **Rhode Island Department of State's** free public business entity database (`business.sos.ri.gov`). Look up a business by entity name, officer/individual name, ID number, filing number, registered agent, address, NAICS industry code, or business purpose text, and get entity type, status, formation date, principal/mailing address, registered agent details, and more. HTTP-only via the public CorpWeb search form — no login required.

### Data Source & Usage Notes

**Read this before running a large job.**

- **No login, no CAPTCHA.** The source is a classic ASP.NET WebForms search form with no account wall or bot challenge observed on normal traffic.
- **Single-page results (up to 100 per search).** Rhode Island's results grid supports server-side paging via `__doPostBack` events that require grid-side session state this actor does not replicate reliably (attempting a "next page" postback consistently errors even with a faithful field replay). The actor requests the grid's own "100 items per page" display option and returns that first page. For very broad queries (e.g. a one-letter entity-name prefix) there may be more matches on the source site than the 100 returned here — narrow your search (fuller name, specific individual, specific agent) to get a complete result set.
- **`entityStatus` is a required, exclusive filter** on the source's own search form (a single Active/Inactive radio button) — every search returns entities of exactly one status.
- **Conservative by design.** `maxItems` is capped at 100. The actor only ever uses Apify's free datacenter (AUTO) proxy group — never a paid residential proxy — to get a fresh IP if a request is ever blocked.
- **Not affiliated with the State of Rhode Island.** This is an independent third-party tool using the source's own public, no-login search form.

#### Why Rhode Island instead of Wyoming?

This actor was originally scoped as a Wyoming SOS (`sos.wyo.gov` / `wyobiz.wyo.gov`) business entity search. Live verification showed `wyobiz.wyo.gov` and `sos.wyo.gov` are not reachable — connection attempts from two independent network paths both got `ECONNREFUSED`/connection timeout on port 443 despite DNS resolving correctly, consistent with the Wyoming state network blocking non-residential source ranges outright (which would also block Apify's own datacenter proxy IPs). Per this project's zero-cost reliability policy, the target was replaced with Rhode Island's SOS business search — the same free, no-login, no-CAPTCHA "CorpWeb" ASP.NET platform used by several New England states, confirmed live and returning real data.

### What this actor does

- **8 search modes**, matching every axis Rhode Island's own search form exposes:
  - `byEntityName` — entity name, with begins-with / exact / full-text / soundex match
  - `byIndividual` — officer/director/manager first/middle/last name, with begins-with / exact / full-text / soundex match
  - `byIdentificationNumber` — exact RI entity ID number
  - `byFilingNumber` — exact filing document number
  - `byAgent` — registered agent name, with begins-with / contains match
  - `byAddress` — street address text
  - `byNAICS` — NAICS industry classification code
  - `byPurpose` — business purpose text
- **Active/Inactive status filter** on every search
- **Full entity detail** — automatically follows through from search results to each entity's detail page for entity type, dates, addresses, agent, NAICS, and purpose
- **Officer match context** — `byIndividual` searches additionally return the matched officer's name and position at that entity
- **Empty fields are omitted**

### What's NOT included (and why)

- **Filing history** (list of individual filed documents/dates) — the detail page exposes only a static list of *filing-type categories* to filter by, not actual filing history records; there is no free endpoint returning the entity's real filing timeline.
- **Mailing address** — only present on the source's detail page for some entity types (e.g. LLCs); when absent for a given entity (e.g. many corporations), the field is omitted rather than left null.
- **A small fraction of rows the source's own search grid returns are unresolvable and are silently skipped.** Confirmed live: for a small number of grid rows (roughly 1 in 5 on some queries), Rhode Island's own results grid embeds an ID number that resolves — via the source's own detail-page link — to a *different, unrelated* entity than the name shown in the row (an upstream data-integrity defect on RI SOS's own site, reproduced by fetching the row's own link directly outside this actor). The actor detects this by comparing the fetched detail page's entity name back against the search row's entity name, and skips the row rather than emit a name that doesn't match what was searched. This means a search may return fewer records than the row count implied by the results grid.
- **Filing number as an independent identifier** — Rhode Island's "filing number" search field is confirmed live and submitted correctly, but no test filing number returned a match during verification; the field is exposed as documented on the source form and fails soft (0 records) for values the source doesn't recognize, same as any other exact-lookup mode.

### Output per entity

- `entityName`
- `idNumber` — Rhode Island entity ID number (shown as "ID Number" on the source)
- `entityType` — e.g. `Domestic Limited Liability Company`, `Domestic Profit Corporation`
- `status` — `Active` or `Inactive` (per the search filter used)
- `formationDate` — `YYYY-MM-DD`
- `effectiveDate` — `YYYY-MM-DD`
- `naicsCode`, `naicsDescription` — when on file
- `principalAddress`, `principalCity`, `principalState`, `principalZip`
- `mailingAddress`, `mailingCity`, `mailingState`, `mailingZip` — when on file (LLC-type entities)
- `registeredAgentName`, `registeredAgentAddress`, `registeredAgentCity`, `registeredAgentState`, `registeredAgentZip`
- `purpose` — stated business purpose text, when on file
- `matchedIndividualName`, `matchedIndividualPosition` — mode=`byIndividual` only
- `sourceUrl`
- `recordType: "entity"`, `scrapedAt`

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `byEntityName` | One of the 8 search modes |
| `entityStatus` | string | `Active` | `Active` / `Inactive` |
| `entityName` | string | `AMAZON` | mode=byEntityName |
| `entityNameMatchType` | string | `B` | `B`/`M`/`F`/`S` — begins with / exact / full text / soundex |
| `firstName`, `middleName`, `lastName` | string | – | mode=byIndividual |
| `individualMatchType` | string | `B` | `B`/`M`/`F`/`S` |
| `identificationNumber` | string | – | mode=byIdentificationNumber |
| `filingNumber` | string | – | mode=byFilingNumber |
| `agentName` | string | – | mode=byAgent |
| `agentMatchType` | string | `B` | `B`/`C` — begins with / contains |
| `address` | string | – | mode=byAddress |
| `naicsCode` | string | – | mode=byNAICS |
| `purpose` | string | – | mode=byPurpose |
| `proxyConfiguration` | object | AUTO proxy | Apify proxy config; always datacenter (AUTO), never residential |
| `maxItems` | int | `25` | Hard cap (1–100) |

#### Example: search by entity name prefix

```json
{
  "mode": "byEntityName",
  "entityName": "TESLA",
  "entityStatus": "Active",
  "maxItems": 10
}
````

#### Example: search by officer/individual last name

```json
{
  "mode": "byIndividual",
  "lastName": "SMITH",
  "entityStatus": "Active",
  "maxItems": 10
}
```

#### Example: lookup by exact ID number

```json
{
  "mode": "byIdentificationNumber",
  "identificationNumber": "001741304",
  "entityStatus": "Active"
}
```

#### Example: search by registered agent

```json
{
  "mode": "byAgent",
  "agentName": "Corporation Service Company",
  "agentMatchType": "C",
  "entityStatus": "Active",
  "maxItems": 25
}
```

#### Example: search by NAICS code

```json
{
  "mode": "byNAICS",
  "naicsCode": "541810",
  "entityStatus": "Active",
  "maxItems": 25
}
```

### Use cases

- **Due diligence** — confirm a counterparty's Rhode Island formation date, entity type, and registered agent before contracting
- **Compliance & KYC** — cross-check a business's legal entity name and ID number
- **Registered agent research** — find every entity a specific agent represents
- **Industry research** — pull every active entity under a NAICS code
- **People search** — find every RI entity where a specific individual is an officer/director/manager
- **Company name availability checks** — see what similarly-named entities already exist before choosing a new name

### FAQ

**What's the data source?** The Rhode Island Department of State's own free public business entity search at `business.sos.ri.gov`. This actor is an independent third-party tool and is not affiliated with the State of Rhode Island.

**Is this data official / legally binding?** No. For an official Certificate of Good Standing or certified copies, use the state's paid ordering channels (see the source site). This actor returns the same free-tier informational data the public search page shows.

**Why does every search need a status filter?** Rhode Island's own search form requires exactly one of Active/Inactive on every query — there is no "both" option upstream.

**Why did my run return 0 results?** Either the query genuinely has no match under the selected status, or the match type (begins-with vs. exact vs. full-text vs. soundex) is narrower than expected. Try a broader match type or the other status value.

**Why is `maxItems` capped at 100?** The source's own results grid returns at most 100 matches per page and this actor does not currently paginate beyond that page (see Data Source & Usage Notes above).

**What's the difference between the match types?** `Begins with` matches the start of the name; `Exact match` requires the full name; `Full text` matches anywhere in the name; `Soundex` matches phonetically similar names. These mirror Rhode Island's own search form options exactly.

**How fresh is the data?** Real-time — the search reflects the Department of State's database as of the moment of the search.

**Why does my run sometimes return fewer records than the search page showed?** Rhode Island's own search grid occasionally embeds a stale ID number for a row (roughly 1 in 5 on some queries), which resolves to a different, unrelated entity than the name shown in the row — a data-integrity issue on the state's own site, not this actor. The actor detects this by checking the fetched entity's name against the search row's name and skips any row that doesn't match, rather than return the wrong business under the name you searched for. See "What's NOT included" above for details.

# Actor input Schema

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

Which search axis to use.

## `entityStatus` (type: `string`):

Filter to Active or Inactive entities. Rhode Island's search form requires exactly one of these on every query.

## `entityName` (type: `string`):

Business entity name to search for, e.g. `AMAZON`.

## `entityNameMatchType` (type: `string`):

How `entityName` is matched.

## `firstName` (type: `string`):

First name of an officer, director, or manager to search for.

## `middleName` (type: `string`):

Middle name of an officer, director, or manager to search for.

## `lastName` (type: `string`):

Last name of an officer, director, or manager to search for, e.g. `SMITH`.

## `individualMatchType` (type: `string`):

How the individual's name fields are matched.

## `identificationNumber` (type: `string`):

Exact Rhode Island entity ID number (a.k.a. Federal ID/FEIN as recorded by RI SOS), e.g. `001741304`.

## `filingNumber` (type: `string`):

Exact filing number for a specific filing document.

## `agentName` (type: `string`):

Registered agent name to search for, e.g. `Corporation Service Company`.

## `agentMatchType` (type: `string`):

How `agentName` is matched.

## `address` (type: `string`):

Street address (or partial address) to search for, e.g. `Main Street`.

## `naicsCode` (type: `string`):

North American Industry Classification System code, e.g. `541810`.

## `purpose` (type: `string`):

Text to search for within registered entities' stated business purpose, e.g. `restaurant`.

## `proxyConfiguration` (type: `object`):

Uses Apify's free datacenter (AUTO) proxy group to get a fresh IP if a request is temporarily blocked. Residential proxy is never used by this actor.

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

Hard cap on emitted records. The source's own results grid returns at most 100 matches per search (see README), so this is capped at 100.

## Actor input object example

```json
{
  "mode": "byEntityName",
  "entityStatus": "Active",
  "entityName": "AMAZON",
  "entityNameMatchType": "B",
  "lastName": "SMITH",
  "individualMatchType": "B",
  "agentMatchType": "B",
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "maxItems": 10
}
```

# Actor output Schema

## `entities` (type: `string`):

Dataset containing all scraped Rhode Island business entity records.

# 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": "byEntityName",
    "entityStatus": "Active",
    "entityName": "AMAZON",
    "entityNameMatchType": "B",
    "lastName": "SMITH",
    "individualMatchType": "B",
    "agentMatchType": "B",
    "proxyConfiguration": {
        "useApifyProxy": true
    },
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/rhode-island-sos-business-search-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": "byEntityName",
    "entityStatus": "Active",
    "entityName": "AMAZON",
    "entityNameMatchType": "B",
    "lastName": "SMITH",
    "individualMatchType": "B",
    "agentMatchType": "B",
    "proxyConfiguration": { "useApifyProxy": True },
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/rhode-island-sos-business-search-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": "byEntityName",
  "entityStatus": "Active",
  "entityName": "AMAZON",
  "entityNameMatchType": "B",
  "lastName": "SMITH",
  "individualMatchType": "B",
  "agentMatchType": "B",
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "maxItems": 10
}' |
apify call crawlerbros/rhode-island-sos-business-search-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=crawlerbros/rhode-island-sos-business-search-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Rhode Island Secretary of State Business Search Scraper",
        "description": "Search Rhode Island's free public business entity database by entity name, officer name, ID number, filing number, registered agent, address, NAICS code, or purpose. Get entity type, status, formation date, address, and registered agent details.",
        "version": "1.0",
        "x-build-id": "wdgzPIOLg4t6nKgK1"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~rhode-island-sos-business-search-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-rhode-island-sos-business-search-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/crawlerbros~rhode-island-sos-business-search-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-rhode-island-sos-business-search-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/crawlerbros~rhode-island-sos-business-search-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-rhode-island-sos-business-search-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": [
                    "mode",
                    "entityStatus",
                    "proxyConfiguration"
                ],
                "properties": {
                    "mode": {
                        "title": "Search mode",
                        "enum": [
                            "byEntityName",
                            "byIndividual",
                            "byIdentificationNumber",
                            "byFilingNumber",
                            "byAgent",
                            "byAddress",
                            "byNAICS",
                            "byPurpose"
                        ],
                        "type": "string",
                        "description": "Which search axis to use.",
                        "default": "byEntityName"
                    },
                    "entityStatus": {
                        "title": "Entity status",
                        "enum": [
                            "Active",
                            "Inactive"
                        ],
                        "type": "string",
                        "description": "Filter to Active or Inactive entities. Rhode Island's search form requires exactly one of these on every query.",
                        "default": "Active"
                    },
                    "entityName": {
                        "title": "Entity name (mode=byEntityName)",
                        "type": "string",
                        "description": "Business entity name to search for, e.g. `AMAZON`.",
                        "default": "AMAZON"
                    },
                    "entityNameMatchType": {
                        "title": "Entity name match type (mode=byEntityName)",
                        "enum": [
                            "B",
                            "M",
                            "F",
                            "S"
                        ],
                        "type": "string",
                        "description": "How `entityName` is matched.",
                        "default": "B"
                    },
                    "firstName": {
                        "title": "First name (mode=byIndividual)",
                        "type": "string",
                        "description": "First name of an officer, director, or manager to search for."
                    },
                    "middleName": {
                        "title": "Middle name (mode=byIndividual)",
                        "type": "string",
                        "description": "Middle name of an officer, director, or manager to search for."
                    },
                    "lastName": {
                        "title": "Last name (mode=byIndividual)",
                        "type": "string",
                        "description": "Last name of an officer, director, or manager to search for, e.g. `SMITH`.",
                        "default": "SMITH"
                    },
                    "individualMatchType": {
                        "title": "Individual name match type (mode=byIndividual)",
                        "enum": [
                            "B",
                            "M",
                            "F",
                            "S"
                        ],
                        "type": "string",
                        "description": "How the individual's name fields are matched.",
                        "default": "B"
                    },
                    "identificationNumber": {
                        "title": "ID number (mode=byIdentificationNumber)",
                        "type": "string",
                        "description": "Exact Rhode Island entity ID number (a.k.a. Federal ID/FEIN as recorded by RI SOS), e.g. `001741304`."
                    },
                    "filingNumber": {
                        "title": "Filing number (mode=byFilingNumber)",
                        "type": "string",
                        "description": "Exact filing number for a specific filing document."
                    },
                    "agentName": {
                        "title": "Registered agent name (mode=byAgent)",
                        "type": "string",
                        "description": "Registered agent name to search for, e.g. `Corporation Service Company`."
                    },
                    "agentMatchType": {
                        "title": "Agent name match type (mode=byAgent)",
                        "enum": [
                            "B",
                            "C"
                        ],
                        "type": "string",
                        "description": "How `agentName` is matched.",
                        "default": "B"
                    },
                    "address": {
                        "title": "Address (mode=byAddress)",
                        "type": "string",
                        "description": "Street address (or partial address) to search for, e.g. `Main Street`."
                    },
                    "naicsCode": {
                        "title": "NAICS code (mode=byNAICS)",
                        "type": "string",
                        "description": "North American Industry Classification System code, e.g. `541810`."
                    },
                    "purpose": {
                        "title": "Business purpose text (mode=byPurpose)",
                        "type": "string",
                        "description": "Text to search for within registered entities' stated business purpose, e.g. `restaurant`."
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Uses Apify's free datacenter (AUTO) proxy group to get a fresh IP if a request is temporarily blocked. Residential proxy is never used by this actor.",
                        "default": {
                            "useApifyProxy": true
                        }
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Hard cap on emitted records. The source's own results grid returns at most 100 matches per search (see README), so this is capped at 100.",
                        "default": 25
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
