# Washington Contractor License Lookup Scraper (`automation-lab/washington-contractor-license-lookup-scraper`) Actor

Search Washington L\&I Verify for contractor licenses, UBI, bond, insurance, and compliance details.

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

## Pricing

Pay per event

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## Washington Contractor License Lookup Scraper

Export public Washington State L&I Verify contractor and business records from `secure.lni.wa.gov/verify`.

Use this Apify Actor to search Washington contractor registrations, tradesperson records, UBI numbers, and workers' compensation account references, then save structured records for compliance checks, lead generation, insurance workflows, and marketplace onboarding.

### Overview

Washington Contractor License Lookup Scraper turns the public Washington Department of Labor & Industries Verify lookup into a repeatable dataset export.

The actor searches the same public Verify system that users access in a browser, but it returns clean JSON records instead of requiring manual copy and paste.

Each result can include license status, license number, UBI number, business location, expiration dates, specialties, bond counts, insurance counts, owner/principal names, and public compliance flags.

It is designed for teams that need to verify many Washington contractors or keep a recurring contractor compliance list up to date.

### What it extracts

The actor can save the following fields when Washington L&I returns them:

- Business or contractor name
- Contractor license or registration number
- Washington UBI number
- Workers' comp account reference when available
- License status
- License type
- Contractor type and contractor group
- Specialty names
- Effective date
- Expiration date
- Suspend date
- Business type
- Phone number
- Street address
- City
- State
- ZIP code
- County
- Safety violation flag
- Contractor violation flag
- Workers' comp display status
- Bond count
- Insurance count
- Lawsuit count
- Warrant count
- Violation count
- Bond summary records
- Insurance summary records
- Owner and principal summary records
- Source URL
- Original query
- Search type
- Scrape timestamp

### Who is it for

Use this actor if you work with Washington construction or trade businesses and need public license verification at scale.

### Who should use it

This actor is built for buyers who need repeatable Washington contractor verification instead of one-off browser checks.

Common users include:

- Contractor marketplaces
- Construction lead-generation teams
- Insurance brokers
- Surety bond teams
- Lenders
- Compliance analysts
- Procurement teams
- Property management companies
- Vendor onboarding teams
- Background-check and due-diligence teams

### Business use cases

#### Contractor lead generation

Search broad terms such as `roofing`, `construction`, `electric`, or local business names to build a prospect list from public L&I records.

#### License verification

Search a contractor license number and confirm status, expiration date, license type, specialties, and source URL.

#### Insurance and bond checks

Fetch detailed records to review bond and insurance counts and returned policy summaries.

#### Marketplace onboarding

Use the dataset as an automated check before a Washington contractor is approved for a marketplace, vendor network, or customer referral workflow.

#### Recurring compliance monitoring

Schedule the actor to run monthly or weekly with your saved contractor list and compare current statuses against previous exports.

### Input options

#### Search queries

`queries` is a list of values to search.

Examples:

