# Insurance Adjuster License Verification - All Lines & P\&C (`kempdata/us-insurance-adjuster-licenses`) Actor

Verify insurance adjuster license status in bulk. 189,547 active credentials from the Texas TDI registry - the de facto national roster, since most working adjusters hold a Texas licence. Search by RESIDENT state to find adjusters near a storm. All Lines, P\&C and public adjusters, with lapsed flags.

- **URL**: https://apify.com/kempdata/us-insurance-adjuster-licenses.md
- **Developed by:** [Mark Kemp](https://apify.com/kempdata) (community)
- **Categories:**
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.50 / 1,000 adjuster 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

## US Insurance Adjuster Licenses — Texas Registry

**198,000+ licensed insurance adjusters from the Texas Department of Insurance registry — and roughly 62% of them live outside Texas, across 56 states and territories.**

**States included:** Texas. That single registry reaches nationwide for a reason: Texas sits on the hurricane coast *and* takes enormous hail losses every year, so that is where the claims work is. Adjusters who want to stay active carry a Texas license no matter where they live. Every state that publishes its full adjuster roster through an official data feed gets added as we find it — no request needed.

### Who this is for

- **Independent adjusting firms staffing catastrophe deployments** — when a storm lands, you need adjusters who are licensed and near it. Filter by the adjuster's **home state** and credential class to build a deployment roster in one run.
- **Firms tracking their own bench** — adjusting firms are routinely unsure which licenses a given adjuster actually holds. Every record carries the **National Producer Number**, the industry's universal ID, so a roster can be matched against your own list without guessing at name spellings.
- **Continuing-education providers** — adjusters must complete CE to stay licensed. The *expiring soon* filter is the renewal season, named.
- **Carriers and vendor-management teams** — verify that an adjuster's credential is current before work is assigned.

### What you get

One record per adjuster license: name, National Producer Number, license number, credential class decoded into plain English (All Lines, Property & Casualty, Workers' Compensation, Public Insurance Adjuster), home city/state/ZIP, issue and expiration dates, plus computed `expires_in_days`, `is_active`, `is_expiring_soon`, `is_new_license`, `years_licensed`, and `is_designated_home_state`.

That last flag is worth knowing: it marks adjusters whose own state does not license adjusters at all, so Texas stands in as their designated home state.

Export to Excel, CSV, or JSON, or pull on a schedule via API.

### One schema across every state

Every licence roster in this catalogue delivers **the same columns, in the same
order, meaning the same thing** — whichever state or profession the records came
from. Stack this dataset on top of any other KempData roster and the columns
line up.

That takes real work. Illinois writes a lapsed licensee as `NOT RENEWED` in
block capitals; Delaware writes the identical situation as `Delinquent`. Both
arrive here as `status: "lapsed"`. Names arrive SHOUTING and glued together;
they leave as `full_name`, `first_name`, `middle_name`, `last_name` in proper
case. Dates are **MM/DD/YYYY**, with an `_iso` twin for spreadsheets and imports.

**The state's own word is never thrown away.** Every translated value ships
beside a `*_raw` twin — `status_raw`, `credential_raw`, `name_raw` — holding the
source's exact string, so you can always check our work or apply your own rules.
`status_basis` tells you whether the standing is the state's published fact or
computed from the expiration date.

**`lapsed` is worth knowing about.** It is the recall pool: people who held the
licence, let it run out, and can renew. When you need experienced people in a
hurry, that is the list to call.

Full column reference: `docs/SCHEMA.md` in the source repository.

### Data source & fair use

The Texas Department of Insurance licensee registry, published as open data by the State of Texas (dataset `kxv3-diwf`) — a public record the state maintains for exactly this use. No scraping; paged, rate-limit-respecting requests.

The registry does not carry a status column, so **active** is computed honestly from the expiration date rather than asserted.

### Support

Questions answered fast — usually within hours. Want a profession or license category we don't cover yet? Open an issue and name it — new license products get built in the order people ask.

# Actor input Schema

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

Which adjuster credential to return. "All Lines" adjusters can handle any claim type; "Property & Casualty" is the storm and property lane; "Public" adjusters represent policyholders rather than insurers.

## `residentStates` (type: `array`):

Two-letter state codes for where the adjuster LIVES (e.g. LA, FL, GA). Most adjusters in this registry live outside Texas, so this is how you find licensed adjusters near a storm. Leave empty for all states.

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

Limit to adjusters whose home address is in this city. Leave empty for all cities.

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

"Expiring soon" catches adjusters before a lapse takes them out of the field. "Recently licensed" finds adjusters new to the profession. "Lapsed" returns licenses already past their expiration date.

## `expiringWithinMonths` (type: `integer`):

For the expiring-soon filter: include licenses that expire within this many months.

## `newWithinMonths` (type: `integer`):

For the recently-licensed filter: include licenses first issued within this many months.

## `designatedHomeStateOnly` (type: `boolean`):

Return only adjusters who use Texas as their designated home state - meaning their own state does not license adjusters at all.

## `onlyActive` (type: `boolean`):

Skip licenses whose expiration date has already passed. The registry has no status column, so active is computed from the expiration date.

## `maxRecords` (type: `integer`):

Stop after this many results. You are only charged for records actually returned.

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

Optional Texas Open Data app token. Not required - only useful for very large pulls, to lift the anonymous rate limit.

## Actor input object example

```json
{
  "adjusterType": "all",
  "residentStates": [],
  "city": "",
  "recordFilter": "all",
  "expiringWithinMonths": 6,
  "newWithinMonths": 6,
  "designatedHomeStateOnly": false,
  "onlyActive": true,
  "maxRecords": 1000
}
```

# Actor output Schema

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

Dataset of licensed insurance adjusters with credential class, home state, expiration tracking and lead reasons.

# 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("kempdata/us-insurance-adjuster-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("kempdata/us-insurance-adjuster-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 kempdata/us-insurance-adjuster-licenses --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,kempdata/us-insurance-adjuster-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/eWktQJtpVEganzViT/builds/1iSt1Z5wrT49C53qL/openapi.json