# CourtListener Litigation Party & Counsel Scraper (`parseforge/courtlistener-party-scraper`) Actor

Scrape litigation parties and their counsel from CourtListener RECAP: one row per party, with law firms, attorneys, judge and case. Export to CSV, JSON, Excel or XML.

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

## Pricing

from $3.62 / 1,000 results

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 Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 🧑‍⚖️ CourtListener Litigation Party & Counsel Scraper

> 🚀 **Export the litigants and the law firms behind federal court cases in seconds.** Search by party, attorney or firm name and get one 39-field row per party, with the firms and attorneys of record, the judge, the nature of suit and the docket it belongs to. 2,838,130 federal dockets in the RECAP archive have counsel on record.

Every federal lawsuit is a list of names: the plaintiffs, the defendants, the intervenors, and the law firms that show up for each of them. CourtListener's RECAP archive carries that list for millions of PACER dockets, but its public search returns it buried inside a case record. This Actor turns it around: one row per party, with the counsel roster of the case attached to every row, so a firm's client list, a company's litigation history or a court's most active defense bar all fall out of a single export to CSV, JSON, Excel, or XML.

Search runs on the names themselves. `party:()`, `attorney:()` and `firm:()` are real fielded queries on the public API, so "every case where Kirkland and Ellis appeared since 2024" is one request, not a crawl. Coverage measured on 2026-09-08 across 60 live civil dockets: parties on 60 of 60, party IDs on 58, attorneys on 58, law firms on 53. No login and no API key required.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Law firm business development | Which firms appear opposite you, and for whom, by court and practice area |
| Litigation finance and insurers | Party-level exposure across dockets, with counsel quality as a signal |
| Corporate legal and compliance | Every federal case a counterparty is named in, as plaintiff or defendant |
| Legal recruiters | Attorneys of record by court, firm and nature of suit |
| Legal tech and AI teams | A party-and-counsel graph with stable CourtListener IDs |

### 📋 What the CourtListener Litigation Party & Counsel Scraper does

> 💡 **Why it matters:** PACER has no cross-district party search, and CourtListener's own dockets, parties and attorneys endpoints all return 401 without a token. The one open surface is the search index, and it publishes the party, attorney and firm arrays on every RECAP docket. This Actor expands those arrays into rows, so the unit of analysis is the litigant rather than the case, and it never bills for a record it did not deliver.

Give it a party, an attorney or a firm to look for, or just a nature of suit and a date range, and it queries the CourtListener search API live, following the cursor until it has the rows you asked for.

- 🧑‍⚖️ **One row per party.** Party name and CourtListener party ID, the side of the caption it sits on, the co-parties on the same docket, the case caption and URL, court and court ID, PACER docket number and case ID, case type, filing and termination dates, JS-44 nature of suit as raw text, code, label and category, cause of action, jurisdiction type, jury demand, the judge and any magistrate referral, and the counsel roster.
- 🏢 **Firm-first search.** `lawFirmKeywords` runs a fielded `firm:()` query, so one firm name returns every docket where that firm appeared. Several names are ORed. Combine a firm with an attorney and you get only the cases where both are on the record.
- 💼 **Counsel and firm IDs on every row.** `attorneys`, `attorneyIds`, `lawFirms` and `lawFirmIds` come straight from RECAP with their CourtListener IDs, plus `attorneyCount` and `lawFirmCount` for sorting.
- ✅ **Represented parties only, by default.** A server-side `_exists_:firm_id` clause keeps the 2,838,130 dockets that have a firm on record and drops the bankruptcy petition stubs that carry a single unrepresented debtor. Turn it off to take everything.
- 🔣 **JS-44 nature of suit in 14 pickable groups.** Civil rights, intellectual property, labor, contract, torts and the rest, each expanding to its cover-sheet codes and searched in turn with the row budget split between them.
- 🗂 **Case types split.** Civil, criminal, bankruptcy petitions and bankruptcy adversary proceedings are told apart from the PACER docket number and the bankruptcy chapter, and you can keep only the ones you want.
- 🏷️ **No blanks.** Values the source can carry but did not fill read `Not Disclosed`; values that do not apply to that record read `N/A`; booleans read `Yes` or `No`.

### 🎬 Full Demo (🚧 Coming soon)

A short walkthrough video is in production.

### 📊 Output

