# TX Real Estate Licenses - TREC & TALCB Register (`j0401/tx-real-estate-licenses`) Actor

Texas real-estate licenses (TREC + TALCB public data): sales agents, brokers and broker companies in one register (~324k) with the agent-to-broker chain, plus appraisers (~24k) and inspectors (~9k). Verify active licenses, screen status, or find every agent under a broker.

- **URL**: https://apify.com/j0401/tx-real-estate-licenses.md
- **Developed by:** [Wenhao Yang](https://apify.com/j0401) (community)
- **Categories:**
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$1.00 / 1,000 tx real-estate 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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

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

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

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

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

# README

## TX Real Estate Licenses - TREC Sales Agents, Brokers & Appraisers + TALCB Inspectors

The Texas Real Estate Commission publishes its **entire license register** as open data - every licensed sales agent, broker, appraiser, and the TALCB-registered real-estate inspectors. This actor turns those registers into a **charged-per-record lookup and screening tool**.

**Built for:** real-estate due diligence - verifying that an agent / broker actually holds a current Texas license, **mapping the agent-to-broker chain** (who works under which broker, which broker heads a company), hiring & onboarding checks, mortgage / title-industry verification, and state / county industry analysis.

### What it covers

| Register (`type`) | What it is | Rows |
|---|---|---|
| `real-estate` | Sales agents + brokers in one register | 324,348 |
| `appraiser` | TREC appraisers | 24,453 |
| `inspector` | TALCB real-estate inspectors | 8,948 |

#### `real-estate` - the agent-to-broker chain (default)

**324,348 license rows** covering every sales agent, broker individual and broker company. **Every currently-active agent (99.97%) and every broker company carries its sponsoring license** on the row: a Sales Agent links to its employing **Broker Company** (the broker they work under), and a Broker Company links to its **designated Broker Individual**. One row gives you the whole picture - search a broker company to find the sales agents working under it (`relatedTo`), or look up an agent to see their sponsoring broker. (A broker individual is the top of the chain and carries no sponsor; rows that lapsed before a sponsor was recorded carry no link.)

| License type | Rows |
|---|---|
| Sales Agent | 262,643 |
| Broker Individual | 42,573 |
| Broker Company | 19,132 |

Each row carries the license number, license type, **status**, the holder's / company's name, county, original-issue and **expiration dates**, a designated-supervisor flag, and the related license's number / type / name. **188,880 rows are currently Active.**

Statuses match the source exactly: **Active** / Expired less than 6 months / Expired more than 6 months / Inactive / Revoked / Suspended / Deceased / Surrendered / Probation - Active / Military / Closed - Upgraded / ...

#### `appraiser` & `inspector`

**Appraisers (24,453):** Trainee, Certified Residential, Certified General, Licensed Residential, Temporary Non-Resident - with status and expiry. **Inspectors (8,948):** TALCB Professional / Apprentice / Real-Estate inspectors (the education-and-inspection trade licenses), same shape as the real-estate register (their register carries no county).

### Typical questions

- "Is this **agent's license current**, and who is their **sponsoring broker**?"
- "**Every sales agent working under broker company X** (`relatedTo` = the company's number)."
- "Show all **active brokers in Harris County**."
- "Which **broker individual heads this company**?"
- "How many **appraisers by type** in Texas?"
- "Screen a name across the register for **revoked / suspended** status."

### Inputs

| Input | What it does |
|---|---|
| `type` | real-estate (default) / appraiser / inspector |
| `licenseNumber` | exact number (e.g. 857303-SA) -> that license |
| `relatedTo` | a sponsoring license number -> **every license under it** (the reverse chain) |
| `name` / `lastName` / `firstName` | holder name substring |
| `licenseType` | Sales Agent / Broker Individual / Broker Company / Certified General / Professional / ... |
| `county` | county of license (real-estate register) |
| `status` | Active (default) / Expired / Inactive / Revoked / ... - blank = Active, 'all' = full register |
| `aggregate` / `groupBy` | one summary row per group - license type / status / county |
| `maxResults` | cap records (default 200) |

**Default run = 200 currently-Active real-estate licenses** - a representative live slice, fast for the daily auto-test. For a targeted query add a `licenseNumber` / `relatedTo` / `name` / `county` filter; for a broad view use `aggregate`.

### Low cost

**From $0.001 per record** - billed only for the rows you use, with a per-run charge cap so a broad query can't surprise-bill.

Texas keeps these in **three differently-shaped registers** (the agent/broker one with the sponsorship chain, the appraisers, the inspectors) whose statuses don't line up - "expired" alone splits into *less than 6 months* and *more than 6 months* buckets, one register's county column is empty on every row, license numbers only resolve with their suffix intact, and company rows carry no person name to search on. Unifying that into one register where a `name` / `county` / `status` / `relatedTo` query returns exactly the licenses you mean - every agent under a broker, both expiry buckets when you ask for expired - is the work. Every pull is integrity-checked against each register's known shape, so a degraded source fails loudly instead of returning bad rows.

### Source

- [Texas Real Estate Commission](https://www.trec.texas.gov/) + [TALCB](https://www.talcb.texas.gov/) - data.texas.gov open-data datasets `s7ft-44qi` (real-estate), `nmqp-zmi7` (appraiser), `pkr9-9isv` (inspector).
- Reflects the agencies' published record on the refresh date; not an endorsement of any licensee or firm.

# Actor input Schema

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

real-estate = sales agents + broker individuals + broker companies in one register (~324k), with the agent-to-broker chain on every row. appraiser = TREC appraisers (~24k). inspector = TALCB real-estate inspectors (~9k).

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

Exact license number, e.g. 857303-SA (sales agent), 770095-B (broker), 9017226-BB (broker company), 1382201-LR (appraiser). Returns that license.

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

License type. real-estate: 'Sales Agent', 'Broker Individual', 'Broker Company'. appraiser: 'Certified Residential', 'Certified General', 'Licensed Residential', 'Trainee', 'Temporary Non-Resident'. inspector: 'Professional', 'Apprentice', 'Real Estate'. Substring, case-insensitive.

## `name` (type: `string`):

License holder's last or first name (substring). For a broker company, matches the company name.

## `lastName` (type: `string`):

License holder's last name (substring). Not on broker-company rows.

## `firstName` (type: `string`):

License holder's first name (substring).

## `status` (type: `string`):

License status. Blank defaults to Active (the ~189k live real-estate licenses). Set to 'all' / '\*' for the full register. 'expired' matches any expired status (both the <6m and >6m buckets); or use an exact value: Active, Expired less than 6 months, Expired more than 6 months, Inactive, Revoked, Suspended, Deceased, Surrendered.

## `county` (type: `string`):

County (substring), e.g. 'Harris', 'Dallas'. Only on the real-estate register (appraiser and inspector registers carry no county).

## `relatedTo` (type: `string`):

Reverse lookup: find every license whose related/sponsoring license is this number. E.g. a broker-company number returns all its sales agents; a broker-individual number returns the companies they head. The agent-to-broker chain.

## `aggregate` (type: `boolean`):

When on, returns one summary record per group (see groupBy) with license count and share - instead of individual licenses. Computed server-side.

## `groupBy` (type: `string`):

Which dimension to aggregate over. Blank = licenseType. For real-estate / inspector: licenseType (sales agent vs broker), status, county. For appraiser: licenseType, status.

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

Cap the number of records pushed (0 = unlimited, up to ~10k rows per run). A license query can reach the run's charge cap; an aggregate over a register has at most a few dozen groups.

## Actor input object example

```json
{
  "type": "real-estate",
  "licenseNumber": "",
  "licenseType": "",
  "name": "",
  "lastName": "",
  "firstName": "",
  "status": "",
  "county": "",
  "relatedTo": "",
  "aggregate": false,
  "groupBy": "",
  "maxResults": 200
}
```

# Actor output Schema

## `recordsUrl` (type: `string`):

Texas real-estate license records or aggregates - as JSON

## `datasetUrl` (type: `string`):

No description

## `runUrl` (type: `string`):

No description

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("j0401/tx-real-estate-licenses").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("j0401/tx-real-estate-licenses").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 '{}' |
apify call j0401/tx-real-estate-licenses --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,j0401/tx-real-estate-licenses"
        }
    }
}

```

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/RJuVtUvCqpJJA3F0e/builds/tj7k9Dpt8mid3gnix/openapi.json