# Global Court Records Aggregator Scraper (`parseforge/global-court-records-aggregator-scraper`) Actor

Scrapes court records from five national and international court systems in parallel. Returns each case as a flat row with source, title, docket, date, and full opinion text where available.

- **URL**: https://apify.com/parseforge/global-court-records-aggregator-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Automation, Other
- **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/platform/actors/running/actors-in-store#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)

### Global Court Records Aggregator Scraper

**Aggregate court records from the US, UK, Brazil, and the International Court of Justice, up to a million per run.** Each record returns the case name, docket number, court, date, and full opinion text where available. No API keys or legal portal logins. Export to CSV, JSON, Excel, or XML.

Finding case law across multiple jurisdictions means visiting separate portals, learning each one's search syntax, and manually merging results. This Actor queries US Caselaw Access, UK Find Case Law, the International Court of Justice, Brazil's CNJ DataJud, and US Supreme Court Opinions in parallel, returning a single unified dataset. A keyword filter runs across all sources so only matching cases land in your output.

| Who uses it | What they scrape Global Court Records Aggregator for |
|---|---|
| Legal researchers | Comparing how different jurisdictions have ruled on the same legal question. |
| Law firms | Monitoring new filings or decisions that cite a specific statute or precedent. |
| Journalists | Tracking high-profile litigation across multiple countries for an investigation. |
| Academic researchers | Building a corpus of judicial opinions for quantitative legal studies. |

### What it does

This Actor collects court records from five national and international court systems and returns each case as a flat row with its source, title, docket, date, and body text.

- ⚖️ **Parallel court queries:** pick any combination of US Caselaw, UK Find Case Law, ICJ, Brazil CNJ, and SCOTUS, and the Actor splits your item limit evenly across them.
- 🔍 **Cross-source keyword filter:** a single search term filters cases as they are read, so you only get records mentioning 'antitrust', 'climate', or any phrase you choose.
- 🏛️ **Per-source drill-down:** narrow US results to a specific reporter slug, pick an ICJ list type, choose a Brazilian tribunal, or set SCOTUS October Terms.
- 📄 **Full opinion text:** where the source provides it, the complete body of the opinion is included in the output row.

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

### What you can do with Global Court Records Aggregator data

**⚖️ Cross-jurisdictional precedent search.**

A legal researcher enters 'data privacy' and selects all five court systems to collect every recent case that mentions the term, then compares reasoning across the US, UK, Brazil, and the ICJ.

**📰 Investigative litigation tracking.**

A journalist monitors new filings by setting a keyword for a corporation's name and running the Actor weekly across US Caselaw and UK Find Case Law to catch lawsuits as they appear.

**📊 Quantitative legal corpus building.**

An academic downloads 50,000 SCOTUS and US Caselaw opinions with full text, then runs natural language processing to study how judicial language has shifted over the last five terms.

**🏛️ Brazilian tribunal monitoring.**

A São Paulo law firm sets the Brazil CNJ source to TJSP, adds a keyword for a specific statute, and pulls every matching case to track how local judges are interpreting the new law.

### Why choose this scraper

| | What you get |
|---|---|
| **One query, five systems** | Search across US, UK, international, and Brazilian courts in a single run without visiting each portal. |
| **Unified schema** | Every case, regardless of source, lands in the same flat structure for easy comparison and analysis. |
| **No logins or API keys** | Reads public court records directly, so you skip registration, OAuth, and rate-limit negotiations. |
| **Scalable collection** | Paid users can pull up to 1,000,000 records; free users get a 10-record preview to test their query. |

### How it compares

No other Store actor targets Global Court Records Aggregator the same way, so the honest comparison is with the alternatives teams actually weigh.

| | Global Court Records Aggregator Scraper | Build it in-house | By hand |
|---|---|---|---|
| Setup | Run it now, zero config | Days of engineering | None, but hours per pull |
| When Global Court Records Aggregator changes | Maintained for you | You fix it | You re-learn the page |
| Proxies, retries, anti-bot | Built in | Your problem | Browser only |
| Output | Fixed JSON schema, CSV/Excel export | Whatever you build | Copy-paste |
| Cost | Pay per result | Engineering time | Analyst hours |

### Configure the run

Drive the Actor from a keyword query and your choice of court systems, then refine with per-source filters like a US reporter slug, an ICJ list type, a Brazilian tribunal code, or SCOTUS terms. The Input tab lists every parameter.

A first run with the defaults:

```json
{
 "maxItems": 10,
 "sources": [
 "caselaw",
 "bailii",
 "icj",
 "brazil_cnj",
 "scotus"
 ]
}
```

A larger pull:

```json
{
 "maxItems": 200,
 "sources": [
 "caselaw",
 "bailii",
 "icj",
 "brazil_cnj",
 "scotus"
 ]
}
```