Each row is one party to one federal docket. Fields, in dataset order:

| Field | Description |
|---|---|
| 🧑‍⚖️ `partyName` | The litigant as PACER records it, for example `ELI LILLY AND COMPANY` |
| 🆔 `partyId` | CourtListener party ID, stable across runs. `N/A` when the source ships an unequal ID list |
| ⚖️ `captionSide` | `Plaintiff side`, `Defendant side` or `Not Disclosed`, derived from the case caption |
| 📌 `caseName` | Case caption, for example `Lida Sedgh v. Eli Lilly and Company` |
| 🔗 `url` | Docket page on courtlistener.com |
| 🆔 `docketId` | CourtListener docket ID |
| 🔢 `docketNumber` | PACER docket number as written, for example `2:26-cv-06571` |
| 🏛 `court` / 🏷 `courtId` / 📎 `courtCitationString` | Court name, CourtListener court ID (for example `paed`), reporter-style abbreviation |
| 🧾 `pacerCaseId` | PACER's internal case ID |
| 🗂 `caseType` | `Civil`, `Criminal`, `Bankruptcy` or `Bankruptcy adversary` |
| 📕 `bankruptcyChapter` | Chapter on a bankruptcy petition, `N/A` on everything else |
| 📅 `dateFiled` / 🏁 `dateTerminated` / ⏳ `isPending` | Filing date, termination date (`N/A` while pending), `Yes` or `No` |
| 📝 `natureOfSuitRaw` / 🔣 `natureOfSuitCode` / 📄 `natureOfSuit` / 🗃 `suitCategory` | The cover-sheet text as PACER wrote it, the JS-44 code, its label and its group |
| 📜 `cause` / 🌐 `jurisdictionType` / 👥 `juryDemand` | Statute the complaint is brought under, basis of jurisdiction, who demanded a jury |
| 👩‍⚖️ `assignedTo` / `assignedToId` / `referredTo` / `referredToId` | District judge and any magistrate referral, with CourtListener IDs |
| 🔢 `partyCount` / `attorneyCount` / `lawFirmCount` / ✅ `hasCounsel` | How many litigants, attorneys and firms the docket carries |
| 💼 `attorneys` / `attorneyIds` | Attorneys of record on the case, semicolon-separated, with IDs |
| 🏢 `lawFirms` / `lawFirmIds` | Law firms on the case, semicolon-separated, with IDs |
| 👨‍👩‍👧 `coParties` | The other litigants on the same docket |
| 🕓 `dateCreated` | When the docket entered RECAP |
| 🕒 `scrapedAt` | ISO timestamp of the collection |
| ❌ `error` | `null` on success; error rows carry only this field and are never charged |

Three real records from a verification run (`lawFirmKeywords` `["Kirkland and Ellis LLP"]`, filed since 01/01/2024, Max Items 5):

