# UK Court Listings (`spookyweb/uk-court-listings`) Actor

Daily hearing lists from the HMCTS Court and Tribunal Hearings service. Case number, party, hearing type, time, courtroom and judge for Crown, magistrates, civil, family, tribunal and Insolvency and Companies Court lists.

- **URL**: https://apify.com/spookyweb/uk-court-listings.md
- **Developed by:** [丂卩ㄖㄖҜㄚ](https://apify.com/spookyweb) (community)
- **Categories:** Business, News
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.60 / 1,000 hearings

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

## UK Court Listings

### 🔍 What does UK Court Listings do?

**UK Court Listings** reads the daily hearing lists published by HMCTS on the
[Court and Tribunal Hearings service](https://www.court-tribunal-hearings.service.gov.uk)
and returns them as structured rows: **what is being heard, where, when, and before which judge**.
It covers around **365 courts and tribunals** in England and Wales, including Crown courts,
magistrates courts, civil and family courts, Social Security and Child Support tribunals, and the
Business and Property Courts at the Rolls Building, where the **Insolvency and Companies Court**
publishes its daily cause list.

The easiest way to try it is to press **Start** with the fields as they come. That reads the Rolls
Building plus three large regional courts and returns a few hundred hearings listed for the next
sitting day. To follow something specific, put a company name in **Party name contains** or a case
prefix in **Case number contains**.

The Actor needs **no proxy**. The pages it reads
are published openly by HMCTS.

### 📊 What data can I extract?

One row per listed hearing. Every field below is emitted on every row, and is `null` where the
court did not publish that column for that list.

| Field | Type | Description |
|---|---|---|
| `courtName` | string | Court or tribunal the list belongs to, as named in the service A to Z |
| `locationId` | number | HMCTS numeric location id of the court |
| `listType` | string | Title of the published list this hearing appeared on |
| `listTypeSlug` | string | Service identifier for the kind of list, for example `crown-daily-list` |
| `listDate` | string | Day the hearings are listed for, as `YYYY-MM-DD` |
| `listLastUpdated` | string | When the court last amended this list, as printed on the page |
| `venueSection` | string | Building or venue heading the hearing was listed under |
| `courtRoom` | string | Courtroom the hearing is listed in |
| `judge` | string | Judge listed to hear the case, from the row or the section heading |
| `hearingTime` | string | Listed start time, in the wording the court published |
| `hearingType` | string | Kind of hearing, such as a companies application or a trial |
| `caseType` | string | Case category, published by the civil and family lists |
| `caseNumber` | string | Case reference, URN or appeal reference as published |
| `caseName` | string | Case name or the party named in the list, as published |
| `applicant` | string | Applicant or petitioner, where the list has its own column |
| `respondent` | string | Respondent, where the list has its own column |
| `prosecutingAuthority` | string | Prosecuting authority on a Crown or magistrates list |
| `tribunal` | string | Tribunal panel or judge, published by the tribunal lists |
| `venue` | string | Where the hearing takes place, including remote and non-attendance |
| `duration` | string | Listed duration, published by the civil and family lists |
| `additionalInformation` | string | Listing notes the court added against this hearing |
| `fields` | object | Every column of the source row, keyed by the heading the court used |
| `listUrl` | string | Page on the hearings service this row was read from |
| `retrievedAt` | string | When this row was collected, ISO 8601 |

Different list types use different column names for the same thing. A Crown court writes
`Case Reference`, a magistrates list writes `URN`, a tribunal writes `Appeal reference number`.
UK Court Listings maps all of them onto `caseNumber` so one query works across every court, and
keeps the original headings in `fields` so nothing published is lost.

### 💡 Why monitor court hearing lists?

- **Winding up and insolvency.** The Insolvency and Companies Court publishes its daily cause list
  at the Rolls Building. Filter `listTypes` to `insolvency` and you get the companies applications,
  petitions and interim hearings listed for that day, with case numbers and company names.
- **Litigation tracking.** Put a case number prefix in `caseNumberContains` and the same case
  reappears in the dataset every time it is relisted, with the new date, room and judge.
- **Counterparty watch.** Put a company name in `partyContains` and the run returns any hearing on
  that day naming it, across every court you selected, whether the company is applicant, respondent
  or the case name.
- **Court reporting.** Journalists covering a specific court get the whole day's list in one call,
  with courtroom and judge, rather than clicking through a court at a time.
- **Judicial listings.** `judgeContains` follows one judge's list across courts and days.
- **Coverage planning.** Run with no court filter and a high `maxCourts` to see everything listed
  nationally for the next sitting day.

### 🚀 How do I use UK Court Listings?

1. Click **Try for free** on the Apify Store listing, or open the Actor in Apify Console.
2. Leave the input as it comes for a first run, or type court names into **Court or tribunal names**.
   Names match as a substring, so `Manchester` reaches every Manchester court.
3. Narrow the lists if you want a specific kind, for example `insolvency` or `crown` in **List types**.
4. Narrow the hearings with **Case number contains**, **Party name contains**, **Hearing type
   contains** or **Judge name contains**. They combine as AND.
5. Press **Start** and wait. A four court run finishes in well under a minute.
6. Download the results as JSON, CSV, Excel or XML from the **Storage** tab, or pull them from the
   API using the examples below.
7. To keep watching a court or a case, open **Schedules** and run it every morning. Lists appear the
   working day before the hearing.

### ⬇️ Input

| Field | Type | Default | What it does |
|---|---|---|---|
| `courtNames` | array | empty | Court names to read, matched as a case insensitive substring. Empty means every court |
| `locationIds` | array | empty | Numeric HMCTS location ids, used instead of or alongside the names |
| `maxCourts` | integer | 25 | Hard cap on how many matching courts are visited |
| `listTypes` | array | empty | Keep only lists whose type contains one of these words |
| `listDateFrom` | string | empty | Keep only lists dated on or after this day, `YYYY-MM-DD` |
| `listDateTo` | string | empty | Keep only lists dated on or before this day, `YYYY-MM-DD` |
| `includeWelsh` | boolean | `false` | Include the Welsh language edition of a bilingual list |
| `caseNumberContains` | string | empty | Keep only hearings whose case number contains this text |
| `partyContains` | string | empty | Keep only hearings naming this party in any party column |
| `hearingTypeContains` | string | empty | Keep only hearings of this kind |
| `judgeContains` | string | empty | Keep only hearings before a judge whose name contains this text |
| `maxHearings` | integer | 1000 | Hard cap on hearings saved, and so on what one run can cost |

Every filter is applied by the Actor to rows it has already parsed, and each one is covered by a
test that checks the filter narrowed the result and that every remaining row satisfies it.

```json
{
  "courtNames": ["Business and Property Courts Rolls Building"],
  "listTypes": ["insolvency"],
  "maxCourts": 1,
  "maxHearings": 500
}
```

### ⬆️ Output

#### Table view

| listDate | hearingTime | courtName | courtRoom | caseNumber | caseName | hearingType | judge |
|---|---|---|---|---|---|---|---|
| 2026-08-17 | 10:30am | Business and Property Courts Rolls Building | | BR-2025-001331 | Example Person | Pre-trial review | Chief Insolvency and Companies Court Judge Briggs |
| 2026-08-17 | 12pm | Business and Property Courts Rolls Building | | CR-2026-003628 | Example Trading Limited | Companies application | Chief Insolvency and Companies Court Judge Briggs |
| 2026-08-17 | 10am | Plymouth Combined Court | Courtroom 01 | 183DC462 | Example v Example Foam Products Limited | PTR Hearing (Civil) | Her Honour Judge Ingham |

#### JSON

```json
{
  "courtName": "Business and Property Courts Rolls Building",
  "locationId": 111,
  "listType": "Insolvency and Companies Court (Chancery Division) Daily Cause List 17 August 2026",
  "listTypeSlug": "insolvency-and-companies-court-chd-daily-cause-list",
  "listDate": "2026-08-17",
  "listLastUpdated": "14 August 2026 at 4:43pm",
  "venueSection": null,
  "courtRoom": null,
  "judge": "Chief Insolvency and Companies Court Judge Briggs",
  "hearingTime": "12pm",
  "hearingType": "Companies application",
  "caseType": null,
  "caseNumber": "CR-2026-003628",
  "caseName": "Example Trading Limited",
  "applicant": null,
  "respondent": null,
  "prosecutingAuthority": null,
  "tribunal": null,
  "venue": "Remotely via MS Teams",
  "duration": null,
  "additionalInformation": null,
  "fields": {
    "Judge": "Chief Insolvency and Companies Court Judge Briggs",
    "Time": "12pm",
    "Venue": "Remotely via MS Teams",
    "Type": "Companies application",
    "Case number": "CR-2026-003628",
    "Case name": "Example Trading Limited",
    "Additional information": null
  },
  "listUrl": "https://www.court-tribunal-hearings.service.gov.uk/insolvency-and-companies-court-chd-daily-cause-list?artefactId=71ada28b-6e93-4cac-ae77-9985837308da",
  "retrievedAt": "2026-08-16T13:24:07.512Z"
}
```

### 📋 What the source publishes, and what this Actor adds

This matters, because court and insolvency lists name people.

HMCTS publishes these lists openly, with no sign-in, under the
[Open Justice Licence](https://caselaw.nationalarchives.gov.uk/open-justice-licence/version/2)
and its own [publishing policy](https://www.court-tribunal-hearings.service.gov.uk/publishing-policy).
A daily list carries the case reference, the parties or the defendant's name, the hearing type, the
time, the courtroom and the judge, because a hearing in open court is public and the list is how the
public and the press find it.

**UK Court Listings adds nothing to that.** It does not enrich a name against Companies House, a
credit file, an address register or any other source. It does not infer, score, classify or link
individuals. It reshapes the published page into rows and returns the same words the court printed,
with `listUrl` on every row so any value can be checked against its source.

Two properties of the source are worth knowing before you build on it:

- **Lists are short lived.** A list is published the working day before the hearing and comes down
  once that day has passed. There is no archive on the service, so a history has to be built by
  running on a schedule and keeping the results.
- **Lists change.** Courts amend a list during the day, which is why `listLastUpdated` is on every
  row. The same hearing can appear on an original and an amended list, and the Actor removes those
  duplicates within a run.

Handling this data means handling personal data, and that is your responsibility as the controller.
The lawful basis, the retention period and the question of whether a given use is fair are yours to
decide, not ours. Court lists are published for open justice, and republishing them for another
purpose is a decision worth taking with advice.

### 🌍 What is covered, and what is not

Covered: England and Wales, and some non-devolved tribunals sitting in Scotland, exactly as the
service itself covers them. Around 365 courts and tribunals, including Crown, magistrates, county,
civil and family courts, the Business and Property Courts, administrative courts, Social Security
and Child Support tribunals, and Single Justice Procedure lists.

Not covered, because the service does not publish them: the
[Scottish courts](https://www.scotcourts.gov.uk/), the
[Northern Ireland Courts and Tribunals Service](https://www.justice-ni.gov.uk/topics/courts-and-tribunals),
and any hearing held in private. A court with nothing listed publishes no list at all, which the
Actor reports as an empty result rather than an error.

### 💰 How much does it cost?

UK Court Listings uses Apify's **pay per event** pricing. It charges one **`hearing-listed`** event
for each hearing saved to the dataset, plus Apify's standard Actor start event. Nothing else is
charged: reading the A to Z of courts and reading each court's index of published lists are free.

The live price per hearing is shown on the Actor's Store listing, above this page. To work out what
a run will cost, multiply that figure by the hearings you expect:

- One day of the Insolvency and Companies Court daily cause list is around **10 to 30 hearings**.
- One large magistrates court for one day is around **100 hearings**.
- One Crown court for one day is around **40 to 50 hearings**.
- The default input, four courts for one day, saved **300 hearings** when this page was written.

`maxHearings` is the ceiling on a run, so it is also the ceiling on the cost of that run. Set it to
what you actually need and a run cannot surprise you. A run that matches nothing saves nothing and
therefore charges nothing beyond the start event.

You need an [Apify account](https://console.apify.com/sign-up) to run it. The free tier includes
monthly platform credit, which is enough to try this Actor properly.

### 🔌 Integrations

UK Court Listings is an ordinary Apify Actor, so everything the platform offers applies to it:

- **[Schedules](https://docs.apify.com/platform/schedules)** run it every morning, which is how you
  turn a service with no archive into a history you own.
- **[Webhooks](https://docs.apify.com/platform/integrations/webhooks)** fire when a run finishes, so
  a new hearing on a case you are watching can raise an alert the moment it is found.
- **[Integrations](https://docs.apify.com/platform/integrations)** push results straight into Slack,
  Google Sheets, Airtable, Zapier, Make or a webhook of your own.
- **[Monitoring](https://docs.apify.com/platform/monitoring)** alerts you when a scheduled run fails
  or returns less than you expected.
- **[MCP](https://docs.apify.com/platform/integrations/mcp)** exposes the Actor to AI agents, which
  can call it with the same inputs described above.

### 🔗 Using UK Court Listings with the Apify API

Start a run and wait for the results in one call:

```bash
curl -X POST "https://api.apify.com/v2/acts/spookyweb~uk-court-listings/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "courtNames": ["Business and Property Courts Rolls Building"],
    "listTypes": ["insolvency"],
    "maxHearings": 200
  }'
```

With the [JavaScript client](https://docs.apify.com/api/client/js):

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

const client = new ApifyClient({ token: 'YOUR_TOKEN' });

const run = await client.actor('spookyweb/uk-court-listings').call({
    courtNames: ['Manchester Crown Court'],
    partyContains: 'Limited',
    maxHearings: 500,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

With the [Python client](https://docs.apify.com/api/client/python):

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")

run = client.actor("spookyweb/uk-court-listings").call(run_input={
    "listTypes": ["insolvency"],
    "maxCourts": 5,
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["caseNumber"], item["caseName"], item["hearingTime"])
```

### ❓ FAQ

#### Do I need an account or an API key for the court service?

No. The Court and Tribunal Hearings service publishes these lists openly, and the Actor reads the
same pages a member of the public reads.

#### How far ahead and how far back do the lists go?

Lists are published the working day before the hearing and are removed once the day has passed, so
in practice you see today and the next sitting day. The service keeps no archive, so if you need
history, schedule the Actor daily and keep the dataset.

#### Why did my run return nothing?

Most often because the courts you chose have nothing listed. A court with no hearings publishes no
list, which is normal and not an error, so the run finishes successfully with zero rows. It can also
mean a court name did not match, or that the case, party, hearing type or judge filters were too
narrow. The run log says which of the three happened.

#### How do I find winding up petitions and insolvency hearings?

Set `courtNames` to `Business and Property Courts Rolls Building` and `listTypes` to `insolvency`.
That returns the Insolvency and Companies Court daily cause list, which is where companies
applications, petitions and interim hearings are listed at the Rolls Building. District registries
publish their own insolvency hearings within their local lists.

#### Are the filters actually applied?

Yes, and it is tested rather than assumed. The service takes no filter parameters of its own, so all
filtering happens inside the Actor on rows it has parsed. The test suite asserts for each filter that
it narrowed the result and that every surviving row satisfies it.

#### Can I search by court name if I do not know the exact wording?

Yes. Court names match as a case insensitive substring with punctuation ignored, so `Manchester`
finds every Manchester court and `magistrates` finds every magistrates court. Set `maxCourts` to
control how many of the matches are actually read.

#### Does it use a browser or a proxy?

Neither. The pages are server rendered, so the Actor makes plain HTTP requests. That keeps it fast,
cheap and well within a small memory allocation.

#### Is it polite to the service?

Yes. It reads at most two pages at a time with a delay between requests, honours `Retry-After`,
backs off on HTTP 429 and 5xx, and slows itself down for the rest of the run after being throttled.

#### Are the names in the results real people?

Yes, where the court published a name. Criminal, insolvency and family lists name defendants,
parties and appellants because hearings are held in open court. Please read
[what the source publishes](#-what-the-source-publishes-and-what-this-actor-adds) before you build
anything on this data.

### ⚖️ Is it legal to collect UK court listings?

Collecting publicly published information is legal in the UK and the EU, and HMCTS publishes these
lists deliberately so the public and the press can find hearings. They carry the
[Open Justice Licence](https://caselaw.nationalarchives.gov.uk/open-justice-licence/version/2) and
sit under [Crown copyright](https://www.nationalarchives.gov.uk/information-management/re-using-public-sector-information/uk-government-licensing-framework/crown-copyright/).
This Actor requests those pages the way a browser does and adds nothing to them.

What you then do with the data is a separate question, and it is yours. These lists contain personal
data, so under UK GDPR you become the controller the moment you store them. The Open Justice Licence
sets conditions on reuse, reporting restrictions apply to some hearings and are noted on the lists
themselves, and contempt of court rules apply to what is published about live proceedings. None of
this is legal advice. If you plan to republish or make decisions about people from this data, take
advice first.

### 👍 Your feedback

Found a court that parses badly, a column that is not mapped, or a list type that is missed? Open an
issue on the Actor's **Issues** tab and it will be looked at. Requests for extra fields, other list
types or a different output shape are welcome, and if you need something related built as a custom
Actor, say so in an issue.

### 🔎 You might also like

- [UK Case Law Search and Monitor](https://apify.com/spookyweb/uk-case-law-search-monitor), for the
  judgments that come out of these hearings.
- [UK Employment Tribunal Decisions](https://apify.com/spookyweb/uk-employment-tribunal-decisions),
  for published employment tribunal outcomes.
- [UK Insolvency Register Search](https://apify.com/spookyweb/uk-insolvency-register-search), for
  bankruptcies, IVAs and debt relief orders on the official register.
- [UK Disqualified Directors](https://apify.com/spookyweb/uk-disqualified-directors), for
  disqualification orders and undertakings.
- [UK FCA Enforcement Notices](https://apify.com/spookyweb/uk-fca-enforcement-notices), for
  regulatory action against firms and individuals.
- [UK Business Risk Report](https://apify.com/spookyweb/uk-business-risk-report), which pulls several
  UK registers together for one company.

# Actor input Schema

## `courtNames` (type: `array`):

Names of the courts to read, matched as a case insensitive substring, so "Manchester" reaches every Manchester court and "Crown Court" reaches all of them. Leave empty to read every court the service publishes. Apostrophes and punctuation are ignored when matching.

## `locationIds` (type: `array`):

Numeric HMCTS location ids, used instead of or alongside the names when you already know the exact court. For example 111 is the Business and Property Courts at the Rolls Building and 109 is the Royal Courts of Justice.

## `maxCourts` (type: `integer`):

Hard cap on how many matching courts are visited in one run. The service publishes around 365 courts, so a run with no court filter is capped by this number rather than by patience.

## `listTypes` (type: `array`):

Keep only lists whose type contains one of these words, for example insolvency, crown, magistrates, family, civil or sscs. Leave empty to keep every list the selected courts publish.

## `listDateFrom` (type: `string`):

Keep only lists dated on or after this day, written as YYYY-MM-DD. Lists appear the working day before the hearing and are removed once the day has passed, so this is a narrow window in practice.

## `listDateTo` (type: `string`):

Keep only lists dated on or before this day, written as YYYY-MM-DD. Use it with the earliest list date to pin the run to a single hearing day.

## `includeWelsh` (type: `boolean`):

Welsh courts publish the same list twice, once in English and once in Welsh. They are excluded by default so the same hearing is not returned and billed twice.

## `caseNumberContains` (type: `string`):

Keep only hearings whose case number contains this text, matched without case sensitivity. A prefix such as CR-2026 picks out this year's companies cases, and a full reference tracks one case.

## `partyContains` (type: `string`):

Keep only hearings naming this party, matched across the case name, applicant, respondent and prosecuting authority columns because each list type names the parties in a different place.

## `hearingTypeContains` (type: `string`):

Keep only hearings of this kind, for example "winding up", "companies application", "sentence" or "trial". Matched as a case insensitive substring of the hearing type column.

## `judgeContains` (type: `string`):

Keep only hearings before a judge whose name contains this text. Useful for following one judge's list across a week, or for isolating a specialist judge within a large court.

## `maxHearings` (type: `integer`):

Hard cap on the number of hearings saved in one run. Each hearing saved is one billable result, so this is also the ceiling on what a single run can cost.

## Actor input object example

```json
{
  "courtNames": [
    "Business and Property Courts Rolls Building",
    "Manchester Crown Court",
    "Birmingham Magistrates' Court",
    "Westminster Magistrates' Court"
  ],
  "maxCourts": 8,
  "includeWelsh": false,
  "maxHearings": 300
}
```

# Actor output Schema

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

Every hearing found, one row per listed hearing.

## `runSummary` (type: `string`):

Courts read, lists read and hearings saved for this run.

# 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 = {
    "courtNames": [
        "Business and Property Courts Rolls Building",
        "Manchester Crown Court",
        "Birmingham Magistrates' Court",
        "Westminster Magistrates' Court"
    ],
    "maxCourts": 8,
    "maxHearings": 300
};

// Run the Actor and wait for it to finish
const run = await client.actor("spookyweb/uk-court-listings").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 = {
    "courtNames": [
        "Business and Property Courts Rolls Building",
        "Manchester Crown Court",
        "Birmingham Magistrates' Court",
        "Westminster Magistrates' Court",
    ],
    "maxCourts": 8,
    "maxHearings": 300,
}

# Run the Actor and wait for it to finish
run = client.actor("spookyweb/uk-court-listings").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 '{
  "courtNames": [
    "Business and Property Courts Rolls Building",
    "Manchester Crown Court",
    "Birmingham Magistrates'\'' Court",
    "Westminster Magistrates'\'' Court"
  ],
  "maxCourts": 8,
  "maxHearings": 300
}' |
apify call spookyweb/uk-court-listings --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,spookyweb/uk-court-listings"
        }
    }
}

```

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/z6KKqxXVw3FPR8C0i/builds/tJ1HtWgTCoH2LXei7/openapi.json