# Contractor License Lookup & Verification — 7 US States (`helenium/us-contractor-license-verification`) Actor

Verify US contractor licences by number or business name. Normalized JSON with status, classifications, expiration, bond and insurance where the state publishes it.

- **URL**: https://apify.com/helenium/us-contractor-license-verification.md
- **Developed by:** [Bio Verse](https://apify.com/helenium) (community)
- **Categories:** Lead generation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## Contractor License Lookup & Verification API — CA, FL, IL, NYC, OR, TX, WA

Verify a contractor license by license number or business name in seconds. Give this actor a
licence number or a business name and it returns one normalized JSON record per licence —
status, trade classifications, expiration date, and, where the state publishes them, the
surety bond and insurance policies.

Every record comes from the licensing board's own public records — CSLB, DBPR, IDFPR, DCWP,
CCB, TDLR, L\&I. Nothing is inferred, nothing is padded, and every record carries a link back
to the source row.

### What you get

| Field | Meaning |
|---|---|
| `status` | Normalized: `ACTIVE`, `EXPIRED`, `SUSPENDED`, `REVOKED`, `INACTIVE`, `UNKNOWN` |
| `status_raw` | The board's exact wording, never modified |
| `business_name`, `qualifier_name` | The company and the individual who holds the licence |
| `classifications` | Trade codes — CA's `B` / `C-10`, WA's `CC`, NYC's `GENERAL CONTRACTOR` |
| `issue_date`, `expiration_date` | Where the board publishes them |
| `bond` | Surety, bond number, amount (CA, OR, WA) |
| `liability_insurance` | Carrier, policy number, limit (OR, WA) |
| `workers_comp` | Carrier and policy (CA); exemption status only (OR) |
| `disciplinary_actions` | Case number, type, date, reason (IL) |
| `address` | Business address as filed |
| `source_url`, `source_name`, `retrieved_at` | Provenance on every single record |
| `data_completeness` | Which fields this board actually supplies |

That last field matters more than it looks. State boards publish wildly different things, so
a `null` bond is ambiguous on its own. `data_completeness` tells you whether it means "this
contractor has no bond" or "this board doesn't publish bonds at all".

### Coverage, and its limits

| State | Board | Read this before you build on it |
|---|---|---|
| **CA** | CSLB | Full coverage. Name searches omit the qualifier; number lookups include it. |
| **FL** | DBPR | Full coverage. No bond or insurance data published. |
| **IL** | IDFPR | **Roofing contractors only** — the one construction trade Illinois publishes. The only state here with disciplinary actions. |
| **NY** | NYC DCWP + DOB | **New York City only.** New York State issues no statewide contractor licence. Covers home improvement contractors, general contractors, master plumbers and electrical contractors. |
| **OR** | CCB | Full coverage, including bond and liability insurance. |
| **TX** | TDLR | **No general contractors.** Texas licenses electricians, HVAC, irrigators and similar trades; general contracting is unregulated at state level. |
| **WA** | L\&I | Full coverage, including bond and liability insurance. |

These caveats are here rather than in the fine print because finding out after you have
integrated is worse than knowing now.

### Input

```json
{
  "state": "CA",
  "licenseNumbers": ["1000004"],
  "names": ["ACME CONSTRUCTION"],
  "limit": 25,
  "includeNotFound": false
}
```

- **state** — one of `CA`, `FL`, `IL`, `NY`, `OR`, `TX`, `WA`.
- **licenseNumbers** — exact numbers. Dashes and spaces are ignored.
- **names** — partial, case-insensitive business or qualifier name search.
- **limit** — how many licences to return per name (1–100).
- **includeNotFound** — add a row for queries that matched nothing. You are never charged
  for these rows.

### Output

One dataset row per licence:

```json
{
  "query": "1000004",
  "query_type": "license_number",
  "state": "CA",
  "license_number": "1000004",
  "status": "ACTIVE",
  "status_raw": "Active",
  "business_name": "SOUTH COAST CONSTRUCTION & DEVELOPMENT",
  "classifications": [{ "code": "B", "description": "General Building Contractor" }],
  "expiration_date": "2027-05-31",
  "bond": { "surety_company": "...", "bond_number": "...", "amount_usd": 25000 },
  "source_url": "https://...",
  "source_name": "California CSLB",
  "retrieved_at": "2026-08-03T00:00:00Z",
  "data_completeness": { "bond": true, "disciplinary_actions": false }
}
```

### Pricing

**Free during beta.** No charge per run or per record while pricing is being finalized.

### Who this is for

- **Lenders and insurers** verifying a contractor before extending credit or writing a policy
- **Marketplaces** vetting contractors at signup instead of trusting a self-reported number
- **Property managers and GCs** checking a sub is still licensed before work starts
- **Compliance teams** who need provenance on every check, which is why `source_url` and
  `retrieved_at` are on every record rather than available on request

### Also available as a REST API

The same backend is on RapidAPI as
[Contractor License Verification](https://rapidapi.com/kriptkor/api/contractor-license-verification2)
if you would rather call it directly. Full schema and per-state coverage notes at
[swanum.com/states](https://swanum.com/states).

### Data sources

California CSLB · Florida DBPR · Illinois IDFPR · NYC DCWP and DOB · Oregon CCB ·
Texas TDLR · Washington L\&I — all public records, refreshed at most 24 hours old
(California weekly).

### FAQ

**How do I check if a contractor is licensed?**
Give this actor the licence number if you have it, or the business name if you don't. Both
return the same normalized record, so nothing downstream needs to know which one you used.

**Can I look up a contractor license by company name instead of a number?**
Yes — the `names` input does a partial, case-insensitive search and can return multiple
matching licences per name.

**Does this include contractor complaints or disciplinary actions?**
Illinois publishes them and this actor returns them. The other six states don't publish
disciplinary data at the board level, so there's nothing to return — see the coverage table
above for exactly what each board does and doesn't publish.

**Is there a free way to try contractor license verification?**
Yes — this actor is free during beta. See Pricing above.

**Which states does this cover?**
CA, FL, IL (roofing contractors only), NYC, OR, TX, and WA. New York is New York City only;
New York State itself issues no statewide contractor licence.

# Actor input Schema

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

Which licensing jurisdiction to query. NY is New York City only — New York State issues no statewide contractor licence.

## `licenseNumbers` (type: `array`):

Exact licence numbers to look up. Dashes and spaces are ignored.

## `names` (type: `array`):

Business or qualifier names to search. Partial, case-insensitive match.

## `limit` (type: `integer`):

How many licences to return for each name search.

## `includeNotFound` (type: `boolean`):

Add a row for each query that matched nothing. You are never charged for these.

## Actor input object example

```json
{
  "state": "CA",
  "licenseNumbers": [
    "1000004"
  ],
  "names": [],
  "limit": 25,
  "includeNotFound": false
}
```

# 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 = {
    "licenseNumbers": [
        "1000004"
    ],
    "names": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("helenium/us-contractor-license-verification").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 = {
    "licenseNumbers": ["1000004"],
    "names": [],
}

# Run the Actor and wait for it to finish
run = client.actor("helenium/us-contractor-license-verification").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 '{
  "licenseNumbers": [
    "1000004"
  ],
  "names": []
}' |
apify call helenium/us-contractor-license-verification --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=helenium/us-contractor-license-verification",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/5UajXFdaG0lSGO0Tq/builds/qGYCssjyrwDUEh2YI/openapi.json