```json
["construction", "roofing", "electric"]
````

For exact lookups, provide the exact identifier and select the matching search type.

#### Search type

`searchType` controls the Washington L\&I search mode.

Supported values:

- `Name` — business name, contractor name, or last name
- `LicenseId` — contractor or tradesperson license number
- `Ubi` — Washington UBI number
- `AccountId` — workers' comp account number

#### Maximum records

`maxItems` limits the total number of dataset records saved across all queries.

Use a small number for tests and a larger number for production exports.

#### Results per request

`pageSize` controls the internal L\&I result page size.

The default is suitable for most users.

#### Fetch detailed records

`includeDetails` controls whether the actor calls the detail endpoint for every result.

Keep it enabled when you need dates, addresses, bonds, insurance, owners, and compliance counts.

Disable it only when you need a very fast search-list export.

#### Active only

`activeOnly` skips non-active detailed statuses.

Leave it disabled for audits because expired, inactive, suspended, or archived records can be important.

### Example input: contractor discovery

```json
{
  "queries": ["construction", "roofing", "electric"],
  "searchType": "Name",
  "maxItems": 100,
  "pageSize": 50,
  "includeDetails": true,
  "activeOnly": false
}
```

### Example input: exact license lookup

```json
{
  "queries": ["CONSTAI083L5"],
  "searchType": "LicenseId",
  "maxItems": 1,
  "includeDetails": true
}
```

### Example input: UBI lookup

```json
{
  "queries": ["601378957"],
  "searchType": "Ubi",
  "maxItems": 5,
  "includeDetails": true
}
```

### Example output

```json
{
  "businessName": "CONSTRUCTION AHEAD INC",
  "licenseNumber": "CONSTAI083L5",
  "ubiNumber": "601378957",
  "status": "ACTIVE",
  "licenseType": "Construction Contractor",
  "contractorType": "General/Specialty Contractor",
  "specialties": ["GENERAL"],
  "effectiveDate": "06/25/1992",
  "expirationDate": "11/05/2027",
  "city": "Richland",
  "state": "WA",
  "zipCode": "99352",
  "bondCount": 1,
  "insuranceCount": 1,
  "sourceUrl": "https://secure.lni.wa.gov/verify/Detail.aspx?UBI=601378957&LIC=CONSTAI083L5&SAW=False",
  "query": "CONSTAI083L5",
  "searchType": "LicenseId",
  "scrapedAt": "2026-07-05T00:00:00.000Z"
}
```

### Output fields explained

`businessName` is the name returned by Washington L\&I.

`licenseNumber` is the contractor, tradesperson, or registration identifier.

`ubiNumber` is the Washington Unified Business Identifier when present.

`status` is the detailed L\&I license status when details are enabled.

`licenseType` and `contractorType` describe the Washington license category.

`specialties` lists specialty classifications returned by L\&I.

`effectiveDate`, `expirationDate`, and `suspendDate` support compliance timing checks.

`hasSafetyViolation` and `hasContractorViolation` are public flags from the search result.

`bondCount`, `insuranceCount`, `lawsuitCount`, `warrantCount`, and `violationCount` summarize related compliance sections.

`bonds`, `insurances`, and `owners` contain sanitized summary arrays from the detail record.

`sourceUrl` links back to the public L\&I detail page.

### Data source

The data source is Washington L\&I Verify.

The actor uses public endpoints behind the public Verify pages:

- Search results endpoint
- Business details endpoint

No account or private credential is required.

### Why use this instead of manual search

Manual Verify searches are fine for a single contractor.

They are slow for a portfolio, marketplace, insurer, or compliance list.

This actor lets you run the same checks in bulk and export the data to JSON, CSV, Excel, or API integrations.

### Scheduling

You can schedule the actor in Apify to monitor known contractors.

Recommended recurring workflows:

- Weekly active-license checks
- Monthly insurance and bond review
- Quarterly vendor file refresh
- Pre-onboarding exact license checks

### Integrations

The output dataset can be consumed from:

- Apify Console downloads
- Apify API
- Webhooks
- Zapier or Make
- Internal ETL jobs
- BI tools
- CRM enrichment workflows

### API usage

Start a run with the Apify API and read the default dataset after the run succeeds.

#### Node.js API example

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });

const input = {
  queries: ['roofing'],
  searchType: 'Name',
  maxItems: 25,
  includeDetails: true,
};

const run = await client.actor('automation-lab/washington-contractor-license-lookup-scraper').call(input);
const { items } = await client.dataset(run.defaultDatasetId).listItems({ limit: 3 });
console.log(items);
```

#### Python API example

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")
run = client.actor("automation-lab/washington-contractor-license-lookup-scraper").call(run_input={
    "queries": ["roofing"],
    "searchType": "Name",
    "maxItems": 25,
    "includeDetails": True,
})

items = list(client.dataset(run["defaultDatasetId"]).iterate_items())
print(items[:3])
```

#### cURL API example

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~washington-contractor-license-lookup-scraper/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"queries":["roofing"],"searchType":"Name","maxItems":25,"includeDetails":true}'
```

### MCP usage

Use Apify MCP when you want Claude Code, Claude Desktop, Cursor, VS Code, or another MCP client to run this actor directly.

The required actor-specific MCP server URL is:

```text
https://mcp.apify.com?tools=automation-lab/washington-contractor-license-lookup-scraper
```

#### Claude Code MCP setup

```bash
claude mcp add apify "https://mcp.apify.com?tools=automation-lab/washington-contractor-license-lookup-scraper"
```

#### Claude Desktop, Cursor, and VS Code MCP setup

