# Federal Court Case Monitor — New Cases & Filings, No Login (`flamboyant_liner/court-case-monitor`) Actor

Watch parties, keywords or courts on CourtListener (PACER/RECAP) and get only NEW federal cases, new docket filings and opinions since the last run, with judge, nature of suit, parties and latest entry. Daily schedule. No login required. MCP-ready. $20 per 1,000 alerts.

- **URL**: https://apify.com/flamboyant\_liner/court-case-monitor.md
- **Developed by:** [Khrystyna Skotte](https://apify.com/flamboyant_liner) (community)
- **Categories:** Lead generation, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $20.00 / 1,000 alerts

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?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Federal Court Case Monitor — new lawsuits, docket filings and opinions, daily

Watch **company names, people, keywords or whole courts** and get only the **new federal cases, new docket
entries and new court opinions since the last run**, straight from CourtListener / the RECAP archive of PACER.
The monitor remembers every case it has already reported, so a scheduled run emits just the delta
(`new_case`, `new_filing`, `new_opinion`), posts a summary to your webhook, and costs you only for what changed.
No PACER account, no login; a CourtListener API token is optional.

Use it for litigation monitoring (is our client, competitor, supplier or portfolio company being sued?),
credit and KYC screening, insurance and compliance alerts, legal-news leads, or tracking your own dockets —
without paying $100+/month per watch to a legacy docket-alert vendor.

### How it works

1. For each watch (every party name, every keyword, or the court list when neither is given) it queries
   CourtListener's search API for dockets **filed within `filedSinceDays`**, newest first, optionally limited
   to `courts`.
2. Every docket not in the monitor's saved state is emitted as `new_case` (up to `maxNewPerWatch` per watch
   and `maxItems` per run) and recorded with the date of its latest docket entry.
3. With `trackDocketEntries` on, it re-checks up to 100 known dockets (most recently active first) and emits
   `new_filing` for any whose newest docket entry is later than the one recorded.
4. With `opinions` in `caseTypes` it does the same for published opinions (`new_opinion`).
5. Saves the state, then POSTs a run summary to `webhookUrl` if set.

State lives in a named key-value store `court-monitor-<hash of monitorId>` in your Apify account, capped at
50,000 dockets and 50,000 opinions (oldest dropped). Delete the store to reset a monitor.

### Input

