# US WARN Act Layoff Monitor — Multi-State Layoff & Closure Feed (`datadeltas/warn-layoff-monitor`) Actor

One clean feed of new US mass-layoff and plant-closure WARN notices across CA, NY, TX, WA, NJ, MD and CO — normalised fields, employee counts as integers, only NEW filings each run. Built for journalists, sales/GTM intelligence, HR-tech and distressed-asset research.

- **URL**: https://apify.com/datadeltas/warn-layoff-monitor.md
- **Developed by:** [Daniel Matthee](https://apify.com/datadeltas) (community)
- **Categories:**
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $15.00 / 1,000 new warn notice detecteds

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 WARN Act Layoff Monitor — Multi-State Layoff & Closure Feed

One clean, normalised feed of **new US mass-layoff and plant-closure (WARN
Act) notices**, pulled straight from each state's official source of truth.
Every scheduled run checks all enabled states and emits **only notices you
have not seen before** — no re-scraping the same filings, no duplicate rows.

Built for:

- **Journalists & researchers** — catch layoff filings the day the state
  posts them, with employee counts as clean integers and one schema across
  states.
- **Sales & GTM intelligence** — companies filing WARN notices are
  restructuring: prime timing for outreach, competitive moves and churn-risk
  flags on your accounts.
- **HR-tech & outplacement** — feed new filings into recruiting, severance
  and workforce-transition products.
- **Distressed-asset & credit analysis** — closures and large layoffs are an
  early operational-stress signal, published weeks before most press
  coverage.

### State coverage (v1)

Every state below is parsed from the state government's own publication —
never from third-party aggregators.

| State | Source | Format |
|---|---|---|
| California | [EDD WARN report](https://edd.ca.gov/en/jobs_and_training/layoff_services_warn/) | Excel, updated ~daily |
| New York | [NY DOL WARN dashboard](https://dol.ny.gov/warn-dashboard) | Dashboard data export |
| Texas | [TWC WARN notices via Texas Open Data](https://data.texas.gov/dataset/Worker-Adjustment-and-Retraining-Notification-WARN/8w53-c4f6) | JSON API |
| Washington | [ESD WARN database](https://fortress.wa.gov/esd/file/WARN/Public/SearchWARN.aspx) | HTML table |
| New Jersey | [NJ DOL WARN notice archive](https://www.nj.gov/labor/business-services/layoffs-and-closing/) | Excel archive |
| Maryland | [MD Labor WARN page](https://labor.maryland.gov/employment/warn.shtml) | HTML table |
| Colorado | [CDLE WARN list](https://cdle.colorado.gov/employers/layoff-separations/layoff-warn-list) | Real-time public sheet |

Honest notes per state:

- **Texas** data comes from the state's open-data mirror, which lags the TWC
  website by roughly 4–8 weeks (the TWC site blocks automated access). Texas
  filings are complete, just slower.
- **New Jersey** publishes the posting month rather than a filing day, and
  does not label closures vs layoffs (`closureType` is `unknown`).
- **Texas** does not label closures vs layoffs either.
- Florida, Illinois, Ohio and Georgia are planned for v1.1 — their current
  publication channels (WAF-blocked portals, login-gated apps) need extra
  plumbing to monitor reliably.

### Example output

```json
{
  "state": "CA",
  "company": "Bumble Bee Foods, LLC",
  "locationCity": null,
  "locationRaw": "280 10th Avenue  Santa Fe Springs CA 90670 — Los Angeles County",
  "employeesAffected": 197,
  "noticeDate": "2026-08-06",
  "effectiveDate": "2026-10-05",
  "closureType": "closure",
  "industry": "31-33 Manufacturing",
  "sourceUrl": "https://edd.ca.gov/en/jobs_and_training/layoff_services_warn/",
  "noticeKey": "CA:1f4c2b9a8d3e7f01",
  "detectedAt": "2026-08-31T05:09:22Z"
}
```

- `employeesAffected` is always an integer (or `null` when the state did not
  publish a count) — messy source values like `"1,024"` are normalised.
- `closureType` is `closure`, `layoff` or `unknown`.
- `noticeKey` is a stable identity per filing, so you can dedupe downstream.

### Input options

| Option | Default | What it does |
|---|---|---|
| `states` | all 7 | Which states to monitor |
| `minEmployeesAffected` | 0 | Only emit filings of at least this size (unstated counts excluded when set) |
| `keywords` | none | Case-insensitive match on company, industry and location |
| `sinceDays` | 30 | Backfill window by notice date on the first run |
| `maxItems` | 500 | Cap per run, shared evenly between the states with new notices; overflow emits on the next run |

### How to use it

Schedule the actor (daily or a few times per week matches state publication
cadence). The first run backfills the `sinceDays` window; every later run
emits only never-seen notices. A run where nothing new was filed emits zero
rows and exits successfully.

Searches this actor answers: *warn act layoff data*, *mass layoff notices
API*, *plant closure feed*, *layoff tracker multi state*, *warn notice
scraper*.

### Reliability

- One state's website changing layout never kills the run: that state logs a
  schema-drift warning and the other states continue.
- State checked, notice detected and actor start are the only charge events
  — you pay per new notice, not per page fetched.
- Sources checked against each state's live site; schema verified weekly.

### Changelog

- **0.2** — `maxItems` is now shared fairly between the states in a run, so a
  small cap no longer fills up with the busiest state (California) and leaves
  the quieter ones for the next run. Overflow still carries over.
- **0.1** — initial release: CA, NY, TX, WA, NJ, MD, CO; seen-notice diff
  feed; employee-count normalisation; keyword and size filters.

# Actor input Schema

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

Which states to monitor. Default: all v1 states.

## `minEmployeesAffected` (type: `integer`):

Only emit notices affecting at least this many workers. Notices without a published count are excluded when this is set above 0.

## `keywords` (type: `array`):

Optional case-insensitive filter matched against company name, industry and location. Leave empty to emit every new notice.

## `sinceDays` (type: `integer`):

How many days of notices to scan by notice date. On the first run this is your backfill; on later runs only never-seen notices are emitted.

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

Cap on new notices emitted in a single run (cost control). Notices over the cap are picked up on the next run.

## Actor input object example

```json
{
  "states": [
    "CA",
    "NY",
    "TX",
    "WA",
    "NJ",
    "MD",
    "CO"
  ],
  "minEmployeesAffected": 0,
  "sinceDays": 30,
  "maxItems": 500
}
```

# Actor output Schema

## `records` (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("datadeltas/warn-layoff-monitor").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("datadeltas/warn-layoff-monitor").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 datadeltas/warn-layoff-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,datadeltas/warn-layoff-monitor"
        }
    }
}

```

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/M4H1gNgzutzYH1L72/builds/fGRq7FSo5TZpprCL4/openapi.json