# TDLR Occupational License Records for Texas Trades (`vexaloom-labs/tdlr-occupational-license-records-for-texas-trades`) Actor

Search Texas TDLR license records across 80+ trades by holder/business name or license number, with trade category, county, and active/expired status filters.

- **URL**: https://apify.com/vexaloom-labs/tdlr-occupational-license-records-for-texas-trades.md
- **Developed by:** [vexaloom-labs](https://apify.com/vexaloom-labs) (community)
- **Categories:** Lead generation, Automation, Real estate
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.49 / 1,000 results

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

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## TDLR Occupational License Records for Texas Trades

The Texas Department of Licensing and Regulation licenses more than 80 trades — cosmetology, electricians, HVAC technicians, tow truck operators, elevator inspectors, auctioneers, property tax professionals, and more. This actor searches those license records by owner name, business name, or license number, returning status, expiration, trade category, county, city, ZIP, and contact details.

### What this actor does

- Searches owner names only, business/DBA names only, or both at once.
- Looks up a specific license number directly when you already know it.
- Filters by any of the 86 current TDLR trade categories, any Texas county (plus out-of-state licensees), city, ZIP code, and active-vs-expired status.
- Works out each license's active/expired status itself by comparing its expiration date against today, since TDLR's own data doesn't carry a separate status field.
- Sorts by license number, owner, business, or expiration date, ascending or descending. Expiration sorting is chronological, not month-first text order.
- Splits TDLR's combined `CITY ST ZIP` text (including full state names like `AUSTIN, Texas 78701`) into separate city, state, and ZIP fields alongside the original value.
- Leaves a field out of a record whenever TDLR never published that value for the license, rather than sending it empty.

### Output per license

| Field | Description |
|---|---|
| `licenseNumber` | TDLR license number |
| `licenseType` | TDLR trade category, e.g. `Cosmetology Operator`, `Electrical Contractor` |
| `licenseSubtype` | TDLR's internal subtype/tier code, when published |
| `ownerName` | Individual or business owner name |
| `businessName` | Business or DBA name |
| `businessAddressLine1`, `businessAddressLine2` | Business street address, when published |
| `businessCity`, `businessState`, `businessZip` | Business location split out of TDLR's combined city/state/ZIP text |
| `businessCityStateZip` | TDLR's original combined business city/state/ZIP text |
| `businessCounty` | Texas county of the business (or `OUT OF STATE`) |
| `businessPhone` | Business phone, when published |
| `mailingAddressLine1`, `mailingAddressLine2` | Mailing street address, when published |
| `mailingCity`, `mailingState`, `mailingZip` | Mailing location split out of the combined text |
| `mailingCityStateZip` | TDLR's original combined mailing city/state/ZIP text |
| `mailingCounty` | Texas county of the mailing address |
| `ownerPhone` | Owner phone, when published |
| `latitude`, `longitude` | Geocoded business location, when published |
| `expirationDate` | License expiration date (`YYYY-MM-DD`) |
| `licenseStatus` | `active` or `expired`, computed from `expirationDate` against today |
| `continuingEducationRequired` | Whether TDLR flags this license as requiring continuing education |
| `sourceUrl` | Link to the matching record(s) on the Texas Open Data Portal |
| `datasetLastUpdated` | When TDLR's published dataset was last refreshed |
| `recordType` | Always `license` |
| `scrapedAt` | UTC timestamp of the scrape |

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `byName` | `byName` (owner or business), `byOwnerName`, `byBusinessName`, or `byLicenseNumber`. |
| `nameQuery` | string | `Smith` | Name to match, used by the three name modes. Optional if a trade category, county, city, or ZIP narrows the query. |
| `licenseNumber` | string | – | TDLR license number to look up, used in `byLicenseNumber` mode. |
| `licenseType` | string | – (all types) | One of the 86 current TDLR trade categories. |
| `countyFilter` | string | – (all counties) | A Texas county from TDLR's own list, or `OUT OF STATE`. |
| `cityFilter` | string | – | Business or mailing city, e.g. `Austin`. A trailing state or ZIP is accepted and ignored. |
| `zipFilter` | string | – | 5-digit ZIP prefix, e.g. `78701`. ZIP+4 is accepted and truncated. |
| `statusFilter` | string | – (both) | `active` or `expired`. |
| `sortBy` | string | `licenseNumber` | `licenseNumber`, `ownerName`, `businessName`, or `expirationDate`. |
| `sortDirection` | string | `asc` | `asc` or `desc` for the selected sort field. |
| `maxItems` | integer | `20` | Maximum number of license records to return (1–5,000). |

#### Example: search by owner name

```json
{
  "mode": "byOwnerName",
  "nameQuery": "Smith",
  "maxItems": 20
}
```

#### Example: active electrical contractors in Houston

```json
{
  "mode": "byBusinessName",
  "nameQuery": "Electric",
  "licenseType": "Electrical Contractor",
  "countyFilter": "HARRIS",
  "cityFilter": "Houston",
  "statusFilter": "active",
  "sortBy": "expirationDate",
  "sortDirection": "desc",
  "maxItems": 50
}
```

#### Example: direct license number lookup

```json
{
  "mode": "byLicenseNumber",
  "licenseNumber": "11484",
  "licenseType": "A/C Contractor"
}
```

#### Example: browse a trade category in one ZIP

```json
{
  "mode": "byName",
  "licenseType": "Tow Truck Operator (Consent Tow)",
  "zipFilter": "78701",
  "maxItems": 100
}
```

### Use cases

- **Contractor vetting** — confirm an electrician, HVAC technician, or contractor's license is active before hiring them.
- **Compliance checks** — verify cosmetology or barbering staff licenses across multiple locations.
- **Vendor and lead validation** — confirm a business's license number resolves to a real, current license.
- **Industry-specific checks** — look up tow truck operators, elevator inspectors, or property tax professionals by trade category.
- **Market mapping** — enumerate licensed businesses by trade category, county, city, or ZIP.

### FAQ

**What's the data source, and is this affiliated with TDLR?**
It's TDLR's own official license dataset, published on the Texas Open Data Portal. This is an independent, third-party actor and isn't affiliated with or endorsed by TDLR or the State of Texas.

**How fresh is the data?**
The Open Data Portal dataset is refreshed by TDLR on a regular cadence — the `datasetLastUpdated` field on each record tells you exactly when. It isn't a live, real-time feed, but it reflects the same license records TDLR itself publishes.

**Why do some records have no street address, phone, or ZIP?**
TDLR publishes contact details for roughly one in ten licensees (about 100,000 businesses out of the full file). When a license only has a name, county, and expiration date, the missing fields are left off rather than shown blank.

**Why do some records have no `licenseType`?**
A small number of rows in TDLR's own dataset don't have a trade category filled in; that field is left off rather than shown blank. Report header/footer rows with no license number at all are skipped.

**Why can the same license number return more than one record?**
TDLR assigns license numbers per trade category rather than globally, so one number can belong to several unrelated license types at once (for example, an A/C Technician and a Property Tax Consultant sharing the same number). Set `licenseType` to narrow to the one you mean.

**Why do I see fewer rows than TDLR's raw file count?**
TDLR's export repeats some license numbers within the same trade category; the actor emits each number + trade category once. A handful of rows also use `01/01/1900` as a "no date on file" placeholder, so no expiration/status is shown for them.

**Do I need a login or proxy?**
No. The Texas Open Data Portal is fully public and doesn't require authentication.

**How is `licenseStatus` worked out?**
By comparing each license's expiration date to the current date: `active` if it expires today or later, `expired` otherwise. TDLR's dataset itself doesn't publish a separate status field.

**Can I search without a name at all?**
Yes — leave `nameQuery` blank and set `licenseType`, `countyFilter`, `cityFilter`, and/or `zipFilter` to browse licenses matching just those filters.

**Did the old Behavior Analyst categories change?**
Yes. TDLR now calls them `Licensed Behavior Analyst` and `Licensed Assistant Behavior Analyst`. Saved tasks and API calls that still send the old labels are mapped automatically.

### Limitations

- The dataset is a periodic export, not the live licensing system. Newly issued or just-renewed licenses may lag by days to weeks.
- It does not contain issue dates, disciplinary actions, bonds, insurance, or exam results. The actor cannot return fields the source does not publish.
- Street address, phone, and coordinates exist for only a subset of licensees (mainly business licenses), so those fields are omitted for individual-only licenses.
- `maxItems` is capped at 5,000 per run. Split a very broad browse by trade category, county, city, or ZIP to collect more.

# Actor input Schema

## `mode` (type: `string`):

How to look up licenses. The three name modes return the same record shape; they only change which name column the search matches.

## `nameQuery` (type: `string`):

Case-insensitive partial match against the license holder name in `byOwnerName`, the business/DBA name in `byBusinessName`, or either in `byName` (e.g. `Smith` or `Star Electrical`). Optional if `licenseType`, `countyFilter`, `cityFilter` or `zipFilter` is set — leaving it blank then browses all licenses matching those filters.

## `licenseNumber` (type: `string`):

The TDLR license number, e.g. `11484`. Note: TDLR numbers licenses per trade category, so the same number can be shared across different license types — use `licenseType` to disambiguate.

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

Only emit licenses of this TDLR trade category. The list mirrors the 86 categories currently present in TDLR's published dataset; the two legacy Behavior Analyst labels at the end are accepted for saved tasks and mapped to their current names.

## `countyFilter` (type: `string`):

Only emit licenses whose business or mailing county is this county. Values are TDLR's own uppercase county names; `OUT OF STATE` covers out-of-state licensees. Saved tasks using mixed-case text still work.

## `cityFilter` (type: `string`):

Only emit licenses whose business or mailing city matches, e.g. `Austin`, `San Antonio` or `Green Bay`. Case-insensitive exact city match; a trailing state or ZIP is accepted and ignored.

## `zipFilter` (type: `string`):

Only emit licenses whose business or mailing ZIP starts with this 5-digit code, e.g. `78701`. ZIP+4 input is accepted and truncated to the 5-digit prefix.

## `statusFilter` (type: `string`):

Only emit licenses that are currently active or expired, based on the license expiration date. Leave unset for both.

## `sortBy` (type: `string`):

Order results are fetched/emitted in. Defaults to license number.

## `sortDirection` (type: `string`):

Ascending or descending for the selected sort field. Expiration sorting is chronological, not month-first text order.

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

Hard cap on emitted license records.

## Actor input object example

```json
{
  "mode": "byName",
  "nameQuery": "Smith",
  "licenseNumber": "11484",
  "licenseType": "",
  "countyFilter": "",
  "statusFilter": "",
  "sortBy": "licenseNumber",
  "sortDirection": "asc",
  "maxItems": 20
}
```

# Actor output Schema

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

Dataset containing all scraped TDLR license records.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "mode": "byName",
    "nameQuery": "Smith",
    "licenseNumber": "11484",
    "licenseType": "",
    "countyFilter": "",
    "statusFilter": "",
    "sortBy": "licenseNumber",
    "sortDirection": "asc",
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("vexaloom-labs/tdlr-occupational-license-records-for-texas-trades").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 = {
    "mode": "byName",
    "nameQuery": "Smith",
    "licenseNumber": "11484",
    "licenseType": "",
    "countyFilter": "",
    "statusFilter": "",
    "sortBy": "licenseNumber",
    "sortDirection": "asc",
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("vexaloom-labs/tdlr-occupational-license-records-for-texas-trades").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "mode": "byName",
  "nameQuery": "Smith",
  "licenseNumber": "11484",
  "licenseType": "",
  "countyFilter": "",
  "statusFilter": "",
  "sortBy": "licenseNumber",
  "sortDirection": "asc",
  "maxItems": 20
}' |
apify call vexaloom-labs/tdlr-occupational-license-records-for-texas-trades --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,vexaloom-labs/tdlr-occupational-license-records-for-texas-trades"
        }
    }
}
```

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

## OpenAPI specification

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