# Virginia Contractor License Lookup (DPOR Bulk) (`fried_calamaries/virginia-contractor-license-lookup`) Actor

Download and filter 50,000+ Virginia DPOR contractor licenses — Class A, B & C plus tradespeople — direct from the official regulant lists. No CAPTCHA, no auth.

- **URL**: https://apify.com/fried\_calamaries/virginia-contractor-license-lookup.md
- **Developed by:** [ByteMe](https://apify.com/fried_calamaries) (community)
- **Categories:** Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$0.004 / license records

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 a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

## Virginia Contractor License Lookup (DPOR Bulk)

### Pain points

- Verifying or sourcing Virginia contractors one at a time through the DPOR search portal is slow and reCAPTCHA-gated.
- No easy way to pull the full Class A/B/C contractor roster for lead-gen, compliance, or enrichment workflows.
- The raw DPOR regulant-list files are tab-delimited and hard to work with without a parser.

### What we solve

- Download the full Virginia DPOR contractor roster — 50,000+ records across Class A, B, and C — in one run.
- Filter by name, city, or license type without touching the reCAPTCHA-gated search portal.
- Returns structured records: license number, rank, specialties, address, expiration date, and email.

### Summary

Pull the full Virginia DPOR contractor and tradesperson roster without ever touching the reCAPTCHA-gated search portal. DPOR publishes free public regulant lists as tab-delimited files refreshed every ~5 business days — this actor downloads them, parses them, and returns structured records for Class A, Class B, Class C contractors, residential tradespeople, and specialty trades. Filter by name, city, or license type; pay per match. Built for lead-gen, compliance workflows, and multi-state contractor data pipelines.

### Who it's for

- Sales and BD teams building lead lists of Virginia contractors by specialty or location
- Compliance teams verifying DPOR licensure status for vetting or KYC workflows
- Insurance underwriters running portfolio checks on contractor clients
- Data platforms normalizing multi-state contractor license data

### 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
{
  "licenseTypes": [
    "class_a",
    "class_b",
    "class_c"
  ],
  "nameFilter": "",
  "cityFilter": "",
  "maxResults": 500
}
````

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

### What you get

One row per record:

| Field | Description |
|---|---|
| `license_number` | DPOR certificate number (e.g. 082040) |
| `license_type` | License category (Class A Contractor, Class B Contractor, etc.) |
| `license_rank` | DPOR rank code (A, B, C, RETR, BPDW, CEM, etc.) |
| `business_name` | Licensed business name (for firm licenses) |
| `individual_name` | Licensee personal name (for individual licenses) |
| `address` | Street address |
| `city` | City |
| `state` | State code |
| `zip_code` | ZIP code |
| `country` | Country (blank for domestic) |
| `expiration_date` | License expiration date (MM/DD/YYYY) |
| `certification_date` | Original certification date (MM/DD/YYYY) |
| `specialties` | List of DPOR specialty codes (e.g. CBC, ELE, H/H, EMW) |
| `email` | Contact email address |
| `source_url` | DPOR regulant lists page |

Sample:

```json
{
  "license_number": "082040",
  "license_type": "Class A Contractor",
  "license_rank": "A",
  "business_name": "CORNERSTONE ENGINEERING AND CONSULTING SERVICES PLLC",
  "individual_name": null,
  "address": "1272 NELLIE JONES RD",
  "city": "LA CROSSE",
  "state": "VA",
  "zip_code": "23950",
  "country": null,
  "expiration_date": "02/29/2028",
  "certification_date": "02/03/2004",
  "specialties": [
    "EMW",
    "ENV"
  ],
  "email": "bdougherty@cornerstoneusa.net",
  "source_url": "https://www.dpor.virginia.gov/RegulantLists"
}
```

### Inputs

| Field | Required | Type | Default | Description |
|---|---|---|---|---|
| `licenseTypes` | no | array | `["class_a", "class_b", "class_c"]` | Which DPOR license categories to include. Leave empty for Class A, B, and C contractors. Valid values: class\_a, class\_a\_legacy, class\_b, class\_c, temporary, residential\_tradesman, backflow\_prevention, elevator\_mechanic, water\_well\_provider, accessibility\_mechanic, energy\_analyst, energy\_analyst\_firm, sprinkler\_inspector. |
| `nameFilter` | no | string | — | Only return records where the individual or business name contains this text (case-insensitive). Leave blank for all. |
| `cityFilter` | no | string | — | Only return records where the city contains this text (case-insensitive). Leave blank for all. |
| `maxResults` | no | integer | `500` | Cap on the number of unique license records to return per run. |

### Pricing (Pay Per Event)

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

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

### Use cases

- Lead generation — pull all Class A contractors in a Virginia city as a prospect list for subcontracting or supply-chain outreach.
- Compliance verification — download the full Class B/C roster and cross-check your vendor list against current DPOR records.
- Multi-state enrichment — join Virginia DPOR records with other state rosters for a national contractor data pipeline.
- Specialty targeting — filter by license type (e.g. elevator mechanics, backflow prevention workers) for niche trade outreach.

### Why this actor

- Straight from the official DPOR regulant lists — same data the state publishes, structured and queryable.
- Bypasses the reCAPTCHA-gated DPOR search portal entirely via the free bulk download path.
- Covers all contractor classes (A, B, C) plus 10+ specialty trade categories in one actor.
- Pay per match; no charge for runs that return no results.

### Limitations & updates

Data is refreshed by DPOR every ~5 business days; records may lag real-time changes by up to one week. The DPOR files do not include phone numbers (DPOR explicitly excludes them). No status field is present in the source data — expiration date is the best proxy for active vs. expired licenses. Specialty codes (CBC, ELE, H/H, etc.) are DPOR internal abbreviations; a code legend is available on the DPOR website. The actor covers DPOR-licensed categories only — some Virginia trades are licensed at the local level and are not in these files.

### FAQ

**Where does the data come from?**

Virginia DPOR publishes free public 'Regulant Lists' as tab-delimited files updated every ~5 business days. This actor downloads and parses those official files directly.

**What license types are covered?**

Class A, B, and C contractors (the main categories); plus residential tradespeople, backflow prevention workers, elevator mechanics, water well providers, accessibility mechanics, residential energy analysts, and sprinkler inspectors. See licenseTypes input for the full list.

**How current is the data?**

DPOR refreshes the regulant-list files every ~5 business days (usually Mondays). Each run fetches the current file at that moment.

**Can I filter by specialty?**

Each record includes a specialties field (e.g. CBC = Commercial Building Construction, ELE = Electrical, H/H = Heating & Air Conditioning). You can filter post-run on this field; the actor's nameFilter and cityFilter cover the most common pre-run narrowing needs.

**How am I charged?**

Pay per license record returned. Runs that return no matching records are not charged.

**Does this need any account or API key?**

No — the DPOR regulant lists are free public files, no auth required.

### Which actor to choose

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

- **California Contractor License Lookup & Verify (CSLB)** — You need a California contractor verified — by license number, business, or owner/personnel name (CSLB).
- **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).
- **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).

