# Nevada Contractor Licenses Scraper (`automation-lab/nevada-contractor-license-lookup`) Actor

Search the official Nevada State Contractors Board registry and export normalized license status, classifications, business details, principals, addresses, and bonds.

- **URL**: https://apify.com/automation-lab/nevada-contractor-license-lookup.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.92 / 1,000 item extracteds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## Nevada Contractor Licenses Scraper

Search **nevada contractor licenses** in the official Nevada State Contractors Board (NSCB) public registry and export normalized records for credential checks, vendor onboarding, and recurring compliance workflows.

The Actor supports the three public NSCB lookup modes:

- contractor license number;
- company name;
- principal or qualified-individual name.

Each result can include license identity, status and dates, classifications, business details, public addresses and phones, principals, qualified individuals, bonds, and official source provenance.

### What does Nevada Contractor Licenses Scraper do?

The Actor automates the public search and detail workflow at the Nevada State Contractors Board.

For every accepted match it:

1. starts a fresh anonymous NSCB session;
2. submits the selected search mode;
3. reads the official result list;
4. opens each selected license detail;
5. normalizes fields into one stable JSON record;
6. deduplicates repeated license numbers across searches;
7. saves records to the default Apify dataset.

It does not guess license validity. `status` is copied from NSCB, while `isActive` is true only when that status is exactly `Active`.

### Who is it for?

- **Procurement teams** verifying a Nevada contractor before onboarding.
- **Compliance teams** refreshing credential records on a schedule.
- **General contractors** checking subcontractor license classifications and expiration dates.
- **Property managers** reviewing public contractor identity and contact details.
- **Insurers and risk analysts** assembling auditable public-license evidence.
- **Data teams** sending normalized NSCB data to a spreadsheet, warehouse, or internal application.

### Why automate the NSCB license lookup?

Manual checks require repeating form submissions and opening individual detail pages.

This Actor adds:

- batch input for up to 25 searches per run;
- one consistent record shape across all three search modes;
- run-level deduplication by official license number;
- an optional active-only filter;
- a configurable result ceiling;
- source and extraction timestamps for traceability;
- standard JSON, CSV, Excel, XML, and RSS exports through Apify datasets.

### What data can I extract?

| Field group | Included fields |
| --- | --- |
| License identity | `licenseNumber`, `nvBusinessId` |
| Business identity | `legalBusinessName`, `dbaName`, `businessType` |
| Standing | `status`, `isActive`, `statusDate`, `originDate`, `expirationDate` |
| Scope | `classifications`, `limitation`, `monetaryLimit` |
| Mailing contact | `mailingAddress`, `mailingCity`, `mailingState`, `mailingPostalCode`, `mailingPhone` |
| Physical contact | `physicalAddress`, `physicalCity`, `physicalState`, `physicalPostalCode`, `physicalPhone` |
| People | `principals`, `qualifiedIndividuals` with public roles |
| Bonds | type, number, agent, surety company, amount, and effective date when listed |
| Provenance | `matchedSearch`, `sourceUrl`, `detailUrl`, `sourceCheckedAt`, `scrapedAt` |

A field can be `null` or an array can be empty when NSCB does not publish that value for a license.

### How to get started

1. Open the Actor in Apify Console.
2. Add one or more objects to **License searches**.
3. Use exactly one mode in each search object.
4. Optionally enable **Active licenses only**.
5. Set **Maximum licenses** to control output volume.
6. Click **Start**.
7. Open the **Dataset** tab to inspect or export results.

A small first run:

```json
{
  "searches": [
    { "licenseNumber": "0083831" }
  ],
  "maxItems": 5
}
```

### Input parameters

#### `searches`

Required array with 1–25 search objects.

Each object must use exactly one of these modes:

```json
{ "licenseNumber": "0083831" }
```

```json
{ "companyName": "Smith" }
```

```json
{
  "principalFirstName": "John",
  "principalLastName": "Smith"
}
```

A principal search may provide a first name, a last name, or both. Do not combine a license number or company name with principal fields in the same object.

#### `activeOnly`

Optional boolean, default `false`.

When true, the Actor opens only result rows whose public NSCB status is `Active`.

#### `maxItems`

Optional integer from 1 to 1,000, default `100`.

The limit applies across all searches after deduplication.

### Output example

A successful record resembles:

