CSLB Contractor License Scraper: Up to 1,000 Free Results a Month

Each license record carries 26 fields, including the full business address, entity type, trade classifications, and current insurance status. This collector retrieves live data from the California Contractors State License Board for licenses and Home Improvement Salesperson registrations. A thousand results cost $5.00 on the free plan. It returns current status, bond numbers, and workers' compensation policy information directly from the CSLB database. This is designed for compliance teams vetting subcontractors and sales professionals building trade-specific lead lists; it is not for those requiring historical bond or insurance records beyond the current filing.

Try it before you read further. Apify's free plan includes $5.00 of usage every month with no credit card, enough for up to 1,000 results at $0.005 each before platform usage. Open CSLB Contractor License Scraper on Apify and run the prefilled example.

How reliable is CSLB Contractor License Scraper in production?

Across the last 30 days of public runs on the Apify platform, CSLB Contractor License Scraper recorded 80 runs with the following outcomes.

No run failed or timed out in the last 30 days. Keep a retry and an alert on scheduled runs all the same: a clean month is a record, not a guarantee.

What does it cost to run CSLB Contractor License Scraper?

Each result costs $0.005 on Apify's free plan, which is $5.00 per 1,000 results. Starting a run is charged separately at $0.005 per GB of Actor memory. Apify also bills the platform usage each run consumes, at the rates of your Apify plan, on top of these charges.

Worked example: collecting 10,000 results costs $50.00 in result charges before run-start fees and platform usage. No run failed or timed out in the last 30 days, so the list price is a fair budget; keep a retry in place all the same.

The result charge is driven by the number of licenses found, making the maxItems control your primary tool for managing the bill. Using the licenseNumbers array is the most efficient way to query specific entities without paying for unintended alphabetical matches found in name searches.

How do you run CSLB Contractor License Scraper from the API?

The schema marks 1 of its 11 controls as required: mode. Every value in the payload below comes from the published schema's own prefills, which means you can paste it, swap the token, and get a real result.

Call the synchronous endpoint to start a run and receive dataset items in one request:

curl -X POST "https://api.apify.com/v2/acts/crawlerbros~cslb-contractor-license-scraper/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"mode":"byLicenseNumber","businessName":"Swinerton","personnelLastName":"Smith","personnelFirstName":"John","hisNumber":"100000"}'

The same run from Python, using the official client:

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

run_input = {
  "mode": "byLicenseNumber",
  "businessName": "Swinerton",
  "personnelLastName": "Smith",
  "personnelFirstName": "John",
  "hisNumber": "100000"
}

run = client.actor("crawlerbros~cslb-contractor-license-scraper").call(run_input=run_input)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

And from Node.js:

import { ApifyClient } from 'apify-client'

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' })

const input = {
  "mode": "byLicenseNumber",
  "businessName": "Swinerton",
  "personnelLastName": "Smith",
  "personnelFirstName": "John",
  "hisNumber": "100000"
}

const run = await client.actor('crawlerbros~cslb-contractor-license-scraper').call(input)
const { items } = await client.dataset(run.defaultDatasetId).listItems()
console.log(items)

That endpoint blocks until the run completes. Fine while you are testing a handful of records, risky once a run takes minutes: a dropped connection loses the response even though the run itself finished. Switch to an asynchronous start with polling or a webhook before you schedule anything.

Which CSLB Contractor License Scraper inputs matter, and which can you skip?

The mode control is the most important setting, as it determines which search interface the Actor uses and which secondary inputs like licenseNumbers or businessName it expects. Most users can leave the proxyConfiguration disabled as the CSLB site has no CAPTCHA and is accessible without them.