# Actor input Schema

## `licenseTypes` (type: `array`):

Which DPOR license categories to include. Leave empty for Class A, B, and C contractors. Valid values: class\_a, class\_a\_legacy, class\_b, class\_c, temporary, residential\_tradesman, backflow\_prevention, elevator\_mechanic, water\_well\_provider, accessibility\_mechanic, energy\_analyst, energy\_analyst\_firm, sprinkler\_inspector.

## `nameFilter` (type: `string`):

Only return records where the individual or business name contains this text (case-insensitive). Leave blank for all.

## `cityFilter` (type: `string`):

Only return records where the city contains this text (case-insensitive). Leave blank for all.

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

Cap on the number of unique license records to return per run.

## Actor input object example

```json
{
  "licenseTypes": [
    "class_a",
    "class_b",
    "class_c"
  ],
  "maxResults": 500
}
```

# Actor output Schema

## `results` (type: `string`):

Contractor and tradesperson license records from the Virginia DPOR regulant lists.

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("fried_calamaries/virginia-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("fried_calamaries/virginia-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 '{}' |
apify call fried_calamaries/virginia-contractor-license-lookup --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Virginia Contractor License Lookup (DPOR Bulk)",
        "description": "Download and filter 50,000+ Virginia DPOR contractor licenses — Class A, B & C plus tradespeople — direct from the official regulant lists. No CAPTCHA, no auth.",
        "version": "0.0",
        "x-build-id": "5Ubi8kt0qGphmgEB0"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fried_calamaries~virginia-contractor-license-lookup/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fried_calamaries-virginia-contractor-license-lookup",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/fried_calamaries~virginia-contractor-license-lookup/runs": {
            "post": {
                "operationId": "runs-sync-fried_calamaries-virginia-contractor-license-lookup",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/fried_calamaries~virginia-contractor-license-lookup/run-sync": {
            "post": {
                "operationId": "run-sync-fried_calamaries-virginia-contractor-license-lookup",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "licenseTypes": {
                        "title": "License types",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Which DPOR license categories to include. Leave empty for Class A, B, and C contractors. Valid values: class_a, class_a_legacy, class_b, class_c, temporary, residential_tradesman, backflow_prevention, elevator_mechanic, water_well_provider, accessibility_mechanic, energy_analyst, energy_analyst_firm, sprinkler_inspector.",
                        "items": {
                            "type": "string"
                        },
                        "default": [
                            "class_a",
                            "class_b",
                            "class_c"
                        ]
                    },
                    "nameFilter": {
                        "title": "Name filter",
                        "type": "string",
                        "description": "Only return records where the individual or business name contains this text (case-insensitive). Leave blank for all."
                    },
                    "cityFilter": {
                        "title": "City filter",
                        "type": "string",
                        "description": "Only return records where the city contains this text (case-insensitive). Leave blank for all."
                    },
                    "maxResults": {
                        "title": "Maximum results",
                        "minimum": 1,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Cap on the number of unique license records to return per run.",
                        "default": 500
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
