# UK Courts and Tribunals Scraper | Judgment Data (`parseforge/uk-courts-tribunals-scraper`) Actor

Extract UK court and tribunal judgments with case name, court, judges, neutral citation, date, and full text. Filter by court or year. Built for legal research, litigation tracking, case law analysis, and AI training datasets across UK jurisdictions.

- **URL**: https://apify.com/parseforge/uk-courts-tribunals-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Other, News
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN 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 a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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 Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## ⚖️ UK Courts and Tribunals Judgments Scraper

> 🚀 **Export UK court and tribunal judgments in seconds.** Pull structured records from The National Archives' Find Case Law service straight into CSV, Excel, JSON, or XML.

> 🕒 **Last updated:** 2026-05-25 · **📊 7 fields** per record · **70k+ judgments** · **all UK courts and tribunals on the official register**

The Find Case Law service at The National Archives is the official source for UK senior court judgments and tribunal decisions. This scraper reads the public Atom feed and turns each judgment into a structured record with title, URL, court, publication and update dates, and a direct link to the official Akoma Ntoso XML document.

Coverage includes the Supreme Court of the United Kingdom, Privy Council, Court of Appeal (Civil and Criminal Divisions), High Court (Chancery, KBD, Family), Court of Protection, Upper Tribunal, Employment Appeal Tribunal, First-tier Tribunals (Tax Chamber and others) and many more. You can filter by court slug, run a free-text query, and choose newest-first or relevance-sorted ordering.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Solicitors, barristers, paralegals, legaltech engineers, journalists, academics | Build case-law alert feeds, populate research databases, train UK legal NLP, monitor specific tribunals, prepare litigation dossiers |

### 📋 What the UK Courts and Tribunals Scraper does

- Pulls the latest judgments and tribunal decisions from Find Case Law
- Supports optional free-text query and court-slug filters
- Returns title, URL, court name, publication date, update date, and the official XML link
- Sorts by date (newest or oldest) or by relevance
- Exports clean tabular data to CSV, Excel, JSON, or XML

> 💡 **Why it matters:** UK case law products and academic studies need machine-readable judgments. This Actor delivers them in seconds with the official Akoma Ntoso XML link included.

### 🎬 Full Demo (_🚧 Coming soon_)

### ⚙️ Input

<table>
<tr><th>Field</th><th>Type</th><th>Required</th><th>Description</th></tr>
<tr><td>query</td><td>string</td><td>No</td><td>Free-text search query</td></tr>
<tr><td>court</td><td>string</td><td>No</td><td>Court slug filter (e.g. ewca/civ, ukut, eat)</td></tr>
<tr><td>order</td><td>select</td><td>No</td><td>Sort order. Default newest first.</td></tr>
<tr><td>maxItems</td><td>integer</td><td>No</td><td>Max records to return. Free plan capped at 10.</td></tr>
</table>

