# TDI Agent Lookup - Bulk Texas Insurance License Search (`lofomachines/tdi-agent-lookup`) Actor

Look up Texas insurance agents, adjusters, escrow officers and agencies by name, license number, NPN, city, ZIP or license category. Returns clean, structured profiles with license status, expiration dates and coverage lines.

- **URL**: https://apify.com/lofomachines/tdi-agent-lookup.md
- **Developed by:** [Lofomachines](https://apify.com/lofomachines) (community)
- **Categories:** Developer tools, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.99 / 1,000 results

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/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

## TDI Agent Lookup — Texas Insurance License Search (Agents, Adjusters & Agencies)

**Search almost one million Texas insurance licenses in seconds.** Look up any insurance agent, claims adjuster, escrow officer, public adjuster or licensed agency in Texas by **name, license number, NPN, city, ZIP code or line of business** — and get back a clean, structured profile with license status, expiration dates, coverage lines and tenure.

No account. No logins. No manual searching one name at a time. Just paste what you have, press Start, and export a spreadsheet-ready list of licensed Texas insurance professionals.

---

### ⚡ Why people use this Actor

| Doing it manually | With TDI Agent Lookup |
| --- | --- |
| One name at a time in a slow web form | Thousands of names, ZIPs or license numbers per run |
| Copy–paste into a spreadsheet | Instant CSV, Excel, JSON or API output |
| Multiple rows per person, hard to read | **One complete profile per licensee**, all licenses merged |
| No idea who is about to lapse | Built-in **expiring soon** filter for renewal campaigns |
| Raw ALL-CAPS text | Clean names, cities, ZIP+4, coverage lines and seniority bands |

---

### 🎯 What you get

Every result is a rich, ready-to-use profile containing:

- **Identity** — full name, first / middle / last name, suffix, business name, organization type, NPN, license number, stable profile ID
- **Licensing** — license type, qualification, readable category, coverage lines, license status (Active / Expiring Soon / Expired), issue date, expiration date, days until expiration
- **Every license held** — all credentials for the same person or business consolidated into one row, plus counts of active vs. expired
- **Experience** — first licensed year, years licensed, seniority band (New / Established / Experienced / Veteran)
- **Location** — city, state, full state name, ZIP, ZIP+4, county, country, resident vs. non-resident flag
- **Enrichment links** — nationwide producer lookup plus ready-made web and professional-profile search links

---

### 👥 Who it's for

- **Insurance recruiters & agency owners** building pipelines of licensed producers
- **IMOs, FMOs and carriers** recruiting appointed agents by line of business and territory
- **B2B sales & marketing teams** selling software, leads, E&O, CE courses or services to insurance professionals
- **Compliance & operations teams** verifying that producers and agencies are properly licensed
- **Claims managers & TPAs** sourcing licensed adjusters, including catastrophe and workers' comp adjusters
- **Title companies and lenders** checking escrow officers and title agencies
- **Analysts, journalists and researchers** studying the Texas insurance market
- **Agencies & consultants** enriching CRMs with verified license data

---

### 💡 Use cases

<details open>
<summary><b>1. Build a targeted producer recruiting list</b></summary>

Pull every active **Life, Accident & Health** agent within a set of Houston ZIP codes, filter by seniority, and hand the list straight to your recruiters.
</details>

<details>
<summary><b>2. Renewal & retention campaigns</b></summary>

Use **Expiring soon** with a 90-day window to find licensees whose credentials lapse this quarter — perfect for CE providers, renewal reminders and win-back campaigns.
</details>

<details>
<summary><b>3. Verify an agent or agency before you do business</b></summary>

Paste a list of names, license numbers or NPNs and instantly confirm status, category and expiration for every one of them.
</details>

<details>
<summary><b>4. Source licensed claims adjusters fast</b></summary>

Filter to **Claims Adjusters** or **Public Adjusters** across Texas and neighbouring states to staff a catastrophe response in hours instead of weeks.
</details>

<details>
<summary><b>5. Territory & market analysis</b></summary>

Export agents by city and ZIP to map producer density, spot underserved territories and size your addressable market.
</details>

<details>
<summary><b>6. Find newly licensed professionals</b></summary>

Set **Licensed on or after** to last month and reach brand-new agents before your competitors do.
</details>

<details>
<summary><b>7. CRM enrichment & data hygiene</b></summary>

Match your existing contacts by NPN or license number, then refresh status, category and location on a schedule.
</details>

<details>
<summary><b>8. Agency M&A and partner scouting</b></summary>

List licensed agencies by organization type, county and line of business to build acquisition or partnership shortlists.
</details>

<details>
<summary><b>9. Title & escrow due diligence</b></summary>

Filter to **Title & Escrow** to review escrow officers and title agencies, including county coverage.
</details>

<details>
<summary><b>10. Lead-gen products & data services</b></summary>

Run scheduled exports and resell or bundle clean, structured Texas licensing data inside your own product.
</details>

---

### 🚀 How to use it

1. Click **Try for free** / **Start**.
2. Fill in what you know: names, license numbers, NPNs — or just a city, ZIP and license category.
3. Press **Start** and download the results as **CSV, Excel, JSON, XML** or pull them from the API.

That's it. There is nothing to install, no key to obtain and no third-party account to connect.

---

### ⚙️ Input examples

**Look up specific people**

```json
{
  "searchScope": "agents",
  "names": ["John Smith", "Maria Rodriguez", "David Nguyen"],
  "licenseStatus": "active",
  "maxResults": 500
}
````

**Build a P\&C recruiting list in Houston**

```json
{
  "searchScope": "agents",
  "cities": ["Houston", "Katy", "Sugar Land"],
  "licenseCategories": ["property_casualty"],
  "licenseStatus": "active",
  "sortBy": "newest",
  "maxResults": 5000
}
```

**Renewal outreach — licenses expiring in the next 60 days**

```json
{
  "searchScope": "all",
  "states": ["TX"],
  "licenseStatus": "expiring",
  "expiringWithinDays": 60,
  "sortBy": "expiring",
  "maxResults": 10000
}
```

**Verify a batch of licenses and NPNs**

```json
{
  "searchScope": "all",
  "licenseNumbers": ["769759", "1500424"],
  "npnNumbers": ["1167317", "10003569"],
  "licenseStatus": "any"
}
```

**Find licensed agencies by ZIP and category**

```json
{
  "searchScope": "agencies",
  "zipCodes": ["750", "752"],
  "licenseCategories": ["title_escrow", "managing_general_agents"],
  "licenseStatus": "active",
  "maxResults": 2000
}
```

#### Input fields

| Field | What it does |
| --- | --- |
| `searchScope` | People, businesses, or both |
| `names` | Full or partial names — word order does not matter |
| `licenseNumbers` | Texas license numbers |
| `npnNumbers` | National Producer Numbers |
| `cities` / `states` / `zipCodes` | Location filters (partial ZIPs supported) |
| `licenseCategories` | P\&C, Life & Health, Adjusters, Title & Escrow, Surplus Lines, MGAs and more |
| `licenseStatus` | Active, Expiring soon, Expired, or Any |
| `expiringWithinDays` | Renewal window for the "Expiring soon" filter |
| `issuedAfter` | Only licenses issued on or after this date |
| `oneProfilePerLicensee` | Merge all licenses of a person or business into one row |
| `sortBy` | Newest, soonest to expire, longest licensed, or A–Z |
| `maxResults` | Cap the number of rows (lower = faster and cheaper) |

***

### 📤 Output example

```json
{
  "recordType": "agent",
  "profileId": "in-1167317",
  "npn": "1167317",
  "licenseNumber": "769759",
  "fullName": "John Smith",
  "firstName": "John",
  "lastName": "Smith",
  "licenseType": "General Lines Agent",
  "qualification": "Life, Accident, Health & HMO",
  "licenseCategory": "Life, Accident & Health",
  "licenseCategories": ["Life, Accident & Health", "Property & Casualty"],
  "coverageLines": ["Life", "Accident", "Health", "HMO", "Property", "Casualty"],
  "licenseStatus": "Active",
  "isActive": true,
  "isExpiringSoon": false,
  "issueDate": "1990-11-09",
  "expirationDate": "2027-01-31",
  "daysUntilExpiration": 192,
  "nextExpirationDate": "2027-01-31",
  "licenseCount": 2,
  "activeLicenseCount": 2,
  "expiredLicenseCount": 0,
  "firstLicensedYear": 1990,
  "yearsLicensed": 35.7,
  "experienceLevel": "Veteran",
  "city": "Fort Worth",
  "state": "TX",
  "stateName": "Texas",
  "postalCode": "76244-7045",
  "zipCode": "76244",
  "county": null,
  "country": "United States",
  "location": "Fort Worth, TX",
  "isTexasBased": true,
  "residencyType": "Resident",
  "licenses": [
    {
      "licenseNumber": "769759",
      "licenseType": "General Lines Agent",
      "qualification": "Life, Accident, Health & HMO",
      "licenseCategory": "Life, Accident & Health",
      "coverageLines": ["Life", "Accident", "Health", "HMO"],
      "licenseStatus": "Active",
      "issueDate": "1990-11-09",
      "expirationDate": "2027-01-31",
      "daysUntilExpiration": 192,
      "yearsLicensed": 35.7
    }
  ],
  "regulator": "Texas Department of Insurance",
  "jurisdiction": "TX",
  "nationalLookupUrl": "https://sbs.naic.org/solar-external-lookup/",
  "webSearchUrl": "https://www.google.com/search?q=...",
  "linkedinSearchUrl": "https://www.google.com/search?q=...",
  "matchedSearchTerm": "John Smith",
  "retrievedAt": "2026-07-23T09:14:22.481Z"
}
```

Every run returns a single, complete **All fields** table — no hidden columns and nothing to toggle. Export it as CSV, Excel, JSON or XML, or pull it straight from the API.

***

### 🔗 Integrations & automation

Works out of the box with everything on the Apify platform:

- **Make (Integromat)** — trigger a scenario on every new result and push profiles into HubSpot, Pipedrive or Salesforce
- **n8n** — schedule a weekly "expiring soon" run and fire renewal emails automatically
- **Zapier** — send new licensees straight to Google Sheets, Airtable, Slack or your CRM
- **Google Sheets / Airtable** — one-click export or live sync
- **REST API & webhooks** — call the Actor from your own backend and receive results as JSON
- **MCP / AI agents** — let an AI assistant run license lookups on demand
- **Scheduler** — daily, weekly or monthly refreshes with zero maintenance

***

### ❓ FAQ

**What is a TDI agent lookup?**
It is a search of the official Texas Department of Insurance licensing records that confirms whether a person or business is licensed to sell insurance or adjust claims in Texas, and shows what they are licensed for.

**Do I need an account, API key or login?**
No. Everything is handled for you — just run the Actor.

**Can I search by NPN?**
Yes. You can search by NPN, by Texas license number, by name, or by any combination of them.

**Does it cover claims adjusters and escrow officers?**
Yes — agents, claims adjusters, public adjusters, escrow officers, surplus lines agents, managing general agents, risk managers, pre-need agents, life settlement brokers, reinsurance intermediaries and more.

**Does it cover agencies and companies?**
Yes. Set the scope to **businesses** or **both** to include licensed agencies, including their organization type and county.

**Can I find agents licensed in Texas who live in another state?**
Yes. Many Texas licensees are non-residents. Leave the state filter empty to include them, and use the `residencyType` field to tell them apart.

**Does it return phone numbers and email addresses?**
Official licensing records do not include personal contact details. Each profile ships with ready-made search links so you can enrich contacts using the tools below.

**How current is the data?**
Records reflect the latest published licensing information, refreshed on every run.

**How many results can I get?**
Up to 50,000 rows per run, and you can run it as often as you like.

**Is this legal to use?**
Yes. Insurance licensing records are public information published by the state regulator. Use them in line with applicable marketing and privacy laws (e.g. CAN-SPAM, TCPA).

***

### 🧰 Works great with these Actors

Turn a license list into a full contact and intelligence pipeline:

- **[Contact Extractor](https://apify.com/lofomachines/contact-extractor)** — pull emails, phone numbers and social links from any agency website
- **[Social Media Lead Finder](https://apify.com/lofomachines/fresh-lead-finder)** — find agents actively discussing insurance topics in real time
- **[LinkedIn Post Search Scraper](https://apify.com/lofomachines/linkedin-post-search-scraper)** — track what licensed producers and agencies are posting
- **[Google Search Results Scraper](https://apify.com/lofomachines/google-serp-scraper)** — locate agency websites and profiles for every licensee
- **[Website URL Extractor](https://apify.com/lofomachines/urls-extractor)** — map an agency's full site before outreach

***

### 📌 Notes

- Results are derived from public insurance licensing records published by the State of Texas.
- Always confirm critical licensing decisions with the Texas Department of Insurance before acting on them.
- This Actor does not collect personal contact details, and it is not a consumer report — do not use it for eligibility decisions covered by the FCRA.

***

**Keywords:** TDI agent lookup, Texas insurance license lookup, TDI license search, Texas insurance agent search, insurance adjuster license lookup Texas, NPN lookup, Texas insurance agency lookup, insurance producer license verification, Texas escrow officer lookup, insurance agent list Texas, licensed insurance agents database.

# Actor input Schema

## `searchScope` (type: `string`):

Choose whether to return licensed people, licensed businesses, or both.

## `names` (type: `array`):

Full or partial names to look up. Works with people (e.g. John Smith) and businesses (e.g. Allstate). Word order does not matter.

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

Texas license numbers to look up.

## `npnNumbers` (type: `array`):

National Producer Numbers (NPN) to look up.

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

Limit results to these cities, for example Houston, Dallas or Austin.

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

Two-letter state codes. Texas licences are also held by out-of-state professionals, so leave this empty to include them.

## `zipCodes` (type: `array`):

Full or partial ZIP codes. A partial code such as 770 matches every ZIP starting with those digits.

## `licenseCategories` (type: `array`):

Limit results to specific lines of business. Leave empty to include every category.

## `licenseStatus` (type: `string`):

Return only currently valid licences, licences that are about to lapse, lapsed licences, or everything.

## `expiringWithinDays` (type: `integer`):

Only used when the license status is set to "Expiring soon".

## `issuedAfter` (type: `string`):

Only include licences issued on or after this date. Great for finding newly licensed professionals.

## `oneProfilePerLicensee` (type: `boolean`):

Combine every licence held by the same person or business into a single, complete profile. Turn this off to get one row per individual licence.

## `sortBy` (type: `string`):

Controls the order in which results are collected and saved.

## `maxResults` (type: `integer`):

Maximum number of rows to save. Lower values finish faster and cost less.

## Actor input object example

```json
{
  "searchScope": "agents",
  "names": [],
  "licenseNumbers": [],
  "npnNumbers": [],
  "cities": [
    "Houston"
  ],
  "states": [],
  "zipCodes": [],
  "licenseCategories": [],
  "licenseStatus": "active",
  "expiringWithinDays": 90,
  "oneProfilePerLicensee": true,
  "sortBy": "newest",
  "maxResults": 1000
}
```

# 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 = {
    "names": [],
    "licenseNumbers": [],
    "npnNumbers": [],
    "cities": [
        "Houston"
    ],
    "states": [],
    "zipCodes": [],
    "licenseCategories": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("lofomachines/tdi-agent-lookup").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 = {
    "names": [],
    "licenseNumbers": [],
    "npnNumbers": [],
    "cities": ["Houston"],
    "states": [],
    "zipCodes": [],
    "licenseCategories": [],
}

# Run the Actor and wait for it to finish
run = client.actor("lofomachines/tdi-agent-lookup").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 '{
  "names": [],
  "licenseNumbers": [],
  "npnNumbers": [],
  "cities": [
    "Houston"
  ],
  "states": [],
  "zipCodes": [],
  "licenseCategories": []
}' |
apify call lofomachines/tdi-agent-lookup --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=lofomachines/tdi-agent-lookup",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "TDI Agent Lookup - Bulk Texas Insurance License Search",
        "description": "Look up Texas insurance agents, adjusters, escrow officers and agencies by name, license number, NPN, city, ZIP or license category. Returns clean, structured profiles with license status, expiration dates and coverage lines.",
        "version": "1.0",
        "x-build-id": "UopYO1IJklgFbR1ni"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/lofomachines~tdi-agent-lookup/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-lofomachines-tdi-agent-lookup",
                "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/lofomachines~tdi-agent-lookup/runs": {
            "post": {
                "operationId": "runs-sync-lofomachines-tdi-agent-lookup",
                "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/lofomachines~tdi-agent-lookup/run-sync": {
            "post": {
                "operationId": "run-sync-lofomachines-tdi-agent-lookup",
                "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": [
                    "searchScope"
                ],
                "properties": {
                    "searchScope": {
                        "title": "What do you want to look up?",
                        "enum": [
                            "agents",
                            "agencies",
                            "all"
                        ],
                        "type": "string",
                        "description": "Choose whether to return licensed people, licensed businesses, or both.",
                        "default": "agents"
                    },
                    "names": {
                        "title": "Names",
                        "type": "array",
                        "description": "Full or partial names to look up. Works with people (e.g. John Smith) and businesses (e.g. Allstate). Word order does not matter.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "licenseNumbers": {
                        "title": "License numbers",
                        "type": "array",
                        "description": "Texas license numbers to look up.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "npnNumbers": {
                        "title": "NPN numbers",
                        "type": "array",
                        "description": "National Producer Numbers (NPN) to look up.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "cities": {
                        "title": "Cities",
                        "type": "array",
                        "description": "Limit results to these cities, for example Houston, Dallas or Austin.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "states": {
                        "title": "States",
                        "type": "array",
                        "description": "Two-letter state codes. Texas licences are also held by out-of-state professionals, so leave this empty to include them.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "zipCodes": {
                        "title": "ZIP codes",
                        "type": "array",
                        "description": "Full or partial ZIP codes. A partial code such as 770 matches every ZIP starting with those digits.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "licenseCategories": {
                        "title": "License categories",
                        "type": "array",
                        "description": "Limit results to specific lines of business. Leave empty to include every category.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "property_casualty",
                                "life_health",
                                "adjusters",
                                "public_adjusters",
                                "title_escrow",
                                "surplus_lines",
                                "managing_general_agents",
                                "specialty_limited",
                                "pre_need",
                                "county_mutual",
                                "risk_management",
                                "life_settlement",
                                "reinsurance"
                            ],
                            "enumTitles": [
                                "Property & Casualty",
                                "Life, Accident & Health",
                                "Claims Adjusters",
                                "Public Adjusters",
                                "Title & Escrow",
                                "Surplus Lines",
                                "Managing General Agents",
                                "Specialty & Limited Lines",
                                "Pre-Need",
                                "County Mutual",
                                "Risk Management",
                                "Life Settlement",
                                "Reinsurance"
                            ]
                        }
                    },
                    "licenseStatus": {
                        "title": "License status",
                        "enum": [
                            "active",
                            "expiring",
                            "expired",
                            "any"
                        ],
                        "type": "string",
                        "description": "Return only currently valid licences, licences that are about to lapse, lapsed licences, or everything.",
                        "default": "active"
                    },
                    "expiringWithinDays": {
                        "title": "Expiring within (days)",
                        "minimum": 1,
                        "maximum": 730,
                        "type": "integer",
                        "description": "Only used when the license status is set to \"Expiring soon\".",
                        "default": 90
                    },
                    "issuedAfter": {
                        "title": "Licensed on or after",
                        "type": "string",
                        "description": "Only include licences issued on or after this date. Great for finding newly licensed professionals."
                    },
                    "oneProfilePerLicensee": {
                        "title": "One row per licensee",
                        "type": "boolean",
                        "description": "Combine every licence held by the same person or business into a single, complete profile. Turn this off to get one row per individual licence.",
                        "default": true
                    },
                    "sortBy": {
                        "title": "Sort results by",
                        "enum": [
                            "newest",
                            "expiring",
                            "tenure",
                            "name"
                        ],
                        "type": "string",
                        "description": "Controls the order in which results are collected and saved.",
                        "default": "newest"
                    },
                    "maxResults": {
                        "title": "Maximum results",
                        "minimum": 1,
                        "maximum": 50000,
                        "type": "integer",
                        "description": "Maximum number of rows to save. Lower values finish faster and cost less.",
                        "default": 1000
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
