# California Contractor License Lookup & Verify (CSLB) (`scrapebench/california-contractor-license-lookup`) Actor

Verify any California contractor by license number or name — status, classifications, bond & workers' comp — from the official CSLB registry.

- **URL**: https://apify.com/scrapebench/california-contractor-license-lookup.md
- **Developed by:** [ScrapeBench](https://apify.com/scrapebench) (community)
- **Categories:** Lead generation
- **Stats:** 45 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$0.004 / dataset-item

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

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

## California Contractor License Lookup & Verify (CSLB)

### Pain points

- Verifying a contractor on the CSLB site is one manual lookup at a time.
- A plain name search won't surface every license a person is tied to across different businesses.
- Registry pages aren't structured for compliance workflows or CRM enrichment.

### What we solve

- Verify any California contractor by license number, business name, or person — one search.
- Name search matches business AND owner/personnel names, so you find every license a person is on (deduped).
- Returns status, classifications, bond, and workers' comp from the official CSLB registry.
- Enrich a name or license number into a full record; pay per match, empty searches free.

### Summary

Look up and verify any California contractor from a single search — type a CSLB license number, a business name, or a person's name and get back the licensed business, status, trade classifications, contractor's bond, and workers' comp, straight from the official CSLB registry. A name search matches both business names AND personnel/owner names (so you find every license a person is listed on), unioned and deduped. Built for fast verification, compliance checks, and enriching a name or license number into a full record.

### Who it's for

- GCs and hiring managers vetting California subcontractors
- Insurance underwriters and lenders running KYC on contractors
- Compliance teams and marketplaces verifying CSLB licenses
- Recruiters and investigators tracing an owner's licenses

### How to use

Set the input, run the actor, and collect results from the run's dataset (export to JSON/CSV/Excel, or pull via the Apify API). Example input:

```json
{
  "query": "Ransome Company",
  "includeDetails": true,
  "maxResults": 25
}
```

See **Inputs** below for every available field.

### What you get

One row per record:

| Field | Description |
|---|---|
| `license_number` | CSLB license number |
| `business_name` | Licensed business name |
| `name_type` | How the name is held (e.g. DBA) — from name searches |
| `matched_by` | Which search surfaced this match: 'license\_number' or 'business\_name' |
| `status` | License status (e.g. 'Active', 'Expired', or the detail status sentence) |
| `city` | Business city |
| `has_detail` | True when the full license detail was fetched and merged |
| `business_type` | Entity type — Sole Owner, Corporation, LLC, Partnership… (detail) |
| `address` | Business street address (detail) |
| `state` | State (detail) |
| `zip_code` | ZIP code (detail) |
| `phone` | Business phone (detail) |
| `issue_date` | Original license issue date (detail) |
| `expiration_date` | License expiration date (detail) |
| `classifications` | Classification codes held, e.g. \["A","C10"] (detail) |
| `surety_company` | Contractor's bond surety company (detail) |
| `bond_number` | Contractor's bond number (detail) |
| `bond_amount` | Contractor's bond amount (detail) |
| `workers_comp_type` | Workers' comp coverage type — Insurance / Exempt (detail) |
| `workers_comp_company` | Workers' comp insurance carrier (detail) |
| `source_url` | Link to the official CSLB license detail page |

Sample:

```json
{
  "license_number": "22726",
  "business_name": "RANSOME COMPANY",
  "name_type": "DBA",
  "matched_by": "business_name",
  "status": "This license is current and active.",
  "city": "SAN LEANDRO",
  "has_detail": true,
  "business_type": "Corporation",
  "address": "1933 WILLIAMS STREET",
  "state": "CA",
  "zip_code": "94577",
  "phone": "(510) 686-9900",
  "issue_date": "07/01/1932",
  "expiration_date": "10/31/2027",
  "classifications": [
    "A",
    "C10"
  ],
  "surety_company": "HARCO NATIONAL INSURANCE COMPANY",
  "bond_number": "354811",
  "bond_amount": "25,000",
  "workers_comp_type": "Insurance",
  "workers_comp_company": "TRAVELERS PROPERTY CASUALTY COMPANY OF AMERICA",
  "source_url": "https://www.cslb.ca.gov/onlineservices/checklicenseII/LicenseDetail.aspx?LicNum=22726"
}
```

### Inputs

| Field | Required | Type | Default | Description |
|---|---|---|---|---|
| `query` | no | string | `"22726"` | A CSLB license number (digits only, e.g. '22726') OR a name. Numbers are looked up directly. A name is searched against BOTH the business-name index AND the personnel/owner-name index, and the results are unioned (deduped by license #). For a person, enter 'First Last' (e.g. 'Phil Ransome') or 'Last, First' with a comma. |
| `queries` | no | array | `["22726", "1000001"]` | Look up many licenses in ONE run instead of starting a run per lookup. Accepts the same values as 'Search query' — license numbers, business names, or person names, mixed freely. Combined with 'Search query' if you fill both, and duplicates are removed. Billing is unchanged: you are charged per matched record returned, not per query submitted. |
| `includeDetails` | no | boolean | `true` | When on (default), each match is enriched with its full license record — entity type, issue/expiry dates, classifications, contractor's bond, and workers' comp. Turn off for a faster, lighter result list (license #, name, city, status only). |
| `maxResults` | no | integer | `50` | Cap on the number of matches returned (and enriched) PER QUERY, not per run — so a batch of 20 names cannot silently return only the first 50 rows overall and read as 'the rest don't exist'. Defaults to 50. A license-number query returns exactly one record regardless. |
| `proxyConfiguration` | no | object | `{"useApifyProxy": false}` | Optional. CSLB is usually reachable directly; enable a proxy (e.g. residential) only if a run is blocked or served a CAPTCHA challenge. |

### Pricing (Pay Per Event)

You pay per result (`dataset-item`) — **no charge for empty runs**. Example: **100 verified license records** at *$0.004/result* ≈ **$0.40**.

Illustrative — the final per-result price is set at publish time. Apify platform usage (compute) is billed separately per your plan.

### Use cases

- License verification — confirm a California contractor's status, classifications, bond, and workers' comp before hiring or onboarding.
- Owner / personnel search — recruiters or investigators find every license a person holds, even under different business names.
- Record enrichment — turn a license number or name into a full structured record for a CRM, marketplace, or vetting workflow.
- Lender / insurer due diligence — pull authoritative CSLB data on demand.

### Why this actor

- Straight from the official CSLB registry — authoritative, not a stale third-party copy.
- Name search matches business AND owner/personnel (RMO/RME) names and dedupes — finds every license a person is on.
- Pay per match; searches with no results are free.

### Limitations & updates

Covers California's CSLB public registry only (public record under Business & Professions Code §7000 et seq.). Results reflect the live registry and change as it updates. A name search unions the business-name and personnel/owner-name indexes; personnel matches return the licenses a person is currently associated with. Runs are bounded (default 50 results) — refine a broad name to narrow it.

### FAQ

**Where does the data come from?**

The official California CSLB 'Check a License' registry — public, authoritative license data.

**Can I find every license a person holds?**

Yes — a name search matches both business names and owner/personnel records (RMO/RME) and dedupes, so you see every license that person is listed on.

**What fields do I get?**

License number, business name, status, classifications, issue/expiration, plus contractor's bond and workers' comp where CSLB publishes them.

**How am I charged?**

Pay-per-result — per license match returned. No charge for searches with no results.

**Is this personal data?**

It's public professional-license data (business and license-holder records as CSLB publishes them); we add no personal/PII enrichment.

**How current is it?**

It reflects the live CSLB record at lookup time.

### Which actor to choose

Part of the contractor-license verification suite — pick the one that fits your goal:

- **Florida Contractor License Lookup & Verify (DBPR)** — You're verifying a Florida contractor or tradesperson — type, status, expiration, county (DBPR).
- **Louisiana Contractor License Lookup** — You want the full Louisiana roster — 50,000+ commercial, residential & specialty licenses as data (LSLBC).
- **Multi-State Contractor & Trade License Lookup** — You don't know the state, or want the same contractor checked across WA, OR, TX & CT in one run.
- **Nevada Contractor License Lookup & Verify (NSCB)** — You need a Nevada contractor's status, trade classifications, bond & principals (NSCB).
- **New Mexico Contractor License Lookup & Verify (NM CID)** — You're verifying a New Mexico contractor — license #, status, city/ZIP, expiry (NM CID).
- **North Carolina Contractor License Lookup & Verify (NCLBGC)** — You're verifying a North Carolina general contractor — classification, status, expiration (NCLBGC).
- **Oregon Contractor License Lookup & Verify (CCB)** — You're verifying an Oregon contractor — status, bond, insurance & RMI (CCB).
- **South Carolina Contractor License Lookup & Verify (SC LLR)** — You're searching or verifying South Carolina contractors — by name, license, city, or classification (SC LLR).
- **Tennessee Contractor License Lookup & Verify (TN DOCI)** — You're verifying a Tennessee contractor or tradesperson — type, status, city & county (TN DOCI).
- **Texas Contractor & Trade License Lookup (TDLR)** — You're verifying a Texas electrician, HVAC or trade license — type, expiration, county & owner (TDLR).
- **Virginia Contractor License Lookup (DPOR Bulk)** — You want the full Virginia roster — 50,000+ Class A/B/C and trade licenses as bulk data (DPOR).
- **Washington Contractor License Lookup & Verify (L\&I)** — You're verifying a Washington contractor — type, status, expiration, principal (L\&I).
- **Alabama Contractor License Lookup & Verify (LBGC)** — You're verifying an Alabama general contractor — classification, city, phone, expiration (LBGC).
- **Arkansas Contractor License Lookup & Verify (ACLB)** — You're verifying an Arkansas contractor — validity, type, expiration, city & county (ACLB).
- **Michigan Contractor License Lookup & Verify (LARA)** — You're verifying a Michigan builder or trade contractor — type, status, expiration (LARA).
- **Minnesota Contractor License Lookup & Verify (DLI)** — You're verifying a Minnesota residential contractor — subtype, status, expiration, enforcement flags (DLI).
- **Massachusetts Construction License Lookup & Verify (CSL)** — You're verifying a Massachusetts Construction Supervisor License — type, status, expiration (CSL).

### Guides & use cases

Written up on **[scrapebench.dev](https://scrapebench.dev)** — the bench that runs and verifies this actor against the live source every night:

- **How-to:** [How to run California Contractor License Lookup & Verify (CSLB)](https://scrapebench.dev/guides/how-to-california-contractor-license-lookup/)
- **Use case:** [Check a California Contractor's Bond & Workers' Comp](https://scrapebench.dev/use-cases/check-california-contractor-bond-workers-comp/)
- **Use case:** [Find Every CSLB License an Owner Holds by Name](https://scrapebench.dev/use-cases/find-cslb-licenses-by-owner-name/)
- **Use case:** [Verify a California Contractor by License Number](https://scrapebench.dev/use-cases/verify-california-contractor-by-license-number/)

More actors, coverage and nightly verification results: **[scrapebench.dev](https://scrapebench.dev)**

### Works with n8n

Ready-made n8n templates that call this actor:

- **[Monitor contractor licences and alert 30 days before expiry](https://n8n.io/workflows/17393-monitor-contractor-licences-weekly-and-send-slack-digests-with-apify/)** — free template. [Step-by-step guide](https://scrapebench.dev/guides/workflow-license-expiration-monitor/)
- **[Verify contractor licenses in your lead list](https://n8n.io/workflows/17355/)** — free template. [Step-by-step guide](https://scrapebench.dev/guides/workflow-license-verify-lead-list/)
- **[Verify a subcontractor's licence when they submit your onboarding form](https://n8n.io/workflows/17598-verify-subcontractor-licenses-from-form-submissions-with-apify-and-slack/)** — free template. [Step-by-step guide](https://scrapebench.dev/guides/workflow-subcontractor-onboarding-gate/)

# Actor input Schema

## `query` (type: `string`):

A CSLB license number (digits only, e.g. '22726') OR a name. Numbers are looked up directly. A name is searched against BOTH the business-name index AND the personnel/owner-name index, and the results are unioned (deduped by license #). For a person, enter 'First Last' (e.g. 'Phil Ransome') or 'Last, First' with a comma.

## `queries` (type: `array`):

Look up many licenses in ONE run instead of starting a run per lookup. Accepts the same values as 'Search query' — license numbers, business names, or person names, mixed freely. Combined with 'Search query' if you fill both, and duplicates are removed. Billing is unchanged: you are charged per matched record returned, not per query submitted.

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

When on (default), each match is enriched with its full license record — entity type, issue/expiry dates, classifications, contractor's bond, and workers' comp. Turn off for a faster, lighter result list (license #, name, city, status only).

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

Cap on the number of matches returned (and enriched) PER QUERY, not per run — so a batch of 20 names cannot silently return only the first 50 rows overall and read as 'the rest don't exist'. Defaults to 50. A license-number query returns exactly one record regardless.

## `proxyConfiguration` (type: `object`):

Optional. CSLB is usually reachable directly; enable a proxy (e.g. residential) only if a run is blocked or served a CAPTCHA challenge.

## Actor input object example

```json
{
  "query": "22726",
  "queries": [
    "22726",
    "1000001"
  ],
  "includeDetails": true,
  "maxResults": 50,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `matches` (type: `string`):

The matched licenses — status, classifications, bond and workers' comp when enriched.

# 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 = {
    "query": "22726",
    "queries": [
        "22726",
        "1000001"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapebench/california-contractor-license-lookup").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 = {
    "query": "22726",
    "queries": [
        "22726",
        "1000001",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("scrapebench/california-contractor-license-lookup").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 '{
  "query": "22726",
  "queries": [
    "22726",
    "1000001"
  ]
}' |
apify call scrapebench/california-contractor-license-lookup --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

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