Add this server to your MCP client configuration and replace `YOUR_APIFY_TOKEN` with your Apify API token.

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/washington-contractor-license-lookup-scraper",
      "headers": {
        "Authorization": "Bearer YOUR_APIFY_TOKEN"
      }
    }
  }
}
```

In VS Code, use the same JSON server definition in your MCP settings. In Cursor, add it under MCP servers. In Claude Desktop, add it to the app MCP configuration and restart the client.

Example prompts:

- "Run the Washington Contractor License Lookup Scraper for license CONSTAI083L5 and summarize whether the contractor is active."
- "Search Washington L\&I for roofing contractors and return the first 20 active records with expiration dates."
- "Check these UBI numbers against Washington L\&I Verify and flag missing bond or insurance records."

Use exact license searches for deterministic assistant workflows.

Use name searches for discovery and lead workflows.

### How much does it cost to scrape Washington contractor license records?

This actor uses pay-per-event pricing.

There is a small run start charge and a per-record charge for each saved license record.

You are charged only for records the actor saves to the dataset, plus the run start event.

Use `maxItems` to control cost.

### Cost control tips

Start with a small `maxItems` value.

Use `LicenseId` or `Ubi` for exact verification.

Disable `includeDetails` only when search-list fields are enough.

Keep `pageSize` near the default unless you have a specific reason to tune it.

### Related scrapers

Other automation-lab scrapers that can support public-record, licensing, or local-market workflows:

- [Washington Contractor License Lookup Scraper](https://apify.com/automation-lab/washington-contractor-license-lookup-scraper)
- [Google Maps Reviews Scraper](https://apify.com/automation-lab/google-maps-reviews-scraper)
- [Yelp Business Scraper](https://apify.com/automation-lab/yelp-business-scraper)
- [Website Contact Finder](https://apify.com/automation-lab/website-contact-finder)

### Limitations

The actor returns data that Washington L\&I makes available through Verify.

It does not infer private information.

It does not guarantee that a contractor is suitable for your project.

Always review official source pages for high-risk decisions.

Search result ordering is controlled by Washington L\&I.

Some records may not have every optional field.

### Legality

The actor accesses public Washington L\&I Verify pages and public JSON endpoints without login, authentication bypass, or private credentials.

### Legal and compliance note

This actor accesses public government records.

You are responsible for using the data in compliance with applicable laws, contracts, and internal policies.

Do not use the output for unlawful discrimination or decisions that require additional regulated procedures.

### FAQ

#### Can I search multiple contractor names at once?

Yes. Add multiple values to `queries`; the actor deduplicates records by license, UBI, violation ID, or business/location key.

#### Does this require a Washington L\&I account?

No. It uses public Verify data.

#### Why are some fields empty?

Washington L\&I does not return every field for every record, and details can be disabled in the input.

### Troubleshooting

If you get no records, check that the search type matches the query.

A license number should use `LicenseId`.

A UBI should use `Ubi`.

A broad company keyword should use `Name`.

If a field is missing, it was not returned by Washington L\&I for that record or details were disabled.

### Changelog

Initial version: searches Washington L\&I Verify by name, license, UBI, or account ID and exports detailed contractor/license records.

### Support

If a run fails or a record looks wrong, include the run ID, input JSON, and expected public Verify result when contacting support.

# Actor input Schema

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

Business names, contractor names, license numbers, UBI numbers, or L\&I account IDs to search. Use search type below to match the query values.

## `searchType` (type: `string`):

The Washington L\&I Verify search mode to use for all queries.

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

Maximum dataset records to save across all queries.

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

Washington L\&I page size used internally. Larger values reduce requests for bulk runs.

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

Fetch each detail endpoint to add addresses, dates, bonds, insurance, owners, and compliance counts.

## `activeOnly` (type: `boolean`):

Skip records whose detailed status is not active. Leave disabled for complete compliance research.

## Actor input object example

```json
{
  "queries": [
    "construction",
    "roofing",
    "electric"
  ],
  "searchType": "Name",
  "maxItems": 20,
  "pageSize": 50,
  "includeDetails": true,
  "activeOnly": false
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "queries": [
        "construction",
        "roofing",
        "electric"
    ],
    "searchType": "Name",
    "maxItems": 20,
    "pageSize": 50,
    "includeDetails": true,
    "activeOnly": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/washington-contractor-license-lookup-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "queries": [
        "construction",
        "roofing",
        "electric",
    ],
    "searchType": "Name",
    "maxItems": 20,
    "pageSize": 50,
    "includeDetails": True,
    "activeOnly": False,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/washington-contractor-license-lookup-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "queries": [
    "construction",
    "roofing",
    "electric"
  ],
  "searchType": "Name",
  "maxItems": 20,
  "pageSize": 50,
  "includeDetails": true,
  "activeOnly": false
}' |
apify call automation-lab/washington-contractor-license-lookup-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Washington Contractor License Lookup Scraper",
        "description": "Search Washington L&I Verify for contractor licenses, UBI, bond, insurance, and compliance details.",
        "version": "0.1",
        "x-build-id": "F2N1plUdV07YF2Fxk"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~washington-contractor-license-lookup-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-washington-contractor-license-lookup-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/automation-lab~washington-contractor-license-lookup-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-washington-contractor-license-lookup-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/automation-lab~washington-contractor-license-lookup-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-washington-contractor-license-lookup-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": [
                    "queries"
                ],
                "properties": {
                    "queries": {
                        "title": "Search queries",
                        "minItems": 1,
                        "type": "array",
                        "description": "Business names, contractor names, license numbers, UBI numbers, or L&I account IDs to search. Use search type below to match the query values.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchType": {
                        "title": "Search type",
                        "enum": [
                            "Name",
                            "LicenseId",
                            "Ubi",
                            "AccountId"
                        ],
                        "type": "string",
                        "description": "The Washington L&I Verify search mode to use for all queries.",
                        "default": "Name"
                    },
                    "maxItems": {
                        "title": "Maximum records",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum dataset records to save across all queries.",
                        "default": 20
                    },
                    "pageSize": {
                        "title": "Results per request",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Washington L&I page size used internally. Larger values reduce requests for bulk runs.",
                        "default": 50
                    },
                    "includeDetails": {
                        "title": "Fetch detailed records",
                        "type": "boolean",
                        "description": "Fetch each detail endpoint to add addresses, dates, bonds, insurance, owners, and compliance counts.",
                        "default": true
                    },
                    "activeOnly": {
                        "title": "Only active licenses",
                        "type": "boolean",
                        "description": "Skip records whose detailed status is not active. Leave disabled for complete compliance research.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```