---
# Required metadata
license: pddl
language:
  - en
pretty_name: CourtListener Legal Dataset
size_categories:
  - 10M<n<100M

# Content metadata
annotations_creators:
  - no-annotation
language_creators:
  - found
multilinguality:
  - monolingual
source_datasets:
  - original

# Task metadata
task_categories:
  - text-generation
  - question-answering
  - text-classification
  - feature-extraction
task_ids:
  - document-retrieval
  - named-entity-recognition
  - text-scoring

# Discovery tags
tags:
  - legal
  - court-opinions
  - case-law
  - courtlistener
  - pacer
  - recap
  - embeddings
  - citations
  - judges
  - dockets

# Dataset configurations
configs:
  - config_name: courts
    data_files:
      - split: train
        path: data/courts/*.parquet
    default: false
  - config_name: opinion-clusters
    data_files:
      - split: train
        path: data/opinion-clusters/*.parquet
    default: true
  - config_name: opinions
    data_files:
      - split: train
        path: data/opinions/*.parquet
  - config_name: dockets
    data_files:
      - split: train
        path: data/dockets/*.parquet
  - config_name: citations
    data_files:
      - split: train
        path: data/citations/*.parquet
  - config_name: citation-map
    data_files:
      - split: train
        path: data/citation-map/*.parquet
  - config_name: parentheticals
    data_files:
      - split: train
        path: data/parentheticals/*.parquet
  - config_name: people-db-people
    data_files:
      - split: train
        path: data/people-db-people/*.parquet
  - config_name: people-db-positions
    data_files:
      - split: train
        path: data/people-db-positions/*.parquet
  - config_name: people-db-schools
    data_files:
      - split: train
        path: data/people-db-schools/*.parquet
  - config_name: financial-disclosures
    data_files:
      - split: train
        path: data/financial-disclosures/*.parquet
  - config_name: oral-arguments
    data_files:
      - split: train
        path: data/oral-arguments/*.parquet
  - config_name: fjc-integrated-database
    data_files:
      - split: train
        path: data/fjc-integrated-database/*.parquet
  - config_name: embeddings-opinion-clusters
    data_files:
      - split: train
        path: embeddings/opinion-clusters/*.parquet
  - config_name: embeddings-opinions
    data_files:
      - split: train
        path: embeddings/opinions/*.parquet

# Dataset info for key configs
dataset_info:
  - config_name: opinion-clusters
    features:
      - name: id
        dtype: int64
      - name: case_name
        dtype: string
      - name: case_name_full
        dtype: string
      - name: date_filed
        dtype: string
      - name: court_id
        dtype: string
      - name: citation_count
        dtype: int64
      - name: precedential_status
        dtype: string
      - name: syllabus
        dtype: string
      - name: judges
        dtype: string
      - name: attorneys
        dtype: string
      - name: docket_id
        dtype: int64
  - config_name: opinions
    features:
      - name: id
        dtype: int64
      - name: cluster_id
        dtype: int64
      - name: plain_text
        dtype: string
      - name: html
        dtype: string
      - name: type
        dtype: string
      - name: author_id
        dtype: int64
      - name: per_curiam
        dtype: bool
  - config_name: courts
    features:
      - name: id
        dtype: string
      - name: full_name
        dtype: string
      - name: short_name
        dtype: string
      - name: jurisdiction
        dtype: string
      - name: in_use
        dtype: bool
  - config_name: citations
    features:
      - name: id
        dtype: int64
      - name: volume
        dtype: int64
      - name: reporter
        dtype: string
      - name: page
        dtype: string
      - name: cluster_id
        dtype: int64
  - config_name: citation-map
    features:
      - name: id
        dtype: int64
      - name: cited_opinion_id
        dtype: int64
      - name: citing_opinion_id
        dtype: int64
      - name: depth
        dtype: int64
  - config_name: embeddings-opinion-clusters
    features:
      - name: id
        dtype: int64
      - name: embedding
        sequence: float32
---

# CourtListener Legal Dataset

Public mirror of [CourtListener](https://www.courtlistener.com/) bulk legal data, converted to Parquet format for efficient querying and ML workflows.

## Quick Start

```python
from datasets import load_dataset

# Load opinion clusters (default - case metadata and summaries)
ds = load_dataset("drengskapur/courtlistener", split="train")

# Load a specific configuration
courts = load_dataset("drengskapur/courtlistener", "courts", split="train")
opinions = load_dataset("drengskapur/courtlistener", "opinions", split="train")

# Stream large datasets (recommended for opinions/dockets)
ds = load_dataset("drengskapur/courtlistener", "opinions", split="train", streaming=True)
for example in ds.take(10):
    print(example["case_name"])
```

## Efficient Querying (Avoid Rate Limits)

### Use DuckDB for Server-Side Filtering (Recommended)

Query directly without downloading - filtering happens on HuggingFace servers:

```python
import duckdb

conn = duckdb.connect()
conn.execute("INSTALL httpfs; LOAD httpfs;")

# Only download Supreme Court cases (server-side filter)
scotus = conn.execute("""
    SELECT id, case_name, date_filed, citation_count
    FROM 'hf://datasets/drengskapur/courtlistener/data/opinion-clusters/*.parquet'
    WHERE court_id = 'scotus'
    ORDER BY citation_count DESC
    LIMIT 1000
""").df()

# Get opinions for specific clusters only
cluster_ids = scotus['id'].tolist()[:100]
opinions = conn.execute(f"""
    SELECT id, cluster_id, plain_text
    FROM 'hf://datasets/drengskapur/courtlistener/data/opinions/*.parquet'
    WHERE cluster_id IN ({','.join(map(str, cluster_ids))})
""").df()
```

### Use Streaming for Large Tables

Avoid loading entire datasets into memory:

```python
from datasets import load_dataset

# Stream and filter - never loads full dataset
ds = load_dataset("drengskapur/courtlistener", "opinions", streaming=True, split="train")

# Process in batches with early stopping
results = []
for i, example in enumerate(ds):
    if example.get("court_id") == "scotus":
        results.append(example)
    if len(results) >= 100:
        break
```

### Cache Results Locally

```python
from datasets import load_dataset

# Download once, cache forever
ds = load_dataset(
    "drengskapur/courtlistener", 
    "courts",  # Small table - safe to download
    split="train",
    cache_dir="./hf_cache"
)

# For large tables, use DuckDB with local caching
import duckdb
conn = duckdb.connect("courtlistener_cache.db")
conn.execute("""
    CREATE TABLE IF NOT EXISTS scotus_cases AS
    SELECT * FROM 'hf://datasets/drengskapur/courtlistener/data/opinion-clusters/*.parquet'
    WHERE court_id = 'scotus'
""")
```

### Table Size Guide

| Config | Rows | Recommended Method |
|--------|------|-------------------|
| `courts` | ~700 | `load_dataset()` - safe to download |
| `people-db-*` | ~16K-30K | `load_dataset()` - safe to download |
| `citations` | ~18M | DuckDB or streaming |
| `opinion-clusters` | ~73M | DuckDB or streaming |
| `dockets` | ~70M | DuckDB or streaming |
| `opinions` | ~9M | DuckDB (large text) or streaming |
| `citation-map` | ~76M | DuckDB only |

## Available Configurations

### Core Legal Data

| Config | Description | Rows | Size |
|--------|-------------|------|------|
| `opinion-clusters` | Case metadata, summaries, citation counts | ~73M | ~2.5GB |
| `opinions` | Full opinion text (plain, HTML, XML) | ~9M | ~54GB |
| `courts` | Court metadata (700+ courts) | ~700 | ~100KB |
| `dockets` | RECAP docket metadata | ~70M | ~5GB |
| `citations` | Citation references to reporters | ~18M | ~1GB |
| `citation-map` | Citation graph edges | ~76M | ~500MB |
| `parentheticals` | Court-written case summaries | ~6.5M | ~300MB |

### People & Financial Data

| Config | Description | Rows |
|--------|-------------|------|
| `people-db-people` | Judge biographical information | ~16K |
| `people-db-positions` | Judge positions and appointments | ~30K |
| `people-db-schools` | Law school information | ~1K |
| `financial-disclosures` | Judge financial disclosure reports | ~1.7M |

### Additional Tables

| Config | Description | Rows |
|--------|-------------|------|
| `oral-arguments` | Oral argument audio metadata | ~200K |
| `fjc-integrated-database` | FJC federal case data | ~10M |

### Embeddings

| Config | Description | Model |
|--------|-------------|-------|
| `embeddings-opinion-clusters` | Case metadata embeddings | BGE-large-en-v1.5 |
| `embeddings-opinions` | Opinion text embeddings | BGE-large-en-v1.5 |

## API Access (No Downloads Required)

Query directly via HuggingFace Datasets Server API:

```bash
# Get rows
curl "https://datasets-server.huggingface.co/rows?dataset=drengskapur/courtlistener&config=courts&split=train&length=10"

# Search (full-text)
curl "https://datasets-server.huggingface.co/search?dataset=drengskapur/courtlistener&config=opinion-clusters&split=train&query=qualified%20immunity"

# Filter (SQL-like WHERE)
curl "https://datasets-server.huggingface.co/filter?dataset=drengskapur/courtlistener&config=courts&split=train&where=jurisdiction='F'"
```

### Python Client with Rate Limit Handling

```python
import time
import httpx

class CourtListenerAPI:
    BASE = "https://datasets-server.huggingface.co"
    
    def __init__(self, max_retries=5):
        self.client = httpx.Client(timeout=30)
        self.max_retries = max_retries
    
    def _request(self, endpoint: str, params: dict):
        for attempt in range(self.max_retries):
            resp = self.client.get(f"{self.BASE}/{endpoint}", params=params)
            if resp.status_code == 200:
                return resp.json()
            if resp.status_code == 429:  # Rate limited
                wait = 2 ** attempt
                print(f"Rate limited, waiting {wait}s...")
                time.sleep(wait)
                continue
            resp.raise_for_status()
        raise Exception("Max retries exceeded")
    
    def search(self, query: str, config: str = "opinion-clusters", length: int = 10):
        return self._request("search", {
            "dataset": "drengskapur/courtlistener",
            "config": config,
            "split": "train",
            "query": query,
            "length": length
        })
    
    def filter(self, where: str, config: str = "courts", length: int = 100):
        return self._request("filter", {
            "dataset": "drengskapur/courtlistener",
            "config": config,
            "split": "train", 
            "where": where,
            "length": length
        })

# Usage
api = CourtListenerAPI()
results = api.search("miranda rights", length=20)
federal_courts = api.filter("jurisdiction='F'", config="courts")
```

## DuckDB Access

Query directly from DuckDB without downloading:

```sql
-- Install and load httpfs extension
INSTALL httpfs; LOAD httpfs;

-- Query Supreme Court cases
SELECT case_name, date_filed, citation_count
FROM 'hf://datasets/drengskapur/courtlistener/data/opinion-clusters/*.parquet'
WHERE court_id = 'scotus'
ORDER BY citation_count DESC
LIMIT 10;

-- Find all opinions citing a specific case
SELECT o.id, o.plain_text
FROM 'hf://datasets/drengskapur/courtlistener/data/opinions/*.parquet' o
JOIN 'hf://datasets/drengskapur/courtlistener/data/citation-map/*.parquet' cm
  ON o.id = cm.citing_opinion_id
WHERE cm.cited_opinion_id = 12345;
```

## Python Examples

### Semantic Search with Embeddings

```python
from datasets import load_dataset
import numpy as np

# Load embeddings
embeddings_ds = load_dataset(
    "drengskapur/courtlistener", 
    "embeddings-opinion-clusters", 
    split="train"
)

# Load metadata
clusters = load_dataset(
    "drengskapur/courtlistener", 
    "opinion-clusters", 
    split="train"
)

# Create a simple search index
def cosine_similarity(a, b):
    return np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))

# Query embedding (get from your embedding model)
query_embedding = get_embedding("qualified immunity police")

# Find top matches
scores = [
    (i, cosine_similarity(query_embedding, row["embedding"]))
    for i, row in enumerate(embeddings_ds)
]
top_indices = sorted(scores, key=lambda x: -x[1])[:10]

for idx, score in top_indices:
    print(f"{clusters[idx]['case_name']}: {score:.3f}")
```

### Filter by Court and Date

```python
from datasets import load_dataset

ds = load_dataset("drengskapur/courtlistener", "opinion-clusters", split="train")

# Filter to Supreme Court cases from 2020
scotus_2020 = ds.filter(
    lambda x: x["court_id"] == "scotus" and 
              x["date_filed"] and 
              x["date_filed"].startswith("2020")
)

for case in scotus_2020:
    print(f"{case['case_name']} ({case['date_filed']})")
```

### Join Citations with Opinion Text

```python
from datasets import load_dataset

# Load citation map and opinions
citations = load_dataset("drengskapur/courtlistener", "citation-map", split="train")
opinions = load_dataset("drengskapur/courtlistener", "opinions", split="train")

# Build opinion lookup (for small-scale use)
opinion_lookup = {op["id"]: op for op in opinions.take(10000)}

# Find what cites a specific opinion
target_opinion_id = 12345
citing = [c for c in citations if c["cited_opinion_id"] == target_opinion_id]
print(f"Found {len(citing)} citations")
```

## Schema Details

### Opinion Clusters

Key fields for case research:

- `id` - Unique identifier
- `case_name`, `case_name_full` - Case names
- `date_filed` - Filing date
- `court_id` - Court identifier (join with `courts`)
- `citation_count` - Number of times cited
- `precedential_status` - Published, Unpublished, etc.
- `syllabus` - Case summary
- `attorneys` - Attorney information
- `judges` - Judges on the panel

### Opinions

Key fields for full text:

- `id` - Unique identifier
- `cluster_id` - Links to opinion-clusters
- `plain_text` - Plain text version (best for NLP)
- `html` - HTML version with formatting
- `type` - Opinion type (majority, dissent, concurrence)
- `author_id` - Judge who wrote the opinion

## Data Source

This dataset mirrors [CourtListener](https://www.courtlistener.com/) bulk data from [Free Law Project](https://free.law/).

- **Update Frequency**: Daily (source data)
- **Source**: CourtListener S3 bulk data exports
- **Format**: Parquet with zstd compression

## License

Public Domain Dedication and License (PDDL) - same as CourtListener source data.

## Citation

```bibtex
@misc{courtlistener,
  author = {Free Law Project},
  title = {CourtListener},
  year = {2024},
  publisher = {Free Law Project},
  howpublished = {\url{https://www.courtlistener.com/}},
}
```