```json
[
  {
    "partyName": "ELI LILLY AND COMPANY",
    "partyId": 23629769,
    "captionSide": "Defendant side",
    "caseName": "Lida Sedgh v. Eli Lilly and Company",
    "url": "https://www.courtlistener.com/docket/74735338/lida-sedgh-v-eli-lilly-and-company/",
    "docketId": 74735338,
    "docketNumber": "2:26-cv-06571",
    "court": "District Court, E.D. Pennsylvania",
    "courtId": "paed",
    "courtCitationString": "E.D. Pa.",
    "pacerCaseId": "661111",
    "caseType": "Civil",
    "bankruptcyChapter": "N/A",
    "dateFiled": "2026-09-01",
    "dateTerminated": "N/A",
    "isPending": "Yes",
    "natureOfSuitRaw": "367 P.I.: Health Care/Pharmaceutical Personal Injury Product Liability",
    "natureOfSuitCode": "367",
    "natureOfSuit": "Health care / pharmaceutical personal injury product liability",
    "suitCategory": "Torts - personal injury",
    "cause": "28:1441 Notice of Removal- Personal Injury",
    "jurisdictionType": "Diversity",
    "juryDemand": "Plaintiff",
    "assignedTo": "Karen Spencer Marston",
    "assignedToId": 15382,
    "referredTo": "N/A",
    "referredToId": "N/A",
    "partyCount": 3,
    "attorneyCount": 2,
    "lawFirmCount": 2,
    "hasCounsel": "Yes",
    "attorneys": "Daniel Setareh; David I Horowitz",
    "attorneyIds": "16012062; 16012063",
    "lawFirms": "Setareth Law APLC; Kirkland and Ellis LLP",
    "lawFirmIds": "1369015; 596983",
    "coParties": "DOES 1 THROUGH 50 INCLUSIVE; Lida Sedgh",
    "dateCreated": "2026-09-01T20:53:39.310719Z",
    "scrapedAt": "2026-09-08T06:42:29.262Z",
    "error": null
  },
  {
    "partyName": "Lida Sedgh",
    "partyId": 23629767,
    "captionSide": "Plaintiff side",
    "caseName": "Lida Sedgh v. Eli Lilly and Company",
    "url": "https://www.courtlistener.com/docket/74735338/lida-sedgh-v-eli-lilly-and-company/",
    "docketId": 74735338,
    "docketNumber": "2:26-cv-06571",
    "court": "District Court, E.D. Pennsylvania",
    "courtId": "paed",
    "courtCitationString": "E.D. Pa.",
    "pacerCaseId": "661111",
    "caseType": "Civil",
    "bankruptcyChapter": "N/A",
    "dateFiled": "2026-09-01",
    "dateTerminated": "N/A",
    "isPending": "Yes",
    "natureOfSuitRaw": "367 P.I.: Health Care/Pharmaceutical Personal Injury Product Liability",
    "natureOfSuitCode": "367",
    "natureOfSuit": "Health care / pharmaceutical personal injury product liability",
    "suitCategory": "Torts - personal injury",
    "cause": "28:1441 Notice of Removal- Personal Injury",
    "jurisdictionType": "Diversity",
    "juryDemand": "Plaintiff",
    "assignedTo": "Karen Spencer Marston",
    "assignedToId": 15382,
    "referredTo": "N/A",
    "referredToId": "N/A",
    "partyCount": 3,
    "attorneyCount": 2,
    "lawFirmCount": 2,
    "hasCounsel": "Yes",
    "attorneys": "Daniel Setareh; David I Horowitz",
    "attorneyIds": "16012062; 16012063",
    "lawFirms": "Setareth Law APLC; Kirkland and Ellis LLP",
    "lawFirmIds": "1369015; 596983",
    "coParties": "DOES 1 THROUGH 50 INCLUSIVE; ELI LILLY AND COMPANY",
    "dateCreated": "2026-09-01T20:53:39.310719Z",
    "scrapedAt": "2026-09-08T06:42:29.262Z",
    "error": null
  },
  {
    "partyName": "WWDC INDUSTRIAL PARK, LLC",
    "partyId": 23533880,
    "captionSide": "Defendant side",
    "caseName": "GREATER DC DIAPER BANK v. WWDC INDUSTRIAL PARK, LLC",
    "url": "https://www.courtlistener.com/docket/74659190/greater-dc-diaper-bank-v-wwdc-industrial-park-llc/",
    "docketId": 74659190,
    "docketNumber": "1:26-cv-02900",
    "court": "District Court, District of Columbia",
    "courtId": "dcd",
    "courtCitationString": "D.D.C.",
    "pacerCaseId": "295642",
    "caseType": "Civil",
    "bankruptcyChapter": "N/A",
    "dateFiled": "2026-08-17",
    "dateTerminated": "N/A",
    "isPending": "Yes",
    "natureOfSuitRaw": "190 Contract: Other",
    "natureOfSuitCode": "190",
    "natureOfSuit": "Other contract",
    "suitCategory": "Contract",
    "cause": "28:1332 Diversity-Breach of Contract",
    "jurisdictionType": "Diversity",
    "juryDemand": "Both",
    "assignedTo": "Timothy James Kelly",
    "assignedToId": 8589,
    "referredTo": "N/A",
    "referredToId": "N/A",
    "partyCount": 3,
    "attorneyCount": 4,
    "lawFirmCount": 3,
    "hasCounsel": "Yes",
    "attorneys": "Madelaine Kramer Katz; Michael F. Williams; Joshua M. Hoffman; Michael T. Marr",
    "attorneyIds": "15958104; 16004941; 16004942; 16004943",
    "lawFirms": "Rifkin, Weiner, Livingston, LLC; Kirkland and Ellis LLP; Franklin & Prokopik, Pc",
    "lawFirmIds": "922162; 58050; 458188",
    "coParties": "DONOHOE REAL ESTATE SERVICES, INC; GREATER DC DIAPER BANK",
    "dateCreated": "2026-08-17T20:13:48.431553Z",
    "scrapedAt": "2026-09-08T06:42:29.263Z",
    "error": null
  }
]
```

