# Arkansas Contractor License Lookup & Verify (ACLB) (`fried_calamaries/arkansas-contractor-license-lookup`) Actor

Verify any Arkansas contractor by name or license number — validity, type, expiration, city, county & address — straight from the official ACLB registry.

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

## Pricing

$0.004 / verified license records

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

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

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

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

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

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

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

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

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

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Arkansas Contractor License Lookup & Verify (ACLB)

### Pain points

- Verifying an Arkansas contractor on the ACLB site is one slow manual lookup at a time.
- The state search returns an unstructured HTML table, not data you can drop into a workflow.
- Checking validity, license type, and expiration across many contractors by hand doesn't scale.

### What we solve

- Verify any Arkansas ACLB contractor by name or license number — one search.
- Returns validity, license type, expiration, city, county, and address from the official registry.
- Turn a name or license number into a structured record; pay per match, empty searches free.

### Summary

Look up and verify any Arkansas contractor from a single search — type a business/DBA name (e.g. 'CONSTRUCTION') or an ACLB license number and get back the license validity, type (Commercial/Residential), expiration, city, county, and address, straight from the official Arkansas Contractors Licensing Board registry. Built for fast verification, compliance checks, and enriching a name or license number into a structured record.

### Who it's for

- GCs and hiring managers vetting Arkansas subcontractors
- Insurance underwriters and lenders running KYC on contractors
- Compliance teams and marketplaces verifying ACLB licenses
- RevOps and BD teams enriching contractor records

### How to use

Set the input, run the actor, and collect results from the run's dataset (export to JSON/CSV/Excel, or pull via the Apify API). Example input:

```json
{
  "query": "CONSTRUCTION",
  "maxResults": 25
}
````

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

### What you get

One row per record:

| Field | Description |
|---|---|
| `state` | Always 'AR' for this actor |
| `license_number` | ACLB license/registration number |
| `business_name` | Licensed business or DBA name |
| `license_type` | ACLB license type (e.g. Commercial, Residential) |
| `status` | Validity flag (e.g. Yes, No, Expired, Inactive, Extended) |
| `expiration_date` | License expiration date |
| `city` | Contractor city |
| `county` | Arkansas county |
| `address` | Street address |
| `zip_code` | ZIP code |
| `phone` | Contact phone |
| `matched_by` | Which search surfaced this match: 'license\_number' or 'business\_name' |
| `source_url` | Link to the official ACLB contractor search |

Sample:

```json
{
  "state": "AR",
  "license_number": "0014780227",
  "business_name": "BELL CONSTRUCTION CO., INC.",
  "license_type": "Commercial",
  "status": "Yes",
  "expiration_date": "02/28/2027",
  "city": "NORTH LITTLE ROCK",
  "county": "Pulaski",
  "address": "PO BOX 9041",
  "zip_code": "72119",
  "phone": "501-375-3325",
  "matched_by": "business_name",
  "source_url": "http://aclb2.arkansas.gov/clbsearch.php"
}
```

### Inputs

| Field | Required | Type | Default | Description |
|---|---|---|---|---|
| `query` | yes | string | `"CONSTRUCTION"` | An Arkansas contractor/DBA name (e.g. 'CONSTRUCTION') OR an ACLB license number. An all-digit query is looked up as a license number (enter the first six digits); anything else is searched against the ACLB business/DBA name index. Results are deduped by license number. |
| `maxResults` | no | integer | `50` | Cap on the number of matches returned in a single run. This is a lookup, not a bulk export — defaults to 50. (The ACLB server itself returns up to 5000 rows for a broad name.) |
| `proxyConfiguration` | no | object | `{"useApifyProxy": false}` | Optional. The ACLB search is reachable directly (HTTP-only, no anti-bot); enable a proxy only if a run is blocked. |

### Pricing (Pay Per Event)

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

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

### Use cases

- License verification — confirm an Arkansas contractor's validity, type, and expiration before hiring or onboarding.
- Record enrichment — turn a name or license number into a structured record for a CRM, marketplace, or vetting workflow.
- Compliance checks — pull authoritative ACLB data on demand for audits and due diligence.
- Lender / insurer due diligence — verify a contractor's standing straight from the state registry.

### Why this actor

- Straight from the official Arkansas ACLB registry — authoritative, not a stale third-party copy.
- Search by name or license number; results deduped by license #.
- Pay per match; searches with no results are free.

### Limitations & updates

Covers Arkansas's ACLB public contractor registry only (contractors on projects of $50,000 or more). Results reflect the live ACLB search at lookup time and change as it updates. The ACLB source is served over plain HTTP (the state box offers no HTTPS) and is old/slow, so a run may take a bit longer than a modern API. A broad name can match thousands of contractors; runs are bounded (default 50 results) — refine a broad name to narrow it. Bond, insurance, and issue-date fields are included in the schema for suite consistency but ACLB does not publish them (returned null).

### FAQ

**Where does the data come from?**

The official Arkansas Contractors Licensing Board (ACLB) public contractor search — authoritative, public license data.

**What can I search by?**

A business/DBA name (e.g. 'CONSTRUCTION') or an ACLB license number (enter the first six digits). Both return the matching licenses, deduped by license number.

**What fields do I get?**

License number, business/DBA name, license type, validity status, expiration, city, county, address, and phone — as ACLB publishes them.

**How am I charged?**

Pay-per-result — per license match returned. No charge for searches with no results.

**Is this personal data?**

It's public professional-license data (business and license records as ACLB publishes them); we add no personal/PII enrichment.

**How current is it?**

It reflects the live ACLB record at lookup time.

### Which actor to choose

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

- **California Contractor License Lookup & Verify (CSLB)** — You need a California contractor verified — by license number, business, or owner/personnel name (CSLB).
- **Florida Contractor License Lookup & Verify (DBPR)** — You're verifying a Florida contractor or tradesperson — type, status, expiration, county (DBPR).
- **Louisiana Contractor License Lookup** — You want the full Louisiana roster — 50,000+ commercial, residential & specialty licenses as data (LSLBC).
- **Multi-State Contractor & Trade License Lookup** — You don't know the state, or want the same contractor checked across WA, OR, TX & CT in one run.
- **Nevada Contractor License Lookup & Verify (NSCB)** — You need a Nevada contractor's status, trade classifications, bond & principals (NSCB).
- **New Mexico Contractor License Lookup & Verify (NM CID)** — You're verifying a New Mexico contractor — license #, status, city/ZIP, expiry (NM CID).
- **North Carolina Contractor License Lookup & Verify (NCLBGC)** — You're verifying a North Carolina general contractor — classification, status, expiration (NCLBGC).
- **Oregon Contractor License Lookup & Verify (CCB)** — You're verifying an Oregon contractor — status, bond, insurance & RMI (CCB).
- **South Carolina Contractor License Lookup & Verify (SC LLR)** — You're searching or verifying South Carolina contractors — by name, license, city, or classification (SC LLR).
- **Tennessee Contractor License Lookup & Verify (TN DOCI)** — You're verifying a Tennessee contractor or tradesperson — type, status, city & county (TN DOCI).
- **Texas Contractor & Trade License Lookup (TDLR)** — You're verifying a Texas electrician, HVAC or trade license — type, expiration, county & owner (TDLR).
- **Virginia Contractor License Lookup (DPOR Bulk)** — You want the full Virginia roster — 50,000+ Class A/B/C and trade licenses as bulk data (DPOR).
- **Washington Contractor License Lookup & Verify (L\&I)** — You're verifying a Washington contractor — type, status, expiration, principal (L\&I).
- **Alabama Contractor License Lookup & Verify (LBGC)** — You're verifying an Alabama general contractor — classification, city, phone, expiration (LBGC).
- **Michigan Contractor License Lookup & Verify (LARA)** — You're verifying a Michigan builder or trade contractor — type, status, expiration (LARA).
- **Minnesota Contractor License Lookup & Verify (DLI)** — You're verifying a Minnesota residential contractor — subtype, status, expiration, enforcement flags (DLI).
- **Massachusetts Construction License Lookup & Verify (CSL)** — You're verifying a Massachusetts Construction Supervisor License — type, status, expiration (CSL).

# Actor input Schema

## `query` (type: `string`):

An Arkansas contractor/DBA name (e.g. 'CONSTRUCTION') OR an ACLB license number. An all-digit query is looked up as a license number (enter the first six digits); anything else is searched against the ACLB business/DBA name index. Results are deduped by license number.

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

Cap on the number of matches returned in a single run. This is a lookup, not a bulk export — defaults to 50. (The ACLB server itself returns up to 5000 rows for a broad name.)

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

Optional. The ACLB search is reachable directly (HTTP-only, no anti-bot); enable a proxy only if a run is blocked.

## Actor input object example

```json
{
  "query": "CONSTRUCTION",
  "maxResults": 50,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `matches` (type: `string`):

The matched licenses — validity, type, expiration, city, county, and address.

# 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 = {
    "query": "CONSTRUCTION"
};

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

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

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

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

