# NAIC Insurance Lookup \[$0.50💰] | Producer License Data (`ahmed_jasarevic/naic-scraper`) Actor

Verify insurance producer licenses via the NAIC State Based Systems lookup. Search by NPN, name, license number or FEIN across 30+ US jurisdictions. Returns license status, types, dates, lines of authority and contact data for compliance and due diligence.

- **URL**: https://apify.com/ahmed\_jasarevic/naic-scraper.md
- **Developed by:** [Ahmed Jasarevic](https://apify.com/ahmed_jasarevic) (community)
- **Categories:** Developer tools, Automation, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 results

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

## NAIC Insurance Producer & License Lookup

Perform NAIC insurance producer lookup across all 50 US states and territories. Query the National Association of Insurance Commissioners database for verified license data, NPN records, and compliance status.

### Use Cases

- **License Verification** — Confirm an insurance agent's license status before onboarding or referral
- **Compliance Auditing** — Batch-check producers against state requirements for regulatory compliance
- **Lead Generation** — Export active licensed producers by state for insurance sales prospecting
- **NPN Lookup** — Resolve National Producer Numbers to full agent profiles and license details
- **Multi-State Research** — Track producers holding licenses across multiple jurisdictions
- **Business Entity Search** — Find insurance agencies, brokerages, and corporate license holders

### How It Works

The actor queries the NAIC State Based Systems (SBS) database — the official source for insurance producer licensing in the United States. You provide search criteria (name, NPN, license number, or business name) and the actor returns structured results including license status, lines of authority, resident/non-resident designation, and issuing state.

### Input

| Field | Type | Required | Default | Notes |
|---|---|---|---|---|
| `state` | `string` | Yes | — | 2-letter US state/territory code (e.g. `MO`, `IL`, `CA`) |
| `searchType` | `string` | No | `individual` | `individual` or `business` |
| `lastName` | `string` | No | — | Producer's last name (individual search) |
| `firstName` | `string` | No | — | Producer's first name (individual search) |
| `middleName` | `string` | No | — | Producer's middle name (individual search) |
| `npn` | `string` | No | — | National Producer Number (e.g. `654321`) |
| `licenseNumber` | `string` | No | — | State-issued license number |
| `businessName` | `string` | No | — | Business entity name (business search) |
| `fein` | `string` | No | — | Federal Employer ID Number (business search) |
| `licenseStatus` | `string` | No | — | Filter: `Active`, `Inactive`, `Expired`, `Cancelled`, `Revoked`, `Surrendered` |
| `licenseType` | `string` | No | — | License type filter (e.g. `Agent`, `Broker`, `Adjuster`) |
| `residentLicense` | `boolean` | No | — | Filter by resident (`true`) or non-resident (`false`) license |
| `autoExpand` | `boolean` | No | `true` | Automatically expand result details |
| `expandDepth` | `integer` | No | `1` | Depth of auto-expansion (1–3) |
| `maxItems` | `integer` | No | `100` | Maximum results to return (hard cap: 1000) |
| `proxyConfiguration` | `object` | No | — | Apify proxy configuration for request routing |

### Output

Each result item contains:

- `npn` — National Producer Number
- `firstName`, `middleName`, `lastName` — Producer name
- `licenseNumber` — State license number
- `licenseStatus` — Current status (Active, Inactive, Expired, Cancelled, Revoked, Surrendered)
- `licenseType` — Type of license
- `residentLicense` — Whether this is the producer's resident state
- `state` — Issuing state code
- `linesOfAuthority` — Authorized lines (e.g. Life, Health, Property, Casualty)
- `issueDate`, `expiryDate` — License dates
- `businessName` — Associated business entity (if applicable)

### Example Input

```json
{
  "state": "MO",
  "searchType": "individual",
  "lastName": "Smith",
  "licenseStatus": "Active",
  "maxItems": 50
}
```

### Example Output

```json
[
  {
    "npn": "12345678",
    "firstName": "John",
    "middleName": "A",
    "lastName": "Smith",
    "licenseNumber": "MO-2024-12345",
    "licenseStatus": "Active",
    "licenseType": "Agent",
    "residentLicense": true,
    "state": "MO",
    "linesOfAuthority": ["Life", "Health", "Variable Life"],
    "issueDate": "2022-03-15",
    "expiryDate": "2025-03-15",
    "businessName": null
  }
]
```

### Integrations

- **Google Sheets** — Export results directly for analysis and sharing
- **Slack** — Send compliance alerts when licenses expire or change status
- **CRM Tools** — Push producer data to Salesforce, HubSpot, or Pipedrive
- **Compliance Platforms** — Feed into insurance compliance management workflows
- **Webhooks** — Trigger downstream automations via Apify webhooks on run completion

### Related Actors

- [Insurance Agent Lead Scraper](https://apify.com/samstorm/insurance-agent-lead-scraper) — Scrape insurance agent leads from Google Maps
- [Indeed Scraper](https://apify.com/borderline/indeed-scraper) — Extract job listings from Indeed including insurance roles

### FAQ

**What is the NAIC SBS database?**
The State Based Systems (SBS) database is maintained by the National Association of Insurance Commissioners and contains official insurance producer licensing data for all US states and territories.

**Can I search without a state?**
No. The `state` field is required. The NAIC database is organized by state — each query targets a specific state's records.

**What does NPN mean?**
NPN stands for National Producer Number — a unique 7–10 digit identifier assigned to insurance producers that remains constant across states.

**Is this data real-time?**
The actor queries the NAIC SBS database which is updated by state insurance departments. Data reflects the latest published records, typically within days of state updates.

### Related Actors

Verified related actors on Apify that pair well with this one. All links point to real, publicly available actors.

- [Indeed Scraper](https://apify.com/misceres/indeed-scraper)
- [LinkedIn Profile Scraper](https://apify.com/harvestapi/linkedin-profile-scraper)

### SEO Keywords

NAIC lookup, insurance producer license verification, NPN lookup, insurance agent database, NAIC SBS license search, insurance license status check, insurance producer data, insurance company license, state insurance license verification, insurance compliance check, insurance agent lead generation, NAIC API alternative, insurance license search by name, insurance producer number lookup, lines of authority lookup, insurance producer search, NAIC producer database, insurance license lookup by state, insurance agent NPN search, NAIC SBS database

### For AI Agents

**Minimal input:** `{ "state": "MO", "lastName": "Smith" }`

**Output fields:** `npn`, `firstName`, `lastName`, `licenseStatus`, `licenseNumber`, `state`, `linesOfAuthority`

**Behaviors:**

- Returns 0 items if no matches found (empty array, not error)
- `maxItems` caps at 1000 — page with offsets for larger datasets
- `state` is always required — the actor will reject requests without it
- Pricing: $0.005 per result item returned

### Legal Disclaimer

This actor accesses publicly available data from the NAIC State Based Systems (SBS) database, which is maintained by a government entity (the National Association of Insurance Commissioners). The data is public record and is provided as-is. This tool is not affiliated with or endorsed by the NAIC. Users are responsible for ensuring their use of this data complies with applicable laws and regulations.

# Actor input Schema

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

Jurisdiction to search (2-letter code like "MO" or full name like "Missouri"). Only jurisdictions participating in the NAIC external lookup are supported (e.g. AL AK AZ AR CT DE DC GU HI ID IL IA KS MD MA MO MT NE NH NJ NM NC ND OK OR PR RI SC SD TN VI VT WV WI). Texas, California and New York are NOT available.

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

Whether to search individual producers or business entities (companies).

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

Producer last name (individual search). Optional but recommended - searches return at most 25 records each, so narrow them down.

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

Producer first name (individual search). Optional - narrows results.

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

Producer middle name (individual search). Optional.

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

Most precise lookup - returns a single producer record.

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

State license number to narrow the search (individual or business).

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

Company name for business-entity searches (or entity name for Business Entity producer lookups).

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

Federal Employer Identification Number. Optional.

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

Optional license status filter. Values vary by state (e.g. Active). Leave empty for all.

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

Optional license type filter exactly as named by the state (e.g. "Insurance Producer"). Leave empty for all.

## `residentLicense` (type: `boolean`):

When checked, only resident license records are returned (individual searches).

## `autoExpand` (type: `boolean`):

The NAIC API returns at most 25 records per query. When enabled, broad searches that hit the cap are automatically split into A-Z sub-queries (by last/company name) and merged, so you get far more records. Ignored when you provide an explicit name/NPN/license filter.

## `expandDepth` (type: `integer`):

How deep capped sub-queries may be split further: 1 = A-Z (up to ~26 requests per capped query), 2 = AA, AB, ... (up to hundreds of requests - much slower). Only used with Auto-expand.

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

Maximum number of records to extract (hard cap 1000). Free users are limited to 10.

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

Proxy used for all requests. If you see HTTP 403 errors, switch to the Apify RESIDENTIAL proxy group here.

## Actor input object example

```json
{
  "state": "MO",
  "searchType": "individual",
  "residentLicense": false,
  "autoExpand": true,
  "expandDepth": 1,
  "maxItems": 100,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `dataset` (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 = {
    "state": "MO",
    "lastName": "",
    "firstName": "",
    "middleName": "",
    "npn": "",
    "licenseNumber": "",
    "businessName": "",
    "fein": "",
    "licenseStatus": "",
    "licenseType": "",
    "expandDepth": 1,
    "maxItems": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("ahmed_jasarevic/naic-scraper").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 = {
    "state": "MO",
    "lastName": "",
    "firstName": "",
    "middleName": "",
    "npn": "",
    "licenseNumber": "",
    "businessName": "",
    "fein": "",
    "licenseStatus": "",
    "licenseType": "",
    "expandDepth": 1,
    "maxItems": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("ahmed_jasarevic/naic-scraper").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 '{
  "state": "MO",
  "lastName": "",
  "firstName": "",
  "middleName": "",
  "npn": "",
  "licenseNumber": "",
  "businessName": "",
  "fein": "",
  "licenseStatus": "",
  "licenseType": "",
  "expandDepth": 1,
  "maxItems": 100
}' |
apify call ahmed_jasarevic/naic-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,ahmed_jasarevic/naic-scraper"
        }
    }
}

```

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/ZE7OqTIWENoTsz0sX/builds/yHeXEnshGuWYHAN5H/openapi.json