# Florida Insurance Licenses - FL DFS Producers & Agencies (`j0401/fl-dfs-insurance`) Actor

Florida DFS insurance licensee register (public data, 1.24M individuals + 105k businesses): licensed producers, adjusters, agencies and warranty firms with NPN, license type, status, residency and address. Search by name, NPN, type, city or county.

- **URL**: https://apify.com/j0401/fl-dfs-insurance.md
- **Developed by:** [Wenhao Yang](https://apify.com/j0401) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.03 / 1,000 florida insurance licensee records

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Florida Insurance Licenses - FL DFS Producers & Agencies

The complete Florida Department of Financial Services insurance licensee
register: **1,240,655 individual licensees** and **105,124 licensed businesses**,
refreshed daily from FL DFS's official bulk export. Producers, adjusters, MGAs,
agencies and warranty firms - with NPN, license type, status, residency and
address.

### Low cost

**From $0.00005 per record, down to $0.00003 at Gold.** Pay only for the records
you actually receive - the whole register stays queryable, you are never billed
for the scan behind it.

### Two corpora, one actor

Pick a `corpus` and search it:

- **`individual`** (default) - every licensed person: name (split into first /
  middle / last), NPN, license type, status, residency and business address.
  Led by NONRES LIFE & VARIABLE ANNUITY (198,281), NONRESIDENT HEALTH (166,238)
  and LIFE INCL VAR ANNUITY & HEALTH (140,685).
- **`business`** - every licensed entity: AGENCY LICENSE (59,210), SERVICE
  WARRANTY (16,390), AUTOMOBILE WARRANTY (10,404), title agencies and more.

### Screen and verify

- **Status** - `VALID` (1,240,332) is the healthy value; `VALID - PROBATION`
  (323) marks licensees under probation.
- **Residency** - Non-Resident (734,796) vs Resident (505,859). Florida licenses
  a large share of out-of-state producers, so residency is a first-class filter.
- **License type** - 71 type-classes on the individual side, from GENERAL LINES
  (PROP & CAS) to SURPLUS LINES, adjusters and life/health.

### Search it

- **Name** - `name="WALKER"` (substring over full / first / middle / last).
- **Exact id** - `licenseNumber`, `npn`.
- **Type** - `licenseType="GENERAL LINES"` (substring).
- **Where** - `city`, `county`, `state` (exact 2-letter), `zipCode` (prefix).

### Example inputs

**An agent by name** - the bread-and-butter lookup.

```json
{ "corpus": "individual", "name": "WALKER", "maxResults": 25 }
```

**One licensee, in full** - by license number.

```json
{ "corpus": "individual", "mode": "profile", "licenseNumber": "A276085" }
```

**General lines producers in Miami** - filter a type and a city.

```json
{ "corpus": "individual", "licenseType": "GENERAL LINES", "city": "MIAMI", "maxResults": 50 }
```

**Agencies in a state** - the business corpus.

```json
{ "corpus": "business", "licenseType": "AGENCY", "maxResults": 25 }
```

**Counts by license type** - `mode=aggregate`.

```json
{ "corpus": "individual", "mode": "aggregate", "groupBy": "licenseType" }
```

### Or roll it up

`mode=aggregate` returns one count row per group - **license type**, **status**,
**residency**, **business state** or **business county**. Every group comes
back; this mode is not cut off by `maxResults`.

### Example output

**One individual licensee** - `mode=profile`:

```json
{
 "platform": "fl-dfs",
 "corpus": "individual",
 "licenseNumber": "A276085",
 "fullName": "WALKER, KEITH J",
 "firstName": "KEITH",
 "lastName": "WALKER",
 "npn": "636278",
 "licenseTypeCode": "0220",
 "licenseType": "GENERAL LINES (PROP & CAS)",
 "licenseStatus": "VALID",
 "residencyType": "Resident",
 "licenseIssueDate": "1995-05-20",
 "businessAddress1": "INSURANCE SOLUTIONS",
 "businessCity": "NAPLES",
 "businessState": "FL",
 "businessZip": "34109",
 "businessCounty": "Collier"
}
```

### Also: the change feed

`mode=changes` returns the diff between the last two daily snapshots - licensees
added, removed, or with any field changed (a status move, an address change).
Each row carries `changeType` (added / removed / updated), and for `updated`
rows the `changedFields` list and the previous `oldValues`.

### Data use

This data is drawn from FL DFS's official public bulk export. FL DFS's download
page carries a non-redistribution style clause, and FL 626.9541(1)(c) is
suspected to restrict using licensee lists for "competitive advantage" (statute
text not yet confirmed). This actor is offered as a **structured, per-query
lookup** over derived licensee fields - a verification and screening tool - not
as a raw file redistribution. If you intend to republish or resell the output in
bulk, review the source terms and your own compliance obligations first.

### Notes on the data, from the source

- **NPN, phone and ZIP arrive as Excel text cells** (`="636278"`) in the raw
  export and are unwrapped here to plain digits.
- **Business county is only 38.8% populated on the individual corpus** - many
  producers work from a state with no Florida county. Blank is expected there.
- **Status is a small set** (VALID / VALID - PROBATION); a suspended or revoked
  licensee drops off the current register.
- **One row = one (licensee, license type) pair.** A producer licensed in
  several lines carries one row per line under the same license number - hence
  the `licenseNumber` + `licenseTypeCode` composite key.

# Actor input Schema

## `corpus` (type: `string`):

individual = licensed people (agents, adjusters; 1.24M rows). business = licensed entities (agencies, MGA, warranty firms; 105k rows).

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

search = filter a corpus. profile = one licensee's full record (needs licenseNumber or npn). aggregate = one row per group. changes = the feed between the last two daily snapshots. Leave blank to auto-route.

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

Exact FL license number, e.g. "A276085". Identifies one licensee row.

## `npn` (type: `string`):

Exact National Producer Number, e.g. "636278".

## `name` (type: `string`):

Name, substring, case-insensitive, over full / first / middle / last name (e.g. "WALKER").

## `licenseType` (type: `string`):

License type description, substring, case-insensitive, e.g. "GENERAL LINES", "LIFE", "ADJUSTER", "AGENCY".

## `status` (type: `string`):

License status. Blank = all. VALID is the healthy value; VALID - PROBATION marks licensees under probation.

## `residency` (type: `string`):

Resident or Non-Resident licensee. Blank = all. Non-Resident is the majority (734,796).

## `city` (type: `string`):

Business city, substring, case-insensitive (e.g. "MIAMI").

## `county` (type: `string`):

Business county, substring, case-insensitive (e.g. "Miami-Dade").

## `state` (type: `string`):

Two-letter business state code, exact (e.g. "FL", "NY").

## `zipCode` (type: `string`):

Business ZIP prefix (digits), e.g. "331".

## `aggregate` (type: `boolean`):

When on, returns one summary record per group with count, instead of individual licensees.

## `changes` (type: `boolean`):

When on, returns the changes between the last two daily snapshots instead of records.

## `groupBy` (type: `string`):

licenseType -> license-type mix; licenseStatus -> valid vs probation; residencyType -> resident vs non-resident; businessState / businessCounty -> geography.

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

Cap the number of records pushed (0 = a reasonable ceiling of 200).

## Actor input object example

```json
{
  "corpus": "individual",
  "aggregate": false,
  "changes": false,
  "groupBy": "licenseType",
  "maxResults": 200
}
```

# Actor output Schema

## `recordsUrl` (type: `string`):

Florida DFS insurance licensee records - as JSON

## `datasetUrl` (type: `string`):

No description

## `runUrl` (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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("j0401/fl-dfs-insurance").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("j0401/fl-dfs-insurance").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{}' |
apify call j0401/fl-dfs-insurance --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,j0401/fl-dfs-insurance"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/Ztsza2yw9DfmcVqBG/builds/OhcjAtTbLNirtvwMC/openapi.json