# US Contractor Leads — Electricians, Plumbers & HVAC (`memo23/us-home-services-contractor-leads`) Actor

License-verified electrician, plumber and HVAC contractor leads from official US state licensing boards. Florida, Louisiana, North Carolina and California — four states in one run. Business name, license number, status, address, phone and opt-in email. Active licensees only.

- **URL**: https://apify.com/memo23/us-home-services-contractor-leads.md
- **Developed by:** [Muhamed Didovic](https://apify.com/memo23) (community)
- **Categories:** Lead generation, Business, AI
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$4.00 / 1,000 contractor leads

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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## US Contractor Leads — Electricians, Plumbers & HVAC (License-Verified)

> **$0.004 per lead** · license-verified from official state boards · active licensees only · opt-in email & phone enrichment

Generate **license-verified contractor leads** — electricians, plumbers and HVAC/AC contractors — straight from official US **state licensing boards**. **Florida, Louisiana, North Carolina and California are live today**, in a single run. Pick your states, the trades you want and a county or city; get one clean row per active licensee with business name, license number, status, expiry, address, phone and (opt-in, plus the board's own email where published) a business email. One actor covers many states through a per-state adapter, so you never juggle a separate scraper per state.

![How the US Contractor Leads scraper works](https://raw.githubusercontent.com/muhamed-didovic/muhamed-didovic.github.io/main/assets/how-it-works-us-contractor-leads.png)

### Why use this scraper

- **License-verified, not a directory dump.** Every lead comes from the state board's own record — real license number, current status and expiry — so you are contacting contractors who are actually licensed and active.
- **Active licensees only.** Void, expired and delinquent records are filtered out by default; you pay for usable leads, not dead rows.
- **Three trades, four states, one run.** Electricians, plumbers and HVAC across FL, LA, NC and CA in a single job, filtered by county (FL, CA) or city (LA, NC).
- **Phone on the record + opt-in email enrichment.** Most boards publish a phone; Louisiana also publishes a contact email. Turn on enrichment and the actor finds each contractor's website and harvests a business email — the detail most boards don't publish.
- **One actor, many states.** A per-state adapter design means new states light up here instead of as yet another separate actor to manage.

### Supported inputs

| Input | Example | Notes |
|---|---|---|
| State | `FL`, `LA`, `NC`, `CA` | See the coverage matrix below; any combination |
| Trade | `electrician`, `plumber`, `hvac` | Any combination; empty = all three |
| County | `Miami-Dade`, `Los Angeles` | **FL & CA** — matched against the board's county list; empty = statewide |
| City | `Charlotte`, `Baton Rouge` | LA/NC: exact-match board city search. FL/CA: filters the licensee address/export by city (FL needs **Fetch full details**) |

### State coverage

| State | Status | Notes |
|---|---|---|
| **Florida (FL)** | ✅ Live | DBPR — electricians, plumbers, HVAC by county |
| **Louisiana (LA)** | ✅ Live | LSLBC — a general-contractor board, so trades are matched by business name; each record includes a board-published contact email. Searched by city |
| **North Carolina (NC)** | ✅ Live | NCBEEC (electrical) + NCPHFSC (plumbing & heating) — full trade classifications, searched by city |
| **California (CA)** | ✅ Live | CSLB Data Portal — electricians (C-10), plumbers (C-36), HVAC (C-20) by county/city; rows include phone |
| Ohio (OH) | 🛠 Coming soon | OCILB eLicense is a Salesforce app; adapter in progress |
| New York (NY) | ⛔ Municipal | These trades are licensed by cities (e.g. NYC DOB), not a state board |
| Pennsylvania (PA) | ⛔ Municipal | Licensed municipally; only home-improvement contractors register statewide |

Requesting a not-yet-live state logs the reason and is skipped — the run never silently returns nothing.

### Use cases

- Build a call/email list of licensed electricians, plumbers or HVAC contractors in a target county.
- Supplier & manufacturer outreach to verified trade businesses.
- Recruiting and subcontractor sourcing from a pool of active license holders.
- Market sizing — how many active plumbing contractors operate in each county.
- Insurance, fintech and SaaS lead-gen aimed at licensed trades.

### How it works

1. **Choose** a state, trades and (optionally) counties or cities.
2. **Query the board** — the state adapter drives the board's public search over plain HTTP (no browser) — a license-type/county search in FL, a city sweep in LA and NC, a statewide classification export in CA — pages through every active licensee and reads the license record.
3. **Enrich (opt-in)** — for each contractor the actor discovers the business website and scrapes a business email and phone, then writes one row per lead.

### Input configuration

| Field | Type | Default | Description |
|---|---|---|---|
| `states` | array | `["FL","LA","NC"]` | State codes to search |
| `trades` | array | all three | `electrician`, `plumber`, `hvac` |
| `counties` | array | statewide | County names (Florida only) |
| `cities` | array | — | City filter; the board city search for LA/NC |
| `maxItems` | integer | `500` | Hard cap on total lead rows |
| `fetchDetails` | boolean | `true` | Open each record for full address, city, ZIP |
| `enrichEmails` | boolean | `false` | Find a business email + phone from the contractor's own site |
| `hunterApiKey` | string (secret) | — | Optional Hunter.io fallback for email discovery |
| `proxyConfiguration` | object | residential | US residential proxy recommended |

Minimal input:

```json
{
    "states": ["FL"],
    "trades": ["electrician"],
    "counties": ["Miami-Dade"]
}
````

### Output — key fields

| Field | Description |
|---|---|
| `businessName` | Licensee / business name |
| `licenseNumber` | State license number (e.g. `EC13014400`) |
| `licenseType` | Board's license category, e.g. "Certified Electrical Contractor" |
| `licenseStatus` / `licenseExpiryDate` | Current status and expiry |
| `address` / `city` / `zip` / `county` | Location, from the board record |
| `phone` | Business phone (populated by opt-in enrichment) |
| `email` / `additionalEmails` / `emailSource` | Business emails (opt-in enrichment) |
| `website` | Discovered business website |
| `trade` / `state` | Which trade and state this row belongs to |
| `sourceUrl` | Link back to the board's public record |

#### Output sample

```json
{
    "state": "FL",
    "trade": "electrician",
    "licenseType": "Certified Electrical Contractor",
    "businessName": "305 ELECTRIC SOLUTIONS, INC.",
    "licenseNumber": "EC13009564",
    "licenseStatus": "Current, Active",
    "licenseExpiryDate": "08/31/2026",
    "address": "8231 NW 8 ST APT 302, MIAMI Florida 33126",
    "city": "MIAMI",
    "zip": "33126",
    "county": "Dade",
    "phone": null,
    "email": null,
    "website": null,
    "sourceUrl": "https://www.myfloridalicense.com/LicenseDetail.asp?id=…",
    "scrapedAt": "2026-07-24T09:00:00.000Z"
}
```

(For FL this sample's `phone`/`email`/`website` populate when **Enrich emails** is on. LA, NC and CA return the board's phone directly, and LA also includes the board's contact email without enrichment.)

### Pricing

**Pay-per-event: $0.004 per contractor lead** written to the dataset. Only active, license-verified rows are produced, so you are not billed for void or expired records. Bound spend with `maxItems`.

### FAQ

**Does it need a browser or proxy?** No browser — the state boards are scraped over plain HTTP. A US residential proxy is recommended for reliable scale.

**Are the leads really licensed?** Yes — every row is a live record from the state licensing board, with the license number, status and expiry. Only active licensees are returned.

**Where do phone and email come from?** LA, NC and CA publish a business phone on the record, and Louisiana also publishes a contact email (Florida publishes neither). For emails elsewhere, turn on **Enrich emails** and the actor finds the contractor's own website and harvests a business email from it.

**Which states work today?** Florida, Louisiana, North Carolina and California are live. Ohio is in progress. New York and Pennsylvania license these trades at the city level, so there is no state board to enumerate — see the coverage matrix.

**Can I filter by city?** Yes, with **Fetch full details** on (the city comes from each licensee's address). County filtering works without it.

**How many leads can I get?** Florida alone has thousands of active licensees per trade per county (e.g. ~4,000 electricians in Broward). Louisiana and North Carolina add statewide city sweeps across hundreds of municipalities, and California's CSLB export lists ~28,000 electricians (C-10), ~17,000 plumbers (C-36) and ~12,000 HVAC contractors (C-20). Use `maxItems` to control volume and cost.

### Support

Found a bug, want another state, or a field added? Open an issue on the actor's Issues tab — it is monitored.

### 🤖 For AI Agents & LLM Apps

**Purpose:** Turn a state + trade + county into a list of license-verified contractor leads (business, license number, status, address, opt-in email/phone). Browser-free, one row per active licensee.

**Minimal input (tested):**

```json
{ "states": ["FL"], "trades": ["electrician"], "counties": ["Miami-Dade"], "maxItems": 50 }
```

**Output fields (flat):** `state`, `trade`, `licenseType`, `businessName`, `ownerName`, `licenseNumber`, `licenseStatus`, `licenseIssuedDate`, `licenseExpiryDate`, `address`, `city`, `county`, `stateRegion`, `zip`, `phone`, `website`, `email`, `additionalEmails[]`, `emailSource`, `sourceUrl`, `scrapedAt`.

**Behaviors agents should know:**

- Live states are `FL`, `LA`, `NC`, `CA`. Requesting a `pending`/municipal state logs the reason and is skipped (check the coverage matrix).
- Only active licensees are emitted; void/expired are filtered.
- `phone` is on the record for LA/NC/CA (FL is the exception — enrich for it). `email` is board-published for LA; for FL/NC/CA set `enrichEmails: true`. `website` needs `enrichEmails: true`.
- LA is a general-contractor board, so its electrician/plumber/hvac split is inferred from the business name.
- Billing is per lead row (`contractor-lead`, $0.004). Bound with `maxItems`.

### Explore more actors

- [Email Finder & Verifier](https://apify.com/memo23/email-finder) — resolve & verify business emails from names or domains.
- [Phone Enrichment](https://apify.com/memo23/phone-enrichment) — validate phone numbers and reverse-lookup US owners.

### ⚠️ Disclaimer

This actor collects only publicly available records published by official US state licensing boards. Use the data in compliance with each board's terms, applicable law, and anti-spam/marketing rules (e.g. TCPA, CAN-SPAM) when contacting contractors. You are responsible for how you use the leads. This actor does not bypass logins, paywalls or access controls.

### SEO Keywords

contractor leads, electrician leads, plumber leads, HVAC leads, licensed contractor scraper, contractor license lookup, state licensing board scraper, Florida DBPR scraper, Louisiana LSLBC scraper, North Carolina NCBEEC scraper, NC plumbing HVAC licensing, California CSLB scraper, CSLB license lookup, contractor email finder, trade contractor database, home services leads, license verification, contractor list by county, contractor leads by city, B2B contractor leads, Apify contractor scraper.

# Actor input Schema

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

US state codes to search. Currently LIVE: FL, LA, NC, CA. Requesting a not-yet-supported state logs why and is skipped (see the README coverage matrix).

## `trades` (type: `array`):

Which contractor trades to include. Leave empty for all three.

## `counties` (type: `array`):

County names to filter by, e.g. "Miami-Dade", "Los Angeles". Empty = statewide. Florida (DBPR) and California (CSLB) support a county filter; LA and NC boards search by city instead (see Cities).

## `cities` (type: `array`):

City names to filter by. For LA and NC this is the board's exact-match city search; for FL and CA it filters the licensee's address/export by city (FL needs "Fetch full details"). Empty = statewide sweep.

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

Hard cap on the number of contractor rows for the whole run.

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

Open each licensee's detail page for full address, ZIP and phone. Slower but richer; also required for city filtering.

## `enrichEmails` (type: `boolean`):

Find a business email for each contractor by discovering and scraping their own website. Off by default.

## `hunterApiKey` (type: `string`):

Paid Hunter.io fallback used only when a site scrape finds no email. Leave empty to use the free site-scrape path only.

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

State licensing boards are US-only sites; a US residential proxy is recommended for reliability at scale.

## Actor input object example

```json
{
  "states": [
    "FL",
    "LA",
    "NC",
    "CA"
  ],
  "trades": [
    "electrician",
    "plumber",
    "hvac"
  ],
  "maxItems": 500,
  "fetchDetails": true,
  "enrichEmails": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# 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 = {
    "states": [
        "FL",
        "LA",
        "NC",
        "CA"
    ],
    "trades": [
        "electrician",
        "plumber",
        "hvac"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "US"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("memo23/us-home-services-contractor-leads").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 = {
    "states": [
        "FL",
        "LA",
        "NC",
        "CA",
    ],
    "trades": [
        "electrician",
        "plumber",
        "hvac",
    ],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "US",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("memo23/us-home-services-contractor-leads").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 '{
  "states": [
    "FL",
    "LA",
    "NC",
    "CA"
  ],
  "trades": [
    "electrician",
    "plumber",
    "hvac"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}' |
apify call memo23/us-home-services-contractor-leads --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=memo23/us-home-services-contractor-leads",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "US Contractor Leads — Electricians, Plumbers & HVAC",
        "description": "License-verified electrician, plumber and HVAC contractor leads from official US state licensing boards. Florida, Louisiana, North Carolina and California — four states in one run. Business name, license number, status, address, phone and opt-in email. Active licensees only.",
        "version": "0.0",
        "x-build-id": "ROhNxFMtHAf90MJS2"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/memo23~us-home-services-contractor-leads/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-memo23-us-home-services-contractor-leads",
                "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/memo23~us-home-services-contractor-leads/runs": {
            "post": {
                "operationId": "runs-sync-memo23-us-home-services-contractor-leads",
                "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/memo23~us-home-services-contractor-leads/run-sync": {
            "post": {
                "operationId": "run-sync-memo23-us-home-services-contractor-leads",
                "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": {
                    "states": {
                        "title": "States",
                        "type": "array",
                        "description": "US state codes to search. Currently LIVE: FL, LA, NC, CA. Requesting a not-yet-supported state logs why and is skipped (see the README coverage matrix).",
                        "items": {
                            "type": "string",
                            "enum": [
                                "FL",
                                "LA",
                                "NC",
                                "CA",
                                "OH",
                                "NY",
                                "PA"
                            ],
                            "enumTitles": [
                                "Florida (live)",
                                "Louisiana (live)",
                                "North Carolina (live)",
                                "California (live)",
                                "Ohio (coming soon)",
                                "New York (municipal)",
                                "Pennsylvania (municipal)"
                            ]
                        },
                        "default": [
                            "FL",
                            "LA",
                            "NC",
                            "CA"
                        ]
                    },
                    "trades": {
                        "title": "Trades",
                        "type": "array",
                        "description": "Which contractor trades to include. Leave empty for all three.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "electrician",
                                "plumber",
                                "hvac"
                            ],
                            "enumTitles": [
                                "Electricians",
                                "Plumbers",
                                "HVAC / Air Conditioning"
                            ]
                        },
                        "default": [
                            "electrician",
                            "plumber",
                            "hvac"
                        ]
                    },
                    "counties": {
                        "title": "Counties (optional, FL & CA)",
                        "type": "array",
                        "description": "County names to filter by, e.g. \"Miami-Dade\", \"Los Angeles\". Empty = statewide. Florida (DBPR) and California (CSLB) support a county filter; LA and NC boards search by city instead (see Cities).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "cities": {
                        "title": "Cities (optional)",
                        "type": "array",
                        "description": "City names to filter by. For LA and NC this is the board's exact-match city search; for FL and CA it filters the licensee's address/export by city (FL needs \"Fetch full details\"). Empty = statewide sweep.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Max leads",
                        "minimum": 1,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Hard cap on the number of contractor rows for the whole run.",
                        "default": 500
                    },
                    "fetchDetails": {
                        "title": "Fetch full details",
                        "type": "boolean",
                        "description": "Open each licensee's detail page for full address, ZIP and phone. Slower but richer; also required for city filtering.",
                        "default": true
                    },
                    "enrichEmails": {
                        "title": "Enrich emails (opt-in)",
                        "type": "boolean",
                        "description": "Find a business email for each contractor by discovering and scraping their own website. Off by default.",
                        "default": false
                    },
                    "hunterApiKey": {
                        "title": "Hunter.io API key (optional)",
                        "type": "string",
                        "description": "Paid Hunter.io fallback used only when a site scrape finds no email. Leave empty to use the free site-scrape path only."
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "State licensing boards are US-only sites; a US residential proxy is recommended for reliability at scale.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ],
                            "apifyProxyCountry": "US"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
