# Florida DBPR License Records Scraper (`cblu/florida-license-records-scraper`) Actor

Extract Florida professional license records (contractors, electricians, cosmetologists, home inspectors, and more) from official DBPR public data. Filter by license type, county, city, status, and expiration date. Pay per record.

- **URL**: https://apify.com/cblu/florida-license-records-scraper.md
- **Developed by:** [Steven Carleton](https://apify.com/cblu) (community)
- **Categories:** Lead generation, Real estate
- **Stats:** 2 total users, 1 monthly users, 66.7% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 license records

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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 DBPR License Records Scraper — Contractor & Professional License Data

Extract **official Florida professional license records** — general contractors, roofers, plumbers, electricians, home inspectors, mold assessors, cosmetologists, barbers, veterinarians, architects, and more — straight from the Florida DBPR's public records data. Filter by **license type, county, city, status, and expiration date** and download clean JSON, CSV, or Excel.

Because this Actor reads the state's **official public extract files** (not a fragile search form), it is fast, complete, and does not miss records: a statewide pull of every active certified general contractor takes about a minute.

### What data do you get?

One result per license record:

| Field | Example |
|---|---|
| `licenseNumber` | `CGC058548` |
| `licenseType` / `licenseTypeName` | `CGC` / Certified General Contractor |
| `licenseeName` | `AALDERINK, JAMES` |
| `dbaName` | Qualified business / DBA name |
| `addressLine1..3`, `city`, `state`, `zip` | Mailing address of record |
| `countyCode` / `countyName` | `60` / Palm Beach |
| `primaryStatus` / `secondaryStatus` | Current / Active |
| `originalLicenseDate` | `1980-01-03` |
| `statusEffectiveDate` | `2010-09-29` |
| `expirationDate` | `2028-08-31` |
| `notes` | e.g. `CE Exempt` |

### Supported professions

- **Construction contractors (CILB)** — general (CGC), building (CBC), residential (CRC), roofing (CCC), plumbing (CFC), HVAC (CAC), mechanical (CMC), pool (CPC), underground utility (CUC), all registered (RG/RB/RR/...) and specialty types
- **Electrical contractors (ECLB)** — EC / ER / ES
- **Home inspectors** (HI)
- **Mold-related services** — assessors & remediators
- **Cosmetology** — cosmetologists, salons, specialists
- **Barbers & barbershops**
- **Veterinary medicine**
- **Architecture & interior design**

### Use cases

- **Lead generation** — build county-level lists of active contractors for insurance, building materials, SaaS, CE courses, or financial products. Combine with `expiresBefore` to target licensees whose **renewal is coming up**.
- **License verification at scale** — verify that subcontractors, vendors, or marketplace signups hold a current, active Florida license.
- **Market sizing & analytics** — count active roofers per county, track new licensees, analyze contractor density.
- **Compliance & risk** — flag partners whose license is expiring, inactive, suspended, or on probation.
- **Recruiting** — source licensed professionals by trade and region.

### How to use it

```json
{
    "profession": "construction",
    "licenseTypes": ["CGC"],
    "counties": ["Palm Beach"],
    "status": "current-active",
    "expiresBefore": "2026-12-31",
    "maxResults": 5000
}
````

Leave `licenseTypes`, `counties`, and `cities` empty for statewide, all-type pulls. `maxResults` caps the run — **you are only charged for records actually returned**.

### Pricing

Pay per result: one charge per license record extracted.

> Suggested store pricing (set in the Apify Console → Publication → Monetization):
>
> - `license-record` event: **$0.002 per record** ($2.00 per 1,000 records)
>
> Rationale: comparable state-license actors (California CSLB, Texas TDLR) charge in the $1–5/1,000 range, and one qualified contractor lead resells for dollars. A 1,000-lead county list costs the customer $2 versus hours of manual DBPR searching.

### Data source & freshness

Records come from the Florida Department of Business & Professional Regulation's free public-records extract files (myfloridalicense.com), which DBPR refreshes on a daily/weekly cadence. This is public information published by the State of Florida under its public-records obligations. Excluded from DBPR extracts: null & void, delinquent, and involuntarily inactive records.

**Note on fairness:** phone numbers and emails are not included because DBPR does not publish them in these files; any actor claiming otherwise is scraping a different, slower source or fabricating data.

### FAQ

**How current is the data?** DBPR regenerates most extract files daily or weekly. Schedule the Actor weekly to keep your lists fresh.

**Can I get all ~500,000 cosmetology licenses?** Yes — set `maxResults` high and let it stream. Runs are memory-safe because the file is processed as a stream.

**A profession you need is missing?** Open an issue on the Actor's Issues tab — adding another DBPR board is usually a same-week change.

# Actor input Schema

## `profession` (type: `string`):

Which DBPR-regulated profession to extract license records for.

## `licenseTypes` (type: `array`):

Optional. Only return licenses whose type code matches, e.g. <code>CGC</code> (Certified General Contractor), <code>CBC</code> (Certified Building), <code>CCC</code> (Certified Roofing), <code>EC</code> (Certified Electrical), <code>HI</code> (Home Inspector), <code>CL</code> (Cosmetologist). Leave empty for all types in the selected profession.

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

Optional. Florida county names (e.g. <code>Palm Beach</code>, <code>Dade</code>, <code>Hillsborough</code>) or DBPR county codes (e.g. <code>60</code>). Leave empty for statewide.

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

Optional. Exact city names of the licensee's address, e.g. <code>MIAMI</code>, <code>TAMPA</code>. Case-insensitive. Leave empty for all cities.

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

Filter by license status. "Current + Active" is the standard choice for lead generation (licensee holds a valid license and actively practices).

## `expiresBefore` (type: `string`):

Optional. Only return licenses expiring before this date (format <code>YYYY-MM-DD</code>). Great for renewal/CE marketing lists.

## `expiresAfter` (type: `string`):

Optional. Only return licenses expiring after this date (format <code>YYYY-MM-DD</code>).

## `nameContains` (type: `string`):

Optional. Case-insensitive substring match against the licensee name and DBA/business name.

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

Maximum number of license records to return. You are only charged for records actually returned.

## Actor input object example

```json
{
  "profession": "construction",
  "licenseTypes": [],
  "counties": [],
  "cities": [],
  "status": "current-active",
  "maxResults": 500
}
```

# 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 = {
    "profession": "construction",
    "maxResults": 500
};

// Run the Actor and wait for it to finish
const run = await client.actor("cblu/florida-license-records-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "profession": "construction",
    "maxResults": 500,
}

# Run the Actor and wait for it to finish
run = client.actor("cblu/florida-license-records-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "profession": "construction",
  "maxResults": 500
}' |
apify call cblu/florida-license-records-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Florida DBPR License Records Scraper",
        "description": "Extract Florida professional license records (contractors, electricians, cosmetologists, home inspectors, and more) from official DBPR public data. Filter by license type, county, city, status, and expiration date. Pay per record.",
        "version": "0.1",
        "x-build-id": "NKCmT0ba4cwDtCvZy"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/cblu~florida-license-records-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-cblu-florida-license-records-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/cblu~florida-license-records-scraper/runs": {
            "post": {
                "operationId": "runs-sync-cblu-florida-license-records-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/cblu~florida-license-records-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-cblu-florida-license-records-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "profession"
                ],
                "properties": {
                    "profession": {
                        "title": "Profession / licensing board",
                        "enum": [
                            "construction",
                            "electrical-contractors",
                            "home-inspectors",
                            "mold-related-services",
                            "cosmetology",
                            "barbers",
                            "veterinary-medicine",
                            "architecture-interior-design"
                        ],
                        "type": "string",
                        "description": "Which DBPR-regulated profession to extract license records for.",
                        "default": "construction"
                    },
                    "licenseTypes": {
                        "title": "License type codes",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Optional. Only return licenses whose type code matches, e.g. <code>CGC</code> (Certified General Contractor), <code>CBC</code> (Certified Building), <code>CCC</code> (Certified Roofing), <code>EC</code> (Certified Electrical), <code>HI</code> (Home Inspector), <code>CL</code> (Cosmetologist). Leave empty for all types in the selected profession.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "counties": {
                        "title": "Counties",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Optional. Florida county names (e.g. <code>Palm Beach</code>, <code>Dade</code>, <code>Hillsborough</code>) or DBPR county codes (e.g. <code>60</code>). Leave empty for statewide.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "cities": {
                        "title": "Cities",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Optional. Exact city names of the licensee's address, e.g. <code>MIAMI</code>, <code>TAMPA</code>. Case-insensitive. Leave empty for all cities.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "status": {
                        "title": "License status",
                        "enum": [
                            "any",
                            "current-active",
                            "current-inactive"
                        ],
                        "type": "string",
                        "description": "Filter by license status. \"Current + Active\" is the standard choice for lead generation (licensee holds a valid license and actively practices).",
                        "default": "current-active"
                    },
                    "expiresBefore": {
                        "title": "License expires before",
                        "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
                        "type": "string",
                        "description": "Optional. Only return licenses expiring before this date (format <code>YYYY-MM-DD</code>). Great for renewal/CE marketing lists."
                    },
                    "expiresAfter": {
                        "title": "License expires after",
                        "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
                        "type": "string",
                        "description": "Optional. Only return licenses expiring after this date (format <code>YYYY-MM-DD</code>)."
                    },
                    "nameContains": {
                        "title": "Name contains",
                        "type": "string",
                        "description": "Optional. Case-insensitive substring match against the licensee name and DBA/business name."
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 1,
                        "maximum": 500000,
                        "type": "integer",
                        "description": "Maximum number of license records to return. You are only charged for records actually returned.",
                        "default": 500
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```