# ICJ Judgments and Advisory Opinions PDF Scraper (`jungle_synthesizer/icj-international-court-judgments-pdf-scraper`) Actor

Scrape every ICJ judgment, advisory opinion, order, and separate / dissenting opinion. Returns paragraph-numbered text (matches international-law citation style), the operative paragraph (dispositif), and document metadata, across all contentious and advisory cases since 1946, in English and French.

- **URL**: https://apify.com/jungle_synthesizer/icj-international-court-judgments-pdf-scraper.md
- **Developed by:** [BowTiedRaccoon](https://apify.com/jungle_synthesizer) (community)
- **Categories:** Business, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $8.00 / 1,000 record scrapeds

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

## ICJ Case Law, Judgment & Advisory Opinion Scraper

Scrape case law from the [International Court of Justice](https://www.icj-cij.org), the United Nations' principal judicial organ. Returns judgments, advisory opinions, orders, and separate / dissenting opinions as paragraph-numbered records — the citation format international lawyers actually use — across contentious and advisory cases dating back to 1946, in English and French.

***

### ICJ Scraper Features

- Extracts every judgment, advisory opinion, order, declaration, separate opinion, dissenting opinion, and written pleading the Court has published for a case.
- Returns paragraph-numbered text, matching how international-law practitioners cite ICJ decisions ("para. 142").
- Captures the operative paragraph — the "FOR THESE REASONS, THE COURT..." dispositif — as its own field, separate from the reasoning.
- Pulls a best-effort judge vote tabulation out of the dispositif when the Court records a roll call, with each judge's role (President, Vice-President, member, ad hoc) and vote.
- Parses applicant and respondent states straight out of the case title for contentious cases.
- Cross-references which judges filed a separate or dissenting opinion on a given judgment.
- Covers both English and French editions. A document published in only one combined bilingual edition still comes back, tagged accordingly.
- Three ways to scope a run: every case, a specific case number, or everything published since a given date.

***

### Who Uses ICJ Case Data?

- **International law firms** — track jurisprudence on treaty interpretation, state responsibility, and sovereignty disputes without re-reading the docket by hand.
- **Foreign-ministry legal teams** — monitor a case your state is a party to, or benchmark how the Court has ruled on a comparable dispute.
- **Academics and researchers** — build a citation-accurate corpus for scholarship, without re-typing paragraph numbers out of a PDF.
- **Geopolitical risk analysts** — follow high-profile proceedings (genocide-convention cases, maritime and territorial disputes) as new orders and judgments land.
- **Journalists** — get the dispositif the moment it's published, in the Court's own numbered-paragraph form, instead of paraphrasing a press release.

***

### How the ICJ Scraper Works

1. Pick a scope — every case, one or more case numbers, or everything published since a date.
2. The scraper walks the Court's case index and pulls every document on each matching case page.
3. Each document is returned as paragraph-numbered text with its own dispositif, document type, and case metadata attached — no separate lookup needed to know which case or party a document belongs to.

***

### Input

```json
{
  "mode": "since_date",
  "sinceDate": "2024-01-01",
  "documentTypes": ["judgment", "advisory_opinion", "order"],
  "languages": ["en"],
  "maxItems": 100
}
```

| Field           | Type    | Default                                                                 | Description |
|-----------------|---------|-------------------------------------------------------------------------|-------------|
| `mode`          | string  | `since_date`                                                            | `all_cases` walks every case; `case_ids` visits only the case numbers you list; `since_date` walks every case but keeps only documents on or after `sinceDate`. |
| `caseIds`       | array   | `[]`                                                                    | ICJ case numbers to scan (e.g. `192` for the South Africa v. Israel genocide-convention case). Used only in `case_ids` mode. |
| `sinceDate`     | string  | `2023-01-01`                                                            | ISO date. Only documents on or after this date are returned. Used only in `since_date` mode. |
| `documentTypes` | array   | judgment, advisory opinion, order, separate opinion, dissenting opinion | Which document types to include. Also accepts declaration, written pleading, and oral proceeding (verbatim record). Leave empty for every type. |
| `languages`     | array   | `["en"]`                                                                | Which language edition of each document to return — `en`, `fr`, or both. |
| `maxItems`      | integer | `10`                                                                    | Maximum number of document records to return. |

Example — pull every document for one case:

```json
{
  "mode": "case_ids",
  "caseIds": ["192"],
  "documentTypes": [],
  "languages": ["en", "fr"],
  "maxItems": 50
}
```

***

### ICJ Scraper Output Fields

```json
{
  "case_id": 192,
  "case_name": "Application of the Convention on the Prevention and Punishment of the Crime of Genocide in the Gaza Strip (South Africa v. Israel)",
  "case_type": "contentious",
  "applicant_state": "South Africa",
  "respondent_state": "Israel",
  "filing_date": "2023-12-29",
  "status": "pending",
  "document_type": "order",
  "document_date": "2026-05-21",
  "document_language": "en",
  "document_phase": "provisional_measures",
  "judges": ["President Salam (president) — with", "Tomka (member) — with"],
  "separate_opinion_authors": [],
  "dissenting_opinion_authors": [],
  "document_url": "https://www.icj-cij.org/sites/default/files/case-related/192/192-20260521-ord-01-00-en.pdf",
  "document_paragraphs": ["1. The Court begins its reasoning here.", "2. The Court continues..."],
  "operative_paragraph_text": "For these reasons, The Court, (1) Unanimously, Finds that it has jurisdiction..."
}
```

| Field                        | Type    | Description |
|------------------------------|---------|--------------|
| `case_id`                    | integer | ICJ case number. |
| `case_name`                  | string  | Full case name. |
| `case_type`                  | string  | `contentious` or `advisory`. |
| `applicant_state`            | string  | Parsed from the case title. Null for advisory opinions and joint-application cases. |
| `respondent_state`           | string  | Parsed from the case title. |
| `filing_date`                | string  | Date the case was introduced (ISO date). Null when the Court's own case index hasn't recorded one yet. |
| `status`                     | string  | `pending` or `concluded`. |
| `document_type`              | string  | judgment, advisory_opinion, order, declaration, separate_opinion, dissenting_opinion, written_pleading, or oral_proceeding. |
| `document_date`              | string  | Date the document was issued (ISO date). |
| `document_language`          | string  | `en`, `fr`, or `bi` (bilingual edition, used when no separate-language file exists). |
| `document_phase`             | string  | Procedural phase tag when the Court publishes one (provisional measures, preliminary objections, intervention). Null otherwise. |
| `judges`                     | array   | Judge vote tabulation, one entry per recorded vote. Populated when the dispositif includes a roll call — orders and shorter rulings often don't carry one. |
| `separate_opinion_authors`   | array   | Judges who filed a separate opinion attached to this document. |
| `dissenting_opinion_authors` | array   | Judges who filed a dissenting opinion attached to this document. |
| `document_url`               | string  | Direct PDF URL on icj-cij.org. |
| `document_paragraphs`        | array   | Numbered paragraphs as `"N. text"` strings, matching international-law citation style. |
| `operative_paragraph_text`   | string  | The dispositif. Null for documents that don't carry one, like press releases or verbatim records. |

***

### FAQ

#### How do I scrape ICJ judgments?

Run this actor with `mode: "case_ids"` and the case number, or `mode: "since_date"` to pull everything published after a given date. No account or API key is needed — the Court publishes its decisions openly.

#### What data can I get from ICJ case law?

Judgments, advisory opinions, orders, and separate or dissenting opinions, returned with paragraph numbering, the operative dispositif, case metadata, and a best-effort judge vote tabulation where the Court recorded one.

#### Can I filter by document type or language?

Yes. `documentTypes` narrows a run to just judgments, just orders, or any combination; `languages` picks English, French, or both.

#### Do I need an account or API key for icj-cij.org?

No. The Court's case documents are public. You configure the scope you want and run the actor.

#### Does this cover advisory opinions, or only contentious cases?

Both. `case_type` tells you which one you're looking at, and advisory opinions get their own `document_type` rather than being lumped in with judgments.

***

### Need More Features?

Need a different filter, an additional field, or a related court's case law? [File an issue](https://console.apify.com/actors/issues) or get in touch.

### Why Use This ICJ Scraper?

- **Citation-accurate** — paragraph numbering preserved exactly as the Court publishes it, so you can cite a finding the way a brief would.
- **Dispositif as its own field** — the operative paragraph is separated from the reasoning that precedes it, which saves you from parsing a 300-page PDF to find the one paragraph that actually decided the case.
- **Bilingual by design** — English and French editions are both addressable, which matters for a Court that publishes authoritative text in both languages.

# Actor input Schema

## `sp_intended_usage` (type: `string`):

What will this data feed? E.g. lead lists, KYB checks, price tracking.

## `sp_improvement_suggestions` (type: `string`):

Provide any feedback or suggestions for improvements.

## `sp_contact` (type: `string`):

We'll personally help with your use case. No spam.

## `mode` (type: `string`):

How to pick which cases to scan. 'since_date' and 'all_cases' walk the full case index; 'case_ids' visits only the case numbers you list.

## `caseIds` (type: `array`):

ICJ case numbers to scan (e.g. 192 for South Africa v. Israel). Only used when mode is 'Specific Case IDs'.

## `sinceDate` (type: `string`):

Only documents dated on or after this date (ISO format). Only used when mode is 'Documents Since Date'.

## `documentTypes` (type: `array`):

Which document types to include. Leave empty for all types.

## `languages` (type: `array`):

Which language version of each document to save. ICJ documents are bilingual EN/FR; a document with no separate-language file falls back to its bilingual edition.

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

Maximum number of document records to return.

## Actor input object example

```json
{
  "sp_contact": "Share your email here...",
  "mode": "since_date",
  "caseIds": [],
  "sinceDate": "2023-01-01",
  "documentTypes": [
    "judgment",
    "advisory_opinion",
    "order",
    "separate_opinion",
    "dissenting_opinion"
  ],
  "languages": [
    "en"
  ],
  "maxItems": 10
}
```

# Actor output Schema

## `results` (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 = {
    "sp_contact": "Share your email here...",
    "mode": "since_date",
    "caseIds": [],
    "sinceDate": "2023-01-01",
    "documentTypes": [
        "judgment",
        "advisory_opinion",
        "order",
        "separate_opinion",
        "dissenting_opinion"
    ],
    "languages": [
        "en"
    ],
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("jungle_synthesizer/icj-international-court-judgments-pdf-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 = {
    "sp_contact": "Share your email here...",
    "mode": "since_date",
    "caseIds": [],
    "sinceDate": "2023-01-01",
    "documentTypes": [
        "judgment",
        "advisory_opinion",
        "order",
        "separate_opinion",
        "dissenting_opinion",
    ],
    "languages": ["en"],
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("jungle_synthesizer/icj-international-court-judgments-pdf-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 '{
  "sp_contact": "Share your email here...",
  "mode": "since_date",
  "caseIds": [],
  "sinceDate": "2023-01-01",
  "documentTypes": [
    "judgment",
    "advisory_opinion",
    "order",
    "separate_opinion",
    "dissenting_opinion"
  ],
  "languages": [
    "en"
  ],
  "maxItems": 10
}' |
apify call jungle_synthesizer/icj-international-court-judgments-pdf-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,jungle_synthesizer/icj-international-court-judgments-pdf-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/dFHz8hmabMBphcXaP/builds/pSVdEloUM1EWLQPBT/openapi.json