```json
{
  "licenseNumber": "0083831",
  "legalBusinessName": "AMERICAN DREAM SHOTCRETE LLC",
  "dbaName": null,
  "nvBusinessId": "NV20181317926",
  "status": "Active",
  "isActive": true,
  "statusDate": "06/01/2026",
  "originDate": "07/25/2018",
  "expirationDate": "07/31/2028",
  "businessType": "Limited Liability Company",
  "monetaryLimit": "$10,000.00",
  "classifications": [
    "C-11 Spraying Mixtures Containing Cement"
  ],
  "physicalCity": "LAS VEGAS",
  "physicalState": "NV",
  "principals": [
    { "name": "RASCON, EVER EDWARDO", "role": "Manager" }
  ],
  "qualifiedIndividuals": [
    { "name": "RASCON, JUAN CARLOS", "role": "CMS and Trade" }
  ],
  "bonds": [
    {
      "type": "Surety",
      "number": "1004636110",
      "amount": "$10,000.00",
      "effectiveDate": "07/25/2018"
    }
  ],
  "sourceCheckedAt": "9/3/2026 7:30:00 AM",
  "scrapedAt": "2026-09-03T14:30:00.000Z"
}
```

Public details can change between runs. Treat the current dataset as a point-in-time extraction.

### Search recipes

#### Verify one contractor

Use an exact license number and a small limit:

```json
{
  "searches": [{ "licenseNumber": "0083831" }],
  "maxItems": 1
}
```

#### Find companies by partial name

```json
{
  "searches": [{ "companyName": "Smith" }],
  "maxItems": 25
}
```

The source can return broad matches. Review `legalBusinessName`, `dbaName`, location, and classifications to identify the intended contractor.

#### Build a recurring active-vendor dataset

```json
{
  "searches": [
    { "companyName": "Smith" },
    { "principalLastName": "Smith" }
  ],
  "activeOnly": true,
  "maxItems": 100
}
```

Schedule this input and compare datasets downstream to detect public status, expiration, address, classification, or bond changes. The Actor returns snapshots; it does not send change alerts itself.

### How much does it cost to look up Nevada contractor licenses?

The Actor uses pay-per-event pricing:

- **$0.0005** once when a license-search run starts;
- **$0.0032 per extracted license record** at the BRONZE tier;
- lower per-record tiers apply at higher platform usage levels.

At BRONZE, calculate a run as one start event plus **$0.0032** multiplied by the number of useful records. For example, 1, 10, and 100 useful records generate 1, 10, and 100 item events respectively.

Empty searches incur the start event but no item events. Apify displays the applicable tier and maximum run charge before execution. Infrastructure usage is included in pay-per-event pricing rather than billed as a separate Actor event.

### Scheduling recurring verification

Use an Apify schedule to rerun a saved Task daily, weekly, or monthly.

A common workflow is:

1. save a Task containing known license numbers or vendor names;
2. schedule the Task;
3. export each dataset to cloud storage or a database;
4. compare `status`, `expirationDate`, `classifications`, addresses, and bonds;
5. route material differences into the organization's review process.

Choose a frequency appropriate for your compliance policy and the source's update cadence.

### Export and integrations

The default dataset works with:

- JSON and JSONL;
- CSV and Excel;
- XML and RSS;
- Google Sheets through Apify integrations;
- webhooks and automation platforms;
- custom ETL code using the Apify API client.

Use `licenseNumber` as the stable business key when comparing runs.

### API usage

Replace `YOUR_TOKEN` with an Apify API token.

#### cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~nevada-contractor-license-lookup/runs?token=YOUR_TOKEN&waitForFinish=120" \
  -H "Content-Type: application/json" \
  -d '{"searches":[{"licenseNumber":"0083831"}],"maxItems":5}'
```

Fetch dataset items using the `defaultDatasetId` from the run response.

#### JavaScript

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/nevada-contractor-license-lookup').call({
  searches: [{ companyName: 'Smith' }],
  activeOnly: true,
  maxItems: 25,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient(token="YOUR_TOKEN")
run = client.actor("automation-lab/nevada-contractor-license-lookup").call(
    run_input={
        "searches": [{"principalLastName": "Smith"}],
        "activeOnly": True,
        "maxItems": 25,
    }
)
items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items)
```

### Use with Apify MCP

Add the Actor to Claude Code:

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/nevada-contractor-license-lookup"
```

#### Claude Desktop

Add this server to the `mcpServers` object in Claude Desktop:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/nevada-contractor-license-lookup"
    }
  }
}
```

#### Cursor

Use the same JSON server entry in Cursor's MCP settings.

#### VS Code

Add the same HTTP MCP server URL through VS Code's MCP server configuration.

Example prompts:

- “Look up Nevada contractor license 0083831 and summarize its current status and expiration.”
- “Find active Nevada contractors whose company name contains Smith.”
- “Export NSCB records linked to principal last name Smith for vendor review.”

