EBSA Employee Benefits Enforcement

EBSA enforcement penalties are public record — but searching the DOL's OCATS database manually is slow, unintuitive, and returns raw data with no risk context. This actor queries the Employee Benefits Security Administration enforcement dataset directly, retrieves closed penalty cases for ERISA Form 5500 filing violations since 2000, and attaches a structured risk score to every record.

The result is a clean, analysis-ready dataset covering late filers, non-filers, and deficient filers — filtered by employer, state, penalty type, date range, or minimum penalty amount. Benefits consultants, M&A due diligence teams, compliance officers, and insurance underwriters use this data to screen employers for ERISA compliance history before entering a business relationship.

What data can you extract?

Why use EBSA Employee Benefits Enforcement?

Researching an employer's ERISA compliance history through the DOL portal means navigating a fragmented interface, applying filters one at a time, and manually downloading paginated results. A benefits consultant screening 50 plan sponsors can spend an entire afternoon on a task that should take minutes. There is no built-in risk scoring, no penalty aggregation by employer, and no way to export a clean dataset for downstream analysis.

This actor automates the entire process: it queries the DOL EBSA OCATS API with your specified filters, paginates through all matching records (up to 5,000), transforms raw government data into structured JSON, and sorts results by computed risk score before saving to your dataset.

• Scheduling — run daily, weekly, or on a custom interval to monitor for new enforcement actions affecting your industry or client portfolio
• API access — trigger runs from Python, JavaScript, or any HTTP client to embed ERISA compliance checks into existing workflows
• Proxy rotation — uses Apify's built-in infrastructure to ensure reliable API access at scale
• Monitoring — get Slack or email alerts when runs fail or when high-risk cases appear in your target state
• Integrations — push results directly to Google Sheets, HubSpot, Zapier, or Make for automated compliance workflows

Features

• Paginated DOL API access — fetches up to 5,000 enforcement cases in a single run using 1,000-record pages with automatic offset management
• Multi-condition filter builder — combines up to 7 filter conditions (employer name, plan name, state, penalty type, date range, minimum penalty) into a single API filter_object query using and logic
• Case-insensitive partial matching — employer name, plan name, and penalty type filters use SQL LIKE operators with uppercase normalization, so "acme" matches "ACME CORPORATION" and "ACME CORP 401(K) PLAN"
• 4-tier risk scoring — every case receives a score from 0–100 based on penalty severity (up to +40), filing status (non-filer +25, deficient filer +15, late filer +10), case type (civil penalty +10), and recency (2023+ cases +5)
• Risk level classification — scores map to Critical (60+), High (40–59), Medium (20–39), and Low (<20) for instant triage
• Results sorted by risk — output is sorted highest-risk first, so the most serious violations appear at the top of the dataset
• Aggregate summary block — every run produces a summary with total cases, total penalties, average penalty, penalty breakdown by state (top 15), breakdown by penalty type (top 10), breakdown by filing status, and top 10 employers by penalty total
• Retry logic with exponential backoff — failed API requests retry up to 4 times with doubling wait intervals; rate-limit (HTTP 429) responses trigger automatic waits before retrying
• 30-second request timeout — prevents hung runs from stalled API connections
• 500ms inter-page delay — respectful pacing between paginated requests to avoid triggering DOL rate limits
• Dry run mode — run without an API key to inspect the output structure using three realistic sample records before committing to a live query
• DOL_API_KEY environment variable support — API key can be passed via actor input or as an environment variable for secure deployment

Use cases for EBSA enforcement penalties

Benefits consultant ERISA due diligence

Benefits consultants onboarding a new employer client need to know whether that employer has a history of Form 5500 filing violations. Manual lookups across EBSA's web portal are time-consuming and return data without any severity context. With this actor, a consultant can run a search by employer name in seconds, get back a risk-scored list of past violations, and include the output in their onboarding report with no additional processing.

Mergers and acquisitions due diligence

