# US Court Dockets Scraper - PACER RECAP Cases (`dataio/pacer-recap-court-dockets`) Actor

Scrape US federal court dockets from PACER RECAP (CourtListener): judge, cause, nature of suit, parties, attorneys and law firms, one row per docket or one row per party. Search by keyword, court and filing date for litigation monitoring and legal lead generation.

- **URL**: https://apify.com/dataio/pacer-recap-court-dockets.md
- **Developed by:** [Tom Awake](https://apify.com/dataio) (community)
- **Categories:** News, MCP servers
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 docket rows

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?

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

### What does US Court Dockets Scraper do?

Federal court cases with **judge, cause, nature of suit, parties, attorneys
and law firms** — one row per docket, or one row per litigant.

**No login. No API key. No proxies.**

### Two shapes, because two questions

**One row per docket** answers *what is happening in this court*: new
filings, assigned judge, nature of suit, how many parties.

**One row per party** answers *who to call*: every litigant as its own row,
with the firms on the case. That is the target list — and it is not a
detail. An antitrust docket carries **41 parties on average**; flattened
into one cell, forty of them are invisible.

### Coverage, measured

Coverage depends heavily on how narrow the search is. Measured 13 September
2026:

| Search | Judge | Firms |
|---|---|---|
| **D. Delaware, nature of suit 830, since 2025** | **100 %** | **92 %** |
| Patent infringement, all courts | 73 % | 67 % |
| Antitrust, all courts | 70 % | 65 % |
| Opinions (published decisions) | 43 % | 0 % |

**Narrow beats broad.** Filtering to a court and a nature-of-suit code gives
near-complete records; a national free-text sweep does not. Opinions carry
no firms at all — that is the dataset, not the Actor.

#### `searchType` and `oneRowPerParty` decide which columns fill

A docket that is still being litigated has no published citation; a
decision that has been handed down has no list of appearing parties.
Asking for one row per party moves the names out of the aggregated
column and into their own. None of this is missing data — it is a
different question being asked.

Measured 17 September 2026, 120 rows of each mode, same query:

| Field | `dockets` | `dockets` + `oneRowPerParty` | `opinions` |
|---|---|---|---|
| `caseName`, `court`, `docketNumber`, `dateFiled` | 100% | 100% | 100% |
| `parties` (aggregated) | **98%** | 0% | 0% |
| `party` (one per row) | 0% | **98%** | 0% |
| `partyRole` | 0% | **31%** | 0% |
| `citeCount` | 0% | 0% | **100%** |
| `status` | 0% | 0% | **100%** |
| `dateArgued` | 0% | 0% | **52%** |
| `citation` | 0% | 0% | 5% |
| `judge` | 72% | 71% | 29% |
| `natureOfSuit` | 87% | 91% | 4% |

`partyRole` is 31% by design, not by accident: the registry does not say
who represents whom, so only the first-listed party is marked
`first-listed` — the courthouse convention for the plaintiff. The rest
are left blank rather than assigned a role the source never stated.

`citation` is thin even on opinions (5%): most decisions in the index
carry no reporter citation. `citeCount` is the reliable one.

### Output

| Field | Example |
|---|---|
| `caseName` | Bristol-Myers Squibb Company v. Amgen Inc. |
| `docketNumber`, `court`, `courtId` | 1:26-cv-01044, D. Delaware, `ded` |
| `dateFiled`, `dateTerminated`, `dateArgued` | |
| `judge`, `referredTo` | assigned and referring judges |
| `cause` | 35:271 Patent Infringement |
| `natureOfSuit` | 830 Patent |
| `jurisdictionType`, `juryDemand` | Federal Question, Plaintiff |
| `party`, `partyRole` | one litigant, when exploded |
| `parties`, `partyCount` | all litigants, when not |
| `attorneys`, `firms`, `firmCount` | counsel on the case |
| `citation`, `citeCount`, `status` | for opinions |
| `docketId`, `pacerCaseId`, `docketUrl` | provenance |

`partyRole` marks only the first-listed party, which by clerk convention is
the plaintiff. The source does not state which attorney represents which
party, so this Actor does not guess — counsel stays at case level.

### Input

```json
{
  "query": "patent infringement",
  "searchType": "dockets",
  "newestFirst": true,
  "maxItems": 300
}
```

| Field | Default | Notes |
|---|---|---|
| `query` | `patent infringement` | Case names and docket text |
| `searchType` | `dockets` | Dockets, opinions, documents, oral arguments |
| `oneRowPerParty` | `false` | Explode litigants into rows |
| `newestFirst` | `true` | Filing date descending |
| `maxItems` | `300` | Counts rows, not cases |
| `court` | — | `cafc`, `ded`, `cand`, `txed`, … |
| `natureOfSuit` | — | `830` patent, `840` trademark, `410` antitrust |
| `filedAfter`, `filedBefore` | — | YYYY-MM-DD |

### Use cases

- **Litigation monitoring** — new filings in your practice area, by court,
  sorted newest first. Records appear within days of filing.
- **Law firm business development** — who is being sued in your speciality,
  and which firms already have the work.
- **Competitive intelligence** — track a company's litigation, as plaintiff
  or defendant.
- **IP and antitrust watch** — patent and antitrust filings by district, by
  nature of suit.
- **Expert and judge research** — which judges hear which kinds of case.

### Running this as a scheduled watch

New filings are the point. A case filed against a company in your
portfolio, or in your practice area, is worth knowing about this week —
not next quarter.

```json
{
  "query": "patent infringement",
  "searchType": "dockets",
  "filedWithinDays": 7,
  "court": "ded",
  "maxItems": 300
}
```

**Why not a fixed `filedAfter` date?** A schedule replays the same input
every time, so a fixed date returns the same dockets at every run and
charges for them again. `filedWithinDays` moves the window on its own.

***

### Limits, honestly

- **Coverage is partial and varies by query.** The table above is measured,
  not promised. Narrow searches are far richer than broad ones.
- The source is **RECAP**, built from PACER documents that users have
  purchased and contributed. It is extensive but not the complete federal
  docket, and older or low-traffic cases may be thin.
- `oneRowPerParty` multiplies output sharply on mass litigation. Set
  `maxItems` with that in mind.
- Attorneys and firms are listed for the case, not mapped to individual
  parties.
- Party and attorney names are personal data on a public record. Using them
  for outreach in the EU or UK makes you the data controller.
- Requests are paced out of courtesy to a free public service run by the
  non-profit Free Law Project.
- Not affiliated with CourtListener or the Free Law Project.

### How much does it cost?

You pay per docket row returned: **$0.003 each**, that is $3.00 per 1,000. There is no start fee, and subscription plans pay less per docket row.

The example input below asks for up to 300 docket rows, so it costs **$0.90 at most**.

If a run reaches the spending limit you set, the output stops at that limit and never goes past it. You are never charged for rows that were not delivered.

### Use US Court Dockets Scraper as an API

Call it from your own code with the Apify client, here in Python:

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("DataIO/pacer-recap-court-dockets").call(run_input={
    'query': 'patent infringement',
    'searchType': 'dockets',
    'newestFirst': True,
    'maxItems': 300,
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)
```

It also works from JavaScript, Make, Zapier, n8n, and from AI agents through the Apify MCP server.

### FAQ

#### Is it legal to use this data?

The actor reads public data from its official source, without logging in and without bypassing any access control. What you do with the data, for example contacting people listed in it, is your responsibility under the laws that apply to you, such as GDPR in Europe.

#### Can I run it on a schedule?

Yes. See *Running this as a scheduled watch* above: use the rolling-window setting so each run returns only what is new.

#### Can AI agents use it?

Yes. It is available through the Apify MCP server, and every input field is described in its input schema, so an agent can call it directly.

### Other actors you might like

- [UK Contracts Finder Scraper](https://apify.com/DataIO/uk-public-contract-awards): Tenders & Awards
- [TED Tenders Scraper](https://apify.com/DataIO/ted-eu-tenders-procurement): EU Public Procurement
- [USAspending Scraper](https://apify.com/DataIO/usaspending-federal-awards): Federal Contract Awards

# Actor input Schema

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

Full-text search across case names and docket text — for example "patent infringement", "antitrust", "trade secret", or a company name.

## `searchType` (type: `string`):

Dockets are live cases with parties and counsel. Opinions are published decisions with citations.

## `oneRowPerParty` (type: `boolean`):

Off, you get one row per case with the parties joined. On, each litigant gets its own row — which is what you want for a target list. An antitrust docket averages 41 parties, so this multiplies the output sharply.

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

Counts rows, so with one row per party a single large case can fill the export.

## `newestFirst` (type: `boolean`):

Sorts by filing date descending, which is what monitoring wants.

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

CourtListener court code, for example cafc (Federal Circuit), ded (D. Delaware), cand (N.D. California), txed (E.D. Texas).

## `natureOfSuit` (type: `string`):

Federal civil code, for example 830 for patent, 840 for trademark, 410 for antitrust.

## `filedWithinDays` (type: `integer`):

Rolling window, for a scheduled watch: 7 returns cases filed in the last seven days. Unlike a fixed date, this moves on its own, so a weekly schedule returns only new filings. Overrides Filed after.

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

YYYY-MM-DD.

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

YYYY-MM-DD.

## Actor input object example

```json
{
  "query": "patent infringement",
  "searchType": "dockets",
  "oneRowPerParty": false,
  "maxItems": 300,
  "newestFirst": true,
  "filedWithinDays": 7
}
```

# Actor output Schema

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

Every row produced by the run, in 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 = {
    "query": "patent infringement",
    "maxItems": 300,
    "filedWithinDays": 7
};

// Run the Actor and wait for it to finish
const run = await client.actor("dataio/pacer-recap-court-dockets").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 = {
    "query": "patent infringement",
    "maxItems": 300,
    "filedWithinDays": 7,
}

# Run the Actor and wait for it to finish
run = client.actor("dataio/pacer-recap-court-dockets").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 '{
  "query": "patent infringement",
  "maxItems": 300,
  "filedWithinDays": 7
}' |
apify call dataio/pacer-recap-court-dockets --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,dataio/pacer-recap-court-dockets"
        }
    }
}
```

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/zbcQDaPmmjle1ZeJY/builds/1beYMpUmXSZWbZ0aR/openapi.json