# Louisiana Contractor Leads Scraper (LSLBC) — with Emails (`memo23/louisiana-contractor-leads-scraper`) Actor

Scrape license-verified contractor leads from Louisiana's LSLBC registry — company, license number, class, status, expiry, address, phone, and the contractor's own email published on the board record. Commercial, residential, home-improvement & mold. Full-state sweep or targeted search.

- **URL**: https://apify.com/memo23/louisiana-contractor-leads-scraper.md
- **Developed by:** [Muhamed Didovic](https://apify.com/memo23) (community)
- **Categories:** Lead generation, Agents, MCP servers
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 1,000 license-verified contractor lead (with email)s

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

## Louisiana Contractor Leads Scraper (LSLBC) — with Emails

**License-verified Louisiana contractor leads, and the board hands you the email.** Every row is pulled live from the Louisiana State Licensing Board for Contractors (LSLBC) public registry — company, license number, classification, status, expiration date, mailing address, phone, and **the contractor's own contact email, published right on the board record**. Sweep the whole state or target a city, classification, company, or license number. JSON or CSV out, billed per lead.

#### How it works

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

#### ✨ Why use this scraper?

- **Emails come standard** — unlike most licensing boards, LSLBC publishes each contractor's contact email on the record itself. In testing, ~100% of active company records carried one. No enrichment step, no guessing, no extra charge: it's in `boardEmail` on every row that has it.
- **License-verified, not directory-scraped** — every lead comes from the board's own registry, so the license number, classification, status, and expiry are authoritative at scrape time.
- **Active-only by default** — Expired / Not Active / Not Valid records are dropped before you pay for them (turn `activeOnly` off for compliance or historical research).
- **Full-state sweep built in** — run it empty and it walks a bundled list of ~1,150 Louisiana place names, metro areas first. No URL hunting.
- **Four license types, cleanly filterable** — Commercial, Residential, Home Improvement, and Mold Remediation, each selectable in the input.
- **Optional extra enrichment** — for the minority of records without a board email, `enrichEmails` discovers the business's website and harvests one, and `qualifyByPayment` flags Stripe/e-commerce signals.
- **New-license monitoring** — flip `monitoringMode` on a schedule and each run returns only contractors licensed since your last run.
- **Zero setup** — US residential proxy is built in; the registry is public, no login or CAPTCHA involved.

#### 🎯 Use cases

| Who | What they do with it |
|---|---|
| **Building-materials & equipment suppliers** | Build ready-to-email lists of active licensed contractors by city and license type — company, phone, address, and email all in one row |
| **SaaS & fintech selling to contractors** | Feed license-verified accounts straight into outbound; `qualifyByPayment` flags who transacts online |
| **Insurance, bonding & lending** | Verify license status and expiration before quoting |
| **Recruiters & M&A scouts** | Map every commercial or residential contractor in a metro; monitor newly licensed firms as expansion signals |
| **GCs & developers** | Verify subs' licenses in bulk from a license-number list before award |

#### 📥 Supported inputs

| Mode | Input | Behaviour |
|---|---|---|
| **Full-state sweep** (default) | *(empty input)* | Walks the bundled LA place list, biggest cities first |
| **City sweep** | `cities: ["New Orleans", "Baton Rouge"]` | Exact match on the licensee's mailing-address city |
| **Classification filter** | `classifications: ["Residential License Certificate"]` | One of the four LSLBC license types |
| **Company search** | `companyNames: ["electric"]` | Board-side substring match on company name |
| **Name search** | `lastName` (+ optional `firstName`) | License-holder name lookup |
| **License lookup** | `licenseNumbers: ["CL.13827"]` | Direct verification; accepts full numbers or bare digits |
| **Phone lookup** | `phoneNumber` | Phone number on record |

**Not supported:** other states or boards. This actor covers the LSLBC commercial/residential/home-improvement/mold registry — Louisiana keeps some trades (e.g. plumbing, electrical journeymen) on separate boards.

#### 🔄 How it works

1. **Builds search jobs** from your criteria — or the full-state city list when the input is empty.
2. **Queries the board's live roster** for each job and parses the result rows (license #, classification, holder, standing).
3. **Filters** inactive licenses (default) and duplicates before any per-lead fetching, so you never pay for records you filtered out.
4. **Fetches each license's detail record** — company, address, phone, **board email**, status, expiry — in parallel.
5. **Optionally enriches** the minority of rows without a board email (website discovery + contact-email harvesting; `qualifyByPayment` adds payment signals).
6. **Pushes one row per license** to the dataset.

#### ⚙️ Input parameters

| Field | Type | Default | Description |
|---|---|---|---|
| `cities` | array | `[]` → full sweep | LA mailing-address cities, matched exactly |
| `classifications` | array | `[]` → all | Any of the 4 license types (label, fragment like `residential`, or numeric code) |
| `activeOnly` | boolean | `true` | Drop licenses not in good standing before fetching |
| `companyNames` | array | — | Substring company-name searches |
| `lastName` / `firstName` | string | — | License-holder name search |
| `licenseNumbers` | array | — | Direct license lookups |
| `phoneNumber` | string | — | Phone-number search |
| `enrichEmails` | boolean | `false` | Website + email discovery for rows lacking a board email |
| `qualifyByPayment` | boolean | `false` | Payment-processor detection (needs `enrichEmails`) |
| `monitoringMode` | boolean | `false` | Only licenses not delivered on previous runs |
| `resetMonitoringState` | boolean | `false` | One-shot: clear the monitoring baseline |
| `maxItems` | integer | `500` | Hard cap on leads |
| `maxConcurrency` | integer | `10` | Parallel detail fetches |
| `searchConcurrency` | integer | `3` | Parallel roster searches |

#### 📊 Output overview

One dataset row per license. The row merges the roster entry and the board's detail record — including the native `boardEmail` — with no separate or padding rows. `isActive` is computed from the authoritative detail status, and `searchCity` records which sweep query surfaced the lead.

#### 📦 Output sample

Real trimmed row from a live run:

```json
{
    "type": "license-lead",
    "stateCode": "LA",
    "trade": "contractor",
    "boardId": "lslbc",
    "boardName": "Louisiana State Licensing Board for Contractors",
    "licenseNumber": "CL.13827",
    "classificationCode": "CL",
    "classification": "Commercial License Certificate",
    "businessName": "PETROTECH, INC.",
    "dbaName": null,
    "licenseStatus": "Active",
    "isActive": true,
    "expirationDate": "2029-05-13",
    "phone": "(504) 620-6600",
    "boardEmail": "jsouto@petrotechinc.com",
    "contactEmail": "jsouto@petrotechinc.com",
    "address": {
        "street": "151 Brookhollow Esplanade",
        "city": "Jefferson",
        "state": "LA",
        "zip": "70123",
        "raw": "151 Brookhollow Esplanade, Jefferson, LA 70123"
    },
    "searchCity": "New Orleans",
    "qualifiers": [],
    "sourceUrl": "https://arlspublic.lslbc.louisiana.gov/Public/Search",
    "scrapedAt": "2026-07-24T07:44:00.000Z"
}
````

With `enrichEmails: true`, rows that had no board email can additionally carry `contactEmail`, `contactWebsite`, and the detailed `emailEnrichment` object.

#### 🗂 Key output fields

| Group | Fields |
|---|---|
| **License** | `licenseNumber`, `classification`, `classificationCode`, `licenseStatus`, `statusNote`, `isActive`, `expirationDate` |
| **Business** | `businessName`, `dbaName`, `phone`, **`boardEmail`**, `contactEmail`, `address.{street,city,state,zip,raw}` |
| **People** | `qualifiers[]` — named individuals on the license, when the board lists them |
| **Enrichment** (opt-in) | `contactWebsite`, `emailEnrichment`, `takesPayments`, `paymentProcessors`, `stripeLiveKey`, `paymentConfidence` |
| **Provenance** | `boardId`, `boardName`, `stateCode`, `trade`, `searchCity`, `sourceUrl`, `scrapedAt` |

#### ❓ FAQ

**Do I really get an email for every lead?**
For active *company* records, almost always — LSLBC publishes the contact email on the record and our testing found one on ~100% of them. Some individual registrations and older records omit it; for those, turn on `enrichEmails` to try to recover one. `boardEmail` is the board's own value; `contactEmail` is the best available (board email first, enriched email as fallback).

**How complete is the full-state sweep?**
The board's search matches on each licensee's *mailing-address city*. The bundled sweep list covers ~1,150 Louisiana municipalities and place names, so in-state coverage is effectively complete; licensees who mail from out of state are only found via company/name/license searches.

**Why fewer leads than the roster shows?**
`activeOnly` (default on) drops Expired / Not Active / Not Valid licenses — on this board that's a large share of historical records. Set it to `false` to get everything.

**How is this different from a license-lookup tool?**
Lookups verify one license number at a time. This sweeps the whole roster (or a city/classification slice), returns one clean row per contractor with the email attached, and can monitor for newly licensed firms on a schedule.

**Is this legal to scrape?**
The registry is a public government licensing record intended for license verification by the public. The actor accesses only those public pages, politely. See the Disclaimer below for your responsibilities.

#### 💬 Support

- 🐛 **Issues:** [the actor's Issues tab](https://apify.com/memo23/louisiana-contractor-leads-scraper/issues)
- 💡 **Feature requests:** same place — concrete requests (new fields, other states, other trades) usually ship fast
- 📧 **Direct:** message via [my Apify profile](https://apify.com/memo23)

#### 🛠 Additional services

Need the same license-verified leads pipeline for **another state or trade**, a custom export, or a managed feed into your CRM? This actor is part of a per-state series built on a shared engine — new boards stamp out quickly. Reach out via my Apify profile.

#### 🔎 Explore more scrapers

Matching state-board leads actors: **[NC Electrical Contractor Leads](https://apify.com/memo23/north-carolina-electrical-contractor-leads-scraper)** and **[NC Plumbing & HVAC Contractor Leads](https://apify.com/memo23/north-carolina-plumbing-hvac-contractor-leads-scraper)**. More lead-gen and directory actors: **[apify.com/memo23](https://apify.com/memo23)** — email finding & verification, business directories, real-estate, and job boards.

#### 🤖 For AI Agents & LLM Apps

This actor is MCP-ready: call it from agent frameworks via the [Apify MCP server](https://mcp.apify.com), or hit it with a single API call and read the dataset as clean JSON. The row schema is stable and flat where it matters (`licenseNumber`, `businessName`, `phone`, `boardEmail`, `address.city`, `isActive`), so it drops straight into RAG pipelines, lead-qualification agents, and compliance-check tools. Typical agent patterns: *"verify this LA contractor's license"* (pass `licenseNumbers`), *"find active residential contractors in Baton Rouge with emails"* (pass `cities` + `classifications`), or a scheduled *"alert me on newly licensed contractors"* loop (`monitoringMode`).

***

### ⚠️ Disclaimer

This Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by the Louisiana State Licensing Board for Contractors, the State of Louisiana, or any of their agencies or affiliates. All trademarks mentioned are the property of their respective owners.

The scraper accesses only the board's publicly available license-verification pages — no authenticated endpoints and no content behind a login. License data, including the contact email, is a public record published by the board for verification purposes. Users are responsible for ensuring their use complies with applicable law and regulation — including data-protection rules (GDPR, CCPA), telemarketing/e-mail regulations (TCPA, CAN-SPAM) when contacting leads, and any obligations of their own organisation.

***

### SEO Keywords

louisiana contractor leads, louisiana contractor license lookup, lslbc license verification, louisiana contractor email list, licensed contractor database louisiana, louisiana commercial contractor leads, residential contractor leads louisiana, contractor leads with email, state licensing board scraper, contractor license verify api, home services leads scraper, new orleans contractor list, baton rouge contractors, home improvement contractor leads, mold remediation contractor list, newly licensed contractors alerts, contractor license monitoring, apify contractor leads, b2b construction leads, louisiana construction data

# Actor input Schema

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

Louisiana cities to sweep, matched EXACTLY against each licensee's mailing-address city (e.g. `New Orleans`, `Baton Rouge`). Empty = the bundled full-state place list, biggest cities first.

## `classifications` (type: `array`):

Keep only these license types. Empty = all four. Values may also be typed as a fragment (`residential`) or the board's numeric code (`23`).

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

Keep only licenses in good standing — Expired / Not Active / Not Valid records are dropped before any detail fetch. Turn off for historical or compliance research.

## `companyNames` (type: `array`):

Company-name searches (the board substring-matches, so `electric` finds every company containing the word). Overrides the city sweep.

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

Search by the license holder's last name. Overrides the city sweep.

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

Optional, only used together with the last name.

## `licenseNumbers` (type: `array`):

Direct license lookups — accepts `U.00025` or bare digits (`25`). Overrides every other mode.

## `phoneNumber` (type: `string`):

Search by the phone number on record. Overrides the city sweep.

## `includePublicMatters` (type: `boolean`):

Also fetch each licensee's public disciplinary matters (adds one request per lead). Adds the `publicMatters` array to every row.

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

Discover each business's website and harvest a contact email from it. Adds `contactEmail`, `contactWebsite`, and the detailed `emailEnrichment` object. Best-effort — no charge on misses.

## `qualifyByPayment` (type: `boolean`):

Piggybacks on email enrichment (only runs when that's on): detects Stripe/Square/e-commerce signals on the business site. Adds `takesPayments`, `paymentProcessors`, `stripeLiveKey`, `paymentConfidence`. Free.

## `monitoringMode` (type: `boolean`):

Skip licenses already delivered to you on previous runs — ideal on a schedule for catching newly licensed contractors. The first run seeds the baseline and returns everything.

## `resetMonitoringState` (type: `boolean`):

One-shot: forget every previously delivered license at run start, so this run returns everything again.

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

Hard cap on leads pushed to the dataset.

## `maxConcurrency` (type: `integer`):

Parallel per-licensee detail fetches.

## `searchConcurrency` (type: `integer`):

Parallel roster searches. Each returns up to ~500 rows; keep modest to stay polite to the board.

## Actor input object example

```json
{
  "cities": [
    "New Orleans",
    "Baton Rouge",
    "Lafayette"
  ],
  "classifications": [],
  "activeOnly": true,
  "includePublicMatters": false,
  "enrichEmails": false,
  "qualifyByPayment": false,
  "monitoringMode": false,
  "resetMonitoringState": false,
  "maxItems": 500,
  "maxConcurrency": 10,
  "searchConcurrency": 3
}
```

# 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 = {
    "cities": [
        "New Orleans",
        "Baton Rouge",
        "Lafayette"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("memo23/louisiana-contractor-leads-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 = { "cities": [
        "New Orleans",
        "Baton Rouge",
        "Lafayette",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("memo23/louisiana-contractor-leads-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 '{
  "cities": [
    "New Orleans",
    "Baton Rouge",
    "Lafayette"
  ]
}' |
apify call memo23/louisiana-contractor-leads-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Louisiana Contractor Leads Scraper (LSLBC) — with Emails",
        "description": "Scrape license-verified contractor leads from Louisiana's LSLBC registry — company, license number, class, status, expiry, address, phone, and the contractor's own email published on the board record. Commercial, residential, home-improvement & mold. Full-state sweep or targeted search.",
        "version": "0.0",
        "x-build-id": "lBbljyxpqBFoWTxUw"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/memo23~louisiana-contractor-leads-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-memo23-louisiana-contractor-leads-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/memo23~louisiana-contractor-leads-scraper/runs": {
            "post": {
                "operationId": "runs-sync-memo23-louisiana-contractor-leads-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/memo23~louisiana-contractor-leads-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-memo23-louisiana-contractor-leads-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",
                "properties": {
                    "cities": {
                        "title": "Cities (mailing address)",
                        "type": "array",
                        "description": "Louisiana cities to sweep, matched EXACTLY against each licensee's mailing-address city (e.g. `New Orleans`, `Baton Rouge`). Empty = the bundled full-state place list, biggest cities first.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "classifications": {
                        "title": "License classifications",
                        "type": "array",
                        "description": "Keep only these license types. Empty = all four. Values may also be typed as a fragment (`residential`) or the board's numeric code (`23`).",
                        "items": {
                            "type": "string",
                            "enum": [
                                "Commercial License Certificate",
                                "Residential License Certificate",
                                "Home Improvement Registration",
                                "Mold Remediation License Certificate"
                            ]
                        },
                        "default": []
                    },
                    "activeOnly": {
                        "title": "Active licenses only",
                        "type": "boolean",
                        "description": "Keep only licenses in good standing — Expired / Not Active / Not Valid records are dropped before any detail fetch. Turn off for historical or compliance research.",
                        "default": true
                    },
                    "companyNames": {
                        "title": "Company names",
                        "type": "array",
                        "description": "Company-name searches (the board substring-matches, so `electric` finds every company containing the word). Overrides the city sweep.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "lastName": {
                        "title": "Licensee last name",
                        "type": "string",
                        "description": "Search by the license holder's last name. Overrides the city sweep."
                    },
                    "firstName": {
                        "title": "Licensee first name",
                        "type": "string",
                        "description": "Optional, only used together with the last name."
                    },
                    "licenseNumbers": {
                        "title": "License numbers",
                        "type": "array",
                        "description": "Direct license lookups — accepts `U.00025` or bare digits (`25`). Overrides every other mode.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "phoneNumber": {
                        "title": "Phone number",
                        "type": "string",
                        "description": "Search by the phone number on record. Overrides the city sweep."
                    },
                    "includePublicMatters": {
                        "title": "Include disciplinary records",
                        "type": "boolean",
                        "description": "Also fetch each licensee's public disciplinary matters (adds one request per lead). Adds the `publicMatters` array to every row.",
                        "default": false
                    },
                    "enrichEmails": {
                        "title": "Find contact emails (opt-in)",
                        "type": "boolean",
                        "description": "Discover each business's website and harvest a contact email from it. Adds `contactEmail`, `contactWebsite`, and the detailed `emailEnrichment` object. Best-effort — no charge on misses.",
                        "default": false
                    },
                    "qualifyByPayment": {
                        "title": "Detect payment processors",
                        "type": "boolean",
                        "description": "Piggybacks on email enrichment (only runs when that's on): detects Stripe/Square/e-commerce signals on the business site. Adds `takesPayments`, `paymentProcessors`, `stripeLiveKey`, `paymentConfidence`. Free.",
                        "default": false
                    },
                    "monitoringMode": {
                        "title": "Only new licenses since last run",
                        "type": "boolean",
                        "description": "Skip licenses already delivered to you on previous runs — ideal on a schedule for catching newly licensed contractors. The first run seeds the baseline and returns everything.",
                        "default": false
                    },
                    "resetMonitoringState": {
                        "title": "Reset monitoring baseline",
                        "type": "boolean",
                        "description": "One-shot: forget every previously delivered license at run start, so this run returns everything again.",
                        "default": false
                    },
                    "maxItems": {
                        "title": "Maximum leads",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Hard cap on leads pushed to the dataset.",
                        "default": 500
                    },
                    "maxConcurrency": {
                        "title": "Detail concurrency",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Parallel per-licensee detail fetches.",
                        "default": 10
                    },
                    "searchConcurrency": {
                        "title": "Search concurrency",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Parallel roster searches. Each returns up to ~500 rows; keep modest to stay polite to the board.",
                        "default": 3
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