M&A teams assessing the employee benefits liability of a target company need to surface any ERISA enforcement history as part of standard due diligence. A non-filer penalty of $150,000 or a pattern of deficient filings signals potential ongoing liability. This actor retrieves the full enforcement history for a named employer, including plan numbers and EINs, in a format that can be attached to a deal memo or fed into a due diligence data room.

Third-party administrator client screening

Third-party administrators (TPAs) and recordkeepers evaluating prospective plan sponsor clients benefit from knowing whether those employers have previously been sanctioned by EBSA. This actor enables batch screening by state or industry: run a search for your target state, filter by minimum penalty amount, and review the risk-scored results before taking on a new client relationship.

Insurance underwriting and ERISA liability assessment

Fiduciary liability and ERISA bond underwriters need enforcement history data to price risk accurately. An employer with a Critical-risk enforcement record — multiple non-filing penalties exceeding $100,000 — represents a materially different risk profile than an employer with a single low-amount late-filing case. This actor delivers the structured data underwriters need to support that distinction.

Compliance officer industry monitoring

Compliance officers at large plan sponsors benefit from monitoring enforcement trends in their industry or state. Running monthly searches by state or penalty type reveals whether EBSA enforcement intensity is increasing in a given region, which informs decisions about internal audit frequency and compliance training investment.

Legal research and penalty precedent analysis

ERISA attorneys and consultants researching enforcement patterns, penalty precedents, or the distribution of penalties by case type can use this actor to extract bulk data from the OCATS dataset and analyze it in Excel, Python, or any BI tool. The aggregate summary provides immediate statistics; the full case-level dataset supports deeper analysis.

How to search EBSA enforcement penalties

1. Get a free DOL API key — Register at dataportal.dol.gov/registration. The key is free and issued immediately. Paste it into the apiKey field.
2. Set your filters — Enter an employer name (e.g., "Pinnacle Industries"), a two-letter state code (e.g., "CA"), and optionally a minimum penalty amount (e.g., 50000). Leave fields blank to search all cases sorted by penalty amount.
3. Run the actor — Click "Start". A typical run returning 500 cases takes 30–90 seconds. Runs fetching the full 5,000 records take 3–5 minutes.
4. Download results — Export as JSON, CSV, or Excel from the Dataset tab. The summary block at the top of each result provides instant aggregate statistics.

Input parameters

*apiKey is required for live data. Without it, only dry run mode is available.

Input examples

Search by employer name (most common use case):

{
    "apiKey": "YOUR_DOL_API_KEY",
    "dryRun": false,
    "employerName": "Pinnacle Industries",
    "maxResults": 100
}

State-level screening with minimum penalty filter:

{
    "apiKey": "YOUR_DOL_API_KEY",
    "dryRun": false,
    "state": "CA",
    "minPenalty": 50000,
    "dateFrom": "2020-01-01",
    "maxResults": 500
}

Dry run to preview output structure:

{
    "dryRun": true
}

Input tips

• Omit all filters to get the highest-penalty cases — with no filters applied, the actor returns cases sorted by penalty amount descending, giving you the most significant enforcement actions first.
• Use partial employer names — the actor converts your search term to uppercase and applies a LIKE match, so "acme" will match "ACME CORPORATION", "ACME CORP 401(K) PLAN", and similar names.
• Combine date range with state for benchmarking — set a 12-month date range with a state filter to generate a regional compliance benchmark dataset for a given year.
• Start with maxResults: 100 for exploratory searches — this returns quickly and costs less; scale up once you have confirmed the right filters.
• The DOL API key is free — registration at dataportal.dol.gov takes under two minutes. The same key works across all DOL Open Data wrapper actors.

Output example