| Field | Default | Notes |
|---|---|---|
| `partyNames` | `["Amazon.com", "Tesla, Inc."]` | One watch per name, phrase-matched against the docket's parties (case name for opinions) |
| `keywords` | `[]` | One full-text watch per entry across case names, parties, entries and documents. CourtListener query syntax works (`"data breach"`, `patent AND infringement`) |
| `courts` | `[]` | CourtListener court IDs, e.g. `cand`, `nysd`, `txed`, `ded`, `ca9`, `scotus`. Restricts every watch; alone, it becomes the watch. [Full list](https://www.courtlistener.com/help/api/jurisdictions/) |
| `caseTypes` | `["dockets"]` | `dockets` (PACER/RECAP cases) and/or `opinions` |
| `filedSinceDays` | `7` | Only cases filed within N days count as new. 3–7 gives a safe overlap for a daily schedule |
| `trackDocketEntries` | `false` | Also re-check known dockets for new entries (≤100 dockets per run, 20 per API call) |
| `maxNewPerWatch` | `5` | Cap per watch; the rest stays unseen and comes out next run |
| `maxItems` | `10` | Hard cap on records per run |
| `firstRunMode` | `emitAll` | `emitAll` reports every current match on the first run; `baseline` records them silently |
| `webhookUrl` | `""` | Optional POST target for the run summary |
| `monitorId` | `default` | One state store per ID — run several watchlists side by side |
| `courtlistenerApiToken` | *(none)* | Optional, secret. Sent as `Authorization: Token …` |

### Rate limits and the API token

CourtListener's search API answers without authentication, but anonymous and default accounts are throttled
to about **5 requests per minute** (rolling; documented account defaults are 5/min, 50/hour, 125/day). The
actor spaces its calls, honours the `Retry-After`-style hint in 429 responses, batches docket-entry checks
20 dockets per call and stops after 60 calls per run. A default run uses 2 calls; each extra party name,
keyword or case type adds one, and tracking 100 dockets adds five.

For bigger watchlists create a free account at courtlistener.com, copy the token from your profile's API
page into `courtlistenerApiToken`, and consider a [Free Law Project membership](https://free.law/membership/)
which raises the limits. Do not create several accounts to multiply quota — CourtListener forbids it.

### Recommended setup for a daily feed

1. Create a task with your party names / keywords / courts and a meaningful `monitorId`.
2. **First run: set `firstRunMode` to `baseline`** and `filedSinceDays` to 30. It records everything
   currently matching and emits nothing, so day one is not a 300-row backlog.
3. Switch `firstRunMode` back to `emitAll` (it only matters while the state is empty), set `filedSinceDays`
   to 3–7, `maxNewPerWatch` to 50 and `maxItems` to 500. Turn on `trackDocketEntries` if you want to follow
   filings on the cases already found.
4. **Schedule the task daily**, e.g. 07:00 America/New\_York. RECAP receives most new filings during the US
   business day, and a morning run catches the previous day's cases.
5. Point `webhookUrl` at Slack (incoming webhook), Zapier, Make, or your own endpoint.

The default settings (`{}`) run in `emitAll` mode on `Amazon.com` and `Tesla, Inc.` so you see real output
on the first try.

### Example: watch three clients in the courts that matter

```json
{
  "partyNames": ["Acme Robotics, Inc.", "Northwind Logistics LLC", "Jane Q. Founder"],
  "keywords": [],
  "courts": ["cand", "nysd", "ded", "txed", "ca9", "ca2"],
  "caseTypes": ["dockets", "opinions"],
  "filedSinceDays": 5,
  "trackDocketEntries": true,
  "maxNewPerWatch": 50,
  "maxItems": 500,
  "firstRunMode": "baseline",
  "webhookUrl": "https://hooks.slack.com/services/XXX/YYY/ZZZ",
  "monitorId": "clients-litigation"
}
```

Other quick profiles:

- **Every new case in one court**: `partyNames: []`, `courts: ["txed"]`
- **Topic watch**: `partyNames: []`, `keywords: ["\"data breach\"", "\"class action\" AND privacy"]`
- **Portfolio screening**: 50 company names, `filedSinceDays: 3`, `trackDocketEntries: false`, with an API token

### Output

`new_case` / `new_filing` record:

```json
{
  "changeType": "new_case",
  "docketId": 74859270,
  "caseName": "Cox v. Amazon.com Inc.",
  "docketNumber": "4:26-cv-04306",
  "court": "scd",
  "courtName": "District Court, D. South Carolina",
  "dateFiled": "2026-09-28",
  "dateLastFiling": "2026-09-28",
  "natureOfSuit": "350 Motor Vehicle",
  "cause": "28:1332 Diversity-Personal Injury",
  "juryDemand": "Plaintiff",
  "assignedJudge": "Joseph Dawson III",
  "parties": ["Amazon.com Services, LLC", "Amazon.com Inc.", "Timothy Elwin Cox", "Ashley Roberts Cox", "Amazon Logistics, Inc."],
  "latestEntry": { "date": "2026-09-28", "description": "NOTICE OF STANDING ORDER (Attachments: # 1 AO 85) (mgod, ) (Entered: 09/28/2026)", "documentNumber": 5, "docketEntryId": 479623294 },
  "pacerCaseId": "324808",
  "courtListenerUrl": "https://www.courtlistener.com/docket/74859270/cox-v-amazoncom-inc/",
  "matchedWatch": "Amazon.com",
  "firstSeenAt": "2026-09-28T20:27:58.376Z",
  "monitorId": "default"
}
```

`new_filing` records carry the same docket fields, `latestEntry` is the entry that triggered the alert,
`matchedWatch` is `"tracked"` and `firstSeenAt` is `null`. `parties` lists the first 10 parties.

`new_opinion` record:

```json
{
  "changeType": "new_opinion",
  "opinionId": 10983012,
  "caseName": "Perez v. v Wax Studio, LLC",
  "docketNumber": "Civil Action No. 2025-3897",
  "court": "dcd",
  "courtName": "District Court, District of Columbia",
  "dateFiled": "2026-09-24",
  "assignedJudge": "Judge Rudolph Contreras",
  "citation": null,
  "status": "Published",
  "snippet": "UNITED STATES DISTRICT COURT FOR THE DISTRICT OF COLUMBIA …",
  "downloadUrl": "https://ecf.dcd.uscourts.gov/cgi-bin/show_public_doc?2025cv3897-16",
  "courtListenerUrl": "https://www.courtlistener.com/opinion/10983012/perez-v-v-wax-studio-llc/",
  "matchedWatch": "Tesla",
  "firstSeenAt": "2026-09-28T21:03:47.011Z",
  "monitorId": "default"
}
```

### Webhook payload

POSTed once per run as `application/json`, also saved as the `SUMMARY` record in the run's key-value store:

```json
{
  "monitorId": "clients-litigation",
  "runAt": "2026-09-29T11:00:03.118Z",
  "newCases": 2,
  "newFilings": 5,
  "newOpinions": 0,
  "scanned": 61,
  "seenDockets": 812,
  "seenOpinions": 40,
  "apiRequests": 11,
  "throttled": 0,
  "baseline": false,
  "records": [ { "...first 50 records, same shape as the dataset..." } ]
}
```

### Pricing

Pay per event: a small start fee plus a per-alert fee **only for records emitted**. A daily monitor that finds
nothing new costs just the start fee.

### Notes

- Coverage is CourtListener's: all federal district, bankruptcy and appellate courts via RECAP (cases appear
  once any RECAP user or the free-law crawlers touch them, which for new civil cases is usually the same
  day), plus published opinions from federal and state courts.
- The search API nests at most three docket entries per case. For a busy docket the monitor records "seen
  through today" instead of guessing, and `trackDocketEntries` reports anything filed after that.
- A watch scans at most 100 dockets (5 pages) per run; use narrower courts or a shorter window if a watch
  matches more than that every day.

# Actor input Schema

## `partyNames` (type: `array`):

Companies or people. Each name is one watch, matched as a phrase against the parties on the docket (e.g. "Amazon.com", "Tesla, Inc.", "John Smith"). For opinions the phrase is matched against the case name.

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

Each entry is one full-text watch across case names, parties, docket entries and documents. CourtListener query syntax works, e.g. "data breach", "patent AND infringement", "securities fraud".

## `courts` (type: `array`):

CourtListener court IDs to restrict every watch to, e.g. cand (N.D. Cal.), nysd (S.D.N.Y.), txed (E.D. Tex.), ded (D. Del.), ca9 (9th Cir.), scotus. Full list: https://www.courtlistener.com/help/api/jurisdictions/. With no party names or keywords, the courts themselves become the watch (every new case in those courts).

## `caseTypes` (type: `array`):

dockets = new federal cases from PACER/RECAP (and new docket entries when trackDocketEntries is on). opinions = new published court opinions.

## `filedSinceDays` (type: `integer`):

Only cases and opinions filed within this many days are considered new. For a daily schedule 3-7 days gives a safe overlap; the seen-state prevents duplicates.

## `trackDocketEntries` (type: `boolean`):

Re-check up to 100 previously seen dockets (most recently active first) and emit a new\_filing record when a docket entry newer than the last one recorded has appeared.

## `maxNewPerWatch` (type: `integer`):

Stop scanning a watch after this many new cases/opinions. Anything beyond stays unseen and comes out on the next run.

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

Hard cap on records emitted in one run across all watches (new cases, filings and opinions).

## `firstRunMode` (type: `string`):

What to do when the monitor has no saved state yet. emitAll: treat every current match as new and emit it (good for a one-off pull or a first test). baseline: silently record every current match as seen and emit nothing, so the next scheduled run reports only what changed since.

## `webhookUrl` (type: `string`):

Optional. After each run a JSON summary {monitorId, runAt, newCases, newFilings, newOpinions, records\[first 50]} is POSTed here (Slack/Zapier/Make/your API).

## `monitorId` (type: `string`):

Name of this watchlist. Each monitor ID keeps its own seen-state in a key-value store named court-monitor-<hash>, so you can run several profiles (e.g. "clients-litigation", "competitors-ip") side by side.

## `courtlistenerApiToken` (type: `string`):

Optional. Unauthenticated access is rate-limited to about 5 requests per minute; a free CourtListener account token (Profile > API) is sent as Authorization: Token ... and a Free Law Project membership raises the limits further.

## Actor input object example

```json
{
  "partyNames": [
    "Amazon.com",
    "Tesla, Inc."
  ],
  "keywords": [],
  "courts": [],
  "caseTypes": [
    "dockets"
  ],
  "filedSinceDays": 7,
  "trackDocketEntries": false,
  "maxNewPerWatch": 5,
  "maxItems": 10,
  "firstRunMode": "emitAll",
  "webhookUrl": "",
  "monitorId": "default"
}
```

# Actor output Schema

## `records` (type: `string`):

Dataset of new cases, new docket filings and new opinions found in this run (JSON).

# 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 = {
    "partyNames": [
        "Amazon.com",
        "Tesla, Inc."
    ],
    "caseTypes": [
        "dockets"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("flamboyant_liner/court-case-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 = {
    "partyNames": [
        "Amazon.com",
        "Tesla, Inc.",
    ],
    "caseTypes": ["dockets"],
}

# Run the Actor and wait for it to finish
run = client.actor("flamboyant_liner/court-case-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 '{
  "partyNames": [
    "Amazon.com",
    "Tesla, Inc."
  ],
  "caseTypes": [
    "dockets"
  ]
}' |
apify call flamboyant_liner/court-case-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,flamboyant_liner/court-case-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/Kh1xQ51Ax3oVjjOmU/builds/wrHJDWIUvybZbgYzW/openapi.json