# Federal Judicial Center Scraper (`parseforge/federal-judicial-center-scraper`) Actor

Scrapes federal judge profiles from the FJC Biographical Directory. Returns each judge as a flat row with appointment history, education, court type, and appointing president. Filter by court, party, or active status.

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

## Pricing

from $19.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

[![ParseForge](https://raw.githubusercontent.com/ParseForge/apify-assets/main/banner-v4.webp)](https://apify.com/parseforge?fpr=vmoqkp)

### Federal Judicial Center Scraper

**Scrape complete federal judge profiles from the Federal Judicial Center’s Biographical Directory, from the Supreme Court to District Courts.** Every record includes appointing president, party, court history, education, and service dates. Export to CSV, JSON, Excel, or XML.

The Federal Judicial Center publishes the official biographical directory of every federal judge who has served since 1789, but browsing it one judge at a time makes large-scale analysis impossible. This Actor reads the entire directory, or a filtered subset, and returns structured profiles in a single dataset. You can filter by court type, appointing president’s party, or active status, and search by judge name.

| Who uses it | What they scrape Federal Judicial Center for |
|---|---|
| Legal researchers | Analyze the career paths and educational backgrounds of Article III judges over two centuries. |
| Journalists | Investigate the demographic and political composition of the federal judiciary at a point in time. |
| Political scientists | Study the relationship between appointing presidents, party affiliation, and judicial tenure length. |
| Law firms | Build a searchable internal database of sitting judges’ professional histories before a case assignment. |

### What it does

This Actor collects federal judge profiles from the FJC Biographical Directory and returns each judge as a flat row with their full career history, education, and appointment details.

- ⚖️ **Court type filter:** restrict results to U.S. District Court, Court of Appeals, Supreme Court, or historical circuit courts.
- 🐘 **Appointing party filter:** select judges first appointed by a Democratic, Republican, Whig, Federalist, or Democratic-Republican president.
- ✅ **Active status toggle:** return only judges who are still serving, with no termination date on their first appointment.
- 🔍 **Name search:** filter by last name, first name, or a partial match to find a specific judge or a family of jurists.

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

### What you can do with Federal Judicial Center data

**📊 Map the judiciary’s political composition.**

A political scientist filters by appointing party and court type to chart how the partisan balance of the federal bench has shifted across administrations.

**📰 Profile a judicial nominee’s future colleagues.**

A reporter scrapes all active district court judges to compare a nominee’s background against the sitting bench they would join.

**🏛️ Audit judicial vacancies and tenure.**

A legal watchdog exports every judge who has left the bench, along with their termination reason and service length, to identify courts with the longest vacancies.

**🎓 Trace law school pipelines to the bench.**

A law school administrator scrapes the full directory to count how many alumni have served as federal judges, broken down by court level.

### Why choose this scraper

|  | What you get |
|---|---|
| **No API key or registration** | The FJC directory is public. This Actor reads it directly with no account setup. |
| **Fixed, flat schema** | Every judge profile is returned in the same predictable format, ready for analysis. |
| **Historical depth** | Covers every Article III judge from the founding of the federal courts to the present day. |
| **Flexible filtering** | Combine court type, party, and active status to isolate exactly the cohort you need. |

### How it compares

This Actor scrapes the FJC Biographical Directory for judge profiles, while the competitors below scrape CourtListener for court records, dockets, and opinions. They serve different research needs.

| Feature | ParseForge | Court Records Scraper | Court Records Scraper - Case Law, Dockets & Judges | Federal Court Records Scraper - PACER RECAP & Opinions |
|---|---|---|---|---|
| Scrapes FJC Biographical Directory | Yes | Not listed | Not listed | Not listed |
| Full judge career history and education | Yes | Not listed | Not listed | Not listed |
| Filter by appointing president's party | Yes | Not listed | Not listed | Not listed |
| Filter by court type | Yes | Not listed | Yes | Not listed |
| Active judge status filter | Yes | Not listed | Not listed | Not listed |
| Court opinions and dockets | Not listed | Yes | Yes | Yes |

### Configure the run

Drive the Actor with an optional name filter, court type, appointing president’s party, and an active-status toggle. Filters run as each profile is read so only matching judges reach your dataset. The Input tab lists every parameter.

A first run with the defaults:

```json
{
  "maxItems": 10
}
```

A larger pull:

```json
{
  "maxItems": 200
}
```

### Pricing

Pay-per-result: **$0.021 per result** collected. You pay only for the results written to your dataset.

| Results collected | Approximate cost |
|---|---|
| 100 results | $2.10 |
| 1,000 results | $21.00 |
| 10,000 results | $210.00 |

New Apify accounts start with $5 in free credit.

### Free users

Free-plan runs return up to 10 results as a preview. [Upgrade your Apify plan](https://console.apify.com/sign-up?fpr=vmoqkp) to collect up to 1,000,000 results 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 [Federal Judicial Center Scraper](https://apify.com/parseforge/federal-judicial-center-scraper?fpr=vmoqkp).
3. Set your inputs and any filters, then 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) (`run-sync-get-dataset-items`) 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 Judicial Center through the Model Context Protocol. Add the Actor to Claude, Cursor, or any MCP client:

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

Then prompt it in plain language to run the scraper and read back the results.

### Troubleshooting

**Why am I getting no results?**

Check that your name filter is spelled correctly and that your court type and party filters are not too restrictive. Try clearing all filters and running with only a name or with no filters to see the full dataset.

**Why does the run stop after 10 records?**

Free Apify accounts are limited to 10 records per run as a preview. Upgrade to a paid plan to increase the maximum records limit and scrape the full directory.

**Why are some judges missing from the results?**

The FJC directory covers only Article III federal judges. If you are looking for a magistrate judge, bankruptcy judge, or state court judge, they will not appear. Also confirm your filters are not excluding the judge you expect.

**Why does the ‘Still Serving Only’ filter return judges I know have retired?**

The filter checks only the first appointment record for a termination date. A judge who took senior status or moved to a different court may still have an open first appointment. Review the full profile data for a complete picture.

**Can I get the data faster?**

The Actor reads each judge’s profile page individually from the FJC website. Running with no filters will take longer because it processes the entire directory. Use filters to narrow your request and reduce runtime.

### FAQ

| Question | Answer |
|---|---|
| What is the Federal Judicial Center Biographical Directory? | It is the official U.S. government database of every judge who has served in an Article III federal court since 1789. The FJC maintains it as a public historical record. |
| Does this Actor include state court judges? | No. The FJC directory covers only Article III federal judges: Supreme Court, Courts of Appeals, District Courts, and the historical Circuit Courts. State judges are not included. |
| Can I filter by a specific appointing president? | You can filter by the appointing president’s party, not by an individual president. The output includes the appointing president’s full name, so you can filter further in your spreadsheet or database. |
| What does the ‘Still Serving Only’ toggle do? | When enabled, the Actor returns only judges whose first appointment has no termination date. This gives you the currently active federal bench. |
| Does this Actor return magistrate or bankruptcy judges? | No. The FJC directory covers Article III judges. Magistrate and bankruptcy judges are not Article III judges and are not included in this dataset. |
| What information is included in each judge’s profile? | Each row includes the judge’s full name, birth and death dates, appointing president and party, court type, commission date, termination date and reason, education, and professional career history. |
| Can I search for a judge by partial name? | Yes. The name filter accepts partial matches, so searching for a last name or a few letters of a first name will return all matching judges. |
| Is there a limit on how many judges I can scrape? | Free users are limited to 10 records as a preview. Paid Apify plans can scrape up to the full directory, which contains several thousand judges. |
| How often is the FJC directory updated? | The FJC updates the directory regularly as judges retire, take senior status, or pass away. You can run this Actor on a schedule to keep your dataset current. |
| Can I export the data to Google Sheets? | Yes. Apify supports direct export to CSV, JSON, Excel, and XML. You can also use Apify integrations to send the data to Google Sheets, Airtable, or a webhook. |

### Related actors

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 Federal Judicial Center. It collects only publicly available data. You are responsible for using the collected data in compliance with the source's terms of service and applicable data-protection laws, including GDPR, CCPA, and PIPL. Do not use it to collect personal data unlawfully.

# Actor input Schema

## `nameFilter` (type: `string`):

Filter judges by last name, first name, or partial match. Leave empty to return every federal judge.

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

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

## `courtTypeFilter` (type: `string`):

Filter to a specific federal court type.

## `appointingPartyFilter` (type: `string`):

Filter to judges first appointed by a president of this party.

## `stillServingOnly` (type: `boolean`):

When enabled, only judges with no termination date on appointment 1 are returned.

## Actor input object example

```json
{
  "maxItems": 10,
  "stillServingOnly": false
}
```

# Actor output Schema

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

Scraped FJC federal judge records

# 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 = {
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/federal-judicial-center-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 = { "maxItems": 10 }

# Run the Actor and wait for it to finish
run = client.actor("parseforge/federal-judicial-center-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 '{
  "maxItems": 10
}' |
apify call parseforge/federal-judicial-center-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,parseforge/federal-judicial-center-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/nOM5fLmCimexk0JLC/builds/UqLuNqIQigZ8XKqCO/openapi.json