{
    "cases": [
        {
            "caseNumber": "EBSA-2024-00789",
            "planName": "GLOBAL INDUSTRIES EMPLOYEE WELFARE BENEFIT PLAN",
            "employerName": "GLOBAL INDUSTRIES LLC",
            "ein": "98-7654321",
            "planNumber": "501",
            "state": "CA",
            "penaltyType": "Civil Penalty - Non-Filing",
            "penaltyAmount": 150000,
            "planYear": "2020",
            "caseCloseDate": "2024-09-22",
            "caseType": "Civil Penalty",
            "filingStatus": "Non-Filer",
            "riskScore": 80,
            "riskLevel": "Critical",
            "riskFactors": [
                "Very high penalty: $150,000 (+40)",
                "Non-filer — complete failure to file Form 5500 (+25)",
                "Civil penalty case (+10)",
                "Recent enforcement action (2023+) (+5)"
            ],
            "extractedAt": "2024-11-01T14:23:07.000Z"
        }
    ],
    "summary": {
        "totalCases": 3,
        "totalPenalties": 250000,
        "averagePenalty": 83333,
        "maxPenalty": 150000,
        "byState": [
            { "state": "CA", "count": 1, "totalPenalties": 150000 },
            { "state": "NY", "count": 1, "totalPenalties": 75000 },
            { "state": "OH", "count": 1, "totalPenalties": 25000 }
        ],
        "byPenaltyType": [
            { "type": "Civil Penalty - Non-Filing", "count": 1, "totalAmount": 150000 },
            { "type": "Civil Penalty - Late Filing", "count": 1, "totalAmount": 75000 },
            { "type": "Civil Penalty - Deficient Filing", "count": 1, "totalAmount": 25000 }
        ],
        "byFilingStatus": [
            { "status": "Non-Filer", "count": 1 },
            { "status": "Late Filer", "count": 1 },
            { "status": "Deficient Filer", "count": 1 }
        ],
        "topEmployers": [
            { "name": "GLOBAL INDUSTRIES LLC", "count": 1, "totalPenalties": 150000 },
            { "name": "ACME CORPORATION", "count": 1, "totalPenalties": 75000 },
            { "name": "MIDWEST MANUFACTURING INC", "count": 1, "totalPenalties": 25000 }
        ]
    }
}

Output fields

Risk scoring reference

Levels: Critical (60+) — High (40–59) — Medium (20–39) — Low (<20)

How much does it cost to search EBSA enforcement penalties?

EBSA Employee Benefits Enforcement uses Apify's standard compute pricing. The actor is lightweight — it calls a government JSON API and processes structured data — so memory usage is minimal (128 MB) and runs are fast.

Apify's free tier includes $5 of monthly compute credits, which covers hundreds of typical runs. You can set a maximum spending limit per run to control costs — the actor stops when your budget is reached.

The DOL API key required to access live data is completely free with no usage limits published. Compare this to commercial ERISA compliance databases that charge $500–$2,000 per month for similar enforcement history lookups.

Search EBSA enforcement penalties using the API

Python

from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")

