Contractor License Verification Scraper

Pricing

Rating

Developer

Actor stats

Categories

Share

Verify contractor and trade license records from official public state lookup systems and turn repetitive compliance checks into a structured Apify dataset.

This actor is built for vendor onboarding, marketplace trust and safety, property-management screening, lead enrichment, insurance review, and any workflow where teams need evidence from public contractor license databases instead of manual copy-paste checks.

Overview

Contractor License Verification Scraper searches supported public government license lookup pages and normalizes the results into one dataset. The first production sources are Texas TDLR and California CSLB public search pages.

Use it when you need to confirm license status, capture license numbers, monitor expiration dates, enrich contractor leads, or create an audit trail for vendor due diligence.

What this actor does

• Searches contractor or licensee names in public state databases.
• Verifies known license numbers when the source supports direct lookup.
• Captures status, license type, expiration date, source agency, and public contact/location fields.
• Keeps the official source URL with every record so reviewers can open the original page.
• Adds scrapedAt timestamps for auditability.
• Saves all records in a typed dataset ready for CSV, Excel, JSON, Google Sheets, or API export.

Supported official license sources

The actor starts with high-value public contractor license sources that are reachable without login:

• Texas Department of Licensing and Regulation (TDLR)
• California Contractors State License Board (CSLB)

Texas TDLR is the primary high-volume source. California CSLB is supported through its public search flow and can return public license-number records for matching names.

Who is it for

This scraper is useful for:

• Compliance teams checking vendor license status.
• Marketplaces onboarding contractors, technicians, installers, inspectors, and repair professionals.
• Insurance and risk teams reviewing contractor eligibility.
• Property managers validating service vendors.
• Lead-generation teams enriching contractor lists with license evidence.
• Developers building repeatable contractor-license verification pipelines.

Typical workflows

1. Search by contractor name prefix to collect possible public records.
2. Verify exact license numbers from your CRM, spreadsheet, or applicant form.
3. Export records and join them back to an internal vendor table.
4. Flag expired, inactive, missing, or mismatched records for manual review.
5. Re-run checks periodically to refresh public status and expiration signals.

Input options

The actor accepts a small set of practical inputs:

• states — select TX, CA, or ALL supported states.
• contractorNames — business, DBA, or person names to search.
• licenseNumbers — known license numbers to verify.
• city — optional city filter when supported by the source.
• zip — optional ZIP filter when supported by the source.
• texasLicenseType — TDLR license type code, with -1 meaning all license types.
• includeDetails — fetch detail pages for richer records when available.
• maxResults — total number of records to save across all queries.

Recommended input strategy

For broad discovery, start with shorter name prefixes and low maxResults values. Texas TDLR treats name searches as prefix-oriented, so A or ABC can return many records while an exact DBA with punctuation may return fewer matches.

For due diligence, prefer exact license numbers whenever your source system already has them. Exact numbers reduce ambiguity and make review queues easier to reconcile.

Example input: Texas name search

{
"states":["TX"],
"contractorNames":["A"],
"maxResults":20,
"includeDetails":false,
"texasLicenseType":"-1"
}

Example input: exact license verification

{
"states":["TX"],
"licenseNumbers":["18554"],
"maxResults":10,
"includeDetails":true,
"texasLicenseType":"-1"
}

Example input: multi-state sample

{
"states":["ALL"],
"contractorNames":["ABC"],
"maxResults":50,
"includeDetails":false,
"texasLicenseType":"-1"
}

Output dataset

Each saved item is one public contractor license record or license-search result. Fields are normalized so you can compare results across supported state agencies.

Core fields include:

• state
• sourceAgency
• queryType
• query
• licenseNumber
• licenseType
• businessName
• dbaName
• status
• issueDate
• expirationDate
• classifications
• address
• city
• stateCode
• zip
• county
• phone
• bondInfo
• insuranceInfo
• publicNotes
• sourceUrl
• scrapedAt

Example output item

{
"state":"TX",
"sourceAgency":"Texas Department of Licensing and Regulation",
"queryType":"name",
"query":"A",
"licenseNumber":"18554",
"licenseType":"Air Conditioning and Refrigeration Contractor",
"businessName":"Example Mechanical Services",
"dbaName":"Example Mechanical",
"status":"Active",
"issueDate":"2020-01-15",
"expirationDate":"2026-01-15",
"classifications":["Air Conditioning"],
"address":"Public address when provided",
"city":"Austin",
"stateCode":"TX",
"zip":"78701",
"county":null,
"phone":null,
"bondInfo":null,
"insuranceInfo":null,
"publicNotes":null,
"sourceUrl":"https://www.tdlr.texas.gov/LicenseSearch/",
"scrapedAt":"2026-06-25T04:40:00.000Z"
}

Data freshness

The actor reads the live public source pages during each run. The scrapedAt timestamp records when the lookup was performed. Government licensing databases can update independently, so treat each run as a point-in-time public-record snapshot.

Detail pages

Set includeDetails to true when you need richer status, issue date, DBA, notes, bond, insurance, or classification fields. Detail-page mode can be slower because the actor opens additional public pages for each matching record.

Use includeDetails: false for fast discovery runs and includeDetails: true for smaller review queues where richer evidence matters.

