# UK Case Law Search and Monitor (`wildorigins/uk-case-law-search-monitor`) Actor

🏷️ From $0.60 / 1K | Search and monitor UK court judgments from Find Case Law. Filter by court, party, judge and date, and export full citations, neutral citations and judgment links.

- **URL**: https://apify.com/wildorigins/uk-case-law-search-monitor.md
- **Developed by:** [Wild Origins](https://apify.com/wildorigins) (community)
- **Categories:** News, Automation
- **Stats:** 4 total users, 0 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.60 / 1,000 judgments

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

## UK Case Law Search and Monitor

Search and monitor UK court judgments and tribunal decisions from [the National Archives Find Case Law service](https://caselaw.nationalarchives.gov.uk/): case name, neutral citation, court, judge, dates, links and optional full text. No account needed.

### 🏛️ Find Case Law has an official API. What does this Actor add?

The official route is good. [Find Case Law](https://caselaw.nationalarchives.gov.uk/) has a search site and a [documented public API](https://nationalarchives.github.io/ds-find-caselaw-docs/public) that needs no key and no account. What the API returns is Atom feeds for search results and LegalDocML XML for each judgment, capped at 50 results per page, with no CSV export. To get a usable table out of it you parse XML, walk the pagination, join the document metadata to the identifiers, and stay inside the service's limit of 1,000 requests per rolling five minutes.

This Actor does that work in one call: flat rows with the citation, court, dates and links already extracted, full judgment text lifted out of the XML when you ask for it, a content hash per judgment so amendments show up as data, and the rate limit respected with built-in throttling. Run it on a schedule and pipe the rows to a spreadsheet, a webhook or a database without writing a parser.

### 🔍 What does UK Case Law Search and Monitor do?

It runs a search against Find Case Law and returns every judgment it finds as a clean row of data, ready for a spreadsheet, a database or your own product.

- Searches across all UK courts and tribunals: Supreme Court, Court of Appeal, High Court (all divisions), Upper Tribunals, Employment Appeal Tribunal, First-tier Tribunals
- Returns structured metadata: case name, neutral citation, date, court, party names, links to HTML, PDF and XML versions
- Optionally fetches the full text of each judgment for document analysis, AI processing, or legal research
- Supports change monitoring via content hashes, run on a schedule to detect when judgments are updated or new ones published
- Paginates automatically through large result sets

Data is licensed under the [Open Justice Licence](https://caselaw.nationalarchives.gov.uk/open-justice-licence), and commercial use is permitted.

### 📊 What data can I extract from Find Case Law?

One row per judgment:

| | Field | Description |
|---|---|---|
| 🏷️ | `title` | Case name, for example "Smith v Jones" |
| 🔢 | `neutralCitation` | Official citation, for example "\[2024] EWCA Civ 123" |
| 🔢 | `fclIdentifier` | Find Case Law internal ID |
| 🔢 | `documentUri` | Stable machine-readable URI for the judgment document |
| 📅 | `dateHandedDown` | Date judgment was handed down (YYYY-MM-DD) |
| 📅 | `dateUpdated` | Date last updated in the Find Case Law system |
| ⚖️ | `court` | Court or tribunal name |
| 🔐 | `contentHash` | Hash of judgment text, for change detection |
| 🔗 | `urlHtml` | Link to the human-readable judgment page |
| 🔗 | `urlXml` | Link to structured LegalDocML XML |
| 🔗 | `urlPdf` | Link to the PDF version |
| 🔢 | `identifiers` | All identifiers, neutral citation plus FCL ID, each with its URL |
| 📄 | `fullText` | Full judgment text, only when "Include full text" is enabled |
| ✅ | `fullTextRequested` | Whether the run asked for full judgment text |
| ✅ | `fullTextFetched` | Whether the full text was actually retrieved, so a failed fetch is visible |

### 💡 Why scrape UK case law?

**Practice area monitoring.** An employment solicitor watching for new Employment Appeal Tribunal judgments on unfair dismissal, running the same search every Monday and reading only what changed.

**Case tracking.** A litigant or journalist waiting for a specific judgment to be handed down, searching by party name daily instead of refreshing the site.

**Regulatory tracking.** A tax adviser following Upper Tribunal (Tax and Chancery) decisions on a scheme their clients used, filtered by court and date range.

**Judicial review watching.** A public affairs team pulling every new Administrative Court judgment that names their department or sector.

**Academic research.** A law researcher building a dataset of every Court of Appeal (Civil) judgment in a year, with citations and dates in columns rather than in PDFs. Note that computational analysis of judgment text needs a separate licence from the National Archives, covered in the FAQ below.

**Amendment detection.** A knowledge team using the `contentHash` field to spot when a judgment they have already cited is quietly amended.

### 🚀 How do I use UK Case Law Search and Monitor?

1. Click **Try for free**.
2. Enter a keyword in `query`, wrapping phrases in double quotes for an exact match.
3. Narrow it with `court`, `party`, `judge` or a `dateFrom` and `dateTo` range.
4. Set `maxResults` to cap the run, and turn on `includeFullText` if you need the judgment text.
5. Click **Start**, then download the results as JSON, CSV or Excel, or pull them from the API.

### ⬇️ Input

```json
{
  "query": "\"unfair dismissal\"",
  "court": "eat",
  "dateFrom": "2024-01-01",
  "maxResults": 50
}
```

| Field | Type | Default | What it does |
|---|---|---|---|
| `query` | string | | Full-text keyword search, wrap phrases in double quotes for exact match |
| `court` | string | all courts | Court code to filter by, see the table below |
| `party` | string | | Filter by party name, partial names work |
| `judge` | string | | Filter by judge name, partial names work |
| `dateFrom` | string | | Only judgments handed down on or after this date (YYYY-MM-DD) |
| `dateTo` | string | | Only judgments handed down on or before this date (YYYY-MM-DD) |
| `maxResults` | integer | `50` | Maximum number of judgments to return, up to 500 |
| `includeFullText` | boolean | `false` | Fetch the full judgment text for each result, slower |
| `orderBy` | string | `-date` | Sort order: `-date` newest first, `date` oldest first, `-updated` or `updated` by last amendment |

### ⬆️ Output

#### Table view

Results arrive as a Judgments table you can sort and filter in the Console, with the case name, citation, court and dates lined up for scanning.

#### JSON

A typical row:

```json
{
  "title": "MUF, R (on the application of) v The Secretary of State for Defence",
  "court": "High Court (Administrative Court)",
  "neutralCitation": "[2026] EWHC 2108 (Admin)",
  "dateHandedDown": "2026-08-07",
  "dateUpdated": "2026-08-07",
  "fclIdentifier": "xhxv8gx6",
  "documentUri": "d-6a6be1b5-9d65-4629-a11b-b03c021f47cd",
  "contentHash": "b67c28468dfb86b159c7ed69e2b92236a50cf882b0803b1cc691319ead8f10d4",
  "urlHtml": "https://caselaw.nationalarchives.gov.uk/ewhc/admin/2026/2108",
  "urlXml": "https://caselaw.nationalarchives.gov.uk/ewhc/admin/2026/2108/data.xml",
  "urlPdf": "https://assets.caselaw.nationalarchives.gov.uk/d-6a6be1b5-9d65-4629-a11b-b03c021f47cd/d-6a6be1b5-9d65-4629-a11b-b03c021f47cd.pdf",
  "fullText": null
}
```

Download it from the run as JSON, CSV or Excel, or read it straight from the API.

### Courts available

| Code | Court |
|---|---|
| `uksc` | UK Supreme Court |
| `ukpc` | Privy Council |
| `ewca/civ` | Court of Appeal (Civil) |
| `ewca/crim` | Court of Appeal (Criminal) |
| `ewhc/kb` | High Court (King's Bench) |
| `ewhc/ch` | High Court (Chancery) |
| `ewhc/fam` | High Court (Family) |
| `ewhc/comm` | High Court (Commercial) |
| `ewhc/pat` | High Court (Patents) |
| `ewhc/tcc` | High Court (Technology and Construction) |
| `ewhc/admin` | High Court (Administrative) |
| `eat` | Employment Appeal Tribunal |
| `ukut/iac` | Upper Tribunal (Immigration and Asylum) |
| `ukut/tax` | Upper Tribunal (Tax and Chancery) |
| `ukut/lc` | Upper Tribunal (Lands Chamber) |
| `ukftt/tc` | First-tier Tribunal (Tax) |
| `ukftt/grc` | First-tier Tribunal (General Regulatory) |

### Scheduling and monitoring

This actor works well on a schedule. To monitor for new judgments in a specific area:

1. Set a keyword query, for example `"unfair dismissal"`, and a court, for example `eat`
2. Set `orderBy` to `Newest first`
3. Set `maxResults` to 10 to 20
4. Schedule it to run daily or weekly via Apify's scheduler

Use the `contentHash` field to detect when existing judgments are amended.

### Rate limits and performance

The National Archives API allows up to 1,000 requests per rolling 5-minute window per IP. This actor automatically respects this limit with built-in throttling and exponential backoff on errors.

Typical run times:

- 50 results, metadata only: around 30 seconds
- 50 results, with full text: 3 to 5 minutes
- 500 results, metadata only: around 5 minutes

### ⏱️ How long does a run take?

Measured on real runs, so you know what normal looks like and can tell it apart from a run that has stalled.

| Judgments returned | Typical run time |
|---|---|
| 5 | 2 to 3 seconds |
| 50 | 5 to 10 seconds |
| 200 | about 30 seconds |

Two things make a run take longer than the table. **Full judgment text** is a separate document fetch per judgment, so 25 judgments with `includeFullText` on took about 27 seconds, roughly what 200 judgments take without it. And the Find Case Law service allows 1,000 requests per rolling five minutes, which this Actor throttles itself to stay inside, so a large run paces itself rather than being refused. The first few seconds of any run are the container starting rather than the work.

A run is never silently stuck. Progress is logged as each page of results is read, and judgments are written to the dataset as they are parsed rather than held back to the end, so a run that hits its time limit still leaves everything it had already collected. A search that matches nothing ends successfully with an empty dataset and the reason in its status message.

**Set the run timeout to suit the size of the ask.** This Actor's default is 3600 seconds, which is comfortably more than the largest run in the table above (500 judgments takes about 4 minutes). You are charged per delivered result rather than per minute, so a generous timeout costs you nothing and a tight one risks losing the run's work. Lower it only if you want a hard ceiling on how long a scheduled run may sit.

### 💰 How much does it cost?

**$0.001 per judgment returned**, plus the standard **$0.00005** Apify charges once when a run starts. There is no monthly rental, so you pay only for what a run actually returns.

So a search that returns **50 judgments** costs **$0.05005**. A scheduled monitoring run that picks up 8 new judgments since it last ran costs **$0.00805**, and a deep pull of 500 judgments costs **$0.50005**. A run that finds nothing new costs $0.00005.

Paid Apify plans pay less per judgment: **$0.00085** on Bronze, **$0.0007** on Silver, **$0.0006** on Gold, **$0.0005** on Platinum and **$0.0004** on Diamond, which is 40 percent of the list price. That same 500 judgment pull is **$0.20005** on Diamond.

Set `maxResults` to cap what a run can cost before it starts. Turning on `includeFullText` makes a run slower but does not change the charge, since you are still charged once per judgment. The Apify listing always shows the current rates.

### 🔌 Integrations

Send results straight to Google Sheets, Slack, Airtable, Zapier, Make or your own webhook using [Apify integrations](https://docs.apify.com/platform/integrations). You can also trigger a run whenever something happens in another tool.

AI agents can call this Actor directly through the [Apify MCP server](https://mcp.apify.com). An agent connected to mcp.apify.com can discover `spookyweb/uk-case-law-search-monitor`, pass it a query, court and date range as tool arguments, and read the judgment rows back as structured results. That makes it usable from Claude, custom agents or any MCP client without writing API glue.

### 🔗 Using UK Case Law Search and Monitor with the Apify API

```bash
curl -X POST "https://api.apify.com/v2/acts/spookyweb~uk-case-law-search-monitor/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"query": "\"unfair dismissal\"", "court": "eat", "dateFrom": "2024-01-01", "maxResults": 50}'
```

Or with the Apify client:

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'YOUR_TOKEN' });
const run = await client.actor('spookyweb/uk-case-law-search-monitor').call({
  query: '"unfair dismissal"',
  court: 'eat',
  dateFrom: '2024-01-01',
  maxResults: 50,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

Full detail is in the [Apify API reference](https://docs.apify.com/api/v2), and every run is also callable from the [Python](https://docs.apify.com/api/client/python) and [JavaScript](https://docs.apify.com/api/client/js) clients.

### ❓ FAQ

#### Is there an official Find Case Law API?

Yes. Find Case Law publishes an API, but it answers in Akoma Ntoso LegalDocML, an XML format you have to parse and flatten before it is any use. This Actor talks to that API for you and hands back flat rows with the citation, court, dates and links already extracted.

#### How far back does coverage go?

Coverage is exactly whatever Find Case Law publishes. It holds the modern judgment record for the courts and tribunals listed above, and the National Archives keeps adding older material. If a judgment is on Find Case Law this Actor will find it. Use `dateFrom` and `dateTo` to bound a search.

#### Can I monitor for new judgments on a topic?

Yes, that is what the scheduling section above is for. Set a query and a court, sort newest first, keep `maxResults` low and schedule it daily. The `contentHash` field also tells you when a judgment you already have has been amended.

#### What is a neutral citation?

It is the court's own citation for a judgment, independent of any law report, for example `[2024] EWCA Civ 123`. It identifies the court, the year and the judgment number, and it is the reliable key for joining this data to anything else.

#### Can I get the full text of a judgment?

Yes, set `includeFullText` to true and the `fullText` field is populated for every result. It is slower because each judgment is fetched individually, so leave it off when you only need metadata.

#### Can I use the data commercially?

Yes, with one carve-out. Find Case Law data is published under the [Open Justice Licence](https://caselaw.nationalarchives.gov.uk/open-justice-licence), which permits copying, sharing and commercial use, including building the data into your own product, subject to attribution. What the licence does not cover is computational analysis of the judgment text, such as data mining or search indexing, which needs a separate licence from the National Archives. Attribution statement: *Contains information licensed under the Open Justice Licence.*

### ⚖️ Is it legal to scrape UK case law?

Judgments are public documents published by the National Archives Find Case Law service. Open justice means court judgments are published deliberately for anyone to read. This reads only that public service, and it never logs in.

Judgments name parties because the court published them that way, so treat any onward use of names under GDPR as your responsibility. Apify's [ethical scraping guide](https://blog.apify.com/is-web-scraping-legal/) covers the wider picture.

### 👍 Your feedback

Found a bug, or want a field that is not here yet? Open an issue on the Actor's Issues tab. Requests that make the data more useful get built, and problems get fixed quickly.

### 🔎 You might also like

| Actor | What it does |
|---|---|
| [UK Employment Tribunal Decisions](https://apify.com/spookyweb/uk-employment-tribunal-decisions) | Employment tribunal decisions from GOV.UK, searchable by employer, claim type and date |
| [UK Financial Ombudsman Decisions](https://apify.com/spookyweb/uk-fos-decisions) | Final FOS decisions filterable by business, sector and outcome, with PDF links |
| [UK FCA Enforcement Notices](https://apify.com/spookyweb/uk-fca-enforcement-notices) | FCA final, decision and warning notices with firm names and penalty amounts |

# Actor input Schema

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

Full-text search across all judgments. Wrap phrases in double quotes for exact match, e.g. "unfair dismissal"

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

Filter by specific court. Leave blank to search all courts.

## `party` (type: `string`):

Search for a specific party (claimant, defendant, appellant etc). Partial names work.

## `judge` (type: `string`):

Filter by judge name. Partial names work, e.g. 'Warby' or 'Lady Rose'.

## `dateFrom` (type: `string`):

Only return judgments handed down on or after this date.

## `dateTo` (type: `string`):

Only return judgments handed down on or before this date.

## `maxResults` (type: `integer`):

Maximum number of judgments to return. Default 50, max 500.

## `includeFullText` (type: `boolean`):

If enabled, fetches and includes the full text of each judgment. Significantly slower and uses more compute. Recommended only for small result sets.

## `orderBy` (type: `string`):

Sort order for the judgments returned. A leading minus reverses it, so -date is newest first and date is oldest first. Use updated to sort by when the record was last amended rather than when judgment was given.

## Actor input object example

```json
{
  "query": "\"breach of contract\" damages",
  "court": "",
  "party": "Smith",
  "judge": "Warby",
  "dateFrom": "2024-01-01",
  "dateTo": "2024-12-31",
  "maxResults": 50,
  "includeFullText": false,
  "orderBy": "-date"
}
```

# Actor output Schema

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

One row per item: court judgments matching the search.

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("wildorigins/uk-case-law-search-monitor").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("wildorigins/uk-case-law-search-monitor").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 '{}' |
apify call wildorigins/uk-case-law-search-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,wildorigins/uk-case-law-search-monitor"
        }
    }
}
```

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/6lC4l96oLTKSJPyH8/builds/fTpV6qnQ46zwQBTY7/openapi.json