# WARN Act Layoff & Plant-Closure Signal Feed (`peepee/warn-layoff-signal-feed`) Actor

Get the earliest, cleanest signal on corporate layoffs. This WARN Act notice scraper pulls official state mass layoff & plant closure filings into one feed: company, location, headcount, dates, and NAICS industry code.

- **URL**: https://apify.com/peepee/warn-layoff-signal-feed.md
- **Developed by:** [K O](https://apify.com/peepee) (community)
- **Categories:** Jobs, News, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $100.00 / 1,000 layoff notices

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

## WARN Act Layoff & Plant-Closure Signal Feed — Layoff Data Scraper & API

A **WARN Act notice scraper** and layoff data API that pulls official,
government-filed WARN Act (Worker Adjustment and Retraining Notification)
notices directly from state labor agency sources and normalizes them into
one clean feed: company, location, headcount affected, notice date, effective
date, and closure type. No news aggregation, no scraping of secondary
trackers — this reads the primary source filings state agencies are legally
required to publish.

Use it to build a **mass layoff tracker**, a **plant closure dataset**, a
sales/recruiting trigger-event feed, or a distress-signal input for
credit/equity research — all from the same normalized WARN Act data feed.

### Why this is worth charging for

Mass-layoff and plant-closure notices are one of the cleanest leading indicators
of corporate distress available anywhere, and they are legally mandated public
record — but there is no unified API for them. Every state publishes its own
WARN notices in its own spreadsheet format, on its own schedule, with its own
column names, and reformats them without warning. Aggregating this by hand across
even a handful of states is a standing, recurring chore. That gap is the product.

Buyers who have historically paid for exactly this kind of signal:

- **Recruiters and staffing agencies** — a fresh, large layoff is a sourcing list.
- **Asset recovery / equipment liquidators and commercial real estate brokers** —
  a facility closure means fixtures, equipment, and space are about to hit the
  market.
- **Distressed-debt and short-side investors** — mass layoffs are a real-time
  input into credit and equity risk models, well ahead of earnings.
- **Journalists and local economic-development offices** — first-to-know on
  regional job losses.
- **Sales teams selling into HR / outplacement / benefits** — a layoff event is
  a textbook trigger-based lead.

### Output

Each dataset item is one normalized layoff/closure notice:

```json
{
  "state": "CA",
  "company": "Acme Manufacturing Inc",
  "noticeDate": "2026-01-05",
  "effectiveDate": "2026-03-10",
  "employeesAffected": 1250,
  "layoffType": "Layoff",
  "county": "Los Angeles",
  "city": "Los Angeles",
  "address": "100 Main St",
  "zip": null,
  "naicsCode": null,
  "region": "LA/Ventura",
  "sourceUrl": "https://edd.ca.gov/siteassets/files/jobs_and_training/warn/warn_report1.xlsx",
  "sourceSheet": "WARN Report",
  "headerDetectionConfidence": "high"
}
````

### Input

| Field | Description |
|---|---|
| `states` | Which state sources to pull (`CA`, `TX` at launch — see Roadmap). |
| `sinceDate` | Only return notices on/after this date (matched against effective date, falling back to notice date). Leave blank for full available history. |
| `maxItems` | Stop after this many normalized notices. Leave blank for no cap. |
| `includeRawRow` | Attach the untouched original spreadsheet row for audit/debugging. |

### Recommended pricing (Pay-Per-Event)

This actor is built for Apify's Pay-Per-Event model:

- **`state-source-checked`** — $0.05, charged once per state per run, regardless
  of how many new notices were found. A "quiet" check is still a monitored
  result; the user is paying to *know* nothing changed, not only for rows.
- **`layoff-notice`** — $0.10 per normalized notice pushed to the dataset. This
  is the primary event.
- `apify-actor-start` (synthetic, Apify-managed) — covers the first 5 seconds of
  compute per run.

A typical scheduled daily run across 2 states with a handful of new filings
costs a buyer $0.20–$2.00; a full historical backfill across both states (several
thousand historical rows) is a one-time $150–$400 pull — priced like the
alternative-data product it is, not like a generic scraper.

### Why the parser doesn't hard-code column positions

State agencies rename, reorder, and add spreadsheet columns without notice —
the actor detects the header row and maps columns by keyword match instead of
fixed index (see `src/parser.js`). If a sheet's header can't be confidently
identified, that sheet is skipped rather than silently emitting garbage rows,
and every record is tagged with `headerDetectionConfidence` so consumers can
filter on it. Run `npm test` for the offline self-test that exercises this
logic against synthetic CA- and TX-shaped workbooks.

### Roadmap

Built to add states without changing the parser: add an entry to
`src/sources.js` and, if that state exposes downloadable WARN data, it should
work with no further changes. New York, Florida, and Ohio are natural next
additions once their file formats are confirmed stable.

### FAQ

**Is there an API for WARN Act layoff notices?**
Yes — this actor is that API. Run it on a schedule and every new WARN notice
across your selected states lands in a structured dataset you can pull via
the Apify API, webhook, or direct export (JSON/CSV/Excel).

**Where does the layoff data come from?**
Directly from each state's official labor agency WARN filing page (e.g.
California's EDD, Texas Workforce Commission) — the same primary-source
spreadsheets employers are legally required to file, not a news aggregator
or third-party tracker.

**Can I filter by date or company size?**
Yes. Use the `sinceDate` input to pull only new notices, and filter the
output dataset by `employeesAffected` after the run — every record includes
the full headcount, so you can slice by mass-layoff threshold yourself.

**How much does it cost to run?**
Pay-per-event pricing: $0.05 per state source checked, $0.10 per layoff
notice returned. A daily monitoring run across a couple of states typically
costs well under $1; a full historical backfill is a one-time cost scaled to
how many notices exist.

**What's the difference between this and a layoff news tracker?**
News trackers report layoffs after they're publicly announced or leaked.
WARN notices are a legal filing requirement with fixed advance-notice
windows, so this feed is often the earliest structured, verifiable signal
available — before it's a headline.

# Actor input Schema

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

Pick which state labor agencies to pull official WARN notices from. Each state adds one 'state-source-checked' charge per run.

## `sinceDate` (type: `string`):

ISO date (YYYY-MM-DD). Leave blank to pull the full available history from each source (California publishes ~10 years back, Texas publishes per calendar year). Filtering is based on effective date, falling back to notice date.

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

Stop once this many normalized layoff notices have been pushed to the dataset. Leave blank for no limit.

## `includeRawRow` (type: `boolean`):

Attach the original, unmodified spreadsheet row as 'rawRow' on every record. Useful for auditing or when a state changes its column layout.

## Actor input object example

```json
{
  "states": [
    "CA",
    "TX"
  ],
  "includeRawRow": false
}
```

# 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("peepee/warn-layoff-signal-feed").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("peepee/warn-layoff-signal-feed").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 '{}' |
apify call peepee/warn-layoff-signal-feed --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=peepee/warn-layoff-signal-feed",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "WARN Act Layoff & Plant-Closure Signal Feed",
        "description": "Get the earliest, cleanest signal on corporate layoffs. This WARN Act notice scraper pulls official state mass layoff & plant closure filings into one feed: company, location, headcount, dates, and NAICS industry code.",
        "version": "1.0",
        "x-build-id": "pj7ZGVGgaJhcgpuau"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/peepee~warn-layoff-signal-feed/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-peepee-warn-layoff-signal-feed",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/peepee~warn-layoff-signal-feed/runs": {
            "post": {
                "operationId": "runs-sync-peepee-warn-layoff-signal-feed",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/peepee~warn-layoff-signal-feed/run-sync": {
            "post": {
                "operationId": "run-sync-peepee-warn-layoff-signal-feed",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "states"
                ],
                "properties": {
                    "states": {
                        "title": "States to monitor",
                        "type": "array",
                        "description": "Pick which state labor agencies to pull official WARN notices from. Each state adds one 'state-source-checked' charge per run.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "CA",
                                "TX"
                            ],
                            "enumTitles": [
                                "California (EDD)",
                                "Texas (TWC)"
                            ]
                        },
                        "default": [
                            "CA",
                            "TX"
                        ]
                    },
                    "sinceDate": {
                        "title": "Only include notices on/after this date",
                        "type": "string",
                        "description": "ISO date (YYYY-MM-DD). Leave blank to pull the full available history from each source (California publishes ~10 years back, Texas publishes per calendar year). Filtering is based on effective date, falling back to notice date."
                    },
                    "maxItems": {
                        "title": "Maximum notices to return",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Stop once this many normalized layoff notices have been pushed to the dataset. Leave blank for no limit."
                    },
                    "includeRawRow": {
                        "title": "Include raw source row",
                        "type": "boolean",
                        "description": "Attach the original, unmodified spreadsheet row as 'rawRow' on every record. Useful for auditing or when a state changes its column layout.",
                        "default": false
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```