Pricing

This actor uses pay-per-event pricing:

• Run start: $0.005 per run.
• License record saved: tiered per item.

Per-item prices by Apify user tier:

You are charged for records that are successfully saved to the dataset. Keep maxResults low while testing a new workflow, then increase it once your inputs are returning the records you expect.

Cost-control tips

• Test with one state and a low maxResults value first.
• Use exact license numbers when available.
• Keep includeDetails off for broad discovery.
• Use shorter name prefixes only when you intentionally want a wider candidate pool.
• Export and deduplicate your own input list before large recurring checks.

API usage

Start runs with automation-lab/contractor-license-verification-scraper and pass the same JSON input you use in the Apify Console.

Node.js example

import{ ApifyClient }from'apify-client';
const client =newApifyClient({token: process.env.APIFY_TOKEN});
const run =await client.actor('automation-lab/contractor-license-verification-scraper').call({
states:['TX'],
contractorNames:['A'],
maxResults:20,
includeDetails:false,
texasLicenseType:'-1'
});
const{ items }=await client.dataset(run.defaultDatasetId).listItems();
console.log(items);

Python example

from apify_client import ApifyClient
import os
client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/contractor-license-verification-scraper').call(run_input={
'states':['TX'],
'contractorNames':['A'],
'maxResults':20,
'includeDetails':False,
'texasLicenseType':'-1',
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)

cURL example

curl-X POST "https://api.apify.com/v2/acts/automation-lab~contractor-license-verification-scraper/runs?token=$APIFY_TOKEN"\
-H'Content-Type: application/json'\
-d'{"states":["TX"],"contractorNames":["A"],"maxResults":20,"includeDetails":false,"texasLicenseType":"-1"}'

MCP usage

Use the actor through Apify MCP Server when you want Claude or another MCP client to launch contractor-license checks from a prompt.

Connection URL:

https://mcp.apify.com/?tools=automation-lab/contractor-license-verification-scraper

Claude Code MCP setup

$claude mcp add apify https://mcp.apify.com/?tools=automation-lab/contractor-license-verification-scraper

MCP JSON configuration

{
"mcpServers":{
"apify":{
"url":"https://mcp.apify.com/?tools=automation-lab/contractor-license-verification-scraper"
}
}
}

MCP prompt examples

Example prompts you can ask after connecting the Apify MCP server:

• "Verify these Texas contractor license numbers and summarize active, expired, and missing records."
• "Search the contractor license scraper for names starting with ABC in Texas and return records with expiration dates."
• "Run a small due-diligence sample for this vendor list before onboarding contractors."

Legality

This actor extracts public records from government lookup pages. Use it for lawful business purposes and only process data that you are authorized to collect, store, and review.

The actor does not replace legal advice, professional licensing review, or direct confirmation with a government agency. Treat results as public-record evidence that may require human review before decisions affecting vendors, applicants, or customers.

Limitations

• Coverage is limited to supported state sources.
• Public websites can change field labels, search behavior, or rate limits.
• Some optional fields are blank when the source does not publish them.
• Name searches can return ambiguous matches.
• California and Texas expose different public fields, so not every column is populated for every state.
• Large detail-page runs are slower than summary searches.

Troubleshooting no results

If a search returns fewer records than expected:

• Try a shorter contractor-name prefix.
• Remove city or ZIP filters.
• Search by exact license number.
• Confirm the state source supports the license type you selected.
• Increase maxResults only after a small run confirms the query is broad enough.

Troubleshooting slow runs

If a run is slower than expected:

• Turn off includeDetails for initial discovery.
• Lower maxResults.
• Split very large input lists into smaller batches.
• Avoid broad one-letter searches when you only need exact license checks.

Quality notes

The actor keeps one normalized dataset so downstream systems can treat Texas and California results consistently. When a state publishes richer data, fields such as bondInfo, insuranceInfo, publicNotes, or classifications are populated where available.

Related actors

These Automation Labs actors can support adjacent contractor lead-enrichment and vendor-review workflows:

• Google Maps Lead Finder — discover contractor businesses and service providers.
• Website Contact Finder — collect public contact pages and emails from company domains.
• Business Email Finder — enrich business records with public email candidates.
• Company Domain Finder — match company names to likely domains.

FAQ: Is this an official government service?

No. This is an independent Apify actor that reads public lookup pages. Always use the official source URL in the dataset when you need to review the original record.

FAQ: Can it verify every contractor in the United States?

Not yet. The current build supports selected public state databases, starting with Texas TDLR and California CSLB. More states can be added when their public lookup systems are technically reachable and commercially reliable.

FAQ: Why are some fields empty?

State agencies publish different fields. A blank optional field usually means the source page did not expose that value for the record or search mode used.

FAQ: Should I use name search or license-number search?

Use license-number search for precise verification. Use name search for discovery, lead enrichment, or when your source list does not include license numbers.

FAQ: How should I review ambiguous matches?

Export the dataset and compare businessName, dbaName, city, zip, licenseType, and sourceUrl against your internal vendor record. Ambiguous matches should be reviewed manually.

Changelog

• 0.1.0 — Initial private build with Texas TDLR and California CSLB public lookup support.