```

## CLI example

```bash
echo '{
  "query": "CONSTRUCTION"
}' |
apify call fried_calamaries/arkansas-contractor-license-lookup --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Arkansas Contractor License Lookup & Verify (ACLB)",
        "description": "Verify any Arkansas contractor by name or license number — validity, type, expiration, city, county & address — straight from the official ACLB registry.",
        "version": "0.0",
        "x-build-id": "q5CNN1NDSCF8Hm9kL"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fried_calamaries~arkansas-contractor-license-lookup/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fried_calamaries-arkansas-contractor-license-lookup",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/fried_calamaries~arkansas-contractor-license-lookup/runs": {
            "post": {
                "operationId": "runs-sync-fried_calamaries-arkansas-contractor-license-lookup",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/fried_calamaries~arkansas-contractor-license-lookup/run-sync": {
            "post": {
                "operationId": "run-sync-fried_calamaries-arkansas-contractor-license-lookup",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "query"
                ],
                "properties": {
                    "query": {
                        "title": "Search query",
                        "type": "string",
                        "description": "An Arkansas contractor/DBA name (e.g. 'CONSTRUCTION') OR an ACLB license number. An all-digit query is looked up as a license number (enter the first six digits); anything else is searched against the ACLB business/DBA name index. Results are deduped by license number."
                    },
                    "maxResults": {
                        "title": "Maximum results",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Cap on the number of matches returned in a single run. This is a lookup, not a bulk export — defaults to 50. (The ACLB server itself returns up to 5000 rows for a broad name.)",
                        "default": 50
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional. The ACLB search is reachable directly (HTTP-only, no anti-bot); enable a proxy only if a run is blocked.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
