# CourtListener Scraper - Case Law, PACER Dockets & Judges (`parseforge/courtlistener-docket-scraper`) Actor

Queries all six CourtListener indexes live: 8.3M case law opinions, 8.8M federal PACER dockets, 60M RECAP filings, 15k judges and 102k oral arguments. Filter by court, date, party, docket number, citation, nature of suit or citation count. No API key needed.

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

## Pricing

from $1.68 / 1,000 case law opinions

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](https://raw.githubusercontent.com/ParseForge/apify-assets/main/banner.jpg)](https://apify.com/parseforge?fpr=vmoqkp)

### CourtListener Scraper - Case Law, PACER Dockets & Judges API

**Query all six CourtListener indexes from one Actor: 8.3 million case law opinions, 8.8 million federal PACER dockets, 60 million RECAP filings, 15,000 federal judges and 102,000 oral argument recordings.** Filter by court, filing date, party, docket number, reported citation, nature of suit, precedential status or citation count. No login and no API key required. Export to CSV, JSON, Excel, or XML.

Most CourtListener actors read one index, usually opinions, and hand back a dozen columns. This one reads the search API that powers courtlistener.com itself, so the same run can pull the leading antitrust opinions of the last century, every docket Google is a party to, the motions to dismiss filed in a district this month, the judges appointed by a given president, and the audio of a Supreme Court argument.

| Who uses it | What they pull from CourtListener |
|---|---|
| Litigation and IP teams | New filings in a court, a case type, or against a named party |
| Legal researchers and academics | Citation networks, precedential status, and full opinion metadata at scale |
| Legal tech and AI teams | Training and retrieval corpora with stable IDs and source PDF links |
| Journalists and watchdogs | Dockets as they are filed, and the free RECAP copies of the documents |
| Investors and analysts | Litigation exposure by company, court and nature of suit |

### What it does

Pick one of six indexes in `searchType` and the Actor queries it live through CourtListener's public search API, following the cursor until it has the rows you asked for. Every filter you set is applied server side, so you pay for matches rather than for filtering afterwards.

- ⚖️ **Case law opinions (8.3M).** Case name, full caption, court, jurisdiction, docket number, filing and argument dates, precedential status, judge, panel, attorneys, reported citations, Lexis and neutral cites, citation count, nature of suit, posture, procedural history, syllabus, SCDB ID, the source PDF URL, a text snippet, the opinions it cites, and its sibling opinions.
- 🗂️ **RECAP dockets (8.8M).** Federal PACER dockets with the matching filings attached: case name, court, docket number, PACER case ID, filed, argued and terminated dates, assigned and referred judge, cause, nature of suit, jurisdiction type, jury demand, bankruptcy chapter, trustee, parties, attorneys and firms.
- 📄 **RECAP documents (60M).** One row per filing: document and attachment number, docket entry, entry date, document type, short and long description, page count, PACER document ID, whether the PDF is free in the RECAP archive, and the opinions it cites.
- 👩‍⚖️ **Judges (15k).** Name, date and place of birth and death, gender, race, religion, law schools, political affiliation, ABA rating, FJC ID, aliases, and the full position history.
- 🎧 **Oral arguments (102k).** Case name, court, docket number, argument date, judges, duration, MP3 URL and file size, and a transcript snippet.

Results export to CSV, JSON, Excel, or XML, or stream from the API.

### What you can do with CourtListener data

**📡 Watch a court, a party or a case type.**

Set `court`, `partyName` or `natureOfSuit`, sort by filing date and run it on a schedule. Each run returns the newest filings first, so a diff against the last run is your alert feed.

**📚 Build a case law corpus.**

Search opinions by topic, filter by precedential status, and keep the source PDF link and the citation graph on every row. `citedGt` pulls only the cases the field actually relies on.

**🏛️ Profile a bench.**

Query the judges index by appointing president, law school or political affiliation, and get the full position history for each one.

**🔍 Find the free copy of a filing.**

Set `availableOnly` and RECAP returns only the documents whose PDF is already in the free archive, with the direct path, so you never hit a PACER paywall.

### Why choose this scraper

| | What you get |
|---|---|
| **Six indexes, not one** | Opinions, RECAP dockets, RECAP documents, dockets, judges and oral arguments in one Actor, each with its own field set. |
| **26 server-side filters** | Court, date range, case name, docket number, citation, judge, precedential status, citation count, party, nature of suit, entry text, document number, free-PDF-only, law school, appointer and political affiliation. Every one was measured against the unfiltered total before it shipped. |
| **No API key needed** | CourtListener throttles anonymous callers at 5 requests a minute per IP. The Actor rotates a fresh proxy session per request, so the throttle never binds. Paste your own free CourtListener token and it uses that instead. |
| **Stable pagination** | The API paginates by cursor, not offset. Measured over seven pages: 120 rows, zero duplicates. |
| **Honest columns** | Fields the search index never fills were removed rather than shipped empty. `dateReargued` is in CourtListener's schema and comes back blank even on Brown v. Board, so it is not a column here. |
| **You pay for what you keep** | Rows are billed as they are written, capped at your `maxItems`, so a page that overshoots the cap is trimmed before it is charged. |

### How it compares

CourtListener actors on the Store are almost all single-index opinion readers. `fortuitous_pirate/courtlistener-legal-data` charges $0.02 to start plus $0.004 a row; `pink_comic/courtlistener-legal-opinions` and `alwaysprimedev/courtlistener-scraper` are opinions-only at $0.002 and $0.0025. None of them expose the RECAP document index, the judges database or the oral argument archive, and none expose the nature-of-suit, party-name or citation-count filters.

ParseForge publishes three narrower CourtListener readers that stay the better pick when they fit: [CourtListener Opinions Scraper](https://apify.com/parseforge/court-listener-opinions-scraper?fpr=vmoqkp) walks a court's opinion feed and returns the full opinion text, which this Actor does not; [US Supreme Court Opinions Scraper](https://apify.com/parseforge/supreme-court-opinions-scraper?fpr=vmoqkp) organises SCOTUS by October Term; [CourtListener Business Bankruptcy Scraper](https://apify.com/parseforge/business-bankruptcy-filings-scraper?fpr=vmoqkp) is purpose-built for chapter filings. Use this one when you need breadth, filters, or any index other than opinions.

### What a row looks like

An opinion row:

```json
{
  "searchType": "opinions",
  "clusterId": 10967534,
  "caseName": "Lucid Group USA v. Johnston",
  "url": "https://www.courtlistener.com/opinion/10967534/lucid-group-usa-v-johnston/",
  "court": "Court of Appeals for the Fifth Circuit",
  "courtId": "ca5",
  "courtCitationString": "5th Cir.",
  "courtJurisdiction": "F",
  "docketNumber": "25-50319",
  "docketId": 70260828,
  "status": "Published",
  "dateFiled": "2026-09-04",
  "citeCount": 0,
  "opinionCount": 1,
  "opinionType": "combined-opinion",
  "perCuriam": false,
  "downloadUrl": "https://www.ca5.uscourts.gov/opinions/pub/25/25-50319-CV0.pdf",
  "citedOpinionIds": "102224; 110290; 321258",
  "scrapedAt": "2026-09-07T16:44:02.118Z"
}
```

A RECAP docket row carries `assignedTo`, `cause`, `suitNature`, `juryDemand`, `party`, `firm` and a `matchedDocuments` array with the filings that matched your query. A judge row carries `school`, `politicalAffiliation`, `abaRating` and a `positions` array.

### Configure the run

| Input | What it does |
|---|---|
| `searchType` | Which index to query: `opinions`, `recap`, `dockets`, `recap-documents`, `judges`, `oral-arguments`. |
| `query` | Full-text search, with quoted phrases and AND/OR/NOT. |
| `court` | Court ID such as `scotus`, `ca9`, `cand`. Space-separate several. |
| `filedAfter` / `filedBefore` | Filing date range. For oral arguments these filter on the argument date. |
| `orderBy` | Relevance, filing date, argument date or citation count, ascending or descending. |
| `caseName`, `docketNumber` | Match the caption, or pin an exact docket number. |
| `citation`, `judge`, `statuses`, `citedGt`, `citedLt` | Opinion filters: reported cite, judge surname, precedential status, and citation count bounds. |
| `partyName`, `natureOfSuit`, `entryDescription`, `documentNumber`, `availableOnly` | RECAP filters. |
| `school`, `appointer`, `politicalAffiliation` | Judge filters. |
| `apiToken` | Your own free CourtListener token. Lifts the anonymous throttle and skips the proxy. |
| `maxItems` | How many rows to return. |

### Pricing

Pay-per-event, and only rows that are actually written are billed: **$0.004 per opinion, RECAP docket or oral argument, $0.003 per docket, $0.002 per RECAP document and $0.005 per judge**, dropping by 58% on Gold and above, plus a run-start fee of $0.002 on the free plan and $0.0002 on any paid one.

| Rows collected | Opinions, free plan | Opinions, Gold | RECAP documents, Gold |
|---|---|---|---|
| 100 | $0.40 | $0.17 | $0.08 |
| 1,000 | $4.00 | $1.68 | $0.84 |
| 10,000 | $40.00 | $16.80 | $8.40 |

New Apify accounts start with $5 in free credit.

### Free users

Free-plan runs return up to 10 rows as a preview. [Upgrade your Apify plan](https://console.apify.com/sign-up?fpr=vmoqkp) to collect up to 1,000,000 rows per run.

### Run it

1. [Create a free Apify account with $5 in credit](https://console.apify.com/sign-up?fpr=vmoqkp).
2. Open the [CourtListener Scraper](https://apify.com/parseforge/courtlistener-docket-scraper?fpr=vmoqkp).
3. Pick a `searchType`, set your filters, and click **Start**.
4. Export the results as CSV, Excel, JSON, or XML from the **Dataset** tab.

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.

### Use with AI agents (MCP)

Give an AI agent live access to federal case law and dockets through the Model Context Protocol:

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

Then prompt it in plain language:

- *"Find the twenty most cited antitrust opinions in the Ninth Circuit."*
- *"List every federal docket filed against Google this year, newest first."*
- *"Which judges appointed by Obama went to Harvard Law?"*

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

```
Use the Apify Actor "parseforge/courtlistener-docket-scraper" to search CourtListener. Input: { "searchType": "opinions" | "recap" | "dockets" | "recap-documents" | "judges" | "oral-arguments", "query": "<text>", "court": "<court id>", "filedAfter": "YYYY-MM-DD", "maxItems": <n> }. It returns case name, court, docket number, dates, status, citation count and source URLs per row. Call it with the ApifyClient and my APIFY_TOKEN.
```

### Troubleshooting

**Why am I getting no results?**

Every filter is ANDed, and an over-narrow combination returns an empty set rather than an error. Drop one filter at a time. `citation` and `citedGt` apply to opinions only; `partyName` and `natureOfSuit` apply to RECAP only, so setting them on the wrong `searchType` silently narrows nothing.

**Why is the run slow without a proxy?**

CourtListener throttles anonymous callers at 5 requests a minute per IP, and each request returns 20 rows. With the proxy on, a fresh session per request means a fresh allowance. With proxy and token both off, expect roughly 100 rows a minute.

**Why is a field empty?**

The search index fills fields sparsely by record age and type. `attorney`, `lexisCite`, `posture` and `scdbId` populate on older and frequently cited opinions and are blank on this week's slip opinions; `dateTerminated`, `chapter` and `trustee` populate on closed and bankruptcy dockets. Empty means the source did not publish it.

**Why fewer rows than `maxItems`?**

Your query has that many matches. The log prints CourtListener's own total for the query on the first page, so compare against that.

### FAQ

| Question | Answer |
|---|---|
| Do I need a CourtListener account? | No. Every endpoint this Actor reads is public and anonymous. A free token is supported and makes long runs faster, but it is optional. |
| Which indexes can I search? | Six: case law opinions, RECAP dockets, RECAP dockets with documents, RECAP documents, judges, and oral arguments. |
| Does it return the full opinion text? | No. It returns the metadata, a text snippet and the source PDF URL. For complete opinion text use [CourtListener Opinions Scraper](https://apify.com/parseforge/court-listener-opinions-scraper?fpr=vmoqkp). |
| Can I get PACER documents for free? | The ones already donated to the RECAP archive, yes. Set `availableOnly` to keep only those, and each row carries the archive path. |
| How fresh is the data? | It is read at run time from the same index that powers courtlistener.com. |
| How many rows per run? | Free plan: 10. Paid: up to 1,000,000, bounded by how many records your query actually matches. |
| Does it deduplicate? | The API paginates by cursor, which is stable under insertion. Measured over seven pages: 120 rows, zero duplicates. |
| Is this an official CourtListener product? | No. It is unofficial and reads only the public API. |

### Related actors

- [CourtListener Opinions Scraper](https://apify.com/parseforge/court-listener-opinions-scraper?fpr=vmoqkp): full opinion text, walked by court feed.
- [US Supreme Court Opinions Scraper](https://apify.com/parseforge/supreme-court-opinions-scraper?fpr=vmoqkp): SCOTUS opinions organised by October Term.
- [CourtListener Business Bankruptcy Scraper](https://apify.com/parseforge/business-bankruptcy-filings-scraper?fpr=vmoqkp): US business bankruptcy filings by chapter and court.
- [Justia Case Law Scraper](https://apify.com/parseforge/justia-case-law-scraper?fpr=vmoqkp): case law from Justia.
- [Harris County Court Records Scraper](https://apify.com/parseforge/harris-county-court-records-scraper?fpr=vmoqkp): county-level dockets from Harris County, Texas.

Browse the full [ParseForge collection](https://apify.com/parseforge?fpr=vmoqkp) for more scrapers.

🆘 **Need help?** Email parseforge@protonmail.com with your run ID, your input, and what you expected.

⚠️ **Disclaimer.** This Actor is unofficial 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

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

Which CourtListener index to query. Opinions are published case law; RECAP dockets and documents are federal PACER filings; judges is the judiciary database; oral arguments are argument audio recordings.

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

Full-text query. Supports the CourtListener query syntax: quoted phrases, AND/OR/NOT, and field prefixes. Leave empty to browse the whole index with the filters below.

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

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

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

Earliest filing date, as YYYY-MM-DD or MM/DD/YYYY. For oral arguments this filters on the argument date instead.

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

Latest filing date, as YYYY-MM-DD or MM/DD/YYYY. For oral arguments this filters on the argument date instead.

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

How to order the results. Relevance only means anything when a search query is set.

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

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

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

Exact docket number, for example 25-50319 or 1:20-cv-03590.

## `citation` (type: `string`):

Look up a reported citation, for example "410 U.S. 113". Ignored for the other search types.

## `judge` (type: `string`):

Judge or panel member surname. Applies to opinions and oral arguments.

## `statuses` (type: `array`):

Which precedential statuses to include. Leave empty for the API default, which is published opinions only.

## `citedGt` (type: `integer`):

Keep only opinions cited more than this many times. Use it to pull the leading cases on a topic.

## `citedLt` (type: `integer`):

Keep only opinions cited fewer than this many times.

## `partyName` (type: `string`):

Name of a party to the case, for example Google. Applies to the RECAP docket and document searches.

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

PACER nature-of-suit code, for example 110 for insurance or 830 for patent.

## `entryDescription` (type: `string`):

Match words in the docket entry description, for example motion or complaint.

## `documentNumber` (type: `string`):

Filter to a specific document number within the docket.

## `availableOnly` (type: `boolean`):

Keep only filings whose PDF is already in the free RECAP archive rather than paywalled behind PACER.

## `school` (type: `string`):

Filter judges by the school they attended, for example harvard.

## `appointer` (type: `string`):

Filter judges by the president who appointed them, for example Obama.

## `politicalAffiliation` (type: `string`):

Filter judges by party code: d for Democratic, r for Republican, i for Independent.

## `apiToken` (type: `string`):

A free CourtListener token lifts the 5 requests/minute anonymous throttle and makes long runs much faster. Leave empty to run anonymously through rotating proxies.

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

CourtListener throttles anonymous callers per IP, so a rotating proxy is what keeps the run fast. Not used when an API token is supplied.

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

How many rows to return. Free-plan runs return up to 10 rows as a preview; paid plans get the full amount.

## Actor input object example

```json
{
  "searchType": "opinions",
  "query": "antitrust",
  "orderBy": "dateFiled desc",
  "availableOnly": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "maxItems": 100
}
```

# Actor output Schema

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

No description

## `csv` (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 = {
    "searchType": "opinions",
    "query": "antitrust",
    "orderBy": "dateFiled desc",
    "proxyConfiguration": {
        "useApifyProxy": true
    },
    "maxItems": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/courtlistener-docket-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 = {
    "searchType": "opinions",
    "query": "antitrust",
    "orderBy": "dateFiled desc",
    "proxyConfiguration": { "useApifyProxy": True },
    "maxItems": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/courtlistener-docket-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 '{
  "searchType": "opinions",
  "query": "antitrust",
  "orderBy": "dateFiled desc",
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "maxItems": 100
}' |
apify call parseforge/courtlistener-docket-scraper --silent --output-dataset

```

## MCP server setup

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