# Florida Insurance License Lookup & Verification (FL DFS) (`stackrelay/florida-dfs-insurance-license`) Actor

Verify Florida insurance licenses and appointments via FL DFS. Search by name, NPN, license number, or email — or bulk-download 350k+ producer records. Includes expiry alerts, CE status, and active appointment data. No proxy needed.

- **URL**: https://apify.com/stackrelay/florida-dfs-insurance-license.md
- **Developed by:** [StackRelay](https://apify.com/stackrelay) (community)
- **Categories:** Lead generation, Business, Developer tools
- **Stats:** 4 total users, 2 monthly users, 91.7% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $7.50 / 1,000 license\_searches

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## Florida Insurance License Lookup — FL DFS Producer & Appointment Verifier

Verify Florida insurance licenses and producer appointments from the **Florida Department of Financial Services** ([licenseesearch.fldfs.com](https://licenseesearch.fldfs.com/)) public licensee search. Search any Florida-licensed agent, adjuster, or agency by name, NPN, license number, or email — or bulk-download the statewide dataset of 350,000+ licensed producers in a single run.

> **Disclaimer — please read before running.** This actor is an independent data tool built by StackRelay. It is **not affiliated with, endorsed by, or operated by** the Florida Department of Financial Services or the Florida CFO's office. Results are a **best-effort, point-in-time snapshot** of the public FL DFS licensee search and bulk downloads, provided **AS-IS with no warranty** of accuracy, completeness, or timeliness — license status, appointments, CE status, and addresses can change at any time after a record is fetched. Every record carries a `source_url` and a `scraped_at` timestamp: **verify independently at the source before acting on any record.** Output includes personal data about individuals (names, address, email, phone); if you process data about EU/UK residents you may be an independent data controller under GDPR/UK GDPR. **This actor's output is not a consumer report and must not be used for FCRA-regulated purposes** — credit, insurance underwriting eligibility, employment, or tenant-screening decisions about an individual. By running this actor you agree to the [Developer Terms of Use](DEVELOPER_TERMS.md).

**No proxy required. No login. No CAPTCHA.** Public government data; the FL DFS bulk files are typically refreshed by the state about once per day, but currency is controlled by the source, not this actor. This actor reads only the public, logged-out search and published downloads — no login, paywall, or access control is bypassed.

Unlike a plain name-and-address scraper, every search record is **enriched with data useful to Florida compliance teams** — active carrier appointments, the `has_qualifying_appointment` binding-authority flag, CE compliance status, and a 60-day appointment-expiry warning — at one flat per-record price with no separate enrichment fee. These enriched flags are **derived by this actor** from the source data; treat them as conveniences and verify at the `source_url`.

**Last verified working:** June 16, 2026.

---

### Why Use This Actor?

Manually checking producer licenses on the FL DFS portal is slow, one-at-a-time work. This actor automates the full verification workflow — from spot-checking a single NPN to auditing your entire Florida producer book — and delivers structured, integration-ready data directly to your Apify dataset.

- **Carriers:** Verify agent appointments and license status before binding a policy in Florida
- **MGAs & wholesalers:** Onboard new producers faster — confirm active FL license, qualifying appointment, and CE compliance in one API call
- **Compliance & licensing teams:** Run quarterly audits of your Florida producer book; flag anyone with an expiring appointment or incomplete CE hours
- **Insurtech platforms:** Enrich your producer CRM with live FL DFS data — license type, NPN, expiration dates, appointing carrier names, and contact info

---

### What It Returns

**Search mode** looks up individual producers by last name, firm name, FL license number, NPN, or email address. For each match it fetches the full FL DFS detail page and returns a normalized record with:

- License number, NPN, full name, and license type
- Active / inactive status and license issue date
- All active appointments — carrier name, appointment type, issue date, and expiration date
- `appointment_expiring_soon` flag — `true` if any appointment expires within 60 days
- `has_qualifying_appointment` — the key compliance gate for binding authority in Florida
- CE due date and compliance status
- Business and mailing addresses split into individual fields
- Email address and business phone

**Bulk mode** streams the complete statewide CSV files published by the Florida CFO's office — up to 1 million+ records — without ever loading the full file into memory. Ideal for building a local mirror of FL producer data or enriching a large CRM dataset.

---

### Search Inputs

| Field | Description |
|---|---|
| `lastName` | Individual last name (min 3 characters) |
| `firstName` | Optional first name to narrow results |
| `firmName` | Agency or firm name search — **partial / contains match** (e.g. `Farm` matches "STATE FARM…") |
| `licenseNumber` | Direct FL license number lookup (e.g. `A245935`) |
| `npnNumber` | National Producer Number — the universal agent ID |
| `emailAddress` | Email address on file with FL DFS — useful for CRM matching |
| `licenseStatus` | `1` = valid only (default), `2` = invalid only, `3` = both |
| `licenseCategory` | Filter by P&C, Life, Health, Adjuster, Title, etc. (see table below) |
| `residentStatus` | Resident, Non-Resident, or both |
| `maxResults` | Cap the result count (search default `50`); `0` = unlimited. The cap is honored exactly. |

---

### Example Input

**Verify a specific producer (NPN lookup):**
```json
{
  "mode": "search",
  "npnNumber": "592200"
}
````

**Audit all active P\&C agents named Johnson:**

```json
{
  "mode": "search",
  "lastName": "Johnson",
  "licenseCategory": "15",
  "licenseStatus": "1",
  "maxResults": 500
}
```

**Find all active Brightway Insurance agencies:**

```json
{
  "mode": "search",
  "firmName": "Brightway Insurance",
  "licenseStatus": "1"
}
```

**Bulk download — all valid individual FL licenses:**

```json
{
  "mode": "bulk",
  "bulkDataset": "individual_licenses",
  "maxResults": 0
}
```

***

### Example Output

**Search mode** — one enriched record per producer:

```json
{
  "license_number": "A245935",
  "full_name": "SMITH - PRENITZER, CAROL A",
  "first_name": "CAROL A",
  "last_name": "SMITH - PRENITZER",
  "npn_number": "592200",

  "license_status": "Active",
  "license_type": "TITLE (0410)",
  "license_issue_date": "1/3/2005",
  "has_qualifying_appointment": true,
  "expiration_date": "5/31/2026",
  "appointment_expiring_soon": true,

  "active_appointments": [
    { "license_type": "TITLE (0410)", "company_name": "DOMA TITLE INSURANCE, INC.", "issue_date": "11/14/2013", "exp_date": "5/31/2026" },
    { "license_type": "TITLE (0410)", "company_name": "FIRST AMERICAN TITLE INSURANCE COMPANY", "issue_date": "4/28/2022", "exp_date": "5/31/2026" }
  ],

  "ce_due_date": "5/31/2026",
  "ce_status": "Compliant",

  "email_address": "CAPRENITZER@GMAIL.COM",
  "business_phone": "(561) 289-8088",

  "business_address1": "FIRST AMERICAN TITLE INSURANCE COMPANY 2580 S. VOLUSIA AVENUE #102",
  "business_city": "ORANGE CITY",
  "business_state": "FL",
  "business_zip": "32763",
  "business_county": "Volusia",

  "mailing_address": "2085 PACKARD AVENUE",
  "mailing_city": "OVIEDO",
  "mailing_state": "FL",
  "mailing_zip": "32785",

  "source_name": "Florida Department of Financial Services — public licensee search (licenseesearch.fldfs.com / myfloridacfo.com bulk downloads)",
  "source_url": "https://licenseesearch.fldfs.com/Licensee/296004",
  "scraped_at": "2026-05-25T12:00:00.000Z"
}
```

**Bulk mode** — one record per CSV row, column names normalized to `snake_case`:

```json
{
  "license_number": "A183305",
  "full_name": "MOORE, JAMES SCOTT",
  "first_name": "JAMES SCOTT",
  "last_name": "MOORE",
  "npn_number": "501707",
  "residency_type": "Resident",
  "ae_name": "RLI INSURANCE COMPANY",
  "eob_status": "ACTIVE",
  "email_address": "SCOTT@8FLAGS.COM",
  "business_phone": "9043106515",
  "business_city": "FERNANDINA BEACH",
  "business_state": "FL",
  "business_zip": "320343093",
  "business_county": "Nassau",
  "source_name": "Florida Department of Financial Services — public licensee search (licenseesearch.fldfs.com / myfloridacfo.com bulk downloads)",
  "source_url": "https://www.myfloridacfo.com/downloads/AAS/LicenseeSearch/ExchangeOfBusinessRegistrations.csv",
  "scraped_at": "2026-05-25T12:00:00.000Z"
}
```

***

### Pricing

Pay only for the records you pull — no subscription, no minimum.

- **Search mode — $0.01 per enriched record.** Every record includes the full FL DFS detail page: active appointments, the qualifying-appointment flag, CE status, expiry warning, and split address fields. There is **no separate enrichment surcharge** — unlike other FL license scrapers that bill a base lookup *plus* a detail-page fee.
- **Bulk mode — $0.003 per record.** Stream entire statewide CSV files at the lowest per-record rate. Best for sampling or filtering a slice of the data; capping with `maxResults` keeps cost predictable.
- **Volume discounts.** Higher Apify subscription tiers get progressively lower per-record prices (down to $0.0075 search / $0.00225 bulk) — automatically applied, no enterprise contract needed.

| Use case | Mode | Records | Cost |
|---|---|---|---|
| Single producer spot-check | search | 1 | $0.01 |
| Onboard 100 new agents | search | 100 | $1.00 |
| Sweep a 500-agent book | search | 500 | $5.00 |
| Sample 5,000 bulk records | bulk | 5,000 | $15.00 |
| Mirror the full individual license file | bulk | ~350,000 | ~$1,050 |

> Full-file bulk pulls are large — use `maxResults` and the dataset filters to take only the slice you need.

***

### License Category Codes

Filter results to a specific line of business using the `licenseCategory` field.

| Code | Line of Business |
|---|---|
| *(blank)* | All Categories |
| `1` | Adjuster |
| `2` | Bail Bonds |
| `3` | Company / MGA Service Staff |
| `4` | Customer Representative |
| `5` | Debit Agent |
| `6` | Health |
| `7` | Insurance Agency |
| `8` | Legal Expense |
| `9` | Life & Annuity |
| `10` | Limited Lines |
| `11` | Mediator |
| `12` | MGA |
| `13` | Navigator |
| `14` | Neutral Evaluator |
| `15` | Property & Casualty |
| `16` | Reinsurance |
| `17` | Surplus Lines |
| `18` | Title |
| `19` | Warranty |
| `50` | Adjusting Firm |

***

### Key Output Fields Explained

| Field | What it means |
|---|---|
| `appointment_expiring_soon` | `true` if any active appointment expires within 60 days of the run date — use this to build automated renewal watchlists |
| `has_qualifying_appointment` | `true` if the producer holds a qualifying appointment — the binding authority gate in Florida |
| `active_appointments` | Complete array of current carrier appointments; always present (empty `[]` when none) |
| `ce_status` | `"Compliant"`, `"In Progress"` (hours not yet met this cycle), or `null` |
| `license_status` | `"Active"` if at least one valid license exists; `"Inactive"` otherwise |
| `business_county` | Populated for FL residents; typically `null` for non-resident producers |

***

### Bulk Dataset Reference

The Florida CFO publishes these files daily. Each is a complete snapshot of that data category.

| Dataset key | Contents | File size |
|---|---|---|
| `individual_licenses` | All valid FL licenses for individual producers — license number, name, NPN, type, issue date, residency, address, email | 320 MB |
| `business_licenses` | Same schema for agencies, adjusting firms, and MGAs | 25 MB |
| `ce_required` | All licensees with a CE requirement — due date, hours required, hours completed | 156 MB |
| `appointments_individual_ag` | Active appointments for producers A–G — producer name, NPN, carrier name, type, status date | 374 MB |
| `appointments_individual_ho` | Same for H–O | 310 MB |
| `appointments_individual_pz` | Same for P–Z | 336 MB |
| `appointments_business` | Active appointments held by agencies and MGAs | 18 MB |
| `county_appointments` | Active appointments by Florida county — for geographic carrier distribution analysis | 243 MB |
| `exchange_registrations` | Exchange of Business registrations — appointing entity, EOB status, issue date, full contact details | 107 KB |

***

### Pairs Well With

[DBPR Florida License Verification](https://apify.com/ws_tony/dbpr-florida-license-verification) — if your compliance workflow covers more than insurance (contractors, real estate agents, CPAs, medical professionals), the DBPR actor covers those license types. Run both for a complete Florida professional license verification stack.

***

### Known Limitations

- Name search requires at least 3 characters — this limit is enforced server-side by FL DFS
- Search mode makes one HTTP request per result for detail-page enrichment; for 500+ records, run time increases proportionally — use `maxResults` to sample first
- `business_county` is only populated for FL resident producers
- `business_address1` for title agents may include the company name as a prefix — this reflects how FL DFS stores the address
- Bulk CSV column names flow through from the state's published format (normalized to `snake_case`) — if the state changes its column structure, those changes pass through automatically

***

### FAQ

**Can I verify a list of 500 producers in one run?**
The most efficient approach is bulk mode — download the full individual license file and filter it by your producer list. For real-time verification of a small list, run search mode with `maxResults` capped per producer. A multi-query batch feature is on the roadmap.

**Can I search by email address?**
Yes — pass `emailAddress`. Useful for cross-referencing a CRM where you have the producer's contact email but not their FL license number.

**Can I check whether an agent can legally bind business in Florida?**
Yes — `has_qualifying_appointment: true` is the signal. An active license alone is not sufficient to bind in FL; the producer also needs a qualifying appointment from a carrier licensed in Florida.

**Can I search by NPN?**
Yes — `npnNumber` in search mode does a direct NPN lookup against FL DFS.

**I searched a firm (or person) and got zero results — why?**
Search defaults to `licenseStatus: "1"` (valid only). Many entities — title companies in particular — hold only inactive licenses, so they won't appear under the default. Set `licenseStatus: "3"` ("Both Valid and Invalid") to include them. Firm names are matched as a partial/contains search, so a short token like `Farm` works.

**What does `appointment_expiring_soon` mean?**
It is `true` when at least one active appointment expires within 60 days of the run date. Build a scheduled actor run to sweep your producer book weekly and alert on any `true` values.

**How fresh is the data?**
Search mode reads the live FL DFS portal on every run, so a record reflects what the source returned at its `scraped_at` time — its currency is controlled by FL DFS, not this actor. Bulk files are refreshed by the state typically once per day. Treat every record as a best-effort, point-in-time snapshot and re-check the `source_url` before relying on it.

### Data accuracy & legal notes

- **What this data is.** A best-effort, point-in-time snapshot of the public Florida DFS licensee search (search mode) and the state's published bulk CSV downloads (bulk mode). The actor is a pipe, not an oracle: search fields are normalized from the FL DFS detail page and bulk columns are normalized to `snake_case` and passed through. Coverage and field completeness vary by record and dataset.
- **It can be wrong or stale.** License status, appointments, CE status, and addresses change continuously. A record is accurate only as of its `scraped_at` timestamp. Every record carries a `source_url` back to the source — **independently verify any record there before relying on it** for binding a policy, an onboarding decision, an audit finding, or any other action.
- **Derived fields are labeled as such.** `license_status` ("Active" when at least one valid license exists, else "Inactive"), `has_qualifying_appointment`, `appointment_expiring_soon` (any appointment within 60 days of the run date), `expiration_date` (latest appointment expiry), and parsed `first_name`/`last_name` are all **computed by this actor** from source data — not verbatim FL DFS status codes. Treat them as conveniences, not source-of-truth, and confirm against the `source_url`.
- **Personal data / GDPR.** Output includes personal data about individuals (names, address, email, business phone). If you process data about EU/UK residents you may act as an independent data controller under GDPR/UK GDPR and are solely responsible for having a lawful basis and honoring data-subject rights.
- **Prohibited uses (FCRA).** The output is **not a "consumer report"** and StackRelay is not a consumer reporting agency. **Do not use this data for FCRA-regulated purposes** — determining an individual's eligibility for credit, insurance coverage, employment, housing, or similar decisions. Verifying that a producer or agency holds an active Florida license/appointment for regulatory-compliance purposes is the intended use. Do not use the data to harass or profile individuals, and note that bulk contact data (email/phone) remains subject to applicable telemarketing, anti-spam, and privacy laws.
- **Not affiliated.** Independently developed by StackRelay; not affiliated with, endorsed by, or operated by the Florida Department of Financial Services or the Florida CFO's office.
- **A disclaimer travels with every run** in the key-value store record `META`, and every dataset row (search and bulk) carries `source_name`, `source_url`, and `scraped_at` provenance fields.
- **Full terms:** see [DEVELOPER\_TERMS.md](DEVELOPER_TERMS.md) — provided AS-IS, no warranty, liability capped at fees paid, Kansas governing law. By running this actor you agree to those terms.

# Actor input Schema

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

search = look up by name or license number (returns individual records). bulk = download a full statewide CSV dataset (hundreds of thousands of records).

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

Individual last name to search. Minimum 3 characters. Partial matches are supported. Leave blank if searching by license number.

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

Optional. Filters results to matching first name. Leave blank to return all matching last names.

## `firmName` (type: `string`):

Optional. Search by agency or firm name instead of (or in addition to) a personal name.

## `licenseNumber` (type: `string`):

Optional. Up to 7 characters. If provided, bypasses name search and does a direct lookup.

## `npnNumber` (type: `string`):

Optional. National Producer Number. Numeric, up to 9 digits.

## `emailAddress` (type: `string`):

Optional. Search by the email address on file with FL DFS. Useful for matching producers from a CRM. Partial matches supported (begins-with).

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

Filter by license validity. Defaults to 'Valid only'. If a firm or person search returns nothing, try 'Both Valid and Invalid' — many entities (e.g. title companies) hold only inactive licenses.

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

Optional. Filter by license category (e.g. Life & Annuity, Property & Casualty, Adjuster). Leave blank for all categories.

## `residentStatus` (type: `string`):

Optional. Filter to Florida residents or non-residents only.

## `bulkDataset` (type: `string`):

Which CSV file to download. Only used in bulk mode. Individual license files are the largest (~320 MB). Appointment files are split A-G / H-O / P-Z by last name.

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

Maximum records to return (this cap is now honored exactly). Search mode default: 50. Bulk mode default: 1,000. Set to 0 for unlimited — note bulk files can contain 350,000+ records, so only use 0 when you intend a full download.

## Actor input object example

```json
{
  "mode": "search",
  "lastName": "Smith",
  "licenseStatus": "1",
  "licenseCategory": "",
  "residentStatus": "",
  "bulkDataset": "individual_licenses",
  "maxResults": 50
}
```

# 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 = {
    "lastName": "Smith",
    "maxResults": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("stackrelay/florida-dfs-insurance-license").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 = {
    "lastName": "Smith",
    "maxResults": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("stackrelay/florida-dfs-insurance-license").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 '{
  "lastName": "Smith",
  "maxResults": 50
}' |
apify call stackrelay/florida-dfs-insurance-license --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=stackrelay/florida-dfs-insurance-license",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Florida Insurance License Lookup & Verification (FL DFS)",
        "description": "Verify Florida insurance licenses and appointments via FL DFS. Search by name, NPN, license number, or email — or bulk-download 350k+ producer records. Includes expiry alerts, CE status, and active appointment data. No proxy needed.",
        "version": "0.1",
        "x-build-id": "N8mhGQgzaFYUFFJN4"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/stackrelay~florida-dfs-insurance-license/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-stackrelay-florida-dfs-insurance-license",
                "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/stackrelay~florida-dfs-insurance-license/runs": {
            "post": {
                "operationId": "runs-sync-stackrelay-florida-dfs-insurance-license",
                "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/stackrelay~florida-dfs-insurance-license/run-sync": {
            "post": {
                "operationId": "run-sync-stackrelay-florida-dfs-insurance-license",
                "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": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "search",
                            "bulk"
                        ],
                        "type": "string",
                        "description": "search = look up by name or license number (returns individual records). bulk = download a full statewide CSV dataset (hundreds of thousands of records).",
                        "default": "search"
                    },
                    "lastName": {
                        "title": "Last Name",
                        "type": "string",
                        "description": "Individual last name to search. Minimum 3 characters. Partial matches are supported. Leave blank if searching by license number."
                    },
                    "firstName": {
                        "title": "First Name",
                        "type": "string",
                        "description": "Optional. Filters results to matching first name. Leave blank to return all matching last names."
                    },
                    "firmName": {
                        "title": "Agency / Firm Name",
                        "type": "string",
                        "description": "Optional. Search by agency or firm name instead of (or in addition to) a personal name."
                    },
                    "licenseNumber": {
                        "title": "FL License Number",
                        "type": "string",
                        "description": "Optional. Up to 7 characters. If provided, bypasses name search and does a direct lookup."
                    },
                    "npnNumber": {
                        "title": "NPN Number",
                        "type": "string",
                        "description": "Optional. National Producer Number. Numeric, up to 9 digits."
                    },
                    "emailAddress": {
                        "title": "Email Address",
                        "type": "string",
                        "description": "Optional. Search by the email address on file with FL DFS. Useful for matching producers from a CRM. Partial matches supported (begins-with)."
                    },
                    "licenseStatus": {
                        "title": "License Status",
                        "enum": [
                            "1",
                            "2",
                            "3"
                        ],
                        "type": "string",
                        "description": "Filter by license validity. Defaults to 'Valid only'. If a firm or person search returns nothing, try 'Both Valid and Invalid' — many entities (e.g. title companies) hold only inactive licenses.",
                        "default": "1"
                    },
                    "licenseCategory": {
                        "title": "License Category",
                        "enum": [
                            "",
                            "1",
                            "2",
                            "3",
                            "4",
                            "5",
                            "6",
                            "7",
                            "8",
                            "9",
                            "10",
                            "11",
                            "12",
                            "13",
                            "14",
                            "15",
                            "16",
                            "17",
                            "18",
                            "19",
                            "50"
                        ],
                        "type": "string",
                        "description": "Optional. Filter by license category (e.g. Life & Annuity, Property & Casualty, Adjuster). Leave blank for all categories.",
                        "default": ""
                    },
                    "residentStatus": {
                        "title": "Resident Status",
                        "enum": [
                            "",
                            "1",
                            "0"
                        ],
                        "type": "string",
                        "description": "Optional. Filter to Florida residents or non-residents only.",
                        "default": ""
                    },
                    "bulkDataset": {
                        "title": "Bulk Dataset",
                        "enum": [
                            "individual_licenses",
                            "business_licenses",
                            "ce_required",
                            "appointments_individual_ag",
                            "appointments_individual_ho",
                            "appointments_individual_pz",
                            "appointments_business",
                            "county_appointments",
                            "exchange_registrations"
                        ],
                        "type": "string",
                        "description": "Which CSV file to download. Only used in bulk mode. Individual license files are the largest (~320 MB). Appointment files are split A-G / H-O / P-Z by last name.",
                        "default": "individual_licenses"
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum records to return (this cap is now honored exactly). Search mode default: 50. Bulk mode default: 1,000. Set to 0 for unlimited — note bulk files can contain 350,000+ records, so only use 0 when you intend a full download.",
                        "default": 50
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
