# Washington L\&I Contractor & Tradesperson License Scraper (`crawlerbros/washington-lni-contractor-scraper`) Actor

Search Washington L\&I contractor, electrician, plumber, and asbestos-worker licenses by name, license number, UBI, or workers' comp account ID. Optional detail enrichment with bonds, insurance, violations. No login required.

- **URL**: https://apify.com/crawlerbros/washington-lni-contractor-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Automation, Lead generation, Other
- **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

## Washington L&I Contractor & Tradesperson License Scraper

Scrape **Washington State Department of Labor & Industries (L&I)** contractor, electrician, plumber, elevator, and asbestos-worker license records from the official "Verify a Contractor, Tradesperson or Business" public registry. Search by business/individual name, license or registration number, UBI (Unified Business Identifier), or workers' comp account ID. Optionally enrich every result with the full license detail record — address, surety bonds, liability insurance, business owners, associated licenses, and safety/contractor violations. No login, no API key, no proxy required.

### What this actor does

- **Four search modes:** by name, by license/registration/certificate number, by UBI number, by workers' comp account ID
- **20 license categories covered:** general/specialty construction contractors, electrical (contractor, administrator, electrician, master electrician, trainee), plumbing (contractor, plumber, plumber trainee, medical gas), asbestos (contractor, supervisor, worker), elevator (contractor, mechanic, primary contact), and manufactured home installers
- **Optional detail enrichment:** attach full business detail — surety bonds, liability insurance, business owners/officers, associated licenses, safety and license violations, DOSH inspections
- **Filters:** license category, license status (active/inactive), city, zip code, and violations-only
- **Empty fields are omitted** — every record only contains data L&I actually returned for that license

### Data source

This actor is built on Washington State L&I's own public JSON search API for the Verify tool (`secure.lni.wa.gov/verify`) — the same backend the official website's search page calls. It requires no login, no API key, and no residential proxy, so it works reliably on Apify's free plan.

This actor replaces an original target of Indiana's professional licensing lookup (`mylicense.in.gov`), which sits behind Cloudflare bot-management that blocks every zero-cost access path we verified: plain HTTP requests, browser-impersonating HTTP clients, and headless-browser automation (including anti-detect browser stacks) were all challenged or blocked before reaching any license data. Washington L&I was chosen as a genuinely open, equivalent public contractor/tradesperson license registry with no such barrier.

### Output per license record

- `licenseId` — the L&I license, registration, or certificate number
- `ubi` — Washington Unified Business Identifier, when on file
- `businessName` — business or individual licensee name
- `contractorType` / `licenseType` — e.g. `Electrician`, `Asbestos Worker`, `General/Specialty Contractor`
- `contractorGroup` — top-level category (e.g. `Electrical`, `Plumber`, `Asbestos`)
- `asbestosGroup` — asbestos-program sub-classification, when the license is asbestos-related
- `status` — `Active`, `Inactive`, `Expired`, `Suspended`, `Out of Business`, `Re-Licensed`, or `Archived`
- `statusDescription` — the raw L&I status text (e.g. `EXPIRED`, `ACTIVE`, `SUSPENDED`) — detail mode only
- `employerDisplayStatus` — L&I's workers'-comp employer-account display status, when on file
- `city`, `state`, `zipCode`, `county`, `address1`, `address2`, `phoneNumber` — detail mode only for address/phone
- `businessType` — e.g. `Limited Liability Company`, `Individual`, `Corporation`
- `parentCompany` — parent/umbrella business, when on file
- `effectiveDate`, `expirationDate`, `suspendDate` — ISO `YYYY-MM-DD`
- `specialtyCode1`, `specialtyName1`, `specialtyText1` and `specialtyCode2`/`specialtyName2`/`specialtyText2` — construction contractor specialty classification
- `contractorTypeDescription` — plain-language description of the license type
- `licenseTypeCode` — L&I's internal short code for the license type (e.g. `CC`) — detail mode only
- `relationType` — the licensee's relation type on the record (e.g. `Business`, `Individual`) — detail mode only
- `hasSafetyViolation`, `hasContractorViolation` — boolean flags
- `hasInactiveWorkersCompAccounts` — boolean
- `associatedLicenses[]` — other licenses/registrations tied to the same business or person
- `businessOwners[]` — owners/officers/partners, with role and start/end dates
- `bonds[]` — surety bond company, account number, amount, effective/expiration dates
- `insurances[]` — liability insurance firm, account ID, amount, effective/expiration dates
- `savingsAccounts[]` — savings account assignment in lieu of bond, when on file
- `violations[]`, `summons[]`, `warrants[]`, `debarments[]`, `strikes[]` — enforcement history, when on file
- `lapses[]` — license lapse/reinstatement history
- `courses[]`, `affidavits[]`, `codes[]` — continuing education and compliance records, when on file
- `doshInspections[]` — Washington DOSH workplace safety inspection history, when on file
- `employerBusinessDetails` — workers'-comp employer business record (legal name, business ID, address), when on file
- `contractorTrackingUrl`, `contractorRegistrationUrl` — related L&I portal links
- `sourceUrl` — canonical L&I Verify detail page URL for the license
- `recordType: "license"`, `scrapedAt`

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `byName` | `byName` / `byLicenseId` / `byUbi` / `byAccountId` |
| `name` | string | `smith` | Business name or individual last name (mode=byName); min 2 characters |
| `licenseId` | string | – | License/registration/certificate number, exact or prefix (mode=byLicenseId) |
| `ubi` | string | – | 9-digit Washington UBI number (mode=byUbi) |
| `accountId` | string | – | Workers' comp account ID, e.g. `123,456-01` (mode=byAccountId) |
| `city` | string | – | Restrict results to a single Washington city (case-insensitive, applied server-side by L&I) |
| `zipCode` | string | – | Restrict results to a single 5-digit Washington zip code (applied server-side by L&I; ignored if `city` is also set) |
| `licenseCategory` | string | – | Restrict results to one of 20 license categories |
| `statusFilter` | string | – | `active` / `inactive` / `expired` / `suspended` / `out of business` / `re-licensed` / `archived` |
| `violationsOnly` | boolean | `false` | Only emit records with a safety and/or contractor violation flagged |
| `sortOrder` | string | `desc` | `desc` / `asc` — L&I's own relevance ranking |
| `fetchDetails` | boolean | `true` | Enrich each result with the full detail record (bonds, insurance, owners, violations, etc.) |
| `maxItems` | integer | `10` | Hard cap on emitted license records (1–500) |

