# Alabama Contractor License Lookup & Verify (LBGC) (`fried_calamaries/alabama-contractor-license-lookup`) Actor

Verify any Alabama general contractor by license number or name — specialty/classification, city, phone, address, and expiration — from the official LBGC registry.

- **URL**: https://apify.com/fried\_calamaries/alabama-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

## Alabama Contractor License Lookup & Verify (LBGC)

### Pain points

- Verifying an Alabama contractor on the LBGC license-search site means paging through one big client-side table by hand.
- The board's roster isn't structured for compliance workflows, subcontractor vetting, or CRM enrichment.
- Pulling specialty classification, city, and expiration across many licensees one at a time doesn't scale.

### What we solve

- Verify any Alabama LBGC general contractor by license number (exact) or business name (substring) — one search.
- Returns specialty/classification, city, phone, street address, ZIP, and license expiration from the official registry.
- Enrich a license number or name into a full structured record; pay per match, empty searches free.

### Summary

Look up and verify any Alabama general contractor from a single search — type an LBGC license number or a business name and get back the contractor's specialty classification, city, phone, street address, ZIP, and license expiration date, straight from the official Alabama Licensing Board for General Contractors (LBGC) registry. Built for fast verification, compliance checks, subcontractor vetting, and enriching a license number or name into a structured record.

### Who it's for

- GCs and hiring managers vetting Alabama subcontractors
- Insurance underwriters and lenders running KYC on contractors
- Compliance teams and marketplaces verifying LBGC 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 'AL' for this actor |
| `license_number` | LBGC general-contractor license number |
| `business_name` | Licensed business name |
| `license_type` | Specialty classification (e.g. BC: BUILDING CONSTRUCTION, HS: HIGHWAYS AND STREETS) |
| `city` | Business city |
| `phone` | Business phone (as published on the roster) |
| `address` | Business street / mailing address (from the detail page) |
| `zip_code` | ZIP code (from the detail page) |
| `expiration_date` | License expiration date (from the detail page) |
| `matched_by` | Which search surfaced this match: 'license\_number' or 'business\_name' |
| `source_url` | Link to the contractor's official LBGC detail page |

Sample:

```json
{
  "state": "AL",
  "license_number": "8",
  "business_name": "DUNN CONSTRUCTION CO INC",
  "license_type": "BC: BUILDING CONSTRUCTION, H/RR: HEAVY AND RAILROAD, HS: HIGHWAYS AND STREETS, MU: MUNICIPAL AND UTILITY",
  "city": "BIRMINGHAM",
  "phone": "(205) 592-3866",
  "address": "P O BOX 11967",
  "zip_code": "35202",
  "expiration_date": "9/30/2026",
  "matched_by": "business_name",
  "source_url": "https://licensesearch.alabama.gov/genconbd/Details/2"
}
```

### Inputs

| Field | Required | Type | Default | Description |
|---|---|---|---|---|
| `query` | yes | string | `"CONSTRUCTION"` | An Alabama LBGC general-contractor license number (exact) or a business name (substring). The board publishes a numeric license number; anything non-numeric is treated as a name search. |
| `maxResults` | no | integer | `50` | Cap on matches returned (bounds cost and detail-page fetches). |
| `includeDetails` | no | boolean | `true` | Fetch each match's detail page to add address, ZIP, and expiration date. Disable for a faster, roster-only run. |
| `proxyConfiguration` | no | object | `{"useApifyProxy": false}` | Optional. The Alabama LBGC site is reachable directly; a proxy is not needed. |

### 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 Alabama contractor's specialty classification and expiration before hiring or onboarding.
- Record enrichment — turn a license number or name into a full structured record for a CRM, marketplace, or vetting workflow.
- Compliance checks — pull authoritative LBGC data on demand for audits and due diligence.
- Lender / insurer due diligence — verify a contractor's standing straight from the state board's registry.

### Why this actor

- Straight from the official Alabama LBGC license registry — authoritative, not a stale third-party copy.
- Search by license number (exact) or business name (substring); results deduped by the board's roster.
- Pay per match; searches with no results are free.

### Limitations & updates

Covers the Alabama LBGC commercial general-contractor registry only (this board does not license residential home-builder trades). Results reflect the board's published roster at run time and change as it updates. A name search matches the business-name column; runs are bounded (default 50 results) — refine a broad name to narrow it. Address, ZIP, and expiration date come from each match's detail page and are fetched only when 'Include detail pages' is on. Bond, insurance, status, and issue date are not published on this registry and are returned null; county is not published.

### FAQ

**Where does the data come from?**

The official Alabama Licensing Board for General Contractors (LBGC) public license-search registry — public, authoritative commercial general-contractor license data.

**What can I search by?**

An LBGC license number (exact match) or a business name (case-insensitive substring). Both return the matching licenses from the board's roster.

**What fields do I get?**

License number, business name, specialty classification, city, phone, street address, ZIP, and license expiration date (address, ZIP, and expiration come from each licensee's detail page).

**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 the LBGC publishes them); we add no personal/PII enrichment.

**How current is it?**

It reflects the LBGC's live license-search roster at run time, so results are as current as the board's published data.

### 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).
- **Arkansas Contractor License Lookup & Verify (ACLB)** — You're verifying an Arkansas contractor — validity, type, expiration, city & county (ACLB).
- **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 Alabama LBGC general-contractor license number (exact) or a business name (substring). The board publishes a numeric license number; anything non-numeric is treated as a name search.

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

Cap on matches returned (bounds cost and detail-page fetches).

## `includeDetails` (type: `boolean`):

Fetch each match's detail page to add address, ZIP, and expiration date. Disable for a faster, roster-only run.

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

Optional. The Alabama LBGC site is reachable directly; a proxy is not needed.

## Actor input object example

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

# Actor output Schema

## `licenses` (type: `string`):

Matched AL licenses: number, business, specialty/classification, city, phone, address, expiration.

# 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/alabama-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/alabama-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/alabama-contractor-license-lookup --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Alabama Contractor License Lookup & Verify (LBGC)",
        "description": "Verify any Alabama general contractor by license number or name — specialty/classification, city, phone, address, and expiration — from the official LBGC registry.",
        "version": "0.0",
        "x-build-id": "srqtrgTNItIiIss8o"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fried_calamaries~alabama-contractor-license-lookup/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fried_calamaries-alabama-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~alabama-contractor-license-lookup/runs": {
            "post": {
                "operationId": "runs-sync-fried_calamaries-alabama-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~alabama-contractor-license-lookup/run-sync": {
            "post": {
                "operationId": "run-sync-fried_calamaries-alabama-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 Alabama LBGC general-contractor license number (exact) or a business name (substring). The board publishes a numeric license number; anything non-numeric is treated as a name search."
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Cap on matches returned (bounds cost and detail-page fetches).",
                        "default": 50
                    },
                    "includeDetails": {
                        "title": "Include detail pages",
                        "type": "boolean",
                        "description": "Fetch each match's detail page to add address, ZIP, and expiration date. Disable for a faster, roster-only run.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional. The Alabama LBGC site is reachable directly; a proxy is not needed.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
