# 📚 RECAP Federal Court Docket Search (`nexgendata/recap-pacer-docket-search`) Actor

Search the free RECAP archive of PACER federal-court dockets (CourtListener): case name, court, dates, cause, nature of suit. A Docket-Navigator-style alternative for litigation analysts.

- **URL**: https://apify.com/nexgendata/recap-pacer-docket-search.md
- **Developed by:** [NexGenData](https://apify.com/nexgendata) (community)
- **Categories:** Business
- **Stats:** 2 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $20.00 / 1,000 test analyzeds

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

## 📚 RECAP Federal Court Docket Search

**Search the free RECAP archive of PACER federal-court dockets and opinions — case name, court, filing date, and docket number — as pay-per-record JSON, a Docket-Navigator-style alternative without the litigation-analytics subscription.**

PACER is the official record of federal litigation, but it charges per page and offers no real search. The RECAP archive — built by the Free Law Project and surfaced through CourtListener — mirrors millions of those PACER dockets and federal court opinions and makes them freely searchable. This actor turns that archive into a structured query interface: pass a case name, party, court, topic, or date and get back clean records — case name, court, filing date, docket number, and a direct URL — ready for a litigation-analytics pipeline.

For a litigation analyst, IP counsel, or legal-data team, the win is that you can ask docket-level questions across the federal courts — "every case filed in the Federal Circuit since January mentioning a party" — and get machine-readable answers, instead of paying PACER per page or licensing an enterprise litigation-analytics platform to do the same search behind a login.

### Why use this

PACER itself is a pay-per-page system with no usable full-text search; you have to know exactly what you are looking for and pay to look. The commercial platforms that layer analytics on top of dockets — Lex Machina, Docket Navigator, Bloomberg Law's litigation suite — wrap the same public docket data in seat licences that run well into five figures a year.

This actor gives you searchable access to the RECAP archive as structured JSON, pay-per-result, with no seat and no commitment. You choose whether to search court opinions or RECAP dockets, narrow by court and date, and pull back records you can load straight into your own case-tracking or analytics workflow.

- **Two search modes in one actor.** `searchType=r` searches RECAP dockets; `searchType=o` searches court opinions — covering both the case-tracking and the precedent-research workflow.
- **Court and date narrowing.** Filter by court ID (e.g. `scotus`, `cafc`) and `dateFiledAfter` to scope a search to the jurisdiction and timeframe you care about.
- **Higher limits when you need them.** Supply an optional free CourtListener token to raise rate limits for heavier pulls.

### What you get

Each record returned by the actor is one docket or opinion match, in flat JSON:

- `caseName` — the case caption
- `court` — the court the case was filed in
- `dateFiled` — the filing date
- `docketNumber` — the docket number
- `url` — a direct link to the record on CourtListener

The schema is stable and additive — safe to load into a litigation-tracking database and refresh on a schedule.

### Use cases

- **Docket monitoring.** Run a saved query for a party, topic, or court on a schedule and surface newly-filed cases as they enter the RECAP archive — a Docket-Navigator-style watchlist without the subscription.
- **IP litigation tracking.** Filter to the Federal Circuit (`cafc`) or the patent-heavy district courts and search by party or technology to follow patent and trademark disputes.
- **Precedent research.** Switch to `searchType=o` to search court opinions for relevant holdings, building a citation list for a brief or memo.
- **Party / competitor litigation mapping.** Search a company name across dockets to assemble its federal-litigation footprint — useful for diligence, risk assessment, and competitive intelligence.
- **Practice-group business development.** Track new filings in a practice area or court to identify potential clients or co-counsel opportunities as disputes emerge.
- **Academic and empirical legal research.** Pull dockets by court and date window to build datasets for studies of filing trends, nature-of-suit distributions, or court caseloads.
- **Newsroom and analyst monitoring.** Watch a court or topic for newly-docketed high-profile cases to break or contextualize a story.

### Sample output

```json
{
  "caseName": "Acme Innovations LLC v. Beta Devices Inc.",
  "court": "Court of Appeals for the Federal Circuit",
  "dateFiled": "2026-05-12",
  "docketNumber": "2026-1487",
  "url": "https://www.courtlistener.com/docket/68123456/acme-innovations-llc-v-beta-devices-inc/"
}
````

A run with `searchType=r`, `court=cafc`, and a recent `dateFiledAfter` returns one such record per matching docket — the working list for a Federal Circuit watch.

### Input parameters

| Parameter | Label | Description |
|---|---|---|
| `searchType` | Search type | `o` = court opinions, `r` = RECAP dockets. |
| `query` | Query | Full-text search across case name, party, or topic. |
| `court` | Court | Court ID filter (e.g. `scotus`, `cafc`). |
| `dateFiledAfter` | Filed after | Only records filed on/after this date (YYYY-MM-DD). |
| `maxResults` | Max results | Maximum number of records to return. |
| `courtListenerToken` | CourtListener token (optional) | Optional free CourtListener token to raise rate limits. |

### How to use

#### Python (apify-client)

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")

run = client.actor("nexgendata/recap-pacer-docket-search").call(run_input={
    "searchType": "r",
    "query": "patent infringement",
    "court": "cafc",
    "dateFiledAfter": "2026-01-01",
    "maxResults": 100,
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["dateFiled"], item["court"], item["docketNumber"], item["caseName"])
```

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/nexgendata~recap-pacer-docket-search/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "searchType": "r",
    "query": "patent infringement",
    "court": "cafc",
    "dateFiledAfter": "2026-01-01",
    "maxResults": 100
  }'
```

Schedule a saved query daily via Apify's scheduler and route new matches to Slack, a case-management system, or your warehouse via webhook.

### Pricing

This actor runs on Apify's **pay-per-event** model — **$0.10 per result record**, plus a negligible one-time actor-start charge per run. No subscription, no seat, no minimum.

Worked examples:

- A daily docket watch returning ~20 new matches → **~$2.00 per run**
- A 100-record litigation-footprint pull on a company → **~$10.00**
- A precedent search returning 50 opinions → **~$5.00**

You pay only for records pushed to the dataset. PACER, by contrast, charges per page viewed — this actor reads the free RECAP mirror instead. Browse the full catalog at https://apify.com/nexgendata?fpr=2ayu9b

### How this compares to Bloomberg Law / Lex Machina / Docket Navigator

| Source | Price | What you get |
|---|---|---|
| PACER (official) | $0.10 / page, no real search | Authoritative dockets, but pay-per-page and no usable full-text search |
| Lex Machina / Docket Navigator | ~$tens of thousands / seat / yr | Deep litigation analytics and outcome data — seat-locked |
| Bloomberg Law litigation | Enterprise subscription | Dockets plus analytics inside a full legal-research platform |
| **NexGenData RECAP Docket Search** | **PPE $0.10 / record** | **Searchable RECAP dockets and opinions with case name, court, date, docket number, and link, as JSON** |

The analytics platforms add outcome prediction, judge analytics, and timing models on top of the underlying dockets — real value if you need it. But if your job is *finding and tracking the dockets themselves* across the federal courts, this actor gives you searchable access to the free RECAP archive as structured data your own tools can consume, priced per record rather than per seat or per PACER page.

### FAQ

**Q: What is RECAP and how does it relate to PACER?**
A: RECAP is a free archive, maintained by the Free Law Project, of PACER documents that users have purchased and contributed back. CourtListener makes it searchable. This actor queries that public archive, so you are not charged PACER's per-page fees.

**Q: What is the difference between the two search types?**
A: `searchType=r` searches RECAP dockets (the case-tracking view); `searchType=o` searches court opinions (the precedent-research view). Choose the one that matches your task.

**Q: Do I need a CourtListener token?**
A: No — it is optional. Supplying a free CourtListener token raises your rate limits, which helps on heavier or more frequent pulls.

**Q: Is every PACER docket in RECAP?**
A: No. RECAP contains the subset of PACER documents that have been contributed to the archive, so coverage is broad but not exhaustive. For guaranteed-complete coverage of a specific case, PACER itself remains the system of record.

**Q: How current is the data?**
A: Each run queries CourtListener live, so results reflect what is in the archive at run time. Schedule daily for ongoing monitoring.

### Schema stability & versioning

This actor follows NexGenData's **additive-only schema** contract. New fields may be added as new JSON keys (defaulting to `null` for older records), but existing fields are never renamed or removed without a major-version bump and advance notice. Date formats and field semantics are never silently changed. Build your litigation-tracking ETL on the five documented fields with confidence.

### Compliance & legal

- The actor queries the **public, free** RECAP archive via CourtListener — federal court records made openly searchable by the Free Law Project.
- No PACER credentials are used or stored; the actor reads the free mirror, not paid PACER directly.
- Federal court records are public, but you remain responsible for complying with any sealing orders, privacy rules, and your jurisdiction's restrictions on downstream use.
- Treat results as informational; verify against the primary docket before relying on them in a filing or legal decision.

### Related NexGenData actors

Part of NexGenData's IP & legal intelligence lane — pair this actor with:

- [CourtListener Court Opinions](https://apify.com/nexgendata/courtlistener-court-opinions?fpr=2ayu9b) — full-text federal and state opinions
- [CourtListener Federal Judges](https://apify.com/nexgendata/courtlistener-federal-judges?fpr=2ayu9b) — judge biographical and appointment data
- [CourtListener Oral Arguments](https://apify.com/nexgendata/courtlistener-oral-arguments?fpr=2ayu9b) — argument audio and metadata
- [USPTO Patent Search](https://apify.com/nexgendata/uspto-patent-search?fpr=2ayu9b) — granted patents and applications
- [TTAB Trademark Opposition Tracker](https://apify.com/nexgendata/ttab-trademark-opposition-tracker?fpr=2ayu9b) — trademark opposition and cancellation proceedings
- [US Copyright Records Search](https://apify.com/nexgendata/us-copyright-records-search?fpr=2ayu9b) — registered copyright records

Explore the full catalog of 200+ buyer-intent actors at https://apify.com/nexgendata?fpr=2ayu9b

# Actor input Schema

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

o = court opinions, r = RECAP dockets.

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

Full-text search (case name, party, topic).

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

Court ID filter (e.g. 'scotus', 'cafc').

## `dateFiledAfter` (type: `string`):

Only records filed on/after this date (YYYY-MM-DD).

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

Maximum records to return.

## `courtListenerToken` (type: `string`):

Optional free CourtListener token to raise rate limits.

## Actor input object example

```json
{
  "searchType": "r",
  "query": "patent infringement",
  "maxResults": 200
}
```

# 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 = {
    "searchType": "r",
    "query": "patent infringement"
};

// Run the Actor and wait for it to finish
const run = await client.actor("nexgendata/recap-pacer-docket-search").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 = {
    "searchType": "r",
    "query": "patent infringement",
}

# Run the Actor and wait for it to finish
run = client.actor("nexgendata/recap-pacer-docket-search").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "searchType": "r",
  "query": "patent infringement"
}' |
apify call nexgendata/recap-pacer-docket-search --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=nexgendata/recap-pacer-docket-search",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "📚 RECAP Federal Court Docket Search",
        "description": "Search the free RECAP archive of PACER federal-court dockets (CourtListener): case name, court, dates, cause, nature of suit. A Docket-Navigator-style alternative for litigation analysts.",
        "version": "0.0",
        "x-build-id": "2sl5lAvOpHHcNRzuS"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/nexgendata~recap-pacer-docket-search/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-nexgendata-recap-pacer-docket-search",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/nexgendata~recap-pacer-docket-search/runs": {
            "post": {
                "operationId": "runs-sync-nexgendata-recap-pacer-docket-search",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/nexgendata~recap-pacer-docket-search/run-sync": {
            "post": {
                "operationId": "run-sync-nexgendata-recap-pacer-docket-search",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "searchType": {
                        "title": "Search type",
                        "type": "string",
                        "description": "o = court opinions, r = RECAP dockets.",
                        "default": "r"
                    },
                    "query": {
                        "title": "Query",
                        "type": "string",
                        "description": "Full-text search (case name, party, topic)."
                    },
                    "court": {
                        "title": "Court",
                        "type": "string",
                        "description": "Court ID filter (e.g. 'scotus', 'cafc')."
                    },
                    "dateFiledAfter": {
                        "title": "Filed after",
                        "type": "string",
                        "description": "Only records filed on/after this date (YYYY-MM-DD)."
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum records to return.",
                        "default": 200
                    },
                    "courtListenerToken": {
                        "title": "CourtListener token (optional)",
                        "type": "string",
                        "description": "Optional free CourtListener token to raise rate limits."
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```