# Federal Court Docket Monitor — New Filings via PACER RSS (`owlabee/federal-court-docket-monitor`) Actor

Monitor new federal court filings from the public PACER RSS feeds of 100+ district and bankruptcy courts: new complaints, bankruptcies, motions and orders, filtered by party name, case number or entry type, with links to the docket. No PACER account. Pay per docket entry.

- **URL**: https://apify.com/owlabee/federal-court-docket-monitor.md
- **Developed by:** [Owlabee](https://apify.com/owlabee) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 matching filing founds

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 Docket Monitor — New Filings via PACER RSS

### What it does

Every federal district and bankruptcy court running CM/ECF publishes a free, public RSS feed of its docket activity from the last 24 hours: case number, case title (the parties), the docket entry text, the document number with a link, and the filing time. This Actor reads those feeds for the courts you pick, normalizes every entry into the same JSON shape, filters them by **party name**, **case number**, **case type**, **entry type**, **keyword** or **bankruptcy chapter**, and in monitor mode flags only what is **new since your last run**. You get new complaints naming a company, new Chapter 11 petitions in Delaware or the Southern District of New York, every motion and order in a case you are watching, or a district's whole day of filings, within an hour of docketing and without a PACER account.

It is built for litigation-intelligence and legal-marketing teams, journalists, insurers, lenders, credit and compliance teams, and AI agents that need federal docket activity as structured data. Results land in an Apify dataset you can download as JSON, CSV or Excel, read over the API, push to a webhook, or query from an agent through the Apify MCP server.

The feeds are the courts' own public endpoints (`https://ecf.<court>.uscourts.gov/cgi-bin/rss_outside.pl`). No login, no PACER fees, no proxies, no browser. Documents are linked, never downloaded.

### How to use

1. Enter the **Courts** to watch: CM/ECF codes such as `nysd` (S.D.N.Y.), `deb` (Bankr. D. Del.), `txwd`, or `all`, `all-district`, `all-bankruptcy`, or a state code like `NY`. The coverage table below lists all 188 courts.
2. Optionally narrow with **Party / case title keywords** (company or person names), **Case numbers**, **Case types**, **Entry types**, **Entry text keywords**, **Bankruptcy chapters** or **New cases only**. With no filter you get every entry in the feed, newest first.
3. Click **Start**, or save the input as a Schedule (hourly works well) with **Only new since last run** on and a **Webhook URL** to get alerts.

### Input

| Field | Type | Required | Description |
|---|---|---|---|
| `courts` | string\[] | yes | CM/ECF court codes (`nysd`, `deb`, `txsb` …), `all`, `all-district`, `all-bankruptcy`, or two-letter state codes. Explicitly named courts are always tried; the `all` and state aliases expand to courts whose feed was live at the last sweep |
| `partyKeywords` | string\[] | no | Keep entries whose case title contains any of these (case-insensitive substring, or `/regex/flags`) |
| `caseNumbers` | string\[] | no | Keep entries in these cases; `1:26-cv-03810`, `26-cv-3810` and `26-11511` all work |
| `caseTypes` | string\[] | no | `civil`, `criminal`, `bankruptcy`, `adversary`, `multidistrict`, `other` |
| `entryTypes` | string\[] | no | `complaint`, `petition`, `answer`, `motion`, `order`, `judgment`, `notice`, `appeal`, `discovery`, `hearing`, `plan`, `claim`, `brief`, `other` (heuristic, see FAQ) |
| `entryKeywords` | string\[] | no | Keep entries whose docket text contains any of these (substring or `/regex/`) |
| `bankruptcyChapters` | string\[] | no | `7`, `9`, `11`, `12`, `13`, `15` |
| `newCasesOnly` | boolean | no | Keep only document number 1 of a case (complaint, petition, indictment, notice of removal) |
| `maxEntriesPerCourt` | integer | no | Cap per court per run, newest first, after filtering (default 5000) |
| `maxResults` | integer | no | Cap across all courts per run (default 100000) |
| `onlyNewSinceLastRun` | boolean | no | Monitor mode: emit only entries not seen in a previous run, flagged `isNew` (default false) |
| `stateStoreName` | string | no | Named key-value store holding the seen-entry memory (default `federal-court-docket-monitor-state`) |
| `webhookUrl` | string | no | POST target for the run summary, emitted entries (max 1,000) and error items |
| `notifyOnlyOnResults` | boolean | no | Call the webhook only when something was produced (default true) |

Filter groups are combined with AND; values inside a group with OR. `partyKeywords: ["Acme"]` with `entryTypes: ["complaint"]` and `newCasesOnly: true` means "a new case was opened against or by Acme".

### Output example

One dataset item per docket entry:

```json
{
  "recordType": "docket-entry",
  "entryId": "nysd:663583:517",
  "entryKey": "nysd:663583:517#5f1c0d3a",
  "court": "nysd",
  "courtName": "U.S. District Court, Southern District of New York",
  "courtType": "district",
  "state": "NY",
  "caseNumber": "1:26-cv-03810",
  "caseNumberShort": "26-cv-3810",
  "caseTitle": "First-Citizens Bank & Trust Company v. Patriot Bank, N.A.",
  "caseType": "civil",
  "caseTypeCode": "cv",
  "defendantNumber": null,
  "judgeInitials": null,
  "bankruptcyChapter": null,
  "trustee": null,
  "office": null,
  "entryText": "Certificate of Service Other",
  "entryCategory": "notice",
  "documentNumber": 153,
  "documentUrl": "https://ecf.nysd.uscourts.gov/doc1/127140563915?caseid=663583&de_seq_num=517",
  "docketUrl": "https://ecf.nysd.uscourts.gov/cgi-bin/DktRpt.pl?663583",
  "caseId": "663583",
  "entrySequence": 517,
  "guid": "https://ecf.nysd.uscourts.gov/cgi-bin/DktRpt.pl?663583&517",
  "filedAt": "2026-10-17T07:34:33.000Z",
  "pubDateRaw": "Sat, 17 Oct 2026 07:34:33 GMT",
  "likelyNewCase": false,
  "matchedFilters": ["party:Patriot Bank"],
  "isNew": true,
  "fetchedAt": "2026-10-17T10:22:00.283Z"
}
```

Bankruptcy entries additionally carry what the court publishes in front of the entry text: `bankruptcyChapter` (7, 9, 11, 12, 13 or 15), `trustee` and `office`; adversary proceedings have `caseType: "adversary"`. `matchedFilters` is present only when filters are set, `isNew` only in monitor mode. `documentUrl` opens the document on PACER (PACER's own fees apply there); `docketUrl` opens the case docket. `filedAt` is null when a court publishes an impossible timestamp (a few do); `pubDateRaw` keeps the original string.

Error items look like `{ "recordType": "error", "court": "cacd", "error": "HTTP_503", "errorMessage": "…", "feedUrl": "…" }` with codes `UNKNOWN_COURT`, `FEED_UNREACHABLE`, `HTTP_<status>`, `FEED_EMPTY`, `FEED_MALFORMED` or `COURT_FAILED`. They are charged at the court-feed rate, because the request was made; the run itself succeeds.

The run's `SUMMARY` record (default key-value store) lists, per court, the HTTP status, the entry types the feed advertises, entries in the feed, new/seen/matched/emitted counts and any error.

### Pricing

Pay per event. You only pay for what the Actor produces; set a **maximum cost per run** in the run options to cap spend.

| Event | Price | Notes |
|---|---|---|
| Court feed checked | $0.005 | Per court feed fetched per run, whether or not anything matched; error items for failing courts are charged at this rate instead |
| Docket entry scraped | $0.001 | Per docket entry saved when **no filter** is set |
| Matching filing found | $0.003 | Per docket entry saved when filters are set; charged **instead of** the docket-entry event |
| Actor start | $0.00005 | Apify platform event |

**Examples:** 1,000 unfiltered entries from one court ≈ **$1.005**. Watching 20 courts every hour for new filings naming your clients, with about 30 matches a day ≈ 20 × 24 × $0.005 + 30 × $0.003 ≈ **$2.49/day**. In monitor mode the first run is a baseline and is charged for every entry it emits; later runs charge only new entries.

### Limits and fair use

- Each feed covers the **trailing 24 hours** only. Schedule the Actor at least daily to miss nothing; hourly is a good default (the courts regenerate feeds every 30–60 minutes). Requests more often than every 15 minutes are discouraged.
- One request per court per run, 20 s timeout, one retry on 429/5xx. Five courts are fetched in parallel; a run over all live courts takes about a minute plus up to 45 s for each court that does not answer.
- Coverage differs per court: 94 courts publish every entry type, 41 publish a subset (typically complaints, motions and orders), 23 answer with no entries and 30 do not answer datacenter requests (mostly California, Oklahoma, Nevada, Minnesota and Missouri). The table below is from the sweep of 2026-10-17; the Actor still tries every court you name and reports what happened.
- Nature of suit, party lists, judges and the full docket text are **not** in the feeds. The case title carries the lead parties ("Smith v. Acme Corp et al"), so a party that is not first-named may be missing; the docket link has the rest.
- `entryTypes` is a heuristic over the entry text (courts label the same event differently); for precision use `entryKeywords`.
- The seen-entry memory keeps 72 hours per court (up to 30,000 entries), enough because a feed never carries anything older than a day.
- Memory: a run over all courts fits in 512 MB.

### Court coverage (sweep of 2026-10-17)

Live feeds: 135 of 188 (94 full, 41 partial); 23 answer with no entries; 30 unreachable from datacenter IPs. Entries in the trailing 24 h at probe time: 86,956.

| State | District court feeds | Bankruptcy court feeds |
|---|---|---|
| AK | `akd` *(unreachable)* | `akb` all |
| AL | Middle `almd` all · Northern `alnd` *(no entries)* · Southern `alsd` all | Middle `almb` answer, appeal, court, motion, order, caseupld, … · Northern `alnb` *(unreachable)* · Southern `alsb` all |
| AR | Eastern `ared` order, order-cr, motion · Western `arwd` all | Eastern `areb` all · Western `arwb` all |
| AZ | `azd` all | `azb` all |
| CA | Central `cacd` *(unreachable)* · Eastern `caed` *(unreachable)* · Northern `cand` *(unreachable)* · Southern `casd` *(unreachable)* | Central `cacb` *(unreachable)* · Eastern `caeb` all · Northern `canb` all · Southern `casb` all |
| CO | `cod` motion, order | `cob` all |
| CT | `ctd` all | `ctb` *(unreachable)* |
| DC | `dcd` all | `dcb` all |
| DE | `ded` all | `deb` all |
| FL | Middle `flmd` all · Northern `flnd` *(no entries)* · Southern `flsd` all | Middle `flmb` answer, appeal, court, motion, order, misc, … · Northern `flnb` all · Southern `flsb` all |
| GA | Middle `gamd` order, order-cr · Northern `gand` *(no entries)* · Southern `gasd` *(no entries)* | Middle `gamb` answer, appeal, court, motion, order · Northern `ganb` *(unreachable)* · Southern `gasb` order |
| GU | `gud` *(no entries)* | `gub` *(no entries)* |
| HI | `hid` cmp, order, order-cr | `hib` appeal, motion, order, misc |
| IA | Northern `iand` motion · Southern `iasd` all | Northern `ianb` answer, appeal, court, motion, order · Southern `iasb` all |
| ID | `idd` allx, motion | `idb` answer, appeal, court, motion, order |
| IL | Central `ilcd` all · Northern `ilnd` order, order-cr, motion, cmp · Southern `ilsd` motion, order, order-cr, cmp, charge-cr | Central `ilcb` all · Northern `ilnb` *(unreachable)* · Southern `ilsb` all |
| IN | Northern `innd` all · Southern `insd` adr, answer, appeal, appeal-cr, charge-cr, cmp, … | Northern `innb` answer, appeal, motion, notice, order, plan · Southern `insb` all |
| KS | `ksd` all | `ksb` all |
| KY | Eastern `kyed` *(no entries)* · Western `kywd` all | Eastern `kyeb` all · Western `kywb` all |
| LA | Eastern `laed` *(unreachable)* · Middle `lamd` *(unreachable)* · Western `lawd` all | Eastern `laeb` answer, appeal, court, misc, motion, order · Middle `lamb` all · Western `lawb` *(unreachable)* |
| MA | `mad` answer, appeal, appeal-cr, charge-cr, cmp, detention-cr, … | `mab` answer, appeal, caseupld, claims, cmp, crbatch, … |
| MD | `mdd` *(no entries)* | `mdb` all |
| ME | `med` order, order-cr | `meb` *(no entries)* |
| MI | Eastern `mied` answer, appeal, appeal-cr, charge-cr, cmp, motion, … · Western `miwd` order, order-cr, motion | Eastern `mieb` *(unreachable)* · Western `miwb` *(no entries)* |
| MN | `mnd` *(unreachable)* | `mnb` *(unreachable)* |
| MO | Eastern `moed` *(unreachable)* · Western `mowd` order, order-cr, motion | Eastern `moeb` all · Western `mowb` *(unreachable)* |
| MP | `nmid` *(no entries)* | `nmib` *(no entries)* |
| MS | Northern `msnd` *(no entries)* · Southern `mssd` all | Northern `msnb` *(unreachable)* · Southern `mssb` *(unreachable)* |
| MT | `mtd` all | `mtb` answer, appeal, court, motion, order |
| NC | Eastern `nced` all · Middle `ncmd` all · Western `ncwd` all | Eastern `nceb` *(no entries)* · Middle `ncmb` all · Western `ncwb` answer, appeal, court, motion, order |
| ND | `ndd` *(no entries)* | `ndb` all |
| NE | `ned` *(unreachable)* | `neb` all |
| NH | `nhd` all | `nhb` answer, appeal, court, motion, order, auditor, … |
| NJ | `njd` all | `njb` answer, appeal, court, motion, order, misc, … |
| NM | `nmd` *(no entries)* | `nmb` *(unreachable)* |
| NV | `nvd` *(unreachable)* | `nvb` *(unreachable)* |
| NY | Eastern `nyed` *(no entries)* · Northern `nynd` cmp, order, order-cr, motion · Southern `nysd` adr, answer, appeal, appeal-cr, charge-cr, cmp, … · Western `nywd` *(no entries)* | Eastern `nyeb` all · Northern `nynb` all · Southern `nysb` all · Western `nywb` answer, appeal, court, motion, order, misc, … |
| OH | Northern `ohnd` cmp, order, order_cr, motion, charge_cr · Southern `ohsd` all | Northern `ohnb` all · Southern `ohsb` all |
| OK | Eastern `oked` *(unreachable)* · Northern `oknd` *(no entries)* · Western `okwd` *(unreachable)* | Eastern `okeb` *(unreachable)* · Northern `oknb` *(unreachable)* · Western `okwb` *(unreachable)* |
| OR | `ord` all | `orb` answer, appeal, court, motion, order, trustee, … |
| PA | Eastern `paed` all · Middle `pamd` *(no entries)* · Western `pawd` order, order-cr, motion, cmp | Eastern `paeb` all · Middle `pamb` all · Western `pawb` all |
| PR | `prd` all | `prb` all |
| RI | `rid` all | `rib` all |
| SC | `scd` all | `scb` all |
| SD | `sdd` all | `sdb` all |
| TN | Eastern `tned` all · Middle `tnmd` order, order-cr, motion · Western `tnwd` all | Eastern `tneb` all · Middle `tnmb` all · Western `tnwb` all |
| TX | Eastern `txed` all · Northern `txnd` order, order-cr, charge-cr, cmp, answer · Southern `txsd` all · Western `txwd` all | Eastern `txeb` answer, appeal, auditor, caseupld, claims, cmp, … · Northern `txnb` all · Southern `txsb` all · Western `txwb` all |
| UT | `utd` order, order-cr, motion | `utb` all |
| VA | Eastern `vaed` *(no entries)* · Western `vawd` all | Eastern `vaeb` *(unreachable)* · Western `vawb` answer, appeal, court, motion, order |
| VI | `vid` order, order-cr | `vib` *(no entries)* |
| VT | `vtd` all | `vtb` all |
| WA | Eastern `waed` all · Western `wawd` all | Eastern `waeb` all · Western `wawb` all |
| WI | Eastern `wied` all · Western `wiwd` all | Eastern `wieb` answer, appeal, court, misc, motion, order, … · Western `wiwb` all |
| WV | Northern `wvnd` all · Southern `wvsd` *(no entries)* | Northern `wvnb` all · Southern `wvsb` all |
| WY | `wyd` all | `wyb` all |

"all" means the court publishes every docket entry type; a list shows the CM/ECF entry types it publishes; *no entries* means the endpoint exists but was empty; *unreachable* means it did not answer from a datacenter IP. Courts in the last two groups are left out of the `all` and state aliases but can be named explicitly.

### Related Actors

Other pay-per-event Actors from the same account, all limited-permission and agent-friendly:

- [US Government Grants & Contract Opportunities Feed](https://apify.com/owlabee/gov-opportunity-feed) — the same "new since last run" feed pattern for Grants.gov and SAM.gov.
- [US Professional License Lookup & Verification API](https://apify.com/owlabee/us-license-verifier) — verify the licenses of parties and professionals you find in dockets.
- [Website Change Monitor — Sitemap & Page Content Diff](https://apify.com/owlabee/website-change-monitor) — watch a court's or a company's website for changes alongside its docket.

### FAQ

**Does this need proxies, a PACER account or an API key?** No. The RSS feeds are public, unauthenticated endpoints that the courts publish for anyone, and they answer datacenter requests (except the courts marked unreachable above). Nothing is downloaded from PACER itself.

**How is cost controlled?** Set `maxEntriesPerCourt`, `maxResults` and the run's maximum total charge. Each entry is charged the moment it is saved and the run stops cleanly when a limit is reached; in monitor mode, entries held back by a cap are emitted on the next run instead of being lost.

**How does "only new since last run" work?** Per court the Actor remembers the id of every entry it has processed (docket entry plus event label) in the named key-value store. On the next run only unseen entries are emitted, flagged `isNew: true`. The first run is a baseline. Delete the store, or use a new `stateStoreName`, to start over.

**Can I run it on a schedule or call it from an AI agent?** Yes — Apify Schedules with `onlyNewSinceLastRun` and a `webhookUrl` is the intended setup, and the Apify MCP server can call it directly. Example prompts: "Which new lawsuits were filed in the Southern District of New York today naming a bank?", "Alert me to every new Chapter 11 petition in Delaware and SDNY Bankruptcy", "List every motion and order filed in case 1:26-cv-03810 since yesterday".

**What happens when a court's feed is down or empty?** The court produces one error item (`FEED_UNREACHABLE`, `HTTP_503`, `FEED_EMPTY`, `FEED_MALFORMED`) and the run continues with the other courts; the run does not fail.

**Why does the same docket entry appear twice?** Some courts attach two event labels to one entry (for example "Order" and "~Util - Set Hearings" on the same document). Both are published, with the same `entryId` and different `entryText`; `entryKey` tells them apart.

**Why is `caseNumber` sometimes missing a type code, or carrying extra letters?** Bankruptcy courts number cases "26-11511" without a code and several append judge initials or the chapter ("26-44611-elm13"). The Actor keeps the number as published, puts a normalized form in `caseNumberShort`, and reads the chapter from the suffix when no "Chapter:" prefix is given.

**Can it tell me the nature of suit, the judge, or all the parties?** Not from the feed. Use `docketUrl` to open the docket on PACER for those details.

### Legal

This Actor reads only the public, unauthenticated RSS feeds the United States federal courts publish for their CM/ECF dockets; it does not log in to PACER, download documents, or bypass any access control. The data is public court record metadata. The Actor and its output are **not legal advice** and do not establish an attorney-client relationship; docket text is published by the courts as entered by filers and clerks and may contain errors. Case titles contain the names of individuals: this Actor is not a consumer reporting agency, its output must not be used for employment, credit, insurance, housing or tenant screening decisions (FCRA), and it is not a background-check tool. Use the data in compliance with applicable law and the courts' terms.

# Actor input Schema

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

CM/ECF court codes, one per line: district courts end in "d" (nysd = S.D.N.Y., txwd = W.D. Tex., ded = D. Del.), bankruptcy courts in "b" (deb = Bankr. D. Del., nysb, txsb). Also accepted: "all" (every court with a live feed), "all-district", "all-bankruptcy", or a two-letter state code ("NY", "TX") for every live court in that state. The README lists all 188 courts and which ones publish a feed. The prefilled value is the cheap example used by Apify's daily automated test.

## `partyKeywords` (type: `array`):

Keep only entries whose case title (the party names, e.g. "Smith v. Acme Corp") contains one of these. Case-insensitive substrings, or regular expressions written as /pattern/flags (e.g. /\bAcme (Corp|Inc)\b/). Company names, debtor names, "USA v." all work.

## `caseNumbers` (type: `array`):

Keep only entries in these cases. Any common form is accepted: "1:26-cv-03810", "26-cv-3810", "26-11511" (bankruptcy). Matching ignores the office prefix, leading zeros and the defendant suffix.

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

Keep only these case types, derived from the case-number code: civil (cv), criminal (cr), bankruptcy (bk or a bankruptcy-court case without a code), adversary (ap), multidistrict (md), other (mc, mj, po, …).

## `entryTypes` (type: `array`):

Keep only docket entries of these kinds. The kind is a heuristic read from the entry text ("\[Complaint]", "\[Motion to Dismiss]", "\[Order granting …]"); courts label entries differently, so combine with keywords for precision. "complaint" also covers notices of removal and indictments; "petition" is a bankruptcy petition.

## `entryKeywords` (type: `array`):

Keep only entries whose docket text contains one of these (case-insensitive substrings or /regex/), e.g. "patent", "class action", "temporary restraining order", "Voluntary Petition".

## `bankruptcyChapters` (type: `array`):

Keep only bankruptcy entries under these chapters (read from the "Chapter: 11" prefix most bankruptcy courts publish, or from the entry text). Entries without a chapter are dropped when this is set.

## `newCasesOnly` (type: `boolean`):

Keep only entries that opened a case: document number 1 on the docket (the complaint, petition, indictment or notice of removal). Combine with party keywords to be alerted when a company is sued or files for bankruptcy.

## `maxEntriesPerCourt` (type: `integer`):

Cap on dataset items per court per run, newest first, applied after filtering. Busy courts publish 2,000–4,000 entries a day.

## `maxResults` (type: `integer`):

Cap on docket entries across all courts per run. Use together with the run's maximum cost to control spend.

## `onlyNewSinceLastRun` (type: `boolean`):

Monitor mode for schedules: remember every docket entry seen per court in the state store and emit only entries not seen before, flagged isNew. The first run is a baseline and emits (and charges for) everything currently in the feed. Entries held back by a cap are emitted on the next run.

## `stateStoreName` (type: `string`):

Named key-value store that remembers the docket entries already seen (monitor mode). Use a different name per schedule, or delete the store to reset.

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

If set, the Actor POSTs a JSON run summary plus the emitted entries (max 1,000) and error items to this URL when it finishes (10 s timeout, 2 retries). Failures are logged, never fatal.

## `notifyOnlyOnResults` (type: `boolean`):

Call the webhook only when at least one docket entry or error item was produced. Turn off to receive a webhook after every run.

## Actor input object example

```json
{
  "courts": [
    "nysd"
  ],
  "newCasesOnly": false,
  "maxEntriesPerCourt": 40,
  "maxResults": 100000,
  "onlyNewSinceLastRun": false,
  "stateStoreName": "federal-court-docket-monitor-state",
  "notifyOnlyOnResults": true
}
```

# Actor output Schema

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

One item per federal docket entry in the default dataset (court, caseNumber, caseTitle, caseType, entryText, entryCategory, documentNumber, documentUrl, docketUrl, filedAt, bankruptcyChapter, likelyNewCase, matchedFilters, isNew; error items carry error and errorMessage). Fields are described in dataset_schema.json.

## `summary` (type: `string`):

SUMMARY record in the run's default key-value store: per-court feed status, entries in each feed, matched/new/emitted counts, charges and webhook delivery status, written when the run finishes.

# 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 = {
    "courts": [
        "nysd"
    ],
    "newCasesOnly": false,
    "maxEntriesPerCourt": 40,
    "onlyNewSinceLastRun": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("owlabee/federal-court-docket-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 = {
    "courts": ["nysd"],
    "newCasesOnly": False,
    "maxEntriesPerCourt": 40,
    "onlyNewSinceLastRun": False,
}

# Run the Actor and wait for it to finish
run = client.actor("owlabee/federal-court-docket-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 '{
  "courts": [
    "nysd"
  ],
  "newCasesOnly": false,
  "maxEntriesPerCourt": 40,
  "onlyNewSinceLastRun": false
}' |
apify call owlabee/federal-court-docket-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,owlabee/federal-court-docket-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/BYBmrKqOHXb0nMnQV/builds/jgaoKmyjYL3qcx6TS/openapi.json