#### Example: search by business name with detail enrichment

```json
{
  "mode": "byName",
  "name": "smith",
  "fetchDetails": true,
  "maxItems": 20
}
````

#### Example: look up an exact license number

```json
{
  "mode": "byLicenseId",
  "licenseId": "ABCAR824BB",
  "fetchDetails": true
}
```

#### Example: search by UBI number, active licenses only

```json
{
  "mode": "byUbi",
  "ubi": "604164913",
  "statusFilter": "active"
}
```

#### Example: browse all licensed electricians without detail hydration (faster)

```json
{
  "mode": "byName",
  "name": "construction",
  "licenseCategory": "Electrician",
  "fetchDetails": false,
  "maxItems": 100
}
```

#### Example: search by name restricted to one city

```json
{
  "mode": "byName",
  "name": "construction",
  "city": "Spokane",
  "maxItems": 25
}
```

#### Example: compliance check for licenses with flagged violations

```json
{
  "mode": "byName",
  "name": "construction",
  "violationsOnly": true,
  "maxItems": 25
}
```

### Use cases

- **Due diligence** — verify a contractor's license, bond, and insurance status before hiring
- **Compliance monitoring** — track license status and violation history for vendors and subcontractors
- **Lead generation** — build lists of licensed contractors/tradespeople by category or region
- **Insurance & surety underwriting** — cross-check bond and insurance coverage on file with L\&I
- **Legal & background research** — pull violation, debarment, and lapse history tied to a business or UBI

### FAQ

**What is the data source?**
This actor uses Washington State Department of Labor & Industries' own public "Verify a Contractor, Tradesperson or Business" lookup tool at `secure.lni.wa.gov/verify`. It is a genuine public REST API with no authentication requirement — the same data the L\&I website itself displays.

**Is this affiliated with Washington State L\&I?**
No. This is an independent, third-party actor that reads L\&I's public verification data. It is not affiliated with or endorsed by the Washington State Department of Labor & Industries.

**Why does `fetchDetails` matter?**
Search results alone give you the license number, business name, category, and basic status. Turning on `fetchDetails` (the default) fetches the full record for each result — address, bonds, insurance, business owners, and violation history — at the cost of one extra request per record. Turn it off for faster, lighter-weight bulk name/category browsing.

**Why are some fields missing on certain licenses?**
L\&I only returns the fields it has on file for a given license. Bonds, insurance, and violation history are commonly empty for license types that don't require them (e.g. individual trade certifications like Electrician or Asbestos Worker don't carry bond/insurance records the way business contractor licenses do). Empty fields are always omitted rather than shown as blank or null.

**What's the difference between "Construction Contractor" and the electrical/plumbing/asbestos/elevator categories?**
"Construction Contractor" is L\&I's general contractor and specialty-trade contractor registration (bonded businesses). Electrical, plumbing, asbestos, and elevator categories are separate certification/licensing programs for individual tradespeople and specialty contractors in those disciplines, each with their own bonding/insurance rules.

**How fresh is the data?**
Every run queries the live L\&I API directly — there is no caching layer, so results reflect L\&I's registry at the moment the actor runs.

**Can I narrow results to a specific city or zip code?**
Yes. Set `city` (e.g. `Seattle`) or `zipCode` (e.g. `98121`) alongside any search `mode` — L\&I's own registry applies the location filter server-side on top of your name/license/UBI/account search, the same as the location dropdown on the official Verify tool's results page. If both are set, `city` takes priority.

**Can I search by partial name?**
Yes. `name` (mode=byName) and `licenseId` (mode=byLicenseId) both support partial/prefix matching, mirroring L\&I's own search behavior — the same as typing into the site's search box.

**Does this include Washington's professional licenses (real estate, cosmetology, etc.)?**
No — those are handled by a different Washington State agency (the Department of Licensing, DOL) with a separate lookup tool. This actor is scoped to L\&I's contractor, tradesperson, and workers'-comp registry only.

# Actor input Schema

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

How to search the L\&I registry.

## `name` (type: `string`):

Business name or last name of an individual (e.g. `smith`, `abc construction`). Partial matches are supported, minimum 2 characters.

## `licenseId` (type: `string`):

The contractor license, electrician/plumber certificate, or registration number (e.g. `ABCAR**824BB`, asterisks included where L\&I's own record has them). Partial prefixes are supported.

## `ubi` (type: `string`):

Washington Unified Business Identifier — exactly 9 digits (e.g. `604164913`).

## `accountId` (type: `string`):

L\&I workers' compensation account ID, formatted like `123,456-01`.

## `city` (type: `string`):

Only emit results located in this Washington city (case-insensitive exact match, e.g. `Seattle`). Applied server-side alongside `mode`. Leave blank for all cities.

## `zipCode` (type: `string`):

Only emit results in this 5-digit Washington zip code (e.g. `98121`). Applied server-side alongside `mode`. Ignored if `city` is also set. Leave blank for all zip codes.

## `licenseCategory` (type: `string`):

Only emit records whose contractor/trade type matches this category. Leave unset for all categories.

## `statusFilter` (type: `string`):

Only emit records with this status. Leave unset for all statuses.

## `violationsOnly` (type: `boolean`):

Only emit records that have a safety violation and/or contractor violation flagged (`hasSafetyViolation` or `hasContractorViolation`). Useful for compliance monitoring and vendor due diligence.

## `sortOrder` (type: `string`):

Sort direction for search results, as ranked by L\&I's own relevance ranking.

## `fetchDetails` (type: `boolean`):

Enrich each result with the full detail record: address, bonds, insurance, business owners, violations, associated licenses, and DOSH inspections. Adds one extra request per record, so it is capped by Max items.

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

Hard cap on emitted license records.

## Actor input object example

```json
{
  "mode": "byName",
  "name": "smith",
  "licenseId": "ABCAR**824BB",
  "ubi": "604164913",
  "city": "",
  "zipCode": "",
  "licenseCategory": "",
  "statusFilter": "",
  "violationsOnly": false,
  "sortOrder": "desc",
  "fetchDetails": true,
  "maxItems": 10
}
```

# Actor output Schema

## `licenses` (type: `string`):

Dataset containing all scraped Washington L\&I license 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": "byName",
    "name": "smith",
    "licenseId": "ABCAR**824BB",
    "ubi": "604164913",
    "city": "",
    "zipCode": "",
    "licenseCategory": "",
    "statusFilter": "",
    "violationsOnly": false,
    "sortOrder": "desc",
    "fetchDetails": true,
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/washington-lni-contractor-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": "byName",
    "name": "smith",
    "licenseId": "ABCAR**824BB",
    "ubi": "604164913",
    "city": "",
    "zipCode": "",
    "licenseCategory": "",
    "statusFilter": "",
    "violationsOnly": False,
    "sortOrder": "desc",
    "fetchDetails": True,
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/washington-lni-contractor-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": "byName",
  "name": "smith",
  "licenseId": "ABCAR**824BB",
  "ubi": "604164913",
  "city": "",
  "zipCode": "",
  "licenseCategory": "",
  "statusFilter": "",
  "violationsOnly": false,
  "sortOrder": "desc",
  "fetchDetails": true,
  "maxItems": 10
}' |
apify call crawlerbros/washington-lni-contractor-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Washington L&I Contractor & Tradesperson License Scraper",
        "description": "Search Washington L&I contractor, electrician, plumber, and asbestos-worker licenses by name, license number, UBI, or workers' comp account ID. Optional detail enrichment with bonds, insurance, violations. No login required.",
        "version": "1.0",
        "x-build-id": "dKVeBKTvlfXVShQre"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~washington-lni-contractor-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-washington-lni-contractor-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~washington-lni-contractor-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-washington-lni-contractor-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~washington-lni-contractor-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-washington-lni-contractor-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"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "byName",
                            "byLicenseId",
                            "byUbi",
                            "byAccountId"
                        ],
                        "type": "string",
                        "description": "How to search the L&I registry.",
                        "default": "byName"
                    },
                    "name": {
                        "title": "Name (mode=byName)",
                        "type": "string",
                        "description": "Business name or last name of an individual (e.g. `smith`, `abc construction`). Partial matches are supported, minimum 2 characters.",
                        "default": "smith"
                    },
                    "licenseId": {
                        "title": "License / registration / certificate number (mode=byLicenseId)",
                        "type": "string",
                        "description": "The contractor license, electrician/plumber certificate, or registration number (e.g. `ABCAR**824BB`, asterisks included where L&I's own record has them). Partial prefixes are supported."
                    },
                    "ubi": {
                        "title": "UBI number (mode=byUbi)",
                        "type": "string",
                        "description": "Washington Unified Business Identifier — exactly 9 digits (e.g. `604164913`)."
                    },
                    "accountId": {
                        "title": "Workers' comp account ID (mode=byAccountId)",
                        "type": "string",
                        "description": "L&I workers' compensation account ID, formatted like `123,456-01`."
                    },
                    "city": {
                        "title": "Filter by city",
                        "type": "string",
                        "description": "Only emit results located in this Washington city (case-insensitive exact match, e.g. `Seattle`). Applied server-side alongside `mode`. Leave blank for all cities.",
                        "default": ""
                    },
                    "zipCode": {
                        "title": "Filter by zip code",
                        "type": "string",
                        "description": "Only emit results in this 5-digit Washington zip code (e.g. `98121`). Applied server-side alongside `mode`. Ignored if `city` is also set. Leave blank for all zip codes.",
                        "default": ""
                    },
                    "licenseCategory": {
                        "title": "Filter by license category",
                        "enum": [
                            "",
                            "Construction Contractor",
                            "Electrical Contractor",
                            "Electrical Administrator",
                            "Electrical Trainee",
                            "Electrician",
                            "Master Electrician",
                            "Modified Trainee",
                            "Asbestos Contractor",
                            "Asbestos Supervisor",
                            "Asbestos Worker",
                            "Plumbing Contractor",
                            "Medical Gas",
                            "Plumber",
                            "Plumber Trainee",
                            "Modified Plumber Trainee",
                            "Elevator Primary Contact",
                            "Elevator Contractor",
                            "Elevator Mechanic",
                            "Elevator Mechanic Temporary",
                            "Manufactured Home Installer"
                        ],
                        "type": "string",
                        "description": "Only emit records whose contractor/trade type matches this category. Leave unset for all categories.",
                        "default": ""
                    },
                    "statusFilter": {
                        "title": "Filter by license status",
                        "enum": [
                            "",
                            "active",
                            "inactive",
                            "expired",
                            "suspended",
                            "out of business",
                            "re-licensed",
                            "archived"
                        ],
                        "type": "string",
                        "description": "Only emit records with this status. Leave unset for all statuses.",
                        "default": ""
                    },
                    "violationsOnly": {
                        "title": "Only show licenses with violations",
                        "type": "boolean",
                        "description": "Only emit records that have a safety violation and/or contractor violation flagged (`hasSafetyViolation` or `hasContractorViolation`). Useful for compliance monitoring and vendor due diligence.",
                        "default": false
                    },
                    "sortOrder": {
                        "title": "Sort order",
                        "enum": [
                            "desc",
                            "asc"
                        ],
                        "type": "string",
                        "description": "Sort direction for search results, as ranked by L&I's own relevance ranking.",
                        "default": "desc"
                    },
                    "fetchDetails": {
                        "title": "Fetch full license details",
                        "type": "boolean",
                        "description": "Enrich each result with the full detail record: address, bonds, insurance, business owners, violations, associated licenses, and DOSH inspections. Adds one extra request per record, so it is capped by Max items.",
                        "default": true
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Hard cap on emitted license records.",
                        "default": 10
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
