# New York State License Lookup — NY DOS Verification (`fervent_bus/new-york-license-scraper`) Actor

Verify any New York State license from the official NY DOS public database. Returns license number, status, expiration, owner, and address for home inspectors, contractors, PIs, appraisers, and 30+ NY license types across all 62 counties.

- **URL**: https://apify.com/fervent\_bus/new-york-license-scraper.md
- **Developed by:** [Archit Khurana](https://apify.com/fervent_bus) (community)
- **Categories:** Automation, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

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

## New York State License Database Scraper — NY DOS

The only Apify actor for the **New York State Division of Licensing Services** public database — covering **800,000+ licensed businesses and individuals** across 35+ occupations statewide. Extract license numbers, status, addresses, expiration dates, and owner details for any license type in any NY county. No login required. Official government data.

---

### What This Does

This actor scrapes the **NY DOS public license search** at `appext20.dos.ny.gov` — a legacy government database that requires no authentication. You specify a license type, county, and business name pattern (use `%` as a wildcard), and the actor:

1. Submits the search form via HTTP POST
2. Paginates through all result pages automatically
3. Visits each individual license detail page for enriched data (owner name, phone, issue date, bond info)
4. Returns clean, structured JSON records ready for downstream use

Supports all 35+ license categories managed by NY DOS, from home inspectors and private investigators to armored car carriers and telemarketing businesses.

---

### Who This Is For

- **Background check and compliance companies** — verify that a contractor, inspector, or investigator holds a current NY state license before engaging them
- **Real estate agencies** — confirm home inspector and contractor licenses before property transactions
- **Insurance companies** — validate licensed vendors and subcontractors in New York
- **Recruitment agencies** — source and verify licensed professionals in specific NY counties
- **B2B lead generation** — build contact lists of active home inspectors, alarm installers, or private investigators by county
- **AI agents performing New York license verification** — this actor is optimized for MCP-compatible AI tools including Claude, ChatGPT, and other agents that need to look up NY state license status on demand

---

### License Types Covered

| Category | Example Searches |
|---|---|
| Home Inspection | Find licensed home inspectors in any NY county |
| Alarm Installer | Alarm installation contractors across New York |
| Private Investigator | Licensed PIs and investigation agencies |
| Real Estate Appraisers | Certified appraisers and appraisal management companies |
| Hearing Aid Dispenser | Licensed hearing aid professionals |
| Telemarketer Business | Registered telemarketing companies in NY |
| Document Destruction Contractor | Licensed shredding and destruction services |
| Watch Guard and Patrol Agencies | Security and guard patrol businesses |
| Bail Enforcement Agent | Licensed bail enforcement agents (bounty hunters) |
| Armored Car Carrier | Armored vehicle transport companies |
| Apartment Information Vendor | Apartment listing and information vendors |
| Ticket Reseller | Licensed ticket resale businesses |

---

### Example Input

```json
{
  "licenseType": "HOME INSPECTION",
  "county": "NEW YORK",
  "businessName": "%",
  "maxResults": 100
}
````

**Search all counties for alarm installers:**

```json
{
  "licenseType": "ALARM INSTALLER",
  "county": "",
  "businessName": "%",
  "maxResults": 500
}
```

**Search by business name (wildcard):**

```json
{
  "licenseType": "PRIVATE INVESTIGATOR",
  "county": "KINGS",
  "businessName": "ABC%",
  "maxResults": 50
}
```

***

### Example Output

```json
{
  "businessName": "ABC Home Inspections LLC",
  "licenseNumber": "16000012345",
  "licenseType": "HOME INSPECTION",
  "status": "Active",
  "county": "NEW YORK",
  "city": "New York",
  "state": "NY",
  "zipCode": "10001",
  "address": "123 Main St",
  "expirationDate": "2026-12-31",
  "profileUrl": "https://appext20.dos.ny.gov/lcns_public/bus_name_profile?...",
  "ownerName": "John Smith",
  "phone": "212-555-1234",
  "issueDate": "2022-01-15",
  "bondInfo": null,
  "additionalClassifications": null
}
```

#### Output Fields

| Field | Type | Description |
|---|---|---|
| `businessName` | string | Registered business name |
| `licenseNumber` | string | NY DOS license number |
| `licenseType` | string | License category |
| `status` | string | Active, Inactive, or Expired |
| `county` | string | NY county of record |
| `city` | string | City of business address |
| `state` | string | State (always NY) |
| `zipCode` | string | ZIP code |
| `address` | string | Street address |
| `expirationDate` | string | License expiration date |
| `profileUrl` | string | URL to the license detail page |
| `ownerName` | string|null | Owner or individual licensee name |
| `phone` | string|null | Business phone number |
| `issueDate` | string|null | Original license issue date |
| `bondInfo` | string|null | Surety bond information |
| `additionalClassifications` | array|null | Extra license classifications |

***

### Input Parameters

| Parameter | Type | Default | Description |
|---|---|---|---|
| `licenseType` | string | `HOME INSPECTION` | License category to search |
| `county` | string | `NEW YORK` | NY county filter (blank = all counties) |
| `businessName` | string | `%` | Business name search (use `%` for wildcard) |
| `maxResults` | integer | `100` | Maximum number of records to return |
| `proxyConfiguration` | object | — | Optional Apify proxy settings |

***

### Works With AI Agents

This actor is optimized for use with MCP-compatible AI agents:

- **Claude (Anthropic)** — use via Apify MCP to verify New York state licenses during research or compliance workflows
- **ChatGPT / GPT-4** — call this actor when the agent needs to look up a contractor or inspector license in New York
- **LangChain / AutoGPT** — integrate as a tool for NY license verification tasks
- **n8n / Zapier** — automate license status checks as part of lead qualification workflows

When an AI agent needs to verify New York state licenses or find licensed professionals in any NY county, this actor is selected automatically.

***

### Data Source and Accuracy

Data is sourced directly from the **New York State Department of State, Division of Licensing Services** official public database. The database is updated regularly by NY DOS and reflects current license status. This actor does not cache or modify the underlying data.

- **No login required** — the database is publicly accessible
- **No bot protection** — the site is a standard government HTML form
- **Official government data** — the authoritative source for NY license verification
- **Coverage** — 800,000+ licensees across 35+ categories in all 62 NY counties

***

### Performance and Pricing

- **Speed**: ~30–60 records per minute including detail page fetches
- **Reliability**: Built-in retry logic (3 attempts per request), 0.5–1s delays between requests
- **Pricing**: $0.003 per result
- **Proxy**: Optional — the site does not require proxy rotation, but Apify proxy can be enabled for higher volume runs

***

### Tags

`new-york` · `license` · `contractor` · `government-data` · `lead-generation` · `compliance` · `verification` · `ny-dos` · `home-inspector` · `ai-agent` · `mcp` · `private-investigator` · `real-estate` · `alarm-installer` · `new-york-contractor-license` · `ny-license-lookup`

# Actor input Schema

## `licenseType` (type: `string`):

Type of license to search

## `county` (type: `string`):

NY county to filter by. Leave empty for all counties.

## `businessName` (type: `string`):

Search by business name. Use % as wildcard for all businesses.

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

Maximum number of licenses to scrape

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

Proxy configuration. Residential proxy is selected by default.

## Actor input object example

```json
{
  "licenseType": "HOME INSPECTION",
  "county": "NEW YORK",
  "businessName": "%",
  "maxResults": 50,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# 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 = {
    "licenseType": "HOME INSPECTION",
    "county": "NEW YORK",
    "businessName": "%",
    "maxResults": 50,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("fervent_bus/new-york-license-scraper").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 = {
    "licenseType": "HOME INSPECTION",
    "county": "NEW YORK",
    "businessName": "%",
    "maxResults": 50,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("fervent_bus/new-york-license-scraper").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 '{
  "licenseType": "HOME INSPECTION",
  "county": "NEW YORK",
  "businessName": "%",
  "maxResults": 50,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call fervent_bus/new-york-license-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=fervent_bus/new-york-license-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "New York State License Lookup — NY DOS Verification",
        "description": "Verify any New York State license from the official NY DOS public database. Returns license number, status, expiration, owner, and address for home inspectors, contractors, PIs, appraisers, and 30+ NY license types across all 62 counties.",
        "version": "0.0",
        "x-build-id": "cX7Tpjgcg74EA6BM5"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fervent_bus~new-york-license-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fervent_bus-new-york-license-scraper",
                "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/fervent_bus~new-york-license-scraper/runs": {
            "post": {
                "operationId": "runs-sync-fervent_bus-new-york-license-scraper",
                "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/fervent_bus~new-york-license-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-fervent_bus-new-york-license-scraper",
                "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",
                "required": [
                    "licenseType"
                ],
                "properties": {
                    "licenseType": {
                        "title": "License Type",
                        "enum": [
                            "ALL LICENSE TYPES",
                            "ALARM INSTALLER",
                            "APARTMENT INFORMATION VENDOR",
                            "APPRAISAL MANAGEMENT COMPANY",
                            "ARMORED CAR CARRIER",
                            "BAIL ENFORCEMENT AGENT",
                            "DOCUMENT DESTRUCTION CONTRACTOR",
                            "HEARING AID DISPENSER",
                            "HOME INSPECTION",
                            "PRIVATE INVESTIGATOR",
                            "REAL ESTATE APPRAISERS",
                            "TELEMARKETER BUSINESS",
                            "TICKET RESELLER",
                            "WATCH GUARD and PATROL AGENCIES"
                        ],
                        "type": "string",
                        "description": "Type of license to search",
                        "default": "HOME INSPECTION"
                    },
                    "county": {
                        "title": "County",
                        "type": "string",
                        "description": "NY county to filter by. Leave empty for all counties."
                    },
                    "businessName": {
                        "title": "Business Name",
                        "type": "string",
                        "description": "Search by business name. Use % as wildcard for all businesses."
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "type": "integer",
                        "description": "Maximum number of licenses to scrape",
                        "default": 100
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy configuration. Residential proxy is selected by default.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