### 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 [Global Court Records Aggregator Scraper](https://apify.com/parseforge/global-court-records-aggregator-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 Global Court Records Aggregator 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/global-court-records-aggregator-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 keyword query is not too narrow. Try removing the query field to return all cases from your selected sources, then add a broader term. Also verify that your per-source filters, like a specific reporter slug, contain cases.

**The Actor returned fewer records than my maxItems setting.**

The Actor splits maxItems across selected sources. If you set 100 items and pick five sources, each source is capped at 20. If a source has fewer than 20 matching cases, the total will be lower. Increase maxItems or reduce the number of sources.

**Some records are missing the full opinion text.**

Not all court systems provide full text for every case. Brazil CNJ DataJud often returns summaries rather than complete opinions, and older cases in US Caselaw Access may have only metadata. This is a limitation of the source, not the Actor.

**I got an error about an invalid reporter slug.**

The US Caselaw reporter slug must match a valid slug from static.case.law. Common values include 'us', 'f3d', 'cal', and 'ny'. Check the case.law documentation for the full list of supported reporters.

**The run timed out.**

Large maxItems values across multiple sources can take time. Try reducing maxItems, selecting fewer court systems, or narrowing your keyword query. Paid Apify plans with higher memory and timeout limits handle larger runs better.

### FAQ

| Question | Answer |
|---|---|
| Which court systems does this Actor cover? | It queries US Caselaw Access (case.law), UK Find Case Law (National Archives), the International Court of Justice, Brazil's CNJ DataJud, and US Supreme Court Opinions. You can select any combination in the input. |
| Do I need API keys or login credentials? | No. The Actor reads publicly available court records directly from each source's open access points. You do not need to register an application or manage OAuth tokens. |
| How does the keyword filter work? | The query field accepts a single keyword or phrase. The Actor applies it as each case is read, so only records whose metadata or text contain the term reach your final dataset. |
| Can I limit results to a specific US court? | Yes. Use the 'US Caselaw reporter slug' field to restrict results to a particular reporter, such as 'us' for US Reports, 'f3d' for Federal Reporter 3d, or a state reporter like 'cal' or 'ny'. |
| What Brazilian courts are available? | You can choose from 13 tribunals via the Brazil tribunal code field, including state courts like TJSP and TJRJ, and superior courts like STJ, STF, and TST. |
| How are items distributed across selected sources? | The Actor divides your maxItems limit evenly among the court systems you select. If you pick two sources and set maxItems to 100, each source returns up to 50 records. |
| Does the Actor return the full text of opinions? | Yes, when the source provides it. US Caselaw Access, UK Find Case Law, SCOTUS, and ICJ typically include the full body text. Brazil CNJ DataJud may return summaries depending on the tribunal. |
| Can I filter ICJ cases by status? | Yes. The ICJ list type field lets you choose from all cases, pending cases, contentious cases, or advisory proceedings. |
| What SCOTUS terms can I query? | You specify two-digit October Terms in the SCOTUS terms field. The default covers the last five terms ('20' through '24'), and you can add or remove terms as needed. |
| Is there a free tier? | Free Apify users can run the Actor with a maxItems limit of 10, which is enough to preview results and test a query before scaling up on a paid plan. |

### 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 various court systems. 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

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

Optional keyword to filter cases across all sources (e.g. 'climate', 'contract', 'antitrust').

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

Free users: limited to 10 court records (preview). Paid users: optional, up to 1,000,000.

## `sources` (type: `array`):

Court systems to query in parallel.

## `caselawReporter` (type: `string`):

Reporter slug for static.case.law (e.g. 'us', 'cal', 'ny', 'f3d').

## `icjListType` (type: `string`):

Which ICJ case list to scrape.

## `brazilTribunal` (type: `string`):

Brazilian tribunal index to query via CNJ DataJud.

## `scotusTerms` (type: `array`):

Two-digit October Terms (e.g. \['24','23','22']).

## Actor input object example

```json
{
  "maxItems": 10,
  "sources": [
    "caselaw",
    "bailii",
    "icj",
    "brazil_cnj",
    "scotus"
  ],
  "caselawReporter": "us",
  "icjListType": "all",
  "brazilTribunal": "tjsp",
  "scotusTerms": [
    "24",
    "23",
    "22",
    "21",
    "20"
  ]
}
```

# Actor output Schema

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

Aggregated court records from 5+ jurisdictions

# 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,
    "sources": [
        "caselaw",
        "bailii",
        "icj",
        "brazil_cnj",
        "scotus"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/global-court-records-aggregator-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,
    "sources": [
        "caselaw",
        "bailii",
        "icj",
        "brazil_cnj",
        "scotus",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/global-court-records-aggregator-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,
  "sources": [
    "caselaw",
    "bailii",
    "icj",
    "brazil_cnj",
    "scotus"
  ]
}' |
apify call parseforge/global-court-records-aggregator-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,parseforge/global-court-records-aggregator-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/ikrkbeMvrkQNcxmfF/builds/WNWzRzQEaKreS8LQe/openapi.json