# New Arizona Contractor Leads – Licensed, with Phone & Owner (`deadwood_data_solutions/az-contractor-leads`) Actor

Licensed Arizona contractors from the AZ Registrar of Contractors (ROC) public registry with business phone, owner, license class, status and issue date. Dedup means scheduled runs return only new licenses. For insurance agents, lenders and B2B sellers.

- **URL**: https://apify.com/deadwood\_data\_solutions/az-contractor-leads.md
- **Developed by:** [K O](https://apify.com/deadwood_data_solutions) (community)
- **Categories:** Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

## New Arizona Contractor Leads – Licensed, with Phone & Owner

This actor pulls licensed contractor records statewide from Arizona's Registrar of Contractors (ROC) public licensee registry. It works as an Arizona contractor database and AZ ROC license lookup tool, delivered as structured lead data instead of a one-off search page. Each output record covers one contractor license: license number, legal business name, business phone, owner/qualifying-party name, entity type, city, state, ZIP, license class, license type, status, issued date, and renewal date. Use it to build contractor licensing lists, verify AZ license status in bulk, or generate phone-enriched leads for insurance, lending, and B2B outreach to Arizona's construction trades.

### Who uses it

**Insurance agents** selling workers'-comp, general liability and bonds to contractors (a licensed AZ contractor is a legally-required-coverage buyer — high intent), **lenders and equipment financiers**, materials and SaaS vendors, and anyone doing B2B outreach to Arizona's construction trades.

### Why this is worth charging for

The ROC registry is public, but the search page is a Salesforce portal built for one-off lookups, not bulk lead lists: no export, results split across per-license detail pages, addresses and class codes jammed into single strings, and no notion of "what's new since I last looked." This actor sweeps the registry, pulls the **business phone that ROC publishes right in the roster**, enriches each license with its issue date / entity type / renewal date, normalizes every field a caller needs, and deduplicates by license number across runs so your schedule bills only for new licenses.

### Input

| Field | Description |
|---|---|
| `searchTerms` | Business-name keywords to search. Empty = sweep A–Z for broad statewide coverage. |
| `classification` | Optional ROC class code filter (e.g. `B` general commercial, `CR-11` electrical). |
| `city` | Optional city filter (e.g. `Phoenix`, `Tucson`, `Mesa`). Empty = statewide. |
| `activeOnly` | Keep only Active licenses (exclude Suspended / Cancelled / Non-Renewal). |
| `enrichDetail` | Fetch per-license detail for issue date, entity type and renewal date (on by default). |
| `onlyNewSinceLastRun` | Recommended for schedules — skips licenses already returned by a previous run. |
| `maxItems` | Stop after this many normalized records. |

### Output

Each dataset item is one normalized contractor lead:

```json
{
  "licenseNumber": "ROC 334871",
  "legalName": "DISCOUNT STEEL REBAR LLC",
  "dbaName": null,
  "phone": "(602) 451-7308",
  "email": null,
  "owner": "Donald Lee Smith",
  "entityType": "LLC",
  "city": "Scottsdale",
  "state": "AZ",
  "zip": "85262",
  "licenseClass": "A-11",
  "licenseType": "Steel and Aluminum Erection",
  "status": "Active",
  "issuedDate": "2021-09-22",
  "renewalDate": "2025-09-30",
  "source": "AZ ROC"
}
````

### Pricing (Pay-Per-Event)

- **`query`** — charged once per run for the registry sweep.
- **`contractor-record`** — charged per normalized contractor lead pushed. This is the primary event.
- `apify-actor-start` (Apify-managed) — covers baseline compute per run.

A daily run filtered to a class or city returns just the new licenses for pennies; a first statewide backfill is a larger one-time run you cap with `maxItems`.

### Source & reliability

Data comes from the public **AZ Registrar of Contractors** licensee registry (`azroc.my.site.com`). No API key, no login, no captcha, no proxy. Phone and owner are published by ROC in the licensee record; issue/renewal dates come from each license's detail record. Run `npm test` for the offline self-test covering address parsing, class-code splitting, phone formatting and owner resolution.

**Data scope:** only public ROC registry fields ship. ROC does not publish licensee **email** or **street address** (city/state/ZIP only), so those are intentionally left blank rather than guessed.

### FAQ

**Is the phone always present?**

ROC publishes the business phone directly in the licensee roster, so fill runs high (~87–100% across sampled searches). It is the licensed business's own contact number, not a proximity guess.

**Do I get email?**

No — the AZ ROC public registry does not publish licensee email, so the `email` field is always null. Everything shipped is genuine public-registry data.

**How "new" are these?**

Turn on `onlyNewSinceLastRun` and schedule the actor; each run returns only licenses not seen before, so you get newly-appearing AZ contractor licenses over time.

***

*SEO keywords: Arizona contractor leads, AZ ROC data, licensed contractor list, contractor phone list, Arizona construction leads, contractor insurance leads, workers comp leads Arizona, ROC license lookup, contractor sales leads*

# Actor input Schema

## `searchTerms` (type: `array`):

Name keywords to search the ROC registry (e.g. company words, or leave empty to sweep A–Z for broad coverage). Each ROC search returns up to ~1000 matches; results are deduplicated by license number.

## `classification` (type: `string`):

Optional ROC classification code to filter by (e.g. 'B' general commercial, 'CR-11' electrical). Leave blank for all classes.

## `city` (type: `string`):

Optional city to filter by (e.g. Phoenix, Tucson, Mesa). Leave blank for statewide.

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

Keep only licenses with an Active status (exclude Suspended, Cancelled, Non-Renewal, etc.).

## `enrichDetail` (type: `boolean`):

Fetch the per-license detail record to add issue date, entity type and renewal date. Turn off for a faster, roster-only run (name, phone, class, status).

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

Stop after this many normalized records have been pushed.

## `onlyNewSinceLastRun` (type: `boolean`):

Recommended for scheduled runs. Uses persisted state to skip licenses already returned earlier, so a recurring schedule only charges for newly-appearing contractor licenses.

## Actor input object example

```json
{
  "searchTerms": [],
  "activeOnly": false,
  "enrichDetail": true,
  "maxItems": 300,
  "onlyNewSinceLastRun": true
}
```

# Actor output Schema

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

All normalized records from this run as JSON.

## `resultsCsv` (type: `string`):

All normalized records from this run as CSV.

# 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 = {
    "searchTerms": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("deadwood_data_solutions/az-contractor-leads").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 = { "searchTerms": [] }

# Run the Actor and wait for it to finish
run = client.actor("deadwood_data_solutions/az-contractor-leads").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 '{
  "searchTerms": []
}' |
apify call deadwood_data_solutions/az-contractor-leads --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "New Arizona Contractor Leads – Licensed, with Phone & Owner",
        "description": "Licensed Arizona contractors from the AZ Registrar of Contractors (ROC) public registry with business phone, owner, license class, status and issue date. Dedup means scheduled runs return only new licenses. For insurance agents, lenders and B2B sellers.",
        "version": "1.0",
        "x-build-id": "ZiKKnr7pIBq01DRLj"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/deadwood_data_solutions~az-contractor-leads/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-deadwood_data_solutions-az-contractor-leads",
                "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/deadwood_data_solutions~az-contractor-leads/runs": {
            "post": {
                "operationId": "runs-sync-deadwood_data_solutions-az-contractor-leads",
                "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/deadwood_data_solutions~az-contractor-leads/run-sync": {
            "post": {
                "operationId": "run-sync-deadwood_data_solutions-az-contractor-leads",
                "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": {
                    "searchTerms": {
                        "title": "Search terms (business name keywords)",
                        "type": "array",
                        "description": "Name keywords to search the ROC registry (e.g. company words, or leave empty to sweep A–Z for broad coverage). Each ROC search returns up to ~1000 matches; results are deduplicated by license number.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "classification": {
                        "title": "License classification filter",
                        "type": "string",
                        "description": "Optional ROC classification code to filter by (e.g. 'B' general commercial, 'CR-11' electrical). Leave blank for all classes."
                    },
                    "city": {
                        "title": "City filter",
                        "type": "string",
                        "description": "Optional city to filter by (e.g. Phoenix, Tucson, Mesa). Leave blank for statewide."
                    },
                    "activeOnly": {
                        "title": "Active licenses only",
                        "type": "boolean",
                        "description": "Keep only licenses with an Active status (exclude Suspended, Cancelled, Non-Renewal, etc.).",
                        "default": false
                    },
                    "enrichDetail": {
                        "title": "Fetch license detail (issue date, entity type, renewal)",
                        "type": "boolean",
                        "description": "Fetch the per-license detail record to add issue date, entity type and renewal date. Turn off for a faster, roster-only run (name, phone, class, status).",
                        "default": true
                    },
                    "maxItems": {
                        "title": "Maximum records to return",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Stop after this many normalized records have been pushed.",
                        "default": 300
                    },
                    "onlyNewSinceLastRun": {
                        "title": "Only return licenses not seen in a previous run",
                        "type": "boolean",
                        "description": "Recommended for scheduled runs. Uses persisted state to skip licenses already returned earlier, so a recurring schedule only charges for newly-appearing contractor licenses.",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```