### ✨ Why choose this Actor

| | What you get |
|---|---|
| **The party is the row** | Case scrapers give you a docket with a semicolon-separated party blob. Here every litigant is its own row with its own CourtListener ID, so a group-by on party name or firm name works without any parsing on your side. |
| **Firm and attorney search that really exists** | `firm:()`, `attorney:()` and `party:()` are fielded queries on the live index, verified on 2026-09-08. One firm name returns 1,897 dockets for Kirkland and Ellis, 4,101 when Latham & Watkins is ORed in. |
| **Counsel with IDs, not just names** | `attorneyIds` and `lawFirmIds` are CourtListener IDs, so the same firm resolves across spelling variants that PACER records inconsistently. |
| **Represented parties by default** | The `_exists_:firm_id` clause runs server side on 2,838,130 dockets, so you are not paying for pages of unrepresented bankruptcy stubs to find the litigated cases. |
| **Honest about the caption** | `captionSide` resolves 36% of parties, measured over 612 parties in 100 dockets. The rest say `Not Disclosed` rather than guessing, because PACER captions name one or two litigants out of six. |
| **No API key needed** | CourtListener throttles anonymous callers at 5 requests a minute and 50 an hour per IP, and each request returns 20 dockets and every party on them. Turn the proxy on for a fresh exit IP per request, or paste your own free CourtListener key and the throttle disappears. |
| **You pay for what you keep** | Rows are billed as they are written and capped at `maxItems`, so a page that overshoots the cap is trimmed before it is charged. Duplicates and out-of-scope case types are dropped before billing, never after. |

### 📈 How it compares to alternatives

| | This Actor | Federal case scrapers | PACER directly |
|---|---|---|---|
| What a row is | One party to a docket | One docket | One docket sheet, per court |
| Search by law firm | Fielded `firm:()` query, several firms ORed | Not exposed | No |
| Search by attorney | Fielded `attorney:()` query | Not exposed | Per court only |
| Party IDs | CourtListener party ID per row | Semicolon-separated list, no per-row ID | None |
| Counsel roster | Attorneys and firms with IDs and counts on every row | Sometimes, as one blob | Behind the docket sheet |
| Party role | `captionSide` on 36% of parties, `Not Disclosed` on the rest | Not exposed | On the docket sheet |
| Rows a free account can preview | 10 | Varies | None |
| Ceiling | Anonymous API throttle of 5 requests a minute per IP, lifted by a free key or the proxy | Same source, same ceiling | Per-page fees |

### 🚀 How to use