```json
{
    "order": "-date",
    "maxItems": 10
}
````

```json
{
    "query": "judicial review",
    "court": "ewhc/admin",
    "order": "-relevance",
    "maxItems": 50
}
```

> ⚠️ **Good to Know:** The Find Case Law register covers senior courts and tribunals only. Magistrates' Court and County Court decisions are not typically published there.

### 📊 Output

| Field | Type | Description |
|---|---|---|
| 📌 `title` | string | Judgment title |
| 🔗 `url` | string | Find Case Law judgment URL |
| 🏛️ `court` | string | Court or tribunal name |
| 📅 `publishedDate` | string | First publication date |
| 🔄 `updatedDate` | string | Last update timestamp |
| 📄 `documentXmlUrl` | string | Official Akoma Ntoso XML URL |
| 🕒 `scrapedAt` | string | Run timestamp |
| ❌ `error` | string | Null on success |

Sample record:

```json
{
    "title": "NHS Kent & Medway Integrated Care Board v OQD & Anor",
    "url": "https://caselaw.nationalarchives.gov.uk/ewcop/t3/2026/23",
    "court": "Court of Protection (Tier 3 - high court judges)",
    "publishedDate": "2026-05-22T00:00:00+00:00",
    "updatedDate": "2026-05-22T14:13:54+00:00",
    "documentXmlUrl": "https://caselaw.nationalarchives.gov.uk/ewcop/t3/2026/23/data.xml",
    "scrapedAt": "2026-05-25T17:46:02.873Z",
    "error": null
}
```

### ✨ Why choose this Actor

| 🔥 Reason | Why it matters |
|---|---|
| 🆓 No account or token required | Run immediately |
| 🏛️ Every senior UK court and tribunal | Supreme Court, Court of Appeal, High Court, UT, FtT |
| 📄 Akoma Ntoso XML links | Production-grade legal markup, ready for downstream tooling |
| ⚡ Atom-feed source | Stable structure, fast responses |
| 🔁 Schedule daily | Build alerts on a budget |

### 📈 How it compares to alternatives

| Approach | Setup | Cost | Output Quality |
|---|---|---|---|
| Find Case Law API direct | None, but no normalization | Free | Raw XML |
| Westlaw / LexisNexis | Heavy contracts | Expensive | Excellent |
| **This Actor** | **None** | **Pay-per-use** | **Clean tabular** |

### 🚀 How to use

1. [Create a free Apify account with $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp)
2. Open the UK Courts and Tribunals Scraper
3. Optionally set `query`, `court`, or `order`
4. Set `maxItems`
5. Click Start and download CSV / Excel / JSON / XML when finished

### 💼 Business use cases

#### Legaltech case alerting

Schedule daily runs on the courts your clients monitor. Push deltas to your platform.

#### Compliance and risk

Track tribunal decisions in regulated industries, including tax, employment, and immigration.

#### Academic research

Build training corpora for UK legal NLP using clean Akoma Ntoso documents.

#### Journalism

Surface fresh High Court rulings for newsroom coverage without manual checking.

### 🔌 Automating UK Courts and Tribunals Scraper

Pipe results into Make, Zapier, Slack, Airbyte, GitHub Actions, or Google Drive via Apify integrations.

### 🌟 Beyond business use cases

#### Research

Study sentencing trends, judicial reasoning, and tribunal outcomes over time.

#### Personal

Track judgments by a specific judge or chamber.

#### Non-profit

Power legal aid dashboards and rights-monitoring projects.

#### Experimentation

Train and benchmark UK legal LLMs against the official corpus.

### 🤖 Ask an AI assistant about this scraper

Open this Actor's page in [ChatGPT](https://chat.openai.com/), [Claude](https://claude.ai/), [Perplexity](https://www.perplexity.ai/), or [Copilot](https://copilot.microsoft.com/) and ask for help wiring it into your workflow.

### ❓ Frequently Asked Questions

**Q: Do I need an account?** A: No. The Atom feed is fully public.

**Q: Which courts are covered?** A: Supreme Court, Privy Council, Court of Appeal, High Court, Court of Protection, Upper Tribunal, Employment Appeal Tribunal, First-tier Tribunals, and more.

**Q: How fresh is the data?** A: Mirrors the official register, typically same-day.

**Q: Do I get full judgment text?** A: The record includes the official XML URL. Fetch that URL for the full document.

**Q: Can I filter by court?** A: Yes. Use the `court` slug parameter.

**Q: How do I search by keywords?** A: Use the `query` parameter.

**Q: Can I export to Excel?** A: Yes. Apify exports CSV, Excel, JSON, XML.

**Q: How do I schedule daily?** A: Use Apify Schedules.

**Q: Is this affiliated with The National Archives?** A: No. It is independent.

**Q: Will it break if the feed changes?** A: We monitor and update.

### 🔌 Integrate with any app

Apify supports Make, Zapier, n8n, Slack, Airbyte, GitHub Actions, Google Sheets, Google Drive, AWS, Azure, BigQuery, Snowflake, and any webhook-aware tool.

### 🔗 Recommended Actors

| Actor | What it does |
|---|---|
| [CourtListener Opinions](https://apify.com/parseforge/court-listener-opinions-scraper) | Free US federal court opinions |
| [USPTO Patent Assignments](https://apify.com/parseforge/uspto-patent-assignments-scraper) | US patent assignment records |
| [WIPO Brand Database](https://apify.com/parseforge/wipo-brand-database-scraper) | Global trademark search |
| [FINRA BrokerCheck](https://apify.com/parseforge/finra-brokercheck-scraper) | US securities-broker disclosures |

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge).

**🆘 Need Help?** [Open our contact form](https://tally.so/r/BzdKgA)

> **⚠️ Disclaimer:** This is an independent tool not affiliated with The National Archives or any UK court. Only publicly available data published on Find Case Law is collected.

# Actor input Schema

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

Optional free-text query passed to Find Case Law. Leave empty for latest decisions across all courts.

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

Optional court filter slug, e.g. ewca/civ, ewhc/ch, ukut, eat, ewcop. Leave empty for all courts.

## `order` (type: `string`):

Sort order for results.

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

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

## Actor input object example

```json
{
  "order": "-date",
  "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 = {
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/uk-courts-tribunals-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/uk-courts-tribunals-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).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/uk-courts-tribunals-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=parseforge/uk-courts-tribunals-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "UK Courts and Tribunals Scraper | Judgment Data",
        "description": "Extract UK court and tribunal judgments with case name, court, judges, neutral citation, date, and full text. Filter by court or year. Built for legal research, litigation tracking, case law analysis, and AI training datasets across UK jurisdictions.",
        "version": "0.1",
        "x-build-id": "qi2dculvJyKQclNNZ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~uk-courts-tribunals-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-uk-courts-tribunals-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/parseforge~uk-courts-tribunals-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-uk-courts-tribunals-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/parseforge~uk-courts-tribunals-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-uk-courts-tribunals-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "query": {
                        "title": "Search Query (optional)",
                        "type": "string",
                        "description": "Optional free-text query passed to Find Case Law. Leave empty for latest decisions across all courts."
                    },
                    "court": {
                        "title": "Court / Tribunal Slug (optional)",
                        "type": "string",
                        "description": "Optional court filter slug, e.g. ewca/civ, ewhc/ch, ukut, eat, ewcop. Leave empty for all courts."
                    },
                    "order": {
                        "title": "Sort Order",
                        "enum": [
                            "-date",
                            "date",
                            "-relevance",
                            "relevance"
                        ],
                        "type": "string",
                        "description": "Sort order for results.",
                        "default": "-date"
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