run = client.actor("ryanclinton/ebsa-benefits-enforcement").call(run_input={
    "apiKey": "YOUR_DOL_API_KEY",
    "dryRun": False,
    "state": "CA",
    "minPenalty": 50000,
    "maxResults": 200,
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    for case in item.get("cases", []):
        print(f"{case['employerName']} | {case['riskLevel']} | ${case['penaltyAmount']:,} | {case['filingStatus']}")

JavaScript

import { ApifyClient } from "apify-client";

const client = new ApifyClient({ token: "YOUR_API_TOKEN" });

const run = await client.actor("ryanclinton/ebsa-benefits-enforcement").call({
    apiKey: "YOUR_DOL_API_KEY",
    dryRun: false,
    state: "CA",
    minPenalty: 50000,
    maxResults: 200,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
for (const item of items) {
    for (const c of item.cases ?? []) {
        console.log(`${c.employerName} | ${c.riskLevel} | $${c.penaltyAmount.toLocaleString()} | ${c.filingStatus}`);
    }
}

cURL

# Start the actor run
curl -X POST "https://api.apify.com/v2/acts/ryanclinton~ebsa-benefits-enforcement/runs?token=YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "apiKey": "YOUR_DOL_API_KEY",
    "dryRun": false,
    "state": "CA",
    "minPenalty": 50000,
    "maxResults": 200
  }'

# Fetch results (replace DATASET_ID from the run response)
curl "https://api.apify.com/v2/datasets/DATASET_ID/items?token=YOUR_API_TOKEN&format=json"

How EBSA Employee Benefits Enforcement works

Data source and API access

The actor queries the DOL's production API at https://apiprod.dol.gov/v4/get/EBSA/ocats/json. This endpoint exposes the OCATS (Office of Chief Accountant Transaction System) dataset, which contains closed enforcement cases with assessed penalties going back to 2000. Each request includes your DOL API key as an X-API-KEY header parameter. Results are returned in pages of up to 1,000 records, sorted by penalty_amount descending so the highest-value cases appear first regardless of pagination order.

Filter construction

Input parameters are translated into a single filter_object query parameter using the DOL API's structured filter syntax. Each filter condition specifies a field name, an operator (eq for exact match, gte/lte for date and amount ranges, like for partial text matching), and a value. When multiple conditions are provided, they are combined into an and object before being JSON-serialized and URL-encoded. Text fields (employer name, plan name, penalty type) are uppercased before submission because the OCATS database stores values in uppercase; this ensures that lowercase or mixed-case search terms still return matches.

Risk scoring algorithm

Every raw OCATS record passes through the assessRisk function after retrieval. The function assigns points across four dimensions: penalty severity (0–40 points based on four penalty amount thresholds), filing violation type (0–25 points based on non-filer, deficient filer, or late filer status derived from filing_status field), case type (0–10 points for civil penalty cases), and recency (5 points for cases closed in 2023 or later). The human-readable factor list records each contributing factor and its point value for full auditability. After scoring, all cases are re-sorted by riskScore descending — overriding the API's penalty-amount sort — so Critical-level cases always appear at the top of the output.

Pagination and reliability

The actor uses a while loop to fetch pages until either the requested maxResults is reached or the API returns fewer records than the page size (indicating no more results exist). A 500-millisecond delay between pages prevents rate limiting. Each request is wrapped in a retry loop with up to 4 attempts and exponential backoff starting at 2 seconds. HTTP 429 responses trigger a separate backoff sequence. Requests time out after 30 seconds. After all pages are collected, the records are sliced to exactly maxResults before transformation, ensuring the output never exceeds the user's requested limit.

Tips for best results

1. Use the dry run first. Set dryRun: true (the default) to verify the output structure and confirm your downstream tooling can consume the data before making a live API call.

2. Register your DOL API key before running. The registration form at dataportal.dol.gov/registration takes under two minutes. An unregistered key returns HTTP 401 and the actor will stop immediately with an error message.

3. Filter by minPenalty to focus on material violations. Setting minPenalty: 10000 eliminates minor administrative penalties and concentrates your results on enforcement actions that represent genuine compliance risk.

4. Combine with other DOL actors for complete employer profiles. Pair this actor with DOL WHD Enforcement to get both ERISA benefit plan penalties and wage-and-hour violations for the same employer in one workflow.

5. Export to CSV for Excel analysis. The dataset export in CSV format maps directly to a spreadsheet where you can pivot by riskLevel, filter by state, or sort by penaltyAmount without any transformation.

6. Schedule monthly runs for ongoing monitoring. Use Apify's built-in scheduler to re-run a state or industry filter monthly. New enforcement cases appear in the dataset as EBSA closes them, giving you a continuously updated compliance monitoring feed.

7. Use the topEmployers summary field for portfolio screening. When running a broad state search, the summary.topEmployers array immediately surfaces the employers with the highest cumulative penalty exposure without requiring you to scan all individual case records.

8. Save API costs by caching results. EBSA enforcement data is historical — closed cases do not change. If you have already fetched a company's full enforcement history, there is no need to re-query unless you want to check for new cases since your last run.

Combine with other Apify actors

Limitations

• Data covers closed cases only. The OCATS dataset contains cases where EBSA has formally closed the enforcement action. Open investigations and cases under appeal are not included.
• No real-time updates. EBSA publishes new closed cases to the OCATS dataset on a periodic basis, not instantly. There may be a lag of weeks to months between a case closing and it appearing in the dataset.
• Coverage starts in 2000. Enforcement cases predating 2000 are not available in the OCATS dataset and cannot be retrieved.
• No PDF documents. The dataset contains structured penalty data but not the underlying case files, settlement agreements, or EBSA correspondence. For full case documents, contact EBSA directly under FOIA.
• EIN may be null. Not all enforcement cases in the OCATS database include the employer's EIN. Where EIN is null, use employer name and state to identify the entity.
• Plan number scope. Plan numbers are assigned by the employer and are not globally unique. Two employers can have the same plan number. Always use employer name or EIN to disambiguate.
• API key required for live data. The free DOL API key must be registered in advance. Without it, only the three dry run sample records are returned.
• DOL API rate limits. The DOL API enforces rate limits. The actor handles HTTP 429 responses with exponential backoff, but very high concurrency across many simultaneous runs may still encounter throttling.

Integrations

• Zapier — trigger an EBSA enforcement lookup whenever a new employer is added to a spreadsheet or CRM, and route Critical-risk results to a Slack channel
• Make — build multi-step compliance workflows: run an EBSA search, filter for Critical-risk cases, and automatically create tasks in your project management tool
• Google Sheets — export enforcement cases to a shared compliance tracking spreadsheet for team review and annotation
• Apify API — integrate ERISA penalty lookups into internal compliance portals, vendor onboarding systems, or M&A deal room platforms via direct API calls
• Webhooks — receive a webhook notification when a run completes, with the dataset URL included, to trigger downstream data processing
• LangChain / LlamaIndex — feed EBSA enforcement case data into an LLM-powered compliance assistant or due diligence report generator as structured context

Troubleshooting

Run returns no cases despite valid filters. The OCATS database stores all text in uppercase. The actor handles this automatically for employer name, plan name, and penalty type. For state filtering, check that you are providing exactly two uppercase letters (e.g., "CA" not "California"). If you still get no results, try removing filters one at a time to identify which one is too restrictive.

HTTP 401 or 403 error on startup. Your DOL API key is invalid, expired, or was not entered correctly. Re-register at dataportal.dol.gov/registration and paste the key into the apiKey field. Ensure there are no leading or trailing spaces.

Run times out on very large requests. Fetching 5,000 records with multiple API pages takes 5–8 minutes. If your Apify actor timeout is set below this, increase it in the actor settings. Alternatively, reduce maxResults to 1,000–2,000 and run multiple times with different date ranges.

Penalty amounts appear as 0. Some OCATS records contain null penalty amounts. The actor maps null penalty amounts to 0 rather than omitting the record, so the case is still included in the output. These records will receive a risk score based solely on filing status and case type.

Summary fields show fewer than expected states or employers. The byState array is capped at 15 states and topEmployers is capped at 10 employers, ordered by total penalty amount. If you need the full breakdown, analyze the cases array directly.

Responsible use

• This actor only accesses publicly available enforcement data published by the US Department of Labor.
• EBSA enforcement records are public government data intended for transparency and compliance research.
• Do not use extracted data to make automated credit, employment, or insurance decisions without human review and compliance with applicable discrimination laws.
• Comply with FCRA and other applicable regulations when using enforcement history data in commercial decision-making contexts.
• For guidance on web scraping and data use legality, see Apify's guide.

FAQ

How do I search EBSA enforcement penalties for a specific employer? Enter the employer name in the employerName field. Partial matches work — entering "Pinnacle" will return cases for "PINNACLE INDUSTRIES LLC" and any other employer with "Pinnacle" in the name. Use maxResults: 50 for a focused single-employer search.

How many EBSA enforcement cases can I retrieve in one run? The actor supports up to 5,000 cases per run. If you need the complete OCATS dataset, run with no filters and maxResults: 5000. The DOL OCATS dataset contains tens of thousands of closed cases going back to 2000.

What is the difference between Non-Filer, Late Filer, and Deficient Filer? Non-Filers completely failed to file Form 5500 for one or more plan years — the most serious violation, weighted at +25 risk points. Late Filers submitted the form but after the deadline. Deficient Filers submitted on time but with material errors or omissions. All three are subject to ERISA civil penalties enforced by EBSA.

Does this actor cover all ERISA enforcement actions, or only Form 5500 penalties? The OCATS dataset covers enforcement cases related to Form 5500 filing requirements. Broader ERISA fiduciary breach cases, prohibited transaction cases, and criminal referrals are tracked in separate DOL systems and are not included in this dataset.

How current is the EBSA enforcement data? The dataset reflects closed enforcement cases. EBSA updates the OCATS dataset periodically, but there can be a lag between a case closing and it appearing in the API. For the most recent enforcement actions, use a dateFrom filter set to 12–18 months ago to capture recently closed cases.

How accurate is the risk score? The risk score is a deterministic calculation based on four objective factors sourced directly from the EBSA record: penalty amount, filing status, case type, and closure date. It is designed to rank cases for triage, not to replace legal analysis. A Critical score (60+) indicates a large penalty, non-filer status, or civil penalty case type — or a combination — that warrants closer review.

Is it legal to use EBSA enforcement data for due diligence and compliance research? Yes. EBSA enforcement cases are public government records published by the US Department of Labor for transparency purposes. Using them for compliance research, due diligence, or business risk assessment is a standard and legally recognized practice. Consult legal counsel regarding any downstream use of this data in automated decision-making systems.

Can I schedule this actor to run automatically every month? Yes. Use Apify's built-in scheduler to run on any interval — daily, weekly, or monthly. Set your filters once and the scheduler will re-run them automatically. New enforcement cases that were closed since your last run will appear in each new dataset.

How is this different from manually searching the DOL website? The DOL EBSA enforcement search portal returns results one page at a time with no export function, no risk scoring, and no aggregation by employer or state. This actor returns structured JSON with risk scores, penalty aggregations, and summary statistics in one API call, and the results can be exported to CSV, JSON, or Excel immediately or pushed to any downstream system.

Can I use this with Python or JavaScript in my own application? Yes. See the API examples above. The actor is callable via the Apify client libraries for Python and JavaScript, or via direct HTTP calls using the cURL example. Pass your DOL API key and search filters as the run_input, and iterate over the returned dataset items.

What happens if the DOL API is down or returns an error? The actor retries each failed request up to 4 times with exponential backoff (doubling wait intervals starting at 2 seconds). Rate-limit responses (HTTP 429) trigger an additional backoff before retrying. If the API remains unavailable after all retries, the actor logs a warning and continues to process any records already retrieved. A completely failed run with zero records will push a diagnostic message object to the dataset.

Does this actor work for non-US benefit plans? No. The OCATS dataset covers only US-based employee benefit plans subject to ERISA, which applies to private-sector employers operating in the United States. Government and church plans are generally exempt from ERISA and do not appear in this dataset.

Help us improve

If you encounter issues, you can help us debug faster by enabling run sharing in your Apify account:

1. Go to Account Settings > Privacy
2. Enable Share runs with public Actor creators

This lets us see your run details when something goes wrong, so we can fix issues faster. Your data is only visible to the actor developer, not publicly.

Support

Found a bug or have a feature request? Open an issue in the Issues tab on this actor's page. For custom solutions or enterprise integrations, reach out through the Apify platform.