1. [Create a free Apify account with $5 in credit](https://console.apify.com/sign-up?fpr=vmoqkp).
2. Open the [CourtListener Litigation Party & Counsel Scraper](https://apify.com/parseforge/courtlistener-party-scraper?fpr=vmoqkp).
3. Type a party, attorney or law firm name, set your dates, and click **Start**.
4. Export the results as CSV, Excel, JSON, or XML from the **Dataset** tab.

One typical run: `lawFirmKeywords` `["Kirkland and Ellis LLP"]`, `filedAfter` `01/01/2024`, `maxItems` `500`. Run it programmatically through the [Apify API](https://docs.apify.com/api/v2) or the [ApifyClient](https://docs.apify.com/api/client/js) for JavaScript and Python.

### 💼 Business use cases

#### 🏢 Build a law firm's federal client list

Put a firm name in `lawFirmKeywords` and every party on every docket that firm appeared in comes back, with the case, the court and the nature of suit. Business development teams use it to see which companies a rival firm actually represents, and in which practice areas, rather than relying on a website's client page.

#### 🔍 Screen a counterparty before you sign

Put the company name in `partyKeywords` and you get every federal case it is named in, on either side of the caption, with the firm that defended it and the judge who heard it. Credit, procurement and M\&A diligence teams run it as a standing check before a contract is signed.

#### 📡 Watch a practice area for new defendants

Pick a nature-of-suit category such as intellectual property or labor, set `filedAfter` to last week, and run it on a schedule. Each run returns the newest parties first, so a diff against the last run is an alert feed of companies that just got sued in your practice area.

#### 🧑‍💼 Map the bar in one court

Set `court` to `cand`, `nysd` or `txed` and pull every party filed in a date range. Group by `lawFirms` and `attorneys` to rank the firms most active before that bench, and by `assignedTo` to see which judge draws which counsel. Recruiters and marketing teams use `attorneyIds` to keep the list clean across spelling variants.

### 🔌 Automating CourtListener Litigation Party & Counsel Scraper

- **Make / Zapier:** trigger a run on a schedule, then push new parties to a CRM, a Google Sheet or a Slack channel.
- **Slack:** post each new party, firm and case caption to a litigation-watch channel.
- **Airbyte:** land the dataset in Snowflake, BigQuery or Postgres and join it to your customer table on party name.
- **GitHub:** commit the JSON export to a repository to keep a versioned history of who is litigating what.
- **Google Drive:** drop the CSV or Excel export into a shared folder for the practice group.

### 🌟 Beyond business use cases

- **Research:** measure how often repeat-player firms appear opposite each other, or how counsel representation varies by district and nature of suit.
- **Personal:** follow a case you are a party to, or check whether a company you deal with is in federal litigation.
- **Non-profit:** track who defends civil rights and immigration cases in the districts you serve, and where parties appear without counsel.
- **Experimentation:** build a party and counsel graph with CourtListener IDs, or train a model that predicts case outcome from the firms on the docket.

### 🤖 Ask an AI assistant about this scraper

Give an AI agent live access to federal litigation parties and counsel through the Model Context Protocol:

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=parseforge/courtlistener-party-scraper"
```

Then prompt it in plain language:

- *"Which parties has Kirkland and Ellis represented in the Northern District of California since 2024?"*
- *"List every federal case where Eli Lilly is a party, with the firms on each side."*
- *"Which law firms appear most often in employment discrimination cases in the Southern District of New York?"*

Copy this into ChatGPT, Claude, or Cursor to start:

```
Use the Apify Actor "parseforge/courtlistener-party-scraper" to search federal litigation parties and counsel. Input: { "partyKeywords": ["<company>"], "attorneyKeywords": ["<name>"], "lawFirmKeywords": ["<firm>"], "suitCategories": ["civil-rights"|"intellectual-property"|"labor"|"contract"|"torts"|...], "natureOfSuitCodes": ["830"], "court": "cand", "filedAfter": "MM/DD/YYYY", "caseTypes": ["Civil"], "maxItems": <n> }. It returns one row per party with the party ID, the caption side, the case, court, docket number, dates, JS-44 nature of suit, cause, judge, co-parties, and the attorneys and law firms of record with their IDs. Call it with the ApifyClient and my APIFY_TOKEN.
```

### ❓ Frequently Asked Questions

#### ❓ What exactly is a row?

One party to one federal docket. A case with six litigants produces six rows, each carrying that party's name and ID plus the full case and counsel context. `maxItems` counts parties, not cases.

#### ❓ Are the attorneys linked to the specific party?

No, and no public CourtListener surface exposes that link. The attorney and firm arrays are recorded per docket and deduplicated across the case, so every party row repeats the same case-level counsel roster. `attorneyCount` and `lawFirmCount` tell you how big that roster is. Per-party representation needs an authenticated CourtListener API token, which this Actor does not require.

#### ❓ Why is `captionSide` often `Not Disclosed`?

Because PACER does not publish party roles to anonymous callers, and the case caption names only one or two litigants out of however many are on the docket. `captionSide` is derived from the caption itself and resolves for about 36% of parties, measured over 612 parties in 100 dockets. When a name cannot be placed on exactly one side, the field says `Not Disclosed` instead of guessing.

#### ❓ Do I need a CourtListener account?

No. Everything runs on the public search API. A free CourtListener API key is optional and only lifts the anonymous throttle.

#### ❓ What is the difference from the case scrapers?

The case scrapers give you one row per docket with the parties as a semicolon-separated blob. This one gives you one row per party with a party ID, the co-parties and the counsel roster, and lets you search by firm and attorney name. Use the case scrapers when the case is the unit of analysis, this one when the litigant or the firm is.

#### ❓ Does it cover state courts?

Not through this Actor. RECAP is the federal PACER archive: district, bankruptcy and appellate courts. State dockets live in a separate CourtListener collection.

#### ❓ Why am I getting no results?

Every filter is ANDed. A firm name plus a nature-of-suit code plus a narrow date range can return an empty set. Widen the dates, drop a code, or turn off "Represented parties only". Firm names must match how PACER wrote them, so try `Kirkland and Ellis LLP` as well as `Kirkland & Ellis LLP`.

#### ❓ Why do some parties have no `partyId`?

The API ships the party names and the party IDs as two arrays. On 2 dockets out of 220 measured the lengths disagreed, which makes the index pairing unsafe, so the Actor writes `N/A` rather than attaching an ID that might belong to someone else.

#### ❓ How fast is it, and what is the ceiling?

Each request returns 20 dockets and every party on them, so a page usually yields 40 to 100 rows. Anonymous callers are throttled at 5 requests a minute and 50 an hour per IP, and a burst escalates the wait past 300 seconds. Turn the proxy on for a fresh exit IP per request or add a free CourtListener key for volume.

#### ❓ Does it deduplicate?

Yes. A party is written once per docket, keyed on docket, party ID and party name, so several nature-of-suit searches that hit the same case never bill twice.

#### ❓ What does "Represented parties only" actually do?

It adds a server-side clause that keeps dockets where PACER recorded at least one law firm. 2,838,130 dockets in the archive pass it. Without it, the unfiltered feed is dominated by bankruptcy petition stubs with one unrepresented debtor and no counsel.

#### ❓ How fresh is the data?

RECAP is populated as PACER dockets are fetched, and `dateCreated` on each row tells you when the docket entered the archive. Newly filed cases usually appear within a day.

#### ❓ Can I get the filings themselves?

Not from this Actor. It returns the party and counsel view of a docket. Use the case and filing scrapers listed below for the docket entries and PDFs.

#### ❓ Why fewer rows than Max Items?

The search ran out of matching dockets, or the run approached its time budget and stopped cleanly with what it had. The log prints how many dockets CourtListener reported for each search.

#### ❓ Are error rows charged?

No. Error rows carry only the `error` field and are pushed without a charge event.

### 🔌 Integrate with any app

The dataset is available through the Apify API and the JavaScript and Python clients, and every run can be scheduled, triggered by webhook or wired into Make, Zapier, n8n, Airbyte, Google Sheets, Slack and GitHub from the **Integrations** tab.

### 🔗 Recommended Actors

- [CourtListener Civil Cases Scraper](https://apify.com/parseforge/courtlistener-civil-cases-scraper?fpr=vmoqkp): the same archive with one row per federal civil docket and its filings.
- [CourtListener Adversary Proceedings Scraper](https://apify.com/parseforge/courtlistener-adversary-scraper?fpr=vmoqkp): bankruptcy adversary lawsuits by Form B1040 nature of suit.
- [CourtListener Business Bankruptcy Scraper](https://apify.com/parseforge/business-bankruptcy-filings-scraper?fpr=vmoqkp): Chapter 7, 11 and 13 petitions from the same index.
- [CourtListener Opinions Scraper](https://apify.com/parseforge/court-listener-opinions-scraper?fpr=vmoqkp): full opinion text, walked by court feed.
- [CourtListener State Court Dockets Scraper](https://apify.com/parseforge/courtlistener-dockets-scraper?fpr=vmoqkp): state court dockets from the same archive.

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for more court, government and public-records scrapers.

**🆘 Need Help?** [Open our contact form](https://tally.so/r/BzdKgA) with your run ID, your input, and what you expected.

> **⚠️ Disclaimer:** This Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by the Free Law Project or CourtListener. It collects only publicly available court data through the public API. You are responsible for using the data in compliance with CourtListener's terms and applicable laws. Court records concern real people: do not use this data to identify, profile, or target individuals.

# Actor input Schema

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

Names of litigants to look for, for example "Eli Lilly and Company" or "Novo Nordisk". Several names are matched as OR inside one search. Words are matched, so a surname or a brand alone works. Leave empty to browse every party in the filtered set.

## `attorneyKeywords` (type: `array`):

Names of attorneys of record, for example "David I Horowitz". Several names are matched as OR. Combined with the other name filters using AND, so an attorney plus a firm returns only the cases where both appear.

## `lawFirmKeywords` (type: `array`):

Names of law firms as PACER records them, for example "Kirkland and Ellis LLP" or "Latham & Watkins LLP". Several firms are matched as OR. This is the fastest way to pull a firm's entire federal client list.

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

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000. One item is one party, so a docket with six litigants produces six rows. Leave empty on a paid plan for 100 rows.

## `suitCategories` (type: `array`):

Pick whole JS-44 groups instead of memorising codes. Each category expands to its nature-of-suit codes and is searched in turn. Leave empty to take parties from every case type.

## `natureOfSuitCodes` (type: `array`):

Exact JS-44 codes, for example 830 for patent, 850 for securities or 442 for employment discrimination. Each code is searched separately and the results are merged, with the row budget split between them. Combines with the categories above.

## `query` (type: `string`):

Full-text query across the case caption, parties and counsel. Supports quoted phrases and AND/OR/NOT. Leave empty to browse with the filters alone.

## `cause` (type: `string`):

The statute the complaint is brought under, as PACER writes it, for example "28:1332 Diversity" or "42:1983". Words are matched, so "civil rights" works too.

## `court` (type: `string`):

Restrict to one court by its CourtListener ID, for example cand, nysd, txed or ilnd. Space-separate several IDs to match any of them.

## `caseName` (type: `string`):

Match words in the case caption, for example "smith" or "united states".

## `docketNumber` (type: `string`):

Exact docket number, for example 1:20-cv-03590. Use it to pull the full party and counsel list of one case.

## `filedAfter` (type: `string`):

Earliest filing date, as MM/DD/YYYY or YYYY-MM-DD.

## `filedBefore` (type: `string`):

Latest filing date, as MM/DD/YYYY or YYYY-MM-DD.

## `requireCounsel` (type: `boolean`):

Keep only dockets where PACER recorded at least one law firm. On by default: without it the unfiltered feed is dominated by bankruptcy petition stubs that carry a single unrepresented debtor. 2.8 million dockets in the archive pass this filter.

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

Keep only parties from these kinds of case. The type is read from the PACER docket number and the bankruptcy chapter. Leave empty to take every type.

## `orderBy` (type: `string`):

How to order the dockets before their parties are expanded. Relevance only means anything when a search query or a name filter is set. Oldest first returns the highest field coverage: measured 2026-09-08, party IDs land on 20 of 20 dockets against 19 of 20 for newest first.

## `courtListenerKey` (type: `string`):

A free CourtListener API key (Profile > API on courtlistener.com) lifts the anonymous throttle and makes long runs faster. Leave empty to run anonymously.

## `proxyConfiguration` (type: `object`):

Off by default: the CourtListener API is open. Turn it on for long anonymous runs so each request gets a fresh exit IP and its own throttle allowance. Not used when an API key is supplied.

## Actor input object example

```json
{
  "lawFirmKeywords": [
    "Kirkland and Ellis LLP"
  ],
  "maxItems": 10,
  "filedAfter": "01/01/2024",
  "requireCounsel": true,
  "orderBy": "dateFiled desc",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `overview` (type: `string`):

Key fields: party, caption side, case, court, docket number, dates, nature of suit, judge, counsel and law firms

## `fullData` (type: `string`):

Complete dataset with all 39 fields, including co-parties, counsel IDs and the PACER case ID

# 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 = {
    "lawFirmKeywords": [
        "Kirkland and Ellis LLP"
    ],
    "maxItems": 10,
    "filedAfter": "01/01/2024",
    "requireCounsel": true,
    "orderBy": "dateFiled desc",
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/courtlistener-party-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 = {
    "lawFirmKeywords": ["Kirkland and Ellis LLP"],
    "maxItems": 10,
    "filedAfter": "01/01/2024",
    "requireCounsel": True,
    "orderBy": "dateFiled desc",
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/courtlistener-party-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 '{
  "lawFirmKeywords": [
    "Kirkland and Ellis LLP"
  ],
  "maxItems": 10,
  "filedAfter": "01/01/2024",
  "requireCounsel": true,
  "orderBy": "dateFiled desc",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call parseforge/courtlistener-party-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,parseforge/courtlistener-party-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/deqrnRqcoeFhe1gh0/builds/mZRzcQwIx5UAm0Ety/openapi.json