• mode (string): Which CSLB search to run. Default: "byLicenseNumber".
• licenseNumbers (array): CSLB contractor license numbers to look up (1-8 digits each; letters/punctuation are stripped automatically). Default: ["1100000"].
• businessName (string): Business name to search for. CSLB matches from this name alphabetically forward (type fewer letters if you don't find the license, e.g. Swinerton instead of Swinerton Builders Inc).
• personnelLastName (string): Last name of a qualifying individual, owner, or officer associated with a license.
• personnelFirstName (string): Optional first name to narrow a personnel name search.
• hisNumber (string): Home Improvement Salesperson (HIS) registration number (1-8 digits; the site's "SP" suffix is added automatically).
• statusFilter (string): Only emit records whose current status matches. Records with no detectable status always pass through. Default: "any".
• classificationFilter (string): Only emit license records that carry this CSLB classification. Records with no classification data always pass through. Ignored in mode=byHISNumber. Default: "any".
• includePersonnel (boolean): Attach the owners/officers/RMO/RME associated with each license (name, title, association date, classification). Adds a few extra requests per license. Default: true.
• maxItems (integer): Hard cap on emitted records. Default: 20.
• proxyConfiguration (object): Optional. CSLB's search form has no CAPTCHA and works reliably without a proxy; this is offered for extra resilience only. Default: {"useApifyProxy":false}.

Fixed-choice controls: mode accepts byLicenseNumber (Search by license number), byBusinessName (Search by business name), byPersonnelName (Search by personnel name), byHISNumber (Search by HIS registration number); statusFilter accepts any (Any status), active, expired, inactive, revoked, suspended, cancelled (Cancelled / Surrendered), other (Other / Unknown); classificationFilter accepts 47 values (default any), including any (Any classification), A (General Engineering Contractor), B (General Building Contractor), C (Specialty Contractor).

What does CSLB Contractor License Scraper return?

The returned records are ideal for verifying current legal standing and insurance coverage but conspicuously do not contain a historical log of past bond or workers' compensation filings. The output includes structured classification codes which allow for easy programmatic filtering of different trade specialties.

Output per license (mode = byLicenseNumber / byBusinessName / byPersonnelName)

• licenseNumber -- CSLB license number
• businessName, dba -- registered name and DBA (if any)
• addressLine1, addressLine2, city, state, zip, phone
• entityType -- Sole Ownership / Partnership / Corporation / LLC / Joint Venture
• issueDate, expireDate
• licenseStatus -- CSLB's own status sentence
• licenseStatusCode -- normalized: active / expired / inactive / revoked / suspended / cancelled / other
• classifications[] -- { code, title }, e.g. {"code": "C-10", "title": "Electrical Contractor"}
• bond -- { bondStatus, suretyCompany, bondNumber, bondAmount, effectiveDate, cancellationDate } -- bondStatus is CSLB's own plain-language sentence (e.g. "filed a Contractor's Bond with X", "No bond information on file for this license"); the rest are only present when CSLB shows structured bond details
• workersComp -- { workersCompStatus, insuranceCompany, policyNumber, effectiveDate, cancellationDate } -- workersCompStatus is CSLB's own sentence (e.g. an exemption reason); the rest are only present when CSLB shows a structured policy
• matchedBusinessName, matchedNameType -- which business-name search result this record came from (mode=byBusinessName only)
• personnelName, personnelNameType, personnelAssociationStatus -- which person and association this record came from (mode=byPersonnelName only)
• personnel[] -- { name, title, associationDate, classification } for every owner/officer/RMO/RME associated with the license (e.g. SOLE OWNER, CFO, RMO); included when includePersonnel is on (default)
• sourceUrl -- the license's canonical cslb.ca.gov page
• recordType: "license", scrapedAt

Output per HIS registration (mode = byHISNumber)

• hisNumber, name, addressLine1, city, state, zip, phone
• issueDate, expirationDate
• registrationStatus, registrationStatusCode
• currentEmployers[] / formerEmployers[] -- { licenseNumber, businessName, phone, effectiveDates }
• sourceUrl, recordType: "hisRegistration", scrapedAt

These are the documented fields. Optional ones can be empty on a given record, so measure how often each field your deliverable depends on is populated across a real sample before automating the handoff.

How do you build the workflow end to end?

Open CSLB Contractor License Scraper and work through these in order. Each step ends with something to check, so a bad configuration surfaces on a small run rather than a scheduled one.

1. Select the appropriate search mode from the mode property, choosing byLicenseNumber for specific IDs or byBusinessName for discovery.
2. Input a list of California license numbers into the licenseNumbers array if searching for known entities.
3. Set statusFilter to active and classificationFilter to B if your objective is specifically general building contractors with current licenses.
4. Enable includePersonnel to ensure the resulting dataset contains the personnel array with names and titles of owners and officers.
5. Adjust maxItems to a low value like 5 for an initial run to verify the licenseStatus and classifications fields meet your needs.
6. Check the sourceUrl in the final dataset to confirm the record corresponds to the live page on the CSLB website.
7. Verify that bondStatus and workersCompStatus contain the expected plain-language descriptions before scaling the run.

How do you apply it? Three worked playbooks

These are CSLB Contractor License Scraper's own documented use cases, each worked through as an operating pattern rather than a description.

Use case 1: Vendor / subcontractor vetting

Outcome: Vendor / subcontractor vetting -- verify a contractor's license is active before signing a contract

Configure: Set mode to byLicenseNumber and populate licenseNumbers with the specific IDs from the vendor's application.

Working method: Execute a targeted search for the provided license numbers, then examine the licenseStatusCode and expireDate fields for each result to ensure they are currently active and not expired.

Deliverable: A verification report containing license status, expiration dates, and current bonding information for the specific contractors.

Stop condition: The licenseStatusCode field returns expired, suspended, or revoked for any critical vendor.

Use case 2: Lead generation

Outcome: Lead generation -- pull active licensed contractors by trade classification

Configure: Set mode to byBusinessName, businessName to a common prefix, statusFilter to active, and classificationFilter to C-10 for electrical contractors.

Working method: Run an alphabetical browse search for a specific trade, collecting business names and phone numbers up to the limit defined in maxItems.

Deliverable: A list of active contractors within a specific trade classification including their business names, addresses, and phone numbers.

Stop condition: The dataset reaches the maxItems limit or the alphabetical search begins returning irrelevant names.

Use case 3: Compliance monitoring

Outcome: Compliance monitoring -- periodically re-check a portfolio of license numbers for status changes

Configure: Set mode to byLicenseNumber and provide the full portfolio of license numbers in the licenseNumbers array.

Working method: Schedule the run to pull the latest status and workersComp details, comparing the new licenseStatusCode against your internal baseline records.

Deliverable: A refreshed dataset of license statuses, bond numbers, and workers' compensation policy details for an existing portfolio.

Stop condition: A previously active license returns a licenseStatusCode of suspended or cancelled.

What breaks, and how do you design around it?

• Over the last 30 days, 0.0% of public runs failed and 0.0% timed out. Build retries and alerting around those rates rather than assuming every run completes.

When a business name search yields fewer results than expected, reduce the length of your businessName input to utilize CSLB's alphabetical browse more effectively. If you need HIS data and only have a name, you must first obtain the registration number elsewhere as this Actor only supports HIS lookups by number.

When should you not use CSLB Contractor License Scraper?

Do not use this Actor if you require historical disciplinary records or a complete history of every bond ever filed by a contractor, as the output only captures the current status and active filings shown on the license detail page. If your project requires vetting attorneys instead of contractors, CA State Bar Attorney Search Scraper is the better tool. For firms monitoring construction professionals across state lines, you should use the Washington L&I Contractor & Tradesperson License Scraper for your Pacific Northwest operations instead of trying to adapt this California-specific tool.

What should you check before trusting the output?

• Verify that licenseStatusCode contains active when statusFilter is set to active to ensure the board's filter logic was applied.
• Check that the classifications array is not empty for records where classificationFilter was used, unless the license carries no trade data.
• Stop the run if the personnel array is missing from all records when includePersonnel is set to true.
• Confirm that bondAmount is present in the bond object for active licenses, noting that exempt licenses will only show bondStatus.
• Validate that the hisNumber field is present and correctly formatted when using mode set to byHISNumber.

None of this proves a record is correct. It gives a scheduled CSLB Contractor License Scraper run defined points where it should stop instead of quietly passing bad data downstream.

Frequently asked questions

What does one thousand results cost?

On Apify's free plan, 1,000 results cost $5.00. This calculation is based on the free-plan price of $0.005 per result. Note that each run also incurs a run-start fee and platform usage charges according to your Apify plan. Apify's free plan includes $5.00 of monthly usage, which covers up to 1,000 results of this Actor before factoring in these additional usage costs.

Has this Actor been reliable recently?

The telemetry for this Actor shows high reliability. In the last 30 days, 80 runs were started and 80 succeeded, representing a 100.0% success rate. No runs failed, timed out, or were aborted by users. This indicates that the Actor is currently well-aligned with the structure of the CSLB website.

Does the output include email addresses for contractors?

No. The CSLB public license check tool does not publish email addresses, and consequently, this Actor does not return them. The records include business names, physical addresses, and phone numbers as they appear on the official public registry provided by the state board.

How do I search for a specific trade like Plumbing?

You should use the classificationFilter control. By selecting a specific option, such as C-36 for Plumbing, the Actor will only emit license records that carry that specific CSLB trade classification. This is particularly useful when combined with a businessName search to filter results to a specific industry specialty.

Why are some bond or insurance fields missing from the JSON?

The Actor omits empty fields. If a contractor is exempt from workers' compensation or has no bond information on file, the structured fields like policyNumber or suretyCompany will be absent. In these cases, the workersCompStatus or bondStatus fields will contain the board's own plain-language explanation for the missing details.

Where to go next

When you are ready to run it, open CSLB Contractor License Scraper on Apify; the free plan covers up to 1,000 results a month.

Other Actors we maintain for related data:

• Washington L&I Contractor & Tradesperson License Scraper: Search Washington L&I contractor, electrician, plumber, and asbestos-worker licenses by name, license number, UBI, or workers' comp account ID.
• CA DRE Real Estate License Lookup Scraper: Look up California real estate salesperson, broker, and corporation licenses from the CA Department of Real Estate.
• NYC Business License Scraper: Search New York City's official business license registry - find active and historical licensed businesses by name, category, borough, license status, or phone number.
• TDLR Texas License Search Scraper: Search Texas Dept. of Licensing and Regulation (TDLR) licenses across 80+ regulated trades: cosmetology, barbering, electricians, HVAC, and more.
• Ohio eLicense Scraper: Look up Ohio professional and occupational licenses issued by the Ohio Department of Commerce's Division of Real Estate & Professional Licensing.
• Chicago Business Licenses Scraper: Scrape Chicago's open business license database - 100,000+ active licenses with business name, address, license type, activity, expiration, and GPS coordinates.
• Texas TREC License Search Scraper: Search Texas Real Estate Commission (TREC) license-holder records: real estate brokers, sales agents, inspectors, easement/right-of-way agents, appraisers, and appraisal management companies.
• CA State Bar Attorney Search Scraper: Search the California State Bar's public attorney licensee directory by name, bar number, or advanced filters.

Related guides:

• Florida DBPR Professional & Contractor License Search Scraper Guide
• CA State Bar Attorney Search Scraper: 21 Data Fields per Record (2026)
• Iowa SOS Business Entity Search Scraper: $5.00 per 1,000 results
• Michigan LARA License Lookup Scraper: 3 Practical Use Cases

Resources

• Actor documentation, input schema, and pricing: verified against the published Actor on 2026-09-29.

• Actor last updated by its maintainers on 2026-07-04.

• Run outcome figures cover the 30 day public window ending 2026-09-29.

• CSLB Contractor License Scraper on Apify