# US Employer & 401(k) Plan Data — Form 5500 (DOL) (`foxlabs/us-employer-benefit-plans`) Actor

Every US employer that files an ERISA benefit plan — 401(k), pension, health & welfare — from the official DOL Form 5500 datasets. Name, EIN, phone, address, industry (NAICS), plan type, participant counts & assets. ~1M plans/year. Public domain, no key, no proxy.

- **URL**: https://apify.com/foxlabs/us-employer-benefit-plans.md
- **Developed by:** [Berkan Kaplan](https://apify.com/foxlabs) (community)
- **Categories:** Lead generation
- **Stats:** 3 total users, 3 monthly users, 77.8% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.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/platform/actors/running/actors-in-store#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

<p align="center"><a href="https://apify.com/foxlabs/us-employer-benefit-plans"><img src="https://data.foxlabs.com.tr/img/us-employer-benefit-plans-banner.svg" alt="US Employer & 401(k) Benefit Plan Data — Form 5500" width="100%" /></a></p>

## US Employer & 401(k) Plan Data — Form 5500 (DOL)

Need a **fresh, contactable list of US employers** — with the retirement and health plans they sponsor, who runs them, and how big they are? This Actor turns the U.S. Department of Labor's official **Form 5500 & 5500-SF** filings into ready-to-use B2B records: **~1,000,000 employer benefit-plan filings per year**, each with the sponsor's **name, EIN, phone, mailing address, industry (NAICS), plan type, participant count and plan assets**.

Built on the DOL's **public-domain** Form 5500 datasets — free to reuse **and resell**. **No API key, no login, no proxies, no fragile HTML scraping** — it reads the official annual data files directly, so it doesn't break.

- 🏢 **~1M plans/year** — every employer that files an ERISA plan (401(k), pension, health & welfare), not a sample
- ☎️ **~99% have a sponsor phone**, ~100% a mailing address & EIN (measured) — a call-ready lead source
- 📊 **Size & money signals** — participant counts on every plan, **total assets on both filing types** (5500-SF direct + Schedule H/I join for full-form filings)
- ⚡ **One run → one clean, flat dataset** (JSON / CSV / Excel / API), filterable by state, industry, size & plan type

### Quick start (API)

Get 100 California health-care employers (NAICS 62) with a phone, in one call:

```bash
curl -X POST "https://api.apify.com/v2/acts/foxlabs~us-employer-benefit-plans/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{ "year": "2023", "states": ["CA"], "industryCodes": ["62"], "onlyWithPhone": true, "maxResults": 100 }'
```

Prefer no code? Open the **Input** tab, set your filters, and click **Start** — then download the results.

### What you get

One clean, flat record per plan filing (an employer can sponsor several plans):

| Field | Type | Description |
|---|---|---|
| `sponsorName` | string | Employer / plan sponsor legal name |
| `dbaName` | string | "Doing business as" name, when filed |
| `ein` | string | 9-digit federal Employer ID Number |
| `phone` | string | Sponsor phone number |
| `address` / `city` / `state` / `zip` | string | Sponsor mailing address |
| `businessCode` / `industry` | string | 6-digit NAICS code + its sector name |
| `planName` | string | Name of the benefit plan |
| `planNumber` | string | 3-digit plan number (unique per sponsor) |
| `planEntityType` | string | Single-employer, multiemployer, multiple-employer or DFE |
| `planEffectiveDate` | string | When the plan started |
| `isPensionPlan` / `isWelfarePlan` | bool | Retirement plan / health & welfare plan |
| `benefitCodes` | string | Raw DOL benefit-type codes (e.g. `2K` = 401(k)) |
| `participants` / `activeParticipants` | number | Participant counts — an employer-size signal |
| `totalAssets` / `totalAssetsFormatted` | number / string | Total plan assets (end of year) — direct on 5500-SF filings, joined from **Schedule H / Schedule I** for full-form (5500) filings |
| `assetsSource` | string | Where the asset figure came from: `form-5500-sf`, `schedule-h`, `schedule-i`, or `null` when the filing reported none (e.g. unfunded welfare plans) |
| `planSize` | string | **Measured** from the participant count: `large` (100+), `small` (under 100), `null` if participants not reported — independent of which form was filed |
| `formType` / `ackId` / `filingDate` | string | Provenance: which form was filed (`5500` / `5500-SF`) & filing identifiers |
| `planYear` | string | Year the **plan year begins** — for fiscal/short plan years this can differ from the filing year you selected |

#### Sample output

```json
{
  "sponsorName": "THE LAW OFFICE OF ANTHONY SCAR",
  "ein": "472100868",
  "phone": "7184762411",
  "address": "9131 QUEENS BLVD STE 522",
  "city": "ELMHURST",
  "state": "NY",
  "zip": "11373",
  "businessCode": "522298",
  "industry": "Finance & Insurance",
  "planName": "THE LAW OFFICE OF ANTHONY SCAR 401(K) PROFIT SHARING PLAN & TRUST",
  "planNumber": "001",
  "planEntityType": "Single-employer plan",
  "isPensionPlan": true,
  "isWelfarePlan": false,
  "benefitCodes": "2E2F2G2J2K2S2T3D",
  "participants": 5,
  "totalAssets": 433758,
  "totalAssetsFormatted": "$434K",
  "assetsSource": "form-5500-sf",
  "planSize": "small",
  "formType": "5500-SF",
  "planYear": "2023",
  "filingDate": "2024-07-01"
}
```

### Input & filters

- **Plan year** — 2019–2023 (filings arrive up to ~10 months after year-end, so the most complete recent year is usually 2 years back).
- **States** — 2-letter codes (`["CA","NY","TX"]`); leave empty for all.
- **Industry (NAICS)** — one or more code prefixes: `62` = health care, `54` = professional services, `23` = construction, `52` = finance, or longer prefixes to narrow.
- **Employer name contains** — keyword match on the sponsor name (`hospital`, `bank`, `acme`).
- **Filings to scan** — the Form 5500 (large-plan form) file, the 5500-SF (small-plan form) file, or both. To filter by employer size, use the participant range — the output `planSize` is measured from participants, not from the form.
- **Plan type** — pension/retirement (401(k), DB), health & welfare, or any.
- **Participant range** — `minParticipants` / `maxParticipants` to target employers by headcount.
- **Minimum assets** — keep only plans reporting at least *N* in total assets (works on both filing types since 0.2).
- **Only employers with a phone** — for call-ready lists.
- **Max results** — up to 500,000.

### Example inputs (copy & paste)

```jsonc
// 1) Lead list — California health-care employers with a phone
{ "year": "2023", "states": ["CA"], "industryCodes": ["62"], "onlyWithPhone": true, "maxResults": 2000 }

// 2) 401(k) advisors — small retirement plans in Texas with $1M–$10M in assets
{ "year": "2023", "states": ["TX"], "planSize": "small", "planType": "pension", "minAssets": 1000000, "maxResults": 5000 }

// 3) Mid-market targeting — employers with 100–1,000 participants nationwide
{ "year": "2023", "planSize": "large", "minParticipants": 100, "maxParticipants": 1000, "maxResults": 20000 }

// 4) Named employer — every plan a specific company sponsors
{ "year": "2023", "keyword": "tesla", "maxResults": 100 }

// 5) Benefits brokers — health & welfare plans in the New York metro
{ "year": "2023", "states": ["NY", "NJ", "CT"], "planType": "welfare", "maxResults": 10000 }

// 6) Whole-state export — every filing employer in Florida
{ "year": "2023", "states": ["FL"], "maxResults": 50000 }

// 7) Construction sector — large plans, NAICS 23, with participant counts
{ "year": "2023", "industryCodes": ["23"], "planSize": "large", "maxResults": 15000 }
```

### Use cases

- **401(k) / retirement-plan sales.** You sell recordkeeping, advisory or TPA services. Filter `planType: "pension"` + `planSize: "small"` + an asset range → a list of plan sponsors with **phone, EIN and plan assets**, ranked by size — the exact book that BrightScope and Judy Diamond built businesses on.
- **Employee-benefits & insurance brokers.** Target `planType: "welfare"` in your states → employers running health & welfare plans, with contacts, to pitch group benefits.
- **B2B lead generation.** Every record is an established US employer with a **verified mailing address and phone** and an industry (NAICS) — a clean, compliant, public-record lead source with a built-in size signal (participants).
- **Market sizing & research.** Count filers by state, industry or plan type; rank sponsors by participants or assets to size a segment and spot the leaders.
- **CRM enrichment.** Match your prospects by EIN or name → append plan type, participant count, assets and industry. Missing fields return `null`, never a guess.
- **Competitive & M\&A intelligence.** Track which employers sponsor which plans, how many participants and how much in assets — filing over filing, year over year.

### Performance & throughput

Each run streams the official annual data file for the chosen year (the large-plan file is ~30 MB, the small-plan file ~130 MB), filtering as it reads — so it stops as soon as your `maxResults` is met. When the full form is in scope, the Actor first streams the year's **Schedule H and Schedule I** datasets once to join plan assets (a fixed extra step of a few seconds at the start of the run). Filtered pulls are fast; a full-year, no-filter export processes ~1M filings. There are no external keys, proxies or rate limits — throughput is bounded only by your Apify plan.

### Integrations

**JavaScript** (`apify-client`):

```js
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });
const run = await client.actor('foxlabs/us-employer-benefit-plans').call({
  year: '2023', states: ['CA'], industryCodes: ['62'], onlyWithPhone: true, maxResults: 500,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

**Python** (`apify-client`):

```python
from apify_client import ApifyClient
client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("foxlabs/us-employer-benefit-plans").call(run_input={
    "year": "2023", "states": ["CA"], "industryCodes": ["62"], "onlyWithPhone": True, "maxResults": 500,
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["sponsorName"], item.get("phone"), item.get("totalAssetsFormatted"))
```

Also works with **Make / n8n / Zapier** (Apify app → run this Actor, map the input), scheduled runs, webhooks, and the **Apify MCP server** for AI agents.

### Data quality (measured, 2023 large plans)

| Field | Fill rate |
|---|---|
| Sponsor name, EIN, plan name, plan type | **100%** |
| Mailing address, city, state, ZIP | **~99.9%** |
| Sponsor phone | **~99.3%** |
| Industry code (NAICS) | **~96.5%** |
| Participant counts | **~96.3%** |
| Total assets | small (5500-SF) plans: **direct (100% measured)**; full-form (5500) plans: **joined from Schedule H / Schedule I** — **100% on pension plans** (measured, n=161), ~57% across all full-form filings; the gap is unfunded/insured **welfare** plans, which file no financial schedule (`assetsSource` marks each origin) |

Measured on the full 2023 large-plan dataset. Every value is read from the filed form — never fabricated; missing values are `null`.

### Pricing

**Pay per result** — you're billed per plan record returned. There's an Apify **free tier** to evaluate the full feature set before you scale. The underlying data is public-domain and there are no proxy or third-party costs.

### FAQ

**Can I use this data commercially / resell it?** Yes. Form 5500 data is a **U.S. government work in the public domain** — free to reuse and redistribute, including commercially.

**How fresh is the data?** It reads the DOL's official annual dataset for the year you pick. DOL refreshes these files as filings and amendments arrive; each run pulls the current "latest filing per plan" version.

**Why is the most complete year ~2 years back?** Plans file up to ~10 months after their year-end, plus extensions. 2023 is essentially complete; the current year is still filling in.

**Do I need an account with the DOL?** No. No key, no login — it's public open data.

**What's an EIN?** The 9-digit federal Employer Identification Number — a stable key to match and dedupe employers across datasets.

**What's the difference between large and small plans?** DOL's threshold is 100 participants: large plans generally file the full Form 5500, small plans the shorter 5500-SF. But form ≠ size — small employers may file the full form, and the 80–120 election keeps some 100+ plans on the SF. That's why `planSize` in the output is **measured from the participant count**, while `formType` tells you which form was actually filed. The `planSize` *input* selects which filing dataset(s) to scan.

**How do I find 401(k) plans specifically?** Filter `planType: "pension"`. The raw `benefitCodes` field carries DOL codes (e.g. `2K` = 401(k) feature) if you need finer detail.

**Do you include plan assets for large plans?** Yes — since 0.2 the Actor joins total end-of-year assets from **Schedule H** (large plans) and **Schedule I** (small plans on the full form) by the filing's `ACK_ID`, so full-form records carry real assets alongside the SF ones. `assetsSource` tells you where each figure came from; a `null` means that filing reported no financial schedule — typically unfunded/insured **welfare** plans, which have no asset figure to report.

**Can I get several years?** Run once per `year` and combine — filings link across years by EIN + plan number.

**How many records in one run?** Up to 500,000 via `maxResults`.

### Troubleshooting

- **0 results** → filters too narrow. Widen the `states`/`industryCodes`, clear `onlyWithPhone`/`minAssets`, or check the `year`.
- **`totalAssets` is null** → that filing reported no asset figure (check `assetsSource`): either the plan's Schedule H row is missing/empty, or the SF field was blank. Values are joined or read directly — never estimated.
- **First results take a moment** → the Actor streams the official annual file at the start of each run (it's built for filtered lists, not single instant lookups); with a `maxResults` it stops early.
- **A sponsor name looks truncated** → small-plan sponsor names are as filed with the DOL; some filers abbreviate. Values are never altered.

### Notes, limits & legal (honest)

- **License.** Form 5500 series data is published by the U.S. Department of Labor (EBSA) as a public-domain U.S. government work; redistribution — including commercial — is permitted.
- **Personal data.** Records describe *employers and their plans*, not consumers. Sponsor phone/address are business contact details filed on a public federal form.
- **Assets on full-form plans.** Joined from the year's Schedule H + Schedule I datasets by `ACK_ID` (fail-loud: if DOL ever changes the layout, the run logs it and leaves assets `null` rather than mapping a wrong column). Unfunded/insured welfare plans file no financial schedule — their assets are legitimately `null`. Participant counts are present on all plans.
- **Amended/duplicate filings.** The Actor uses DOL's "latest filing per plan" dataset, so you get one current record per plan (not every historical amendment).
- **Not affiliated** with the U.S. Department of Labor; this Actor redistributes their public data.

### Support

Questions, a field you'd like added (Schedule H financials, Schedule C service providers?), or a custom build? Open the **Issues** tab on this Actor, or email **info@foxlabs.com.tr**. We reply fast.

*If this Actor saves you time, a ⭐ review really helps.*

### Changelog

#### 0.2 — 2026-07-30

- **Full-form assets filled via Schedule H + Schedule I join** (`ACK_ID`): `totalAssets` is no longer `null` on Form 5500 records; new `assetsSource` field (`schedule-h` / `schedule-i` / `form-5500-sf`). `minAssets` now works across both filing types. Fail-loud if DOL changes the layout; unfunded welfare plans legitimately stay `null`.
- **`planSize` is measured, not assumed:** derived from the participant count (100+ = `large`), independent of which form was filed — in a CA sample 2 of 3 full-form filings had under 100 participants. `formType` keeps the filing fact.
- **`planYear` hardened + documented:** real 4-digit, range-checked year of the plan-year begin date; can legitimately differ from the selected filing year for fiscal/short plan years.

#### 0.1

- Initial release. ~1M US employer benefit-plan filings per year from the official DOL Form 5500 & 5500-SF datasets (public domain): sponsor name, EIN, phone, mailing address, industry (NAICS), plan name & type, participant counts, and plan assets (small plans). Filter by year, state, industry, plan size, plan type, participant range, assets and employer name. No key, no proxy.

***

Part of the **[foXLabs data platform](https://data.foxlabs.com.tr/)** — official public-data company, contact, ownership, jobs, charity, location & AI-search intelligence scrapers. Browse the full suite at **[data.foxlabs.com.tr](https://data.foxlabs.com.tr/)**.

# Actor input Schema

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

Which Form 5500 filing year to pull. Filings arrive up to ~10 months after year-end, so the most complete recent year is usually 2 years back.

## `states` (type: `array`):

Keep only employers in these US states — 2-letter codes (e.g. \["CA", "NY", "TX"]). Leave empty for all states.

## `industryCodes` (type: `array`):

Keep only employers whose business code starts with one of these NAICS prefixes. 2 digits = sector (e.g. "62" health care, "54" professional services, "23" construction), or use longer prefixes to narrow. Leave empty for all industries.

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

Keep only employers whose name contains this text (case-insensitive). Example: "hospital", "bank", "acme". Leave empty to browse by the other filters.

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

Which filing dataset(s) to read: the Form 5500 (large-plan form), the Form 5500-SF (small-plan form), or both. Note: the output `planSize` field is measured from the participant count (100+ = large) independently of the form — to filter by employer size use `minParticipants`/`maxParticipants`.

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

Pension = retirement plans (401(k), defined benefit). Welfare = health, life, disability & other benefits. "Any" returns both.

## `minParticipants` (type: `integer`):

Keep only plans with at least this many participants — a proxy for employer headcount. Leave empty for no minimum.

## `maxParticipants` (type: `integer`):

Keep only plans with at most this many participants. Leave empty for no maximum.

## `minAssets` (type: `integer`):

Keep only plans reporting at least this much in total end-of-year assets. Assets come directly from 5500-SF filings and via the Schedule H join for large (Form 5500) filings; plans with no reported asset figure are excluded when this is set. Leave empty for no minimum.

## `onlyWithPhone` (type: `boolean`):

Return only employers that list a sponsor phone number (≈99% do). Useful for call-ready lead lists.

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

Maximum number of employer/plan records to return.

## Actor input object example

```json
{
  "year": "2023",
  "states": [
    "CA"
  ],
  "industryCodes": [],
  "planSize": "all",
  "planType": "any",
  "onlyWithPhone": false,
  "maxResults": 1000
}
```

# 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 = {
    "states": [
        "CA"
    ],
    "industryCodes": [],
    "maxResults": 1000
};

// Run the Actor and wait for it to finish
const run = await client.actor("foxlabs/us-employer-benefit-plans").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 = {
    "states": ["CA"],
    "industryCodes": [],
    "maxResults": 1000,
}

# Run the Actor and wait for it to finish
run = client.actor("foxlabs/us-employer-benefit-plans").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "states": [
    "CA"
  ],
  "industryCodes": [],
  "maxResults": 1000
}' |
apify call foxlabs/us-employer-benefit-plans --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=foxlabs/us-employer-benefit-plans",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/TCrjxfRwV6cfd2kea/builds/7YgvbM5Ld3kCyBhmy/openapi.json