# US Business Entity Search API (`lentic_clockss/us-business-entity-search`) Actor

Search US companies across 8 directly selectable state registries, 23 optional extended business sources, and optional OFAC, SEC, and IRS nonprofit checks. Returns normalized entity names, status, authority, address, filing, and source metadata.

- **URL**: https://apify.com/lentic\_clockss/us-business-entity-search.md
- **Developed by:** [kane liu](https://apify.com/lentic_clockss) (community)
- **Categories:** Lead generation, MCP servers
- **Stats:** 36 total users, 7 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.005 / actor start

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## US Business Entity Search

Search US business entities across **state registries, extended business sources, and optional federal screening sources** in one run.

This Actor is designed for business verification, early-stage due diligence, vendor onboarding, sales research, and registry-based company checks. Instead of checking multiple Secretary of State portals and public registries one by one, you can search them together and get back a normalized dataset with business names, status fields, addresses, authorities, and source metadata.

The current search coverage is built from:

- **8 directly selectable state registry sources**
- **23 optional extended business sources**
- **optional federal checks** for OFAC, SEC, and IRS nonprofit records

If you want a single search that can help answer questions like:

- Is this company registered in public US business records?
- In which states or registries does it appear?
- Is it active, inactive, dissolved, or otherwise not in good standing?
- Does it also appear in OFAC, SEC, or IRS nonprofit data?

this Actor is the right fit.

---

### Who is this for?

- **Compliance and KYB teams** verifying legal existence before onboarding a counterparty
- **Operations and procurement teams** checking vendors, suppliers, and partners
- **Sales and research teams** validating business names before outreach
- **Legal and diligence teams** collecting public registration evidence
- **Journalists and investigators** tracing business records across public sources
- **Developers and data teams** building registry lookups into internal workflows

This Actor is most useful when you need the public-records layer of company verification without manually searching multiple registry systems.

---

### What this Actor does

This Actor searches one or more company names across selected US public business sources and returns normalized records.

#### 1. State registry search

Use `states: ["ALL"]` to search all 8 directly supported state registry sources. You can also select individual state codes:

- `NY` — New York
- `TX` — Texas
- `CO` — Colorado
- `CT` — Connecticut
- `IA` — Iowa
- `PA` — Pennsylvania
- `OR` — Oregon
- `AK` — Alaska

The `states` input is validated before the Actor starts. Unsupported state codes such as `CA`, `FL`, `DE`, or `NJ` are rejected instead of starting a run that cannot search those states directly. Use `includeExtendedSources` when you need broader public business datasets beyond the 8 direct state registry sources.

Typical use cases:

- confirm that a company appears in public state records
- check whether the listed status is active or inactive
- collect official registry evidence for a company profile

#### 2. Extended business-source search

You can optionally include **extended sources** for broader coverage. These include additional public business datasets such as:

- city-level business-license datasets
- Delaware entity and trade-name data
- Virginia corporation records
- Texas franchise and sales-tax sources
- Oregon new-business and nonprofit sources
- Missouri alcohol-license data
- Washington contractor-license data
- FDIC institution and location data
- GLEIF LEI data
- NAICS reference data

This helps when a company may not only appear in a standard state registry result, but also in related public business or licensing datasets.

#### 3. Optional compliance screening

If you enable `includeCompliance`, the Actor also searches:

- **OFAC sanctions**
- **SEC EDGAR**

Typical use cases:

- add a basic federal compliance layer to a business-entity check
- review whether a searched name also appears in sanctions or SEC filing records

#### 4. Optional nonprofit screening

If you enable `includeNonprofits`, the Actor also searches:

- **IRS Exempt Organizations**

This is useful when you want to know whether an organization appears in public IRS nonprofit records alongside business registry results.

---

### Default example

This example matches the Actor's default input:

```json
{
  "searchTerms": ["Google"],
  "states": ["ALL"],
  "includeCompliance": false,
  "includeNonprofits": false,
  "includeExtendedSources": false,
  "maxResultsPerState": 50,
  "maxTotalResults": 500
}
````

This means the default run:

- searches for `Google`
- uses the `ALL` state-registry group
- uses only the directly supported state-registry sources
- does **not** include OFAC, SEC, or IRS unless you explicitly turn those on

***

### Example use cases

#### Vendor or counterparty verification

Before you onboard a vendor or sign an agreement, search the business name and review whether it appears in public registry records, what the status is, and which authority published the record.

#### Multi-company prospecting or research

Search several companies in one run to see where they appear across state sources, then export a single table for downstream review. Turn on extended sources when you need broader public-record coverage.

#### Basic compliance context

Turn on `includeCompliance` when you want to add OFAC and SEC signals to the same run instead of doing separate searches.

#### Nonprofit identification

Turn on `includeNonprofits` when you need to check whether an organization appears in IRS exempt-organization records.

#### Footprint mapping

Search a known company name and review which state and extended sources return matches. This gives you a public-record view of where the company shows up across available US datasets.

***

### What you get back

Each result row includes source-specific fields plus normalized metadata for filtering and exports.

Common fields include:

- `name`
- `type`
- `status`
- `country`
- `authority`
- `_product_id`
- `_source`
- `_search_term`
- `_collected_at`

Many results also include source-level business fields such as:

- `business_name`
- `license_id`
- `license_type`
- `address`
- `city`
- `state`
- `zip_code`
- `issue_date`

Because upstream public sources use different schemas, the exact field set varies by source. The normalized preview fields make it easier to inspect results across all of them in one dataset.

***

### Data sources

The Actor combines multiple source groups.

#### Core state registry group

| Source group | Coverage |
| --- | --- |
| Direct state registry sources | NY, TX, CO, CT, IA, PA, OR, AK. Use `ALL` to search all of them. |

#### Extended business sources

When `includeExtendedSources` is enabled, the Actor also includes public sources such as:

- Chicago business owners and licenses
- Colorado history and UCC data
- Delaware licenses, historical entities, and trade names
- Denver licenses
- Kansas City licenses
- Missouri alcohol licenses
- New York filings and NYC business records
- Oregon new businesses and nonprofits
- Seattle licenses
- Texas franchise and sales-tax sources
- Virginia corporation records
- Washington contractor licenses
- FDIC institution and location sources
- GLEIF LEI records
- NAICS reference data

#### Optional federal sources

| Toggle | Source |
| --- | --- |
| `includeCompliance` | OFAC sanctions and SEC EDGAR |
| `includeNonprofits` | IRS Exempt Organizations |

***

### Input reference

| Parameter | Type | Default | Description |
| --- | --- | --- | --- |
| `searchTerms` | array of strings | `["Google"]` | One or more business names or keywords to search |
| `states` | array of strings | `["ALL"]` | Search all supported direct state registry sources with `ALL`, or selected supported state codes: NY, TX, CO, CT, IA, PA, OR, AK. Other state codes are rejected by input validation. |
| `includeCompliance` | boolean | `false` | Also search OFAC sanctions and SEC EDGAR |
| `includeNonprofits` | boolean | `false` | Also search IRS exempt-organization records |
| `includeExtendedSources` | boolean | `false` | Include 23 additional business-related public sources |
| `maxResultsPerState` | integer | `50` | Maximum records per source; valid input range is 1 to 200 |
| `maxTotalResults` | integer | `500` | Maximum records written to the dataset for the whole run; this also caps result-based charges |

#### Practical guidance

- Use **specific company names** for cleaner results
- Leave `states` as `["ALL"]` when you want all supported state-registry sources
- Turn on compliance and nonprofit sources only when you need them
- For larger batch jobs, split long company lists into multiple runs for easier review

***

### Sample output patterns

#### State or business source record

```json
{
  "name": "GOOGLE LLC",
  "type": "business_entity",
  "status": "Active",
  "country": "US",
  "authority": "New York Department of State",
  "_product_id": "us_business_ny",
  "_source": "us_business_ny",
  "_search_term": "Google"
}
```

#### OFAC or SEC result

```json
{
  "name": "ACME TRADING LLC",
  "type": "sanctions_record",
  "status": "No match",
  "country": "US",
  "authority": "OFAC",
  "_product_id": "us_ofac_sanctions",
  "_source": "federal_ofac",
  "_search_term": "Acme Trading LLC"
}
```

#### IRS nonprofit result

```json
{
  "name": "Example Foundation",
  "type": "nonprofit_record",
  "status": "Active",
  "country": "US",
  "authority": "IRS",
  "_product_id": "us_irs_nonprofits",
  "_source": "federal_irs",
  "_search_term": "Example Foundation"
}
```

***

### Pricing

This Actor uses **pay-per-event** pricing.

| Event | Price |
| --- | --- |
| Actor start | $0.005 |
| Each business record | $0.002 |

Example totals:

- 20 records: $0.045
- 100 records: $0.205
- 500 records: $1.005

This model works well for:

- one-off company verification
- batch business screening
- internal pay-per-use workflows

***

### How to use it

#### In Apify Console

1. Open the Actor
2. Enter one or more values in `searchTerms`
3. Choose your `states` selection
4. Decide whether to enable compliance, nonprofit, and extended-source options
5. Set `maxResultsPerState` and `maxTotalResults`
6. Start the run and review the Dataset output

#### In automation tools

You can run this Actor from:

- Make
- n8n
- Zapier
- LangChain
- Apify MCP-compatible workflows

#### Python example

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")

run = client.actor("lentic_clockss/us-business-entity-search").call(
    run_input={
        "searchTerms": ["Google"],
        "states": ["ALL"],
        "includeCompliance": False,
        "includeNonprofits": False,
        "includeExtendedSources": False,
        "maxResultsPerState": 50,
        "maxTotalResults": 500,
    }
)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item.get("_source"), item.get("name"))
```

***

### When to use this Actor vs something else

Use this Actor when you want:

- US business-entity and registry lookups
- public business and licensing source coverage
- optional OFAC, SEC, and IRS context in the same run

Use something else if you need:

- non-US company registries
- credit reports or commercial risk scoring
- deep litigation research
- beneficial-ownership mapping
- location-level consumer-business contact data
- broader multi-jurisdiction sanctions screening

If you need company verification outside the US, use a global company-registry search product instead.

***

### FAQ

#### Which states can I select directly?

Direct state selection currently supports `NY`, `TX`, `CO`, `CT`, `IA`, `PA`, `OR`, and `AK`.

#### Can I enter other state codes like CA, FL, DE, or NJ?

No. Those codes are not supported as direct `states` selections in this Actor right now. The input schema rejects unsupported state codes before the run starts. For broader coverage, keep `states` as `["ALL"]` and enable `includeExtendedSources` if you need related city, filing, license, bank, LEI, or industry-code datasets.

#### What does `ALL` mean in `states`?

It searches all directly supported state-registry sources instead of limiting the run to selected state codes.

#### Are compliance sources enabled by default?

No. `includeCompliance` defaults to `false`. Turn it on only when you want OFAC and SEC checked.

#### Are nonprofit sources enabled by default?

No. `includeNonprofits` defaults to `false`.

#### Are extended business sources enabled by default?

No. `includeExtendedSources` defaults to `false` to keep standard runs fast and cost-bounded. Turn it on when you need broader city, filing, license, bank, LEI, or industry-code coverage.

#### Do all sources return the same fields?

No. Public sources use different schemas. The Actor adds normalized preview fields so you can still review mixed-source results in one table.

#### Can I search multiple companies in one run?

Yes. Add multiple values to `searchTerms`.

#### Is this a credit report or beneficial-ownership product?

No. This Actor focuses on public business, licensing, registry, and optional federal screening records.

***

### Related Actors

- [Global Company Search](https://apify.com/lentic_clockss/global-company-search)
- [Global Sanctions Screening](https://apify.com/lentic_clockss/global-sanctions-screening)
- [Regulatory Compliance Search](https://apify.com/lentic_clockss/regulatory-compliance-search)
- [Google Maps Scraper](https://apify.com/lentic_clockss/google-maps-scraper)

Browse more Actors from this publisher at [apify.com/lentic\_clockss](https://apify.com/lentic_clockss).

# Actor input Schema

## `searchTerms` (type: `array`):

Business names or keywords to search (e.g. 'Google', 'Tesla Motors', 'Acme LLC'). Each term is searched across the selected registry, extended, compliance, and nonprofit sources.

## `states` (type: `array`):

US states to query. Use ALL to search all directly supported state sources, or choose one of: NY, TX, CO, CT, IA, PA, OR, AK.

## `includeCompliance` (type: `boolean`):

Also check OFAC sanctions list and SEC filings for each search term.

## `includeNonprofits` (type: `boolean`):

Also search IRS Exempt Organizations (nonprofits).

## `includeExtendedSources` (type: `boolean`):

Search 23 additional OpenData business sources beyond state registries: city-level licenses (Chicago, Denver, KC, NYC, Seattle), Delaware entities, Virginia corporations, Texas franchise & sales-tax permits, Oregon new businesses & nonprofits, Missouri alcohol licenses, Washington contractor licenses, FDIC bank data, GLEIF LEI registry, NAICS codes, and more. Off by default to keep standard runs fast and cost-bounded.

## `maxResultsPerState` (type: `integer`):

Maximum entities to return per SIP search call. The upstream gateway caps each call at 200.

## `maxTotalResults` (type: `integer`):

Maximum records to write to the dataset for the whole run. This also caps result-based charges.

## Actor input object example

```json
{
  "searchTerms": [
    "Google"
  ],
  "states": [
    "ALL"
  ],
  "includeCompliance": false,
  "includeNonprofits": false,
  "includeExtendedSources": false,
  "maxResultsPerState": 50,
  "maxTotalResults": 500
}
```

# Actor output Schema

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

Dataset containing all 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 = {
    "searchTerms": [
        "Google"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("lentic_clockss/us-business-entity-search").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 = { "searchTerms": ["Google"] }

# Run the Actor and wait for it to finish
run = client.actor("lentic_clockss/us-business-entity-search").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 '{
  "searchTerms": [
    "Google"
  ]
}' |
apify call lentic_clockss/us-business-entity-search --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "US Business Entity Search API",
        "description": "Search US companies across 8 directly selectable state registries, 23 optional extended business sources, and optional OFAC, SEC, and IRS nonprofit checks. Returns normalized entity names, status, authority, address, filing, and source metadata.",
        "version": "0.1",
        "x-build-id": "bkGHSEzl1nwzZhRva"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/lentic_clockss~us-business-entity-search/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-lentic_clockss-us-business-entity-search",
                "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/lentic_clockss~us-business-entity-search/runs": {
            "post": {
                "operationId": "runs-sync-lentic_clockss-us-business-entity-search",
                "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/lentic_clockss~us-business-entity-search/run-sync": {
            "post": {
                "operationId": "run-sync-lentic_clockss-us-business-entity-search",
                "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": {
                    "searchTerms": {
                        "title": "Search terms",
                        "type": "array",
                        "description": "Business names or keywords to search (e.g. 'Google', 'Tesla Motors', 'Acme LLC'). Each term is searched across the selected registry, extended, compliance, and nonprofit sources.",
                        "default": [
                            "Google"
                        ]
                    },
                    "states": {
                        "title": "States to search",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "US states to query. Use ALL to search all directly supported state sources, or choose one of: NY, TX, CO, CT, IA, PA, OR, AK.",
                        "items": {
                            "type": "string",
                            "pattern": "^(ALL|all|NY|ny|TX|tx|CO|co|CT|ct|IA|ia|PA|pa|OR|or|AK|ak)$"
                        },
                        "default": [
                            "ALL"
                        ]
                    },
                    "includeCompliance": {
                        "title": "Include compliance screening",
                        "type": "boolean",
                        "description": "Also check OFAC sanctions list and SEC filings for each search term.",
                        "default": false
                    },
                    "includeNonprofits": {
                        "title": "Include IRS nonprofits",
                        "type": "boolean",
                        "description": "Also search IRS Exempt Organizations (nonprofits).",
                        "default": false
                    },
                    "includeExtendedSources": {
                        "title": "Include extended business sources",
                        "type": "boolean",
                        "description": "Search 23 additional OpenData business sources beyond state registries: city-level licenses (Chicago, Denver, KC, NYC, Seattle), Delaware entities, Virginia corporations, Texas franchise & sales-tax permits, Oregon new businesses & nonprofits, Missouri alcohol licenses, Washington contractor licenses, FDIC bank data, GLEIF LEI registry, NAICS codes, and more. Off by default to keep standard runs fast and cost-bounded.",
                        "default": false
                    },
                    "maxResultsPerState": {
                        "title": "Max results per source",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Maximum entities to return per SIP search call. The upstream gateway caps each call at 200.",
                        "default": 50
                    },
                    "maxTotalResults": {
                        "title": "Max total results",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum records to write to the dataset for the whole run. This also caps result-based charges.",
                        "default": 500
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
