# US Professional License Data (`wallman_3rd/us-professional-licenses`) Actor

Public professional-license records from US state licensing boards. Launch scope: New Jersey contractor boards (Electrical Contractors, Master Plumbers, HVACR) -- name, license number, license type, status, city, and state, one record per license.

- **URL**: https://apify.com/wallman\_3rd/us-professional-licenses.md
- **Developed by:** [Z W](https://apify.com/wallman_3rd) (community)
- **Categories:** Lead generation, Automation
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 results

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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## US Professional License Data

**Public professional-license records from US state licensing boards, in one clean dataset.** This Actor extracts every listed licensee for the boards you select — **name, license number, license type, status, city, and state** — one row per license, ready to download as JSON, CSV, or Excel.

Coverage spans **two states and 32 licensing boards** today, all served by the `mylicense.com` verification platform, with more states being added over time without changing how you use it:

- **New Jersey** — 13 boards across skilled trades, professional services, healthcare, and personal services.
- **Indiana** — 19 boards across the same segments. Indiana's source blocks datacenter IPs, so IN runs need an Apify **residential** proxy (set Proxy configuration in the input). Because Indiana's site aggressively rate-limits, IN runs are slower than New Jersey (the scraper automatically rotates proxy IPs to get through). New Jersey needs no proxy.

Pick a **state**, then optionally pick which **boards** within it. The Actor is built to grow into more states and professions without changing how you use it.

Sources: the [New Jersey Division of Consumer Affairs](https://newjersey.mylicense.com/verification/Search.aspx) and [Indiana Professional Licensing Agency](https://mylicense.in.gov/eVerification/Search.aspx) license verification portals.

Running on the Apify platform gives you scheduling, a REST API, webhook/integration output, monitoring, and export to JSON/CSV/Excel out of the box.

### Why use US Professional License Data?

- **Lead lists for suppliers and B2B sales** — reach every licensed electrician, plumber, CPA, or home inspector in a state.
- **License verification and compliance** — confirm a professional's license number, type, and current status (Active, Expired, Pending, Inactive).
- **Market research** — count and map licensed professionals by trade and city.
- **Data enrichment** — match your existing records against the authoritative state roster.

The state portals only let you look up one name at a time and do not offer a free bulk export (their "Download" buttons are paid state services). This Actor gathers the full public roster for you in one run.

### How to use it

1. Click **Start** (or **Try for free**).
2. Pick a **state** (New Jersey or Indiana).
3. Optionally pick which **boards** to scrape — leave empty for that state's small default set.
4. For a quick, cheap test, set **Max records per board** to a small number like 30.
5. Run the Actor. When it finishes, open the **Output** tab.
6. Download the dataset as JSON, CSV, or Excel, or pull it via the API.

### Input

| Field | Type | Description |
| --- | --- | --- |
| `state` | string | Which state to scrape: `NJ` (New Jersey, no proxy needed) or `IN` (Indiana, requires a residential proxy — see Proxy configuration). Default `NJ`. |
| `proxyConfiguration` | object | Proxy settings. Required for Indiana (enable Apify Proxy with the `RESIDENTIAL` group). Not needed for New Jersey. |
| `boards` | array | Which boards to scrape for that state (names must match the state's list below). Empty = the state's bounded default starter set (a few boards), not everything. |
| `maxRecordsPerBoard` | integer | Stop each board after this many records. `0` = unlimited (default). Use a small value for test runs. |

Example:

```json
{
    "state": "IN",
    "boards": ["Accountancy Board", "Plumbing Commission"],
    "maxRecordsPerBoard": 0
}
````

#### Boards by state

**New Jersey** (`state: "NJ"`) — default: Electrical Contractors, Master Plumbers, HVACR

- **Skilled trades:** `Electrical Contractors`, `Master Plumbers`, `HVACR`
- **Professional services:** `Accountancy`, `Engineers & Land Surveyors`, `Architecture`, `Real Estate Appraisers`, `Professional Planners`
- **Healthcare:** `Pharmacy`, `Dentistry`, `Veterinary Medical Examiners`, `Physical Therapy`
- **Personal services:** `Cosmetology and Hairstyling`

**Indiana** (`state: "IN"`) — default: Plumbing Commission, Home Inspectors Board, Accountancy Board

- **Skilled trades:** `Plumbing Commission`, `Home Inspectors Board`, `Manufactured Home Installers`
- **Professional services:** `Accountancy Board`, `Appraiser Board`, `Architect Board`, `Engineer Board`, `Land Surveyor Board`, `Real Estate Commission`, `Auctioneer Commission`
- **Healthcare:** `Pharmacy Board`, `Dentistry Board`, `Veterinary Board`, `Optometry Board`, `Physical Therapy Board`, `Chiropractic Board`, `Psychology Board`, `Massage Therapy Board`
- **Personal services:** `Cosmetology & Barber Board`

Board names must match exactly. Nursing and physician boards are intentionally excluded from both states — they are already commoditized by the free national [Nursys](https://www.nursys.com/) lookup and the federal NPI registry — as are business-entity registrations (e.g. NJ Home Improvement Contractors, IN Corporations), which are not searchable by an individual's last name.

### Output

One record per license. Fields the source does not publish for a given row are `null` rather than guessed.

```json
{
    "id": "in_cp10000509",
    "state": "IN",
    "profession": "Accountancy Board",
    "name": "Aaron, Kimberly D.",
    "licenseNumber": "CP10000509",
    "licenseType": "Certified Public Accountant",
    "licenseStatus": "Expired",
    "city": "Jasper",
    "addressState": "IN",
    "source": "in-mylicense",
    "lastScraped": "2026-07-23T00:00:00.000Z"
}
```

You can download the dataset in various formats such as JSON, HTML, CSV, or Excel.

#### Data fields

| Field | Description |
| --- | --- |
| `id` | Stable unique id (`nj_`/`in_` + license number, or name-based fallback when the license number is blank). |
| `state` | Licensing jurisdiction (`NJ` or `IN`). |
| `profession` | Board / trade the license belongs to. |
| `name` | Licensee full name as listed. |
| `licenseNumber` | State license number. May be empty for pending applications. |
| `licenseType` | Specific license type (e.g. Electrical Contractor, Journeyman Plumber, Certified Public Accountant). |
| `licenseStatus` | Active, Expired, Pending, Inactive, etc. |
| `city` | City on file. |
| `addressState` | State on file (can differ from the licensing state for out-of-state licensees). |
| `source` | Data source identifier (`nj-mylicense`, `in-mylicense`). |
| `lastScraped` | ISO timestamp of the scrape. |

### Cost estimation

The Actor scrapes lightweight HTML with plain HTTP requests (no browser), so runs are inexpensive. **Cost scales with the number of records, and boards can hold thousands of licensees** — so select boards deliberately and, for a first look, set **Max records per board** to a small value like 30 to preview the data cheaply before pulling a full board. Actual usage is visible on the run's detail page.

### Tips

- Pick a state first, then narrow `boards` to just the trades you need — or leave `boards` empty for a quick look at that state's default set.
- Schedule a monthly run to keep your copy of the roster current — statuses (Active/Expired) change over time.
- Some rows legitimately have a blank license number (pending applications, or a secondary license type held by the same person). These are kept, not dropped.

### FAQ, disclaimer, and support

**Is this legal?** The Actor collects only publicly available license-verification data that the state agencies publish for free lookup. Use the data responsibly and in line with applicable laws and the source sites' terms.

**Why is `licenseNumber` sometimes empty?** Pending applications and certain secondary license types are listed without a number by the state. Those rows are still real and are included.

**Which states are supported?** New Jersey and Indiana today. Oregon shares the same platform but its search form is protected by a CAPTCHA on every query, so it cannot currently be collected and is not offered. More states are planned.

**Known limitation:** the portals do not publish phone, email, or street address in the search results, so those fields are not available.

Found a problem or need another state/profession added? Open an issue on the Actor's **Issues** tab. Custom scraping solutions are available on request.

# Actor input Schema

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

Which state's licensing boards to scrape. New Jersey works out of the box. Indiana works too but its source (mylicense.in.gov) blocks datacenter IPs, so IN needs an Apify residential proxy (set Proxy configuration below) — without one, IN returns 0. (Oregon is listed but its source portal requires a CAPTCHA on every search, so it currently returns no data.) Each state has its own set of boards — see the README for the full per-state board list.

## `boards` (type: `array`):

Which licensing boards to scrape for the selected state. Each is an individually-licensed profession (name, license number, license type, status, city, state). Board names must match the selected state's list exactly — see the README for the full per-state board list (e.g. NJ: 'Electrical Contractors', 'Accountancy'; IN: 'Plumbing Commission', 'Accountancy Board'). Pricing is per record and boards can hold thousands of licensees, so pick deliberately. Leave EMPTY to scrape that state's bounded default starter set (a few boards), not everything.

## `maxRecordsPerBoard` (type: `integer`):

Stop each board after this many records (0 = unlimited / full board). Set a small number (e.g. 30) for a cheap test run before pulling a full board.

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

Only needed for Indiana (IN), whose source blocks datacenter IPs — enable Apify Proxy with the RESIDENTIAL group. New Jersey does not need a proxy.

## Actor input object example

```json
{
  "state": "NJ",
  "boards": [
    "Electrical Contractors",
    "Master Plumbers",
    "HVACR"
  ],
  "maxRecordsPerBoard": 0,
  "proxyConfiguration": {
    "useApifyProxy": 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 = {
    "state": "NJ",
    "boards": [
        "Electrical Contractors",
        "Master Plumbers",
        "HVACR"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("wallman_3rd/us-professional-licenses").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 = {
    "state": "NJ",
    "boards": [
        "Electrical Contractors",
        "Master Plumbers",
        "HVACR",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("wallman_3rd/us-professional-licenses").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 '{
  "state": "NJ",
  "boards": [
    "Electrical Contractors",
    "Master Plumbers",
    "HVACR"
  ]
}' |
apify call wallman_3rd/us-professional-licenses --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "US Professional License Data",
        "description": "Public professional-license records from US state licensing boards. Launch scope: New Jersey contractor boards (Electrical Contractors, Master Plumbers, HVACR) -- name, license number, license type, status, city, and state, one record per license.",
        "version": "0.1",
        "x-build-id": "ow1ze3UEUEMkFnKoR"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/wallman_3rd~us-professional-licenses/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-wallman_3rd-us-professional-licenses",
                "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/wallman_3rd~us-professional-licenses/runs": {
            "post": {
                "operationId": "runs-sync-wallman_3rd-us-professional-licenses",
                "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/wallman_3rd~us-professional-licenses/run-sync": {
            "post": {
                "operationId": "run-sync-wallman_3rd-us-professional-licenses",
                "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": {
                    "state": {
                        "title": "State",
                        "enum": [
                            "NJ",
                            "IN",
                            "OR"
                        ],
                        "type": "string",
                        "description": "Which state's licensing boards to scrape. New Jersey works out of the box. Indiana works too but its source (mylicense.in.gov) blocks datacenter IPs, so IN needs an Apify residential proxy (set Proxy configuration below) — without one, IN returns 0. (Oregon is listed but its source portal requires a CAPTCHA on every search, so it currently returns no data.) Each state has its own set of boards — see the README for the full per-state board list.",
                        "default": "NJ"
                    },
                    "boards": {
                        "title": "Boards / professions",
                        "type": "array",
                        "description": "Which licensing boards to scrape for the selected state. Each is an individually-licensed profession (name, license number, license type, status, city, state). Board names must match the selected state's list exactly — see the README for the full per-state board list (e.g. NJ: 'Electrical Contractors', 'Accountancy'; IN: 'Plumbing Commission', 'Accountancy Board'). Pricing is per record and boards can hold thousands of licensees, so pick deliberately. Leave EMPTY to scrape that state's bounded default starter set (a few boards), not everything.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxRecordsPerBoard": {
                        "title": "Max records per board",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Stop each board after this many records (0 = unlimited / full board). Set a small number (e.g. 30) for a cheap test run before pulling a full board.",
                        "default": 0
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Only needed for Indiana (IN), whose source blocks datacenter IPs — enable Apify Proxy with the RESIDENTIAL group. New Jersey does not need a proxy.",
                        "default": {
                            "useApifyProxy": false
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