### Reliability and failure behavior

The Actor uses the official anonymous ASP.NET search and detail pages.

It keeps view state and cookies together for each search, retries temporary network/429/5xx failures up to three times, and processes detail selections sequentially to preserve source session coherence.

The run fails rather than emitting misleading empty data when:

- the source stops returning required ASP.NET state;
- a result or detail page has an unrecognized structure;
- repeated transient errors exhaust retries;
- the input combines incompatible search modes.

A genuine no-result search completes successfully with zero dataset rows.

### Limits and source caveats

- NSCB controls data content, availability, and freshness.
- The Board states that public pages are provided as a courtesy and may not reflect recent changes or updates.
- Completeness and accuracy are not guaranteed by the source or this Actor.
- A broad name can return many matches; use `maxItems` deliberately.
- `activeOnly` checks the result-list status exactly; other statuses remain available when the filter is false.
- Disciplinary-action documents are not extracted by this version.
- The Actor does not monitor continuously or send alerts without an external schedule and comparison workflow.
- No proxy is used or required by default.

### Responsible use and legality

This Actor accesses public NSCB records without login.

You are responsible for complying with applicable laws, source terms, contractual obligations, and internal policies. Use public contact and personal-name fields only for a legitimate purpose. Do not use the data for harassment, spam, unlawful discrimination, or as the sole basis for a high-impact decision.

For authoritative decisions, open `detailUrl` and verify the current record with NSCB or the appropriate regulator.

### Troubleshooting

#### “Search must use exactly one mode”

Split combined criteria into separate search objects. A company search and principal search cannot share one object.

#### A company search returns unexpected matches

The NSCB source supports partial and wildcard name matching. Use a more specific company term or verify identity using license number, business ID, city, and classification.

#### The run returns zero records

Confirm the spelling and search mode on the official registry. Remove `activeOnly` if the license might be inactive, cancelled, suspended, or expired.

#### The source request fails

Check the run log for a temporary NSCB outage or changed page structure. Retry later only after confirming the source is available; repeated identical runs do not fix a deterministic markup change.

### Related Automation Lab Actors

- [California Contractor License Lookup](https://apify.com/automation-lab/california-contractor-license-lookup-v2) for California CSLB records.
- [North Carolina Contractor License Lookup Scraper](https://apify.com/automation-lab/north-carolina-contractor-license-lookup-scraper) for NCLBGC records.

These Actors use different state sources and should not be treated as a multistate substitute for the Nevada registry.

### FAQ

#### Does this Actor use official data?

Yes. Records come from the public Nevada State Contractors Board search and license-detail pages. The Actor is independent and is not endorsed by NSCB.

#### Can I search multiple licenses in one run?

Yes. Add up to 25 search objects. The Actor deduplicates repeated license numbers across them.

#### Can I search by principal?

Yes. Provide a principal first name, last name, or both. Results can include licenses where the person is listed as a principal or qualified individual.

#### Does `isActive` mean the contractor is safe to hire?

No. It only indicates that the source status text was exactly `Active` when extracted. Perform all checks required by your organization.

#### Are empty searches charged per item?

No. An empty search has no item events. The one-time start event still applies.

#### Can I download Excel?

Yes. Open the run dataset and choose Excel, CSV, JSON, or another supported export format.

#### Does it include disciplinary actions?

No. This release focuses on the public license identity and detail record. Follow the NSCB detail/source links for authoritative review and other Board resources.

# Actor input Schema

## `searches` (type: `array`):

One or more searches. Each object must use exactly one mode: licenseNumber, companyName, or principalFirstName/principalLastName.

## `activeOnly` (type: `boolean`):

Return only search rows whose current NSCB status is Active.

## `maxItems` (type: `integer`):

Maximum unique license records saved across all searches.

## Actor input object example

```json
{
  "searches": [
    {
      "companyName": "Smith"
    }
  ],
  "activeOnly": false,
  "maxItems": 10
}
```

# Actor output Schema

## `dataset` (type: `string`):

Dataset containing normalized Nevada contractor license records.

# 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 = {
    "searches": [
        {
            "companyName": "Smith"
        }
    ],
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/nevada-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 = {
    "searches": [{ "companyName": "Smith" }],
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/nevada-contractor-license-lookup").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "searches": [
    {
      "companyName": "Smith"
    }
  ],
  "maxItems": 10
}' |
apify call automation-lab/nevada-contractor-license-lookup --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/nevada-contractor-license-lookup"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/HRtZyhAXRqCVwlA5G/builds/cIr3Zz4lqEcpfts0U/openapi.json