Verify Florida contractor licenses in bulk — DBPR's 46 MB mystery CSV, decoded

If your business touches Florida construction — insurance, lending, building materials, a marketplace, a permit-pulling SaaS — sooner or later you need to answer, at scale: is this contractor actually licensed, and is that license current, active, and not about to expire?

Florida makes this genuinely answerable. Unlike states with no statewide general-contractor license (looking at you, Texas), Florida's DBPR licenses contractors statewide and publishes the entire license roll as public records. The catch: the official ways to read it are either painfully slow or painfully cryptic. This post shows both DIY routes honestly, then the shortcut, and finally how to turn a one-off check into standing compliance alerts.

Route 1: the search portal (fine for one, hopeless for a list)

DBPR's Verify a License portal works one search at a time: pick a board, type a name or license number, click through to a detail page. For a single sub you're about to hire, perfect. For the 400 subcontractors on your book, that's an afternoon of copy-paste — every week, if you care about status changes. Nobody does this twice.

Route 2: the bulk extract files (free, complete, and user-hostile)

The real data lives on DBPR's instant public records page: full statewide extract files per profession, regenerated on a daily/weekly cadence. The construction file is one URL away:

curl -O "https://www2.myfloridalicense.com/sto/file_download/extracts/CONSTRUCTIONLICENSE_1.csv"

That's every licensed contractor in Florida — 46 MB of it (the cosmetology file is ~74 MB). Now the friction starts:

1. No header row. The file opens with data. There are 22 columns and DBPR doesn't label them in the file.
2. Everything is coded. Counties are numbers (23 = Miami-Dade, 60 = Palm Beach — the mapping is on DBPR's "understanding DBPR codes" page). Statuses are letters: primary C/P/S/N/D = Current / Probation / Suspended / Null-and-Void / Delinquent, secondary A/I = Active / Inactive. A usable license is C + A — most rows aren't.
3. Two license-number columns. Column 13 is a bare sequence (0015061); the full number you actually want (CBC015061) is column 21.
4. Rows that aren't licenses. Qualified-business entries ride along with no license number and have to be skipped.
5. The CDN blocks datacenter IPs. The download works from your laptop and then 403s from AWS/GitHub Actions — precisely where your cron job lives. (Ask me how I know.)
6. What's missing matters. DBPR excludes null-and-void, delinquent, and involuntarily-inactive licenses from the extracts. A contractor disappearing from the file is itself a signal.

Here's a working decoder for the construction file (tested against the live extract):

import pandas as pd

# 22 columns, no header row - mapping reverse-engineered from DBPR's code tables
COLS = ["board", "license_type", "licensee_name", "dba_name", "_4",
        "addr1", "addr2", "addr3", "city", "state", "zip", "county_code",
        "license_seq", "primary_status", "secondary_status",
        "original_license_date", "status_effective_date", "expiration_date",
        "_18", "_19", "license_number", "notes"]

PRIMARY = {"C": "Current", "P": "Probation", "S": "Suspended",
           "N": "Null and Void", "D": "Delinquent"}
SECONDARY = {"A": "Active", "I": "Inactive"}

df = pd.read_csv("CONSTRUCTIONLICENSE_1.csv", names=COLS, dtype=str,
                 keep_default_na=False)
df["primary_status"] = df["primary_status"].map(PRIMARY)
df["secondary_status"] = df["secondary_status"].map(SECONDARY)

# Every active certified general contractor in Palm Beach County (code 60):
cgc = df[(df.license_type == "CGC") & (df.county_code == "60")
         & (df.primary_status == "Current") & (df.secondary_status == "Active")]
print(len(cgc), "active Palm Beach CGCs")

To verify your list, inner-join it on license_number and flag anything that isn't Current + Active — plus anything from your list that's not in the file at all (see point 6).

If you only need this once, the DIY route is genuinely fine. The pain compounds when you need it fresh: re-downloading 46-74 MB files, babysitting the 403s, re-checking the column layout, decoding county/status/type codes for eight different boards (electrical, home inspectors, mold, cosmetology... each its own file).

The shortcut: one input, clean records

I maintain an Apify actor that streams the official extracts and hands back decoded, filterable records — county names instead of codes, ISO dates, human-readable statuses and license types, QB rows skipped, proxy business handled:

Florida License Records Scraper (DBPR)

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

Statewide pulls take about a minute, export as JSON/CSV/Excel, and pricing is per record returned — a 1,000-contractor county list costs a couple of dollars. Eight DBPR boards are covered: construction, electrical, home inspectors, mold services, cosmetology, barbers, veterinary, architecture.

The part that actually solves compliance: monitoring mode

Bulk verification has a shelf life of exactly one day — DBPR regenerates the files that often. What compliance teams really want isn't a snapshot, it's an alarm: tell me when something changes.

The actor has a monitor mode for that. Give it a watch list (or a filter set), run it on an Apify Schedule, and each run returns only what changed since the last one:

{
    "mode": "monitor",
    "profession": "construction",
    "licenseNumbers": ["CGC058548", "CCC1330911", "CFC1425030"],
    "alertOnStatusChange": true,
    "expiringWithinDays": 90
}

The first run saves a baseline. Every scheduled run after that emits change records only: status-changed (Current → Suspended is the one you're paying attention for), renewed, expiring-soon (once per license as it enters your 90-day window, with a daysUntilExpiration field), new-license, and removed-from-extract — that disappearing-contractor signal from point 6, delivered instead of silently missed.

Because pricing is per record returned, a run where nothing changed costs roughly a cent of compute and zero record charges. Watching 500 subcontractors costs approximately nothing until the week one of them gets suspended — which is the week it pays for itself a few hundred times over. Wire the run into a Slack/email integration and you're done: set-and-forget license compliance.

Recap

1. Florida publishes its complete contractor license roll as free public extract files — the data access problem is solved.
2. The files are honest work to use: headerless 22-column CSVs, coded everything, datacenter-IP blocking, and meaningful absences.
3. Decode it yourself with ~25 lines of pandas for a one-off; use the actor for clean filtered pulls; use monitor mode on a schedule when what you actually need is "alert me when a license changes."

Fighting with a different state's license data? Drop a comment — Texas TDLR and California CSLB are next on my list.