# TX Insurance Agent & Adjuster Licenses (`j0401/tx-tdi-licenses`) Actor

Texas insurance agent & adjuster licenses (public open data, 963k records, refreshed daily): every producer license under the state's lines - general lines, adjuster, life, personal lines, surplus, escrow. NPN, type, qualification, issue/expiry, city/state. Filter by type/name/state or pull active.

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

## Pricing

$0.10 / 1,000 tx insurance 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 Insurance Agent & Adjuster Licenses - the State's Producer Register

The Texas Department of Insurance publishes its **entire agent-license register** - every license a producer holds under the state's insurance lines, refreshed daily - as open data. This actor turns that register into a **charged-per-record lookup and renewal-pipeline tool**.

**Built for:** insurance-company compliance & producer on-boarding, MGAs & agencies checking a producer's lines before contracting them, renewal-notification pipelines (who has to renew before a given month), and labor-market analysis of the Texas insurance workforce.

### What it covers

**963,695 licenses** - the full register, refreshed ~daily. One row per license, so a producer licensed for both life and property carries two rows:

| License type | Records |
|---|---|
| General Lines Agent | 547,244 |
| Adjuster | 168,113 |
| Life Agent | 132,927 |
| Personal Lines Prop & Cas Agent | 50,335 |
| Adjuster - DHS Texas | 26,874 |
| Surplus Lines / Escrow / Limited Lines / ... | the long tail |

Each record carries the producer's identity and the license's own terms:

- **NPN** (national producer number) and the **TDI license number**
- **license type** (28 exact values) and the finer **qualification line** - "Life, Accident, Health & HMO" vs "Property and Casualty" vs "Adjuster - All Lines" are separate credentials, not one bucket
- **issue date** and **expiration date** - the renewal clock
- **city / state / postal code** of the holder's address

The register holds more than just Texans: **57% of the rows are out-of-state producers licensed to transact Texas business** (Texas itself is 410,551 of the 963,695) - Florida alone carries 96,124, California 43,394, Georgia 29,400. `state` is a first-class filter.

### The register has no status column

TDI doesn't stamp each row Active / Lapsed. The honest split is the **expiration date vs today** - and that's exactly what this actor does for you. `active` mode hands you the live slice (**925,884 licenses** right now, 96% of the file); date filters answer "who has to renew before November".

### Typical questions

- "Is **this NPN / license number** live, and under what lines?"
- "Every **Adjuster** licensed in Texas - active and lapsed."
- "Who with a **Life, Accident, Health & HMO** qualification is licensed in **Dallas**?"
- "All **Florida-based** producers holding Texas licenses."
- "**Renewal pipeline**: every license expiring in Q4 2026."
- "Aggregate the register by **license type**, **state**, or **expiration year**."

### Inputs

| Input | What it does |
|---|---|
| `mode` | `active` (live slice, default) / `rows` (any license) / `aggregate` |
| `licenseType` | exact: General Lines Agent / Adjuster / Life Agent / ... |
| `qualification` | the finer line (fuzzy): 'Life, Accident, Health & HMO', 'Property and Casualty' |
| `name` / `city` / `state` | holder filters (name & city fuzzy, state exact) |
| `expiresBefore/After` | renewal window |
| `issueBefore/After` | original-issue window |
| `groupBy` | aggregate over licenseType / qualification / state / city / expirationYear |
| `maxResults` | cap records (default 200) |

**Default run = the 200 live licenses expiring soonest** (mode defaults to `active`) - fast for the daily auto-test. For a targeted query add a filter; for a broad view use `aggregate` (a handful of summary rows, not a 963k-row dump).

### Low cost

**From $0.0001 per record** - billed only for the rows you use, at the low end of the store. Cost scales with what you pull, not with the size of the register - and because each record is metered individually there's no per-run charge cap to hit on a big pull.

TDI's register is a "just download the CSV" dataset that hides real traps: **there is no status column** (the live/expired split has to be derived from expiration dates, and the naive "current year" read quietly drops the renewals that land in the following January); **the same producer carries multiple rows** - one per line of authority - so a name search returns every license they hold, which is either exactly right or exactly wrong depending on what you asked; **the type vocabulary mixes permanent and temporary lines** ("Temp General Lines - LAH Agent", "Life Agt Not Exceeding $25,000") that a substring filter drags together; and the file is a **national producer list**, so most of it is people outside Texas. Normalizing that into a register where a `licenseType` / `state` / `expiry` query returns exactly the licenses you mean is the actual product. Every pull is integrity-checked against the feed's known shape, so a degraded source fails loudly instead of returning bad rows.

### Source

- [Texas Open Data: Insurance Agent and Adjuster Licenses](https://data.texas.gov/Insurance/Insurance-Agent-and-Adjuster-Licenses/kxv3-diwf) - the Texas Dept. of Insurance's published register. Reflects the state's record as of each refresh; not a verification of any producer's current standing.

# Actor input Schema

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

active = currently-live licenses (expiration still ahead), the default view. rows = licenses matching your filters, active or lapsed (turn activeOnly on to restrict). aggregate = one count row per group (see groupBy).

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

The license type, exact: General Lines Agent, Adjuster, Life Agent, Pers Lines Prop and Cas Agent, Surplus Lines Agent, Escrow Officer, ... Blank = any.

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

The finer license line (fuzzy), e.g. 'Life, Accident, Health & HMO' or 'Property and Casualty' or 'Adjuster - All Lines'.

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

License holder name (fuzzy), e.g. 'SMITH' or a full name.

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

License holder city (fuzzy).

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

Two-letter state of the holder's address (e.g. TX, FL, CA). Many out-of-state producers hold Texas licenses.

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

When on, returns only licenses whose expiration date is still ahead (the live slice). Turn off to include lapsed licenses. Tip: mode=active is the shortcut that turns this on.

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

Only licenses expiring before this date (YYYY-MM-DD) - e.g. 'renewal pipeline'.

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

Only licenses expiring on/after this date.

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

Only licenses issued before this date.

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

Only licenses issued on/after this date.

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

Which dimension to aggregate over. licenseType -> the line mix; state -> in-state vs out-of-state; expirationYear -> renewal volume ahead.

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

Cap the number of records pushed (0 = up to ~10k per run; each record is metered individually, so there is no per-run charge cap). An aggregate has at most a few hundred groups.

## Actor input object example

```json
{
  "mode": "active",
  "licenseType": "",
  "qualification": "",
  "name": "",
  "city": "",
  "state": "",
  "activeOnly": false,
  "expiresBefore": "",
  "expiresAfter": "",
  "issueBefore": "",
  "issueAfter": "",
  "groupBy": "licenseType",
  "maxResults": 50
}
```

# Actor output Schema

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

Texas insurance 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-tdi-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-tdi-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-tdi-licenses --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,j0401/tx-tdi-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/vCcJCa0C9NIXF4qPs/builds/Rkr9fHE9vOnYEe8Yi/openapi.json