# Florida DBPR License Search Scraper (`automation-lab/florida-dbpr-license-records-search`) Actor

Search official Florida DBPR license records by name, license number, city, county, or license type and export status, expiry, location, and verification links.

- **URL**: https://apify.com/automation-lab/florida-dbpr-license-records-search.md
- **Developed by:** [Automation Lab](https://apify.com/automation-lab) (community)
- **Categories:** Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.06 / 1,000 license-record extracteds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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 DBPR License Search Scraper

Run a **Florida DBPR license search** against the official MyFloridaLicense public portal and export structured license records.

Search by:

- licensee or organization name;
- exact license number;
- city;
- county code;
- DBPR board and license type.

Each saved record can include licensee identity, profession, license number, rank, current status, expiration date, public location, county, licensure date, and an official verification link.

### What can you do with this Actor?

- Verify a Florida professional license before vendor onboarding.
- Build a focused list of licensees by profession and location.
- Export current status and expiration details to CSV, Excel, or JSON.
- Save a repeatable batch of checks as an Apify Task.
- Schedule weekly or monthly snapshots for downstream comparison.
- Keep official DBPR provenance beside every normalized record.

The Actor returns snapshots from the public registry.
It does not itself calculate changes, send alerts, or make eligibility decisions.
Use Apify Schedules and your downstream system for those steps.

### Who is it for?

Compliance and procurement teams can verify regulated vendors.
Property and operations teams can screen contractors and service providers.
Recruiting teams can check credentials for regulated roles.
Sales operations teams can build narrowly scoped public-license lists.
Developers can integrate official license data into internal workflows.

This Actor covers professions and businesses in the Florida Department of Business and Professional Regulation portal.
It is not a Florida DMV, insurance, medical, attorney, or parole-record search.

### Why use it?

The DBPR portal is designed for interactive searches.
This Actor turns the same public results into consistent dataset rows and handles:

- request-verification tokens;
- coherent cookie sessions;
- source pagination;
- optional detail-page enrichment;
- duplicate suppression across batch searches;
- bounded retries after temporary source failures;
- stable JSON, CSV, and spreadsheet exports.

The implementation uses direct HTTP rather than a browser or paid proxy because the official anonymous server-rendered flow works reliably and at low cost.

### What data is extracted?

| Field | Description |
| --- | --- |
| `searchMode` | Name, license number, city, county, or license type |
| `searchQuery` | Normalized criteria that produced the row |
| `licenseeName` | Public person or business name |
| `nameType` | Relationship such as Primary |
| `licenseNumber` | Official DBPR license identifier |
| `licenseRank` | Rank or subtype shown by DBPR |
| `licenseType` | DBPR license type |
| `profession` | Profession represented by the license type |
| `status` | Current source status text |
| `expirationDate` | Expiration date shown by DBPR |
| `issueDate` | Licensure date when details are enabled |
| `address` | Public main address where available |
| `city`, `state`, `postalCode` | Normalized public location fields |
| `county` | County from the detail page |
| `verificationUrl` | Official DBPR detail link |
| `sourceUrl` | Official results endpoint |
| `scrapedAt` | UTC retrieval timestamp |

Some public records omit address, county, issue date, or expiry information.
Missing source fields are not invented.

### How to search Florida DBPR licenses

1. Open the Actor in Apify Console.
2. Select a search mode.
3. Enter the mode's required field.
4. Optionally add a board, location, or historic-license filter.
5. Set `maxItems` to cap exported records.
6. Keep `includeDetails` enabled for county and licensure-date fields.
7. Start the run.
8. Open the default dataset and export it in your preferred format.

A precise first run is:

```json
{
  "searchMode": "licenseNumber",
  "licenseNumber": "BK3330278",
  "maxItems": 1,
  "includeDetails": true
}
```

### Input parameters

| Input | Type | Purpose |
| --- | --- | --- |
| `searchMode` | enum | `name`, `licenseNumber`, `city`, `county`, or `licenseType` |
| `lastName` | string | Last name for name mode |
| `firstName`, `middleName` | string | Optional person-name filters |
| `organizationName` | string | Business or establishment name |
| `licenseNumber` | string | Exact DBPR license number |
| `city` | string | City for city mode |
| `countyCode` | string | DBPR numeric county code |
| `boardCode` | string | DBPR board/profession code |
| `licenseTypeCode` | string | DBPR type code within a board |
| `state` | string | Two-letter state filter; defaults to `FL` |
| `includeHistoric` | boolean | Include historic records when supported |
| `includeDetails` | boolean | Fetch detail pages for richer fields |
| `searches` | array | Batch of search objects replacing top-level criteria |
| `maxItems` | integer | Maximum unique rows, from 1 to 10,000 |
| `resultsPerPage` | integer | Source page size, from 1 to 50 |
| `maxRequestRetries` | integer | Fresh-session retries, from 0 to 3 |

Name mode requires a person-name or organization field.
License-number mode requires `licenseNumber`.
City and county modes require their corresponding location field.
DBPR's location form also requires both `boardCode` and `licenseTypeCode` for city and county searches.
License-type mode requires the same two profession codes.

### Batch searches

Use `searches` for recurring checks that need several independent criteria in one run:

```json
{
  "searches": [
    {
      "searchMode": "licenseNumber",
      "licenseNumber": "BK3330278",
      "includeHistoric": true
    },
    {
      "searchMode": "county",
      "countyCode": "58",
      "boardCode": "25",
      "licenseTypeCode": "2501"
    }
  ],
  "maxItems": 25,
  "includeDetails": true
}
```

The Actor applies one shared `maxItems` limit and removes duplicate official detail URLs across the batch.

### Output example

A current detail-enabled license-number search produces this shape:

```json
{
  "searchMode": "licenseNumber",
  "searchQuery": "license=BK3330278",
  "licenseeName": "SAMPLE LICENSEE",
  "nameType": "Primary",
  "licenseNumber": "BK3330278",
  "licenseRank": "Broker Sales",
  "licenseType": "Real Estate Broker or Sales",
  "profession": "Real Estate Broker or Sales",
  "status": "Current,Active",
  "expirationDate": "09/30/2027",
  "issueDate": "07/20/2015",
  "address": "SAMPLE PUBLIC ADDRESS",
  "city": "SOUTH PASADENA",
  "state": "FL",
  "postalCode": "33707",
  "county": "Pinellas",
  "verificationUrl": "https://www.myfloridalicense.com/portalsearches/VerifyLicensee/LicenseDetail?ID=...",
  "sourceUrl": "https://www.myfloridalicense.com/portalsearches/VerifyLicensee/Results",
  "scrapedAt": "2026-09-15T20:07:54.287Z"
}
```

The name and street address above are anonymized.
Field names and value formats reflect real current Actor behavior.

### How much does it cost to verify Florida DBPR license records?

Pay-per-event pricing includes a **$0.005 start fee** and a tiered charge for every license record saved.
On the BRONZE tier, a record costs **$0.00344**.
That is approximately:

- **$0.00844** for 1 saved record;
- **$0.0394** for 10 saved records;
- **$0.349** for 100 saved records.

Higher Apify subscription tiers receive the lower per-record prices shown in Console.
No record event is charged for duplicates, invalid rows, failed source requests, or searches with no matches.
Detail enrichment is included in the same license-record event rather than charged separately.

### Recurring compliance workflow

Create an Apify Task with stable license numbers or location/profession searches.
Schedule it weekly or monthly.
Send each completed dataset to a warehouse, spreadsheet, or webhook destination.
Compare `licenseNumber`, `status`, `expirationDate`, and `scrapedAt` between runs.

The official verification URL lets a reviewer open the source record before a consequential decision.
A DBPR row is one compliance signal, not a substitute for insurance, sanctions, references, or legal review.

### Integrations

- **Apify Tasks and Schedules:** repeat the same verification batch automatically.
- **Google Sheets and Excel:** export a dataset as CSV or XLSX.
- **Zapier and Make:** route new snapshot rows to review workflows.
- **Webhooks:** notify your service when a run succeeds or fails.
- **Warehouses and BI tools:** retrieve datasets through the API and compare snapshots.
- **MCP clients:** let an AI assistant run precise license checks with structured output.

### API usage

#### cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~florida-dbpr-license-records-search/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"searchMode":"licenseNumber","licenseNumber":"BK3330278","maxItems":1}'
```

#### JavaScript

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/florida-dbpr-license-records-search').call({
  searchMode: 'name',
  lastName: 'Smith',
  boardCode: '25',
  maxItems: 25,
  includeDetails: true,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/florida-dbpr-license-records-search').call(
    run_input={
        'searchMode': 'licenseNumber',
        'licenseNumber': 'BK3330278',
        'maxItems': 1,
        'includeDetails': True,
    }
)
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### Use with Apify MCP

Add the Actor to Claude Code:

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/florida-dbpr-license-records-search"
```

For Claude Desktop, Cursor, or VS Code, use:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/florida-dbpr-license-records-search"
    }
  }
}
```

Example prompts:

- “Verify Florida DBPR license BK3330278 and summarize its status and expiry.”
- “Find the first 20 DBPR real estate licenses for Smith and return official verification links.”
- “Run my saved Florida license compliance batch and format the dataset as a table.”

### Reliability, pagination, and limits

The Actor follows DBPR's anonymous server-rendered search flow.
It retains cookies and verification tokens within each search.
It paginates until the source is exhausted or `maxItems` is reached.
Temporary transport and server failures receive bounded retries with a fresh session.
Persistent HTTP failures, missing tokens, and unknown page shapes fail the run visibly.

Detail pages are fetched in batches of five.
Disable `includeDetails` for faster list building when issue date and county are not required.
Direct HTTP is used by default; no paid proxy traffic is automatically triggered.

DBPR controls portal availability, fields, historical coverage, and update timing.
Very broad surnames or county searches can match thousands of records.
Use a board or license-type filter and a practical `maxItems` value.

### Limitations

- County inputs use DBPR's numeric county codes, not free-text county names.
- City, county, and license-type searches require the source's board and type codes.
- Public records may omit optional dates or addresses.
- The Actor does not enrich email, phone, sanctions, insurance, or private data.
- It does not monitor state changes internally or send alerts.
- It does not cover licenses maintained by other Florida agencies.
- Critical decisions should be confirmed on the linked official record.

### Legality and responsible use

DBPR exposes these records publicly for license verification.
Use the Actor lawfully and only for a legitimate purpose.
Follow applicable source terms, privacy rules, anti-discrimination law, and retention requirements.
Collect only fields needed for the workflow.
Do not represent the Actor as an official DBPR product or imply regulator endorsement.
Do not make an adverse employment, housing, credit, or eligibility decision solely from an automated row.

### Troubleshooting

**Why was my input rejected?**
Check the selected mode and its required fields.
License type, city, and county modes need both profession codes; county also needs a numeric county code.

**Why did a valid search return no rows?**
Try enabling `includeHistoric`, confirm spelling and source codes, or verify the record manually on DBPR.
A zero-match search is not charged a record event.

**Why is county or issue date missing?**
Keep `includeDetails` enabled.
Even then, DBPR may omit an optional public field.

**What if the portal is unavailable?**
Inspect the run log.
Temporary failures are retried; persistent failures end the run with a non-success status so schedules can detect them.

### FAQ

#### Is this an official Florida DBPR tool?

No.
It is an independent Apify Actor that reads the official public portal and preserves source links.

#### Can it search more than one license at a time?

Yes.
Put several criteria in `searches` and set a shared `maxItems` cap.

#### Can it export CSV or Excel?

Yes.
Use the default dataset's export controls or dataset API formats.

#### Does it include inactive licenses?

Set `includeHistoric` to request historical records when the selected DBPR mode supports them.

#### Does it use residential proxies?

No automatic proxy is enabled.
The current official flow works through direct HTTP, which avoids unnecessary transfer cost.

### Related Automation Lab Actors

- [Florida Sunbiz Business Search](https://apify.com/automation-lab/florida-sunbiz-business-search) — company identity, filing status, officers, and registered-agent records.
- [Florida Bar Attorney Directory Scraper](https://apify.com/automation-lab/florida-bar-attorney-directory) — Florida attorney directory records.
- [Florida Adjuster License Search](https://apify.com/automation-lab/florida-adjuster-license-search) — Florida DFS insurance adjuster credentials.

# Changelog

This Actor's version history is a separate document: https://apify.com/automation-lab/florida-dbpr-license-records-search/changelog.md

# Actor input Schema

## `searchMode` (type: `string`):

How DBPR should interpret the supplied filters. If omitted, the Actor infers the mode.

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

Licensee last name for a name search.

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

Optional licensee first name.

## `middleName` (type: `string`):

Optional licensee middle name.

## `organizationName` (type: `string`):

Business or establishment name for a name search.

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

Exact DBPR license number, for example BK3330278.

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

City used by DBPR's location search. City mode also requires boardCode and licenseTypeCode.

## `countyCode` (type: `string`):

DBPR county code, such as 58 for Orange, 39 for Hillsborough, 60 for Palm Beach, or 62 for Pinellas. County mode also requires boardCode and licenseTypeCode.

## `boardCode` (type: `string`):

DBPR board code, such as 25 for Real Estate, 06 for Construction, or 05 for Cosmetology.

## `licenseTypeCode` (type: `string`):

DBPR license-type code for the selected board. Required in licenseType mode.

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

Two-letter state filter. Defaults to FL.

## `includeHistoric` (type: `boolean`):

Include inactive and historic licenses when DBPR supports it for the selected mode.

## `includeDetails` (type: `boolean`):

Fetch each DBPR detail page for issue date, county, and normalized address fields.

## `searches` (type: `array`):

Optional array of searches. When supplied, these replace the top-level search fields.

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

Maximum unique license records saved across all searches.

## `resultsPerPage` (type: `integer`):

Records requested per source page. DBPR allows up to 50.

## `maxRequestRetries` (type: `integer`):

Number of fresh cookie-session retries after temporary DBPR failures.

## Actor input object example

```json
{
  "searchMode": "licenseNumber",
  "licenseNumber": "BK3330278",
  "state": "FL",
  "includeHistoric": false,
  "includeDetails": true,
  "maxItems": 1,
  "resultsPerPage": 50,
  "maxRequestRetries": 2
}
```

# Actor output Schema

## `dataset` (type: `string`):

Default dataset containing the matched Florida DBPR licenses.

# 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 = {
    "searchMode": "licenseNumber",
    "licenseNumber": "BK3330278",
    "maxItems": 1
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/florida-dbpr-license-records-search").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 = {
    "searchMode": "licenseNumber",
    "licenseNumber": "BK3330278",
    "maxItems": 1,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/florida-dbpr-license-records-search").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 '{
  "searchMode": "licenseNumber",
  "licenseNumber": "BK3330278",
  "maxItems": 1
}' |
apify call automation-lab/florida-dbpr-license-records-search --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/florida-dbpr-license-records-search"
        }
    }
}
```

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/cKC05LmOok63jYcfB/builds/boqhbsADrvTEwSzCA/openapi.json