# Public Court Filings & Dockets Monitor (`datapilot/public-court-filings-dockets-monitor`) Actor

Extracts case ID, case name and parties, court, filing date, docket number, jurisdiction type, and case links. Supports automatic pagination, duplicate filtering, retry handling, and structured Apify Dataset output. Useful for legal research and court case monitoring.

- **URL**: https://apify.com/datapilot/public-court-filings-dockets-monitor.md
- **Developed by:** [Data Pilot](https://apify.com/datapilot) (community)
- **Categories:**
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 scraped results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

⚖️ **Public Court Filings & Dockets Monitor** is a powerful Apify Actor designed to discover, track, and collect U.S. court docket data directly from CourtListener's own public REST API. This tool provides comprehensive **Public Court Filings & Dockets Monitor** intelligence including case parties, court name, filing date, docket number, jurisdiction type, and a direct link to the official docket page for any search keyword. Whether you're building a legal research dashboard, tracking litigation involving a company or individual, or conducting court transparency research, the Public Court Filings & Dockets Monitor delivers actionable **Public Court Filings & Dockets Monitor** insights efficiently.

With direct CourtListener API access, cursor-based pagination, automatic proxy fallback, and reliable Apify Dataset delivery, the Public Court Filings & Dockets Monitor ensures comprehensive **Public Court Filings & Dockets Monitor** coverage across any search keyword. It focuses on key **Public Court Filings & Dockets Monitor** signals including case parties, court, and filing date, making it an essential tool for legal research and litigation monitoring.

***

### 📋 Table of Contents

- [Features](#-features)
- [Data Source](#-data-source)
- [How It Works](#-how-it-works)
- [Input](#-input)
- [Output](#-output)
- [Technical Stack](#-technical-stack)
- [Data Fields](#-data-fields-explained)
- [Use Cases](#-use-cases)
- [Quick Start](#-quick-start)
- [Configuration](#-configuration)
- [Performance](#-performance)
- [Important Notes](#-important-notes)
- [License & Legal](#-license--legal)

***

### 🔥 Features

- **Direct CourtListener API Access** – Queries CourtListener's official REST v4 Search API directly for fast, structured **Public Court Filings & Dockets Monitor** data.
- **Docket-Type Search** – Restricts results specifically to docket records (`type=d`) rather than opinions or other document types.
- **Cursor-Based Pagination** – Follows the API's own `next` cursor URL directly, avoiding manual offset/page-number tracking.
- **Automatic Proxy Fallback** – Retries instantly without a proxy if a proxied request times out, keeping the run resilient.
- **Global Deduplication** – Tracks seen case IDs to prevent duplicate docket entries in the output.
- **Direct Docket Links** – Builds a link to the official CourtListener docket page for every result, with a fallback URL pattern if the absolute URL is missing.
- **Configurable Result Cap** – Caps total results at 50 per run by default to keep runs fast and predictable.
- **Incremental Dataset Push** – Pushes each batch of results to the Dataset as it's collected, not just at the end.
- **Graceful Empty-Response Handling** – Stops cleanly when the API returns no further results, without treating it as an error.

***

### 📊 Data Source

#### **CourtListener REST v4 Search API**

- **Authority**: CourtListener (a project of the Free Law Project), via its official public REST v4 Search API (`courtlistener.com/api/rest/v4/search/`)
- **Access Method**: Browser-impersonated HTTP requests via `curl_cffi`, run through an executor for async compatibility
- **Coverage**: Any publicly listed U.S. court docket matching the given search keyword
- **Data**: Structured JSON docket records, including case name, court, filing date, and docket number
- **Access**: Public API, no API key required for standard search usage
- **Update Frequency**: Reflects CourtListener's currently indexed docket data at time of run

***

### ⚙️ How It Works

The Public Court Filings & Dockets Monitor accepts a search keyword and queries CourtListener's REST v4 Search API with the docket document type filter. The Actor follows the API's own pagination by using the `next` URL returned in each response, rather than manually tracking offsets, continuing until the configured maximum result count is reached or no further pages are available. Each request is attempted first without extra retry overhead; if a request fails, the Actor immediately retries once without a proxy, since proxied requests to CourtListener can otherwise hang or rate-limit. For every returned docket, the Actor extracts the case ID, party names, court, filing date, docket number, and jurisdiction type, building a direct link to the docket's official CourtListener page. A global set of seen case IDs prevents duplicates, and each batch of new dockets is pushed to the Apify Dataset as it's collected.

**Key Processing Steps:**

1. **Input Parsing** – Accept a search keyword (defaults to `"Tesla"` if none provided)
2. **Request Setup** – Configure headers and an impersonated HTTP session
3. **Initial Search Request** – Query the Search API with the keyword and docket type filter
4. **Proxy Fallback** – Instantly retry without a proxy if the initial request fails or times out
5. **Docket Normalization** – Extract case ID, parties, court, filing date, docket number, and jurisdiction from each result
6. **Deduplication Check** – Skip any case ID already seen in a previous page
7. **Incremental Push** – Push each batch of new dockets to the Dataset as it's ready
8. **Cursor Pagination** – Follow the API's `next` URL directly to fetch the following page
9. **Result Cap Enforcement** – Stop once the configured maximum result count is reached
10. **Rate Limiting** – Apply a short delay between paginated requests

**Key Benefits:**

- Pull **Public Court Filings & Dockets Monitor** data for any keyword without manually searching CourtListener
- Track litigation involving a specific company, individual, or case name
- Get resilient results even when proxied requests to CourtListener would otherwise fail
- Feed legal research pipelines, litigation monitoring tools, or court transparency dashboards
- Automate recurring **Public Court Filings & Dockets Monitor** checks as new dockets are filed

***

### 📥 Input

The Actor accepts the following input parameters:

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| `keywords` / `keyword` | string | `"Tesla"` | Search term used to find matching court dockets. |

> Note: This Actor caps total results at 50 per run (`MAX_RESULTS = 50`), and intentionally does not route CourtListener requests through an Apify proxy, to avoid rate-limiting hangs.

**Example Input:**

```json
{
  "keywords": "Tesla"
}
```

**Search a Different Party or Case Name:**

```json
{
  "keyword": "Acme Corporation"
}
```

***

### 📤 Output

The Actor pushes **Public Court Filings & Dockets Monitor** records with the following structure:

| Field | Type | Description |
|-------|------|-------------|
| `search_keyword` | string | The keyword used for this search |
| `case_id` | string | The docket's unique CourtListener ID |
| `parties` | string | The case name/parties (e.g., "Smith v. Jones"), or `"Untitled Case"` if unavailable |
| `court` | string | The court name or court identifier, or `"N/A"` if unavailable |
| `filing_date` | string | The docket's filing date, as returned by the API |
| `docket_number` | string | The official docket number, if available |
| `jurisdiction_type` | string | The jurisdiction type classification, if available |
| `link` | string | Direct URL to the docket's official CourtListener page |
| `scraped_at` | string | ISO 8601 timestamp of when the record was scraped |

**Example Public Court Filings & Dockets Monitor Record:**

```json
{
  "search_keyword": "Tesla",
  "case_id": "67891234",
  "parties": "Example Plaintiff v. Tesla, Inc.",
  "court": "N.D. Cal.",
  "filing_date": "2026-06-18",
  "docket_number": "3:26-cv-01234",
  "jurisdiction_type": "Federal",
  "link": "https://www.courtlistener.com/docket/67891234/example-plaintiff-v-tesla-inc/",
  "scraped_at": "2026-09-04T09:00:00+00:00"
}
```

***

### 🧰 Technical Stack

- **HTTP Client:** `curl_cffi` with Chrome impersonation for reliable access to the CourtListener API
- **Concurrency:** `asyncio` with an executor bridge for running the impersonated client asynchronously
- **Pagination:** Direct cursor-following via the API's own `next` URL field
- **Date Handling:** `datetime` with timezone-aware UTC timestamps
- **Proxy:** Intentionally disabled for CourtListener requests to avoid rate-limiting hangs, with instant no-proxy retry on failure
- **Logging:** Apify Actor logging system
- **Platform:** Apify Actor serverless environment

***

### 📊 Data Fields Explained

#### **Docket Identity**

- **case\_id**: CourtListener's unique identifier for the docket
- **parties**: The case name, typically formatted as "Plaintiff v. Defendant"

#### **Case Details**

- **court**: The court where the case was filed
- **filing\_date**: The date the docket was filed
- **docket\_number**: The official court-assigned docket number
- **jurisdiction\_type**: The jurisdiction classification for the case

#### **Access**

- **link**: Direct link to the docket's full record on CourtListener
- **search\_keyword**: The keyword that produced this result

***

### 🎯 Use Cases

- **Litigation Monitoring** – Track new court filings involving a specific company, individual, or case
- **Legal Research** – Search for dockets related to a particular legal matter or party name
- **Corporate Due Diligence** – Check a company's litigation history before a partnership or investment
- **Journalism** – Source primary docket data for legal and courtroom news coverage
- **Academic Research** – Study public litigation patterns and court activity at scale
- **Compliance Monitoring** – Track regulatory or legal proceedings relevant to your organization

***

### 🚀 Quick Start

#### **1. Prepare Input**

Go to Apify Console and enter:

```json
{
  "keywords": "Tesla"
}
```

#### **2. Run the Actor**

Click **Start**. The Actor will:

- Query CourtListener's Search API for dockets matching the keyword
- Follow the API's own pagination cursor to fetch further pages
- Deduplicate dockets by case ID
- Push batches to the Dataset incrementally as they're collected

#### **3. Monitor Progress**

Console shows:

```
🔎 Fetching CourtListener dockets for: 'Tesla'...
Saved 20 dockets | Total: 20/50
🎉 Complete! Successfully harvested 20 court dockets.
```

#### **4. View & Download Results**

- **Results Tab**: All **Public Court Filings & Dockets Monitor** records
- **Export**: JSON, CSV, Excel, or HTML
- **Filter**: By court or filing date
- **API Access**: Available via the Apify API

***

### ⚙️ Configuration

Default keyword search:

```json
{
  "keywords": "Tesla"
}
```

Search a specific company or individual:

```json
{
  "keyword": "Acme Corporation"
}
```

***

### 📈 Performance

#### **Processing Speed**

- One or more paginated requests, capped at 50 total results per run
- 0.3 second delay between paginated requests to stay within fair-use expectations
- Instant no-proxy retry on request failure, avoiding long proxy-related timeouts

#### **Resource Usage**

- Memory: Low, since no browser instance is launched
- Network: Multiple lightweight JSON requests, scaling with result volume up to the 50-record cap
- Proxy: Not used for CourtListener requests by design, to avoid rate-limiting hangs

***

### ⚠️ Important Notes

#### **Legal & Compliance**

- **Fair Use**: Includes a descriptive `User-Agent` and applies pacing delays between paginated requests to the public CourtListener API
- **Public Data Only**: Retrieves only publicly available U.S. court docket data already indexed by CourtListener
- **Legal**: Not legal advice — consult qualified professionals before using this data for legal, compliance, or business decisions

#### **Data Quality**

- **Freshness**: Reflects CourtListener's currently indexed docket data at time of run, which may lag behind official court systems (e.g., PACER)
- **Completeness**: `court`, `docket_number`, and `jurisdiction_type` may be blank or `"N/A"` depending on what CourtListener has indexed for a given docket
- **Accuracy**: Sourced directly from CourtListener's own REST API, a project of the nonprofit Free Law Project
- **Verification**: Cross-check high-stakes legal details against the official court record (e.g., PACER) before relying on them

#### **Best Practices**

- Use specific party names, company names, or case identifiers to keep result volume relevant
- Remember this Actor caps output at 50 results per run regardless of how many matches exist
- Re-run periodically to catch newly filed dockets
- Do not rely on this data alone for time-sensitive legal deadlines — verify against official court systems
- Update the contact email in the User-Agent header before running in production

***

### 📄 License & Legal

**Terms of Use:**

- Use for legitimate legal research, journalism, and due diligence purposes
- Respect CourtListener's API Terms of Use
- Use **Public Court Filings & Dockets Monitor** data responsibly and in compliance with applicable laws
- Not a substitute for professional legal advice or official court records

**Disclaimer:**
Public Court Filings & Dockets Monitor is provided as-is for research and monitoring purposes. Users are responsible for compliance with CourtListener's terms and all applicable laws. This is not legal advice, and this data should not be relied upon for time-sensitive legal matters without verification against official court systems.

***

### ⚖️ Public Court Filings & Dockets Monitor Excellence

This Actor is optimized for **Public Court Filings & Dockets Monitor** research with:

- ✅ Direct, official CourtListener API access — no HTML scraping fragility
- ✅ Cursor-based pagination following the API's own next-page links
- ✅ Automatic proxy fallback for resilient requests
- ✅ Global deduplication across paginated results
- ✅ Incremental Dataset push
- ✅ Production-ready code

# Actor input Schema

## `keywords` (type: `string`):

Party name, company name, case title, or topic (e.g., 'Tesla', 'patent infringement').

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

Select Residential Proxy for CourtListener API requests.

## Actor input object example

```json
{
  "keywords": "Tesla",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `crawlResults` (type: `string`):

No description

## `docketsOverview` (type: `string`):

No description

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("datapilot/public-court-filings-dockets-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("datapilot/public-court-filings-dockets-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 '{}' |
apify call datapilot/public-court-filings-dockets-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,datapilot/public-court-filings-dockets-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/Nt2Dkx4GgdbZiPkJb/builds/T2KzdDASFYaFGhPOi/openapi.json