# Securities Class Action Filings Scraper (`parseforge/securities-class-action-filings-scraper`) Actor

Scrape the Stanford Securities Class Action Clearinghouse: every federal securities class action filed since 1996 with its status, judge, filing date and case narrative, plus settlement amounts, class periods and counsel parsed from the narrative.

- **URL**: https://apify.com/parseforge/securities-class-action-filings-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Lead generation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $6.23 / 1,000 class action filings

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

[![ParseForge](https://raw.githubusercontent.com/ParseForge/apify-assets/main/banner.jpg)](https://apify.com/parseforge?fpr=vmoqkp)

### Securities Class Action Scraper - Stanford Filings Database

**Download the Stanford Securities Class Action Clearinghouse as data: roughly 6,400 federal securities class actions from 1996 to July 2025, each with its company, filing date, case status, presiding judge and the Clearinghouse's own case narrative.** No login, no API key, no browser. Export to CSV, JSON, Excel, or XML.

The Clearinghouse is the reference record of securities class action litigation, but its website shows fifteen results at a time, offers no export, and gates sorting and advanced search behind a sign-up. This Actor reads the public case pages, returns them as flat rows, and parses the narrative for the things the database never puts in a field: settlement amounts, class periods, lead counsel, the statutes pleaded and the share price move behind the case.

| Who uses it | What they use class action data for |
|---|---|
| D\&O insurers and brokers | Loss history by industry, court and year for pricing and reserving |
| Securities defence and plaintiff firms | Case histories by company, judge and allegation before filing or answering |
| Investor relations and general counsel | What peer companies were sued over and how those cases ended |
| Academics and economists | A 30-year litigation panel with status, dates and narrative text |
| Litigation finance and data vendors | Filing and outcome series with stable case ids to join onto tickers |

### What it does

The Clearinghouse gives every case an id and a public case page. This Actor walks those pages and returns one row per case with:

- 🧾 **The case:** company name, normalised company name, case title, the related entity when a case is filed against a fund or a certificate series, and the Clearinghouse case id and URL.
- 🗓️ **The dates:** filing date with its year, month and quarter, days since filing, the status date and days since it.
- ⚖️ **The outcome:** case status (ONGOING, SETTLED, DISMISSED), the event that set it ("Date of order of final judgment", "Court's order of dismissal", "Notice of voluntarily dismissal"), and the presiding judge.
- 🏛️ **Court and security:** district court, exchange and ticker for the cases the Clearinghouse lists on its filings index.
- 📝 **The narrative:** a 300 character excerpt in every row, and the complete case summary as an option.
- 💵 **Parsed from the narrative** (each one optional): settlement amounts and approval, class period start and end, lead plaintiffs and counsel firms, the statutes pleaded, docket and MDL references, the share price drop, and allegation tags such as accounting restatement, insider selling, FDA trial, SPAC, crypto or artificial intelligence.

Leave the filters empty and the run returns the newest cases the Clearinghouse lists, which is the fastest way to check the database. Give it a date range and the run bisects the case id space to find the window for those dates and sweeps it.

Every row contains: `caseId`, `caseUrl`, `companyName`, `companyNameNormalized`, `caseTitle`, `relatedEntity`, `filingDate`, `filingDateRaw`, `filingYear`, `filingMonth`, `filingQuarter`, `daysSinceFiling`, `caseStatus`, `statusDate`, `statusEvent`, `daysSinceStatus`, `isOngoing`, `isSettled`, `isDismissed`, `presidingJudge`, `hasJudge`, `districtCourt`, `exchange`, `tickerSymbol`, `hasSummary`, `summaryExcerpt`, `summaryLength` and `scrapedAt`.

### What you can do with securities class action data

**Build a D\&O loss history.**

Pull a decade of cases with `dateFrom` and `dateTo`, turn on settlement terms and allegation tags, and you have filings and outcomes by year, status and theme. In a 300 case sample from 2020 the split was 211 dismissed, 75 settled and 14 still ongoing.

**Check what a company or its peers were sued over.**

`companyNameContains` keeps only cases whose company name or title matches, and the narrative tells you what the complaint alleged and how it ended.

**Research a judge.**

`judgeNameContains` returns every case in the database before that judge, with the status and the event that closed it.

**Find the cases that match a theme.**

`summaryContains` searches the narrative text, so "restatement", "clinical trial", "SPAC" or a law firm name pulls exactly those cases. Allegation tags do the same job as a fixed vocabulary.

### Why choose this scraper

|  | What you get |
|---|---|
| **The archive as a table** | Roughly 6,400 cases from 1996 to July 2025, exported in one run instead of read fifteen at a time |
| **Outcome, not just filing** | Status, status date and the court event that set it, so settled and dismissed cases are separable |
| **The narrative parsed** | Settlement amounts, class periods, counsel, statutes and price drops that exist only as prose on the site |
| **Honest hit rates** | Each parsed block is charged only when it found something, and the older the case the more it finds |
| **Date windows without a full sweep** | The run bisects the case id space, so a single year costs a few hundred requests instead of nine thousand |
| **No login** | Everything here comes from the public case pages; nothing behind the Clearinghouse sign-up is touched |

### How it compares

No other Apify Actor covers this database. The comparison that matters is against the Clearinghouse website itself and against court-record scrapers, which carry dockets but not the Clearinghouse's curated case narrative or its status labels.

| Feature | ParseForge | SCAC website | Court record actors |
|---|---|---|---|
| Bulk export to CSV, JSON, Excel | Yes | No | Yes |
| Cases back to 1996 with status | Yes | Yes | Rarely |
| Case narrative text | Yes | Yes | No |
| Settlement amount parsed | Yes, where the narrative states it | No field | No |
| Allegation tags | Yes | No | No |
| Filter by judge, company or narrative text | Yes | Sign-up required | Sometimes |
| Price per row | $0.007 | Free, manual | $0.003 to $0.005 |

### What a case looks like

```json
{
  "caseId": 108637,
  "caseUrl": "https://securities.stanford.edu/filings-case.html?id=108637",
  "companyName": "Replimune Group, Inc.",
  "companyNameNormalized": "REPLIMUNE",
  "caseTitle": "Replimune Group, Inc. Securities Litigation",
  "relatedEntity": "N/A",
  "filingDate": "2025-07-24",
  "filingDateRaw": "July 24, 2025",
  "filingYear": 2025,
  "filingMonth": 7,
  "filingQuarter": "Q3",
  "daysSinceFiling": 400,
  "caseStatus": "ONGOING",
  "statusDate": "2025-07-24",
  "statusEvent": "Date of last review",
  "daysSinceStatus": 400,
  "isOngoing": "Yes",
  "isSettled": "No",
  "isDismissed": "No",
  "presidingJudge": "Hon. Julia E. Kobick",
  "hasJudge": "Yes",
  "districtCourt": "D. Massachusetts",
  "exchange": "NASDAQ",
  "tickerSymbol": "REPL",
  "hasSummary": "Yes",
  "summaryExcerpt": "According to the Complaint, Replimune Group, Inc. was founded in 2015 with the mission to transform cancer treatment by pioneering the development of novel oncolytic immunotherapies. This class action was filed against Replimune and two of its Officers…",
  "summaryLength": 896,
  "scrapedAt": "2026-08-27T17:00:47.430Z"
}
```

`districtCourt`, `exchange` and `tickerSymbol` come from the Clearinghouse filings index, which lists the most recent cases; cases pulled from deeper in the archive return `Not Disclosed` for those three.

### Configure the run

Run it with no input to see the newest cases. Add a date range to sweep the archive, and tick the parsed blocks you need.

The newest cases in the database:

```json
{ "maxItems": 30 }
```

A full year with the outcome and the theme:

```json
{
  "dateFrom": "2015-01-01",
  "dateTo": "2015-12-31",
  "includeCaseNarrative": true,
  "includeAllegationTags": true,
  "includeStatutesAndClaims": true,
  "maxItems": 500
}
```

Settled cases with the amounts, for a loss study:

```json
{
  "dateFrom": "2004-01-01",
  "dateTo": "2008-12-31",
  "caseStatuses": ["SETTLED"],
  "includeSettlementTerms": true,
  "includeClassPeriod": true,
  "includeCounselAndPlaintiffs": true,
  "maxItems": 1000
}
```

Everything a company was sued over:

```json
{ "companyNameContains": "Wells Fargo", "includeCaseNarrative": true, "maxItems": 100 }
```

### Pricing

Pay-per-event. **$7 per 1,000 cases** plus $0.02 per run start and $0.004 per catalog probe, which is the filings index and the handful of requests that locate your date window. The parsed blocks are opt-in and are charged only when they return something.

| Event | Price | When |
|---|---|---|
| `filing-record` | $0.007 | Every case written |
| `catalog-probe` | $0.004 | Index and id-window requests, never more than the rows written |
| `case-narrative` | $0.005 | Full case summary attached |
| `settlement-terms` | $0.008 | A settlement amount or approval was found |
| `class-period` | $0.006 | The narrative states the class period |
| `counsel-and-plaintiffs` | $0.006 | A lead plaintiff or law firm was found |
| `statutes-and-claims` | $0.005 | At least one statute is pleaded in the narrative |
| `docket-references` | $0.005 | A docket, court or MDL number was found |
| `stock-move-metrics` | $0.006 | The narrative gives the price move |
| `allegation-tags` | $0.005 | At least one theme tag applies |

| Run | Approximate cost |
|---|---|
| 30 newest cases | $0.35 |
| 500 cases with narrative and tags | $12.02 |
| 1,000 cases, index fields only | $9.02 |
| 6,000 cases with every block that fires | up to $70 |

New Apify accounts start with $5 in free credit.

### Free users

Free-plan runs return up to 10 cases as a preview. [Upgrade your Apify plan](https://console.apify.com/sign-up?fpr=vmoqkp) to sweep the archive.

### Run it

1. [Create a free Apify account with $5 in credit](https://console.apify.com/sign-up?fpr=vmoqkp).
2. Open the [Securities Class Action Filings Scraper](https://apify.com/parseforge/securities-class-action-filings-scraper?fpr=vmoqkp).
3. Set a date range or a company, tick the parsed blocks you want, then click **Start**.
4. Export the results as CSV, Excel, JSON, or XML from the **Dataset** tab.

Run it programmatically through the [Apify API](https://docs.apify.com/api/v2) (`run-sync-get-dataset-items`) or the [ApifyClient](https://docs.apify.com/api/client/js) for JavaScript and Python.

### Use with AI agents (MCP)

Give an AI agent the securities class action archive through the Model Context Protocol:

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=parseforge/securities-class-action-filings-scraper"
```

Then ask: *"How many securities class actions filed in 2015 ended in dismissal?"*, *"Which cases before Judge Rakoff settled?"* or *"Find class actions about clinical trial results"*.

### Troubleshooting

**Why is nothing newer than July 2025?**

Because the Clearinghouse stopped updating. Its own notice says the site "is currently under construction and is temporarily unavailable as it undergoes updates and improvements", is expected to return as part of the Stanford Rock Center for Corporate Governance in Winter 2026, and that "during this period, updates and new filings will not be available". The archive up to 28 July 2025 is complete and served normally; nothing after it exists to scrape yet.

**Why are the settlement or class period fields empty?**

Because that case's narrative does not state them. The Clearinghouse writes a short description when a case is filed and expands it as the case moves, so the parsed blocks fire on older cases and rarely on recent ones. Measured on a 40 case sample from 2005: settlement amounts on 38%, statutes on 68%, law firms on 33%, class period on 18%. On a 300 case sample from 2020: statutes on 6%, allegation tags on 96%. You are not charged for a block that found nothing.

**Why are `districtCourt`, `exchange` and `tickerSymbol` empty?**

Those three come from the Clearinghouse filings index, which only lists its most recent cases. Cases pulled by date range or by id come from the case page, which does not publish them without a sign-up.

**Why fewer rows than I asked for?**

About one in four case ids in the archive is empty, and your filters remove more. The run log prints how many case pages it read against how many rows it wrote.

**Why is the run slow on a wide date range?**

Each case is its own page. The run reads about eight pages a second, so a full year (roughly 300 cases plus the empty ids between them) takes under a minute, and the whole archive takes about twenty.

### FAQ

| Question | Answer |
|---|---|
| What is the Clearinghouse? | The Stanford Securities Class Action Clearinghouse, run with Cornerstone Research, is the standard public record of federal securities class actions since the 1995 Reform Act. |
| How many cases are there? | The archive holds about 6,400 readable case pages between 1996 and July 2025, out of 8,640 case ids. |
| Is the data public? | Yes. Every field comes from public case pages. The Actor does not log in and does not touch the sign-up-only advanced search, complaint PDFs or company and securities tabs. |
| Why is my case missing a ticker? | Ticker, exchange and district court are published only on the filings index for recent cases; the case page does not carry them for the public. |
| Can I search the full text of complaints? | No. The complaint PDFs are behind the Clearinghouse sign-up. `summaryContains` searches the Clearinghouse's own case narrative instead. |
| Does it give settlement amounts? | Where the narrative states one. Turn on settlement terms; the row carries the largest amount named in a settlement sentence plus every amount found. |
| How current is it? | The database itself is frozen until the Clearinghouse relaunches. The newest case in it was filed on 28 July 2025. |
| Can I get cases for one company only? | Yes, with `companyNameContains`. Combine it with a date range to keep the sweep short. |
| How many cases per run? | Free plan: 10. Paid: as many as your filters match, up to the whole archive. |
| Is this an official Stanford product? | No. It is unofficial and reads only public pages. |

### Related actors

- [SEC Litigation Releases Scraper](https://apify.com/parseforge/sec-litigation-releases-scraper?fpr=vmoqkp): SEC enforcement actions with defendants and case links.
- [FINRA BrokerCheck Scraper](https://apify.com/parseforge/finra-brokercheck-scraper?fpr=vmoqkp): broker and firm registration records with disclosures.
- [CourtListener Dockets Scraper](https://apify.com/parseforge/courtlistener-dockets-scraper?fpr=vmoqkp): federal and state docket entries by court and party.
- [SEC Investor Alerts Scraper](https://apify.com/parseforge/sec-investor-alerts-scraper?fpr=vmoqkp): investor alerts and bulletins as they are published.
- [GAO Bid Protest Docket Scraper](https://apify.com/parseforge/gao-bid-protest-docket-scraper?fpr=vmoqkp): federal bid protests with parties and decisions.

Browse the full [ParseForge collection](https://apify.com/parseforge?fpr=vmoqkp) for more scrapers.

🆘 **Need help?** Email parseforge@protonmail.com with your run ID, your input, and what you expected.

⚠️ **Disclaimer.** This Actor is unofficial and is not affiliated with, endorsed by, or sponsored by Stanford University, the Rock Center for Corporate Governance or Cornerstone Research. It collects only publicly available pages from the Securities Class Action Clearinghouse. Case records name real people and companies, so you are responsible for using the data in compliance with applicable laws, including GDPR, CCPA, and PIPL, and with the Clearinghouse's terms. Do not use it to identify, profile, or target individuals.

# Actor input Schema

## `caseIds` (type: `array`):

Clearinghouse case ids to fetch directly, for example 108640. The id is the number in the case page URL.

## `startUrls` (type: `array`):

Paste Clearinghouse case page URLs such as https://securities.stanford.edu/filings-case.html?id=108640.

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

Free users: limited to 10 items (preview). Paid users: up to 1,000,000.

## `dateFrom` (type: `string`):

Earliest filing date to include, as YYYY-MM-DD. The database starts in 1996. Setting a date range switches the run from the latest-filings feed to a sweep of the case archive.

## `dateTo` (type: `string`):

Latest filing date to include, as YYYY-MM-DD. Leave empty for today.

## `caseStatuses` (type: `array`):

Keep only cases in these states. The Clearinghouse publishes three: ONGOING, SETTLED and DISMISSED.

## `companyNameContains` (type: `string`):

Keep only cases whose company name or case title contains this text, for example "Tesla" or "Bancorp".

## `judgeNameContains` (type: `string`):

Keep only cases before a judge whose name contains this text, for example "Rakoff".

## `summaryContains` (type: `string`):

Keep only cases whose narrative contains this text, for example "restatement", "clinical trial" or a law firm name.

## `sortBy` (type: `string`):

Newest filings first, or oldest first. Cases are read in case id order, which follows the filing date.

## `includeCaseNarrative` (type: `boolean`):

Add the Clearinghouse's full case summary to the row: the allegations, the procedural history and, where it happened, the settlement.

## `includeSettlementTerms` (type: `boolean`):

Parse the settlement: the largest amount named in a settlement sentence, every amount found, whether it was approved, the approval date and whether a D\&O insurer funded it.

## `includeClassPeriod` (type: `boolean`):

Parse the class period start and end dates and its length in days.

## `includeCounselAndPlaintiffs` (type: `boolean`):

Parse the lead plaintiffs the court appointed, the lead counsel firms and every law firm named in the narrative.

## `includeStatutesAndClaims` (type: `boolean`):

Tag the statutes the complaint invokes: Exchange Act 10(b) and 20(a), Rule 10b-5, Securities Act 11, 12 and 15, state blue sky law and RICO.

## `includeDocketReferences` (type: `boolean`):

Parse the docket numbers, the district courts and any MDL number named in the narrative.

## `includeStockMoveMetrics` (type: `boolean`):

Parse the share price move behind the case: the percentage drop, the price before and after, and the class period high.

## `includeAllegationTags` (type: `boolean`):

Tag the case by allegation theme: accounting and restatement, misrepresentation, insider selling, FDA or clinical trial, merger, IPO, SPAC, crypto, artificial intelligence, cybersecurity, regulatory investigation, product safety, China-based issuer, bankruptcy and ESG.

## Actor input object example

```json
{
  "maxItems": 10,
  "sortBy": "newest",
  "includeCaseNarrative": false,
  "includeSettlementTerms": false,
  "includeClassPeriod": false,
  "includeCounselAndPlaintiffs": false,
  "includeStatutesAndClaims": false,
  "includeDocketReferences": false,
  "includeStockMoveMetrics": false,
  "includeAllegationTags": false
}
```

# Actor output Schema

## `results` (type: `string`):

No description

## `filings` (type: `string`):

No description

## `csv` (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 = {
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/securities-class-action-filings-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "maxItems": 10 }

# Run the Actor and wait for it to finish
run = client.actor("parseforge/securities-class-action-filings-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "maxItems": 10
}' |
apify call parseforge/securities-class-action-filings-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,parseforge/securities-class-action-filings-scraper"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/djLLHNdL73mO7uhyT/builds/JwzZmrINg8cqj7AgW/openapi.json