# Bank of England Calendar: MPC Dates, Releases & Bank Rate (`yadroo/boe-release-calendar`) Actor

The Bank of England schedule as dated rows: MPC rate-announcement dates with Monetary Policy Report flags, FPC dates with Financial Stability Report flags, statistical release, publication, speech and event feeds with exact UTC moments, and the official Bank Rate change history.

- **URL**: https://apify.com/yadroo/boe-release-calendar.md
- **Developed by:** [Samat Makatov](https://apify.com/yadroo) (community)
- **Categories:** Business, News, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.40 / 1,000 calendar row returneds

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

## Bank of England Calendar: MPC Dates, Releases & Bank Rate

The Bank of England schedule as dated rows: MPC rate-announcement dates with Monetary Policy Report flags, FPC dates with Financial Stability Report flags, statistical release, publication, speech and event feeds with exact UTC moments, and the official Bank Rate change history.

Four schedules of the UK central bank, all read from the Bank's own pages and feeds, all returned as flat rows you can
sort, filter and join: the days the Monetary Policy Committee announces Bank Rate, the days the Financial Policy
Committee reports on financial stability, what the Bank has published lately (statistics, reports, speeches, news,
booked events) with the publication moment to the minute in UTC and London time, and every change of Bank Rate since
January 1975 with its move in basis points. For rates desks, risk and regulatory teams, macro researchers, newsroom
planners and agents that need the UK central-bank diary as data. No API key, no proxy, no browser — one to five plain
requests per run. It answers **when** something happens and **what the rate did**; it carries no market consensus and
no forecast column.

### Use cases

- **When is the next UK rate decision**: `mode: "mpcDates"` returns every announcement day the committee has published
  for this year and next, with `daysUntil` counting down and `bankRateAtFetchPercent` giving the level in force right
  now — enough to drive a countdown widget or an agent's answer in one call.
- **A trading calendar without a portal in the middle**: the announcement days, the quarterly Monetary Policy Report
  days and the financial-stability dates come from the institution that sets them, so nothing breaks when a third-party
  calendar site changes its markup.
- **Watching the statistical releases you depend on**: run `mode: "releases"` with `feeds: ["statistics"]`,
  `sinceHours: 24` and `onlyNew: true` on a schedule and a row appears only when something new has actually come out —
  the rest of the time the run writes nothing.
- **Planning around the financial-stability cycle**: `mode: "fpcDates"` gives risk, treasury and regulatory-affairs
  teams the committee record dates and flags the two dates a year that also bring a Financial Stability Report.
- **Feeding a rate model, a backtest or a chart**: `mode: "bankRate"` returns the policy path as rows — effective date,
  new level, previous level, signed basis points — so a study starts from the official table rather than a hand-typed list.
- **Reading the tone between meetings**: the speeches feed with `sortOrder: "latest"` gives each speech with its exact
  publication moment, the standfirst and the link to the full text, which is what a news monitor or an FX desk reacts to.

### Input

Nothing is required. A run with the defaults returns the MPC announcement days the Bank has published, soonest first,
in one request. The example values shown in the console are prefills, not defaults: clearing them does not switch a
filter back on.

| Field | Type | Default | Allowed values / notes |
|---|---|---|---|
| `mode` | string | `mpcDates` | `mpcDates`, `fpcDates`, `releases`, `bankRate`. See [Modes](#modes) |
| `feeds` | string\[] | — (prefilled `statistics`, `publications`) | Any of `statistics`, `publications`, `speeches`, `news`, `events`. Empty = all five. Only in `releases` mode. See [Feeds](#feeds) |
| `query` | string | — (prefilled `money and credit`) | Keyword matched case-insensitively against the title and the summary. Empty = no keyword. Only in `releases` mode. See [Recurring statistical releases](#recurring-statistical-releases) |
| `sinceHours` | integer | — | 1–8760. Keep entries published inside the last N hours, counted in UTC. Dates still ahead are kept regardless. Only in `releases` mode |
| `onlyUpcoming` | boolean | `false` | Drop rows whose date has already passed. Works in every mode; in `bankRate` it leaves nothing, since every change is in the past |
| `dateFrom` | string | — | Earliest event date, `YYYY-MM-DD`, inclusive |
| `dateTo` | string | — | Latest event date, `YYYY-MM-DD`, inclusive |
| `onlyNew` | boolean | `false` | Write only rows absent or differently dated in the previous run with the same filters. See [The onlyNew watcher](#the-onlynew-watcher) |
| `sortOrder` | string | `soonest` | `soonest` = earliest date first, `latest` = latest first |
| `maxItems` | integer | `25` | 1–1000. Which rows survive is decided per mode before sorting. See [What maxItems keeps](#what-maxitems-keeps) |
| `fields` | string\[] | all | Keep only these fields, in this order, e.g. `["eventDate", "title", "hasMonetaryPolicyReport"]` |

A value that is close to an allowed one is corrected and the correction is logged (`"speechs"` becomes `speeches`);
anything that is not close fails with the list of allowed values. Filters that belong to another mode are switched off
and reported in the log rather than applied silently.

### Reference

#### Modes

| Mode | Reads | Rows per run | What it is for |
|---|---|---|---|
| `mpcDates` | `/monetary-policy/upcoming-mpc-dates` | 16 on 2026-09-29 (this year and next) | Rate-announcement days, minutes and Monetary Policy Report flags |
| `fpcDates` | `/financial-stability/upcoming-fpc-dates` | 8 on 2026-09-29 | Committee record days and Financial Stability Report flags |
| `releases` | `/rss/<feed>`, one request per feed | up to 50 per feed | What the Bank published, or booked, with the moment to the minute |
| `bankRate` | `/boeapps/database/Bank-Rate.asp` | 258 changes on 2026-09-29, back to 1975-01-20 | The policy path with basis-point moves |

#### Feeds

Each feed is one request and carries its 50 most recent entries, so how far back that reaches depends on how often the
Bank publishes into it.

| Feed | What is in it | Reach of 50 entries (2026-09-29) | `eventType` |
|---|---|---|---|
| `statistics` | Monthly and quarterly statistical releases | about eight months | `statisticalRelease` |
| `publications` | Reports, working papers, consultation and policy papers | about three months | `publication` |
| `speeches` | Speeches and remarks by Bank officials | about ten months | `speech` |
| `news` | Announcements, market notices, minutes of market groups | about three months | `news` |
| `events` | Conferences, workshops, calls for papers, citizens' forums | mixed: mostly past, with a handful of future dates | `event` |

#### Recurring statistical releases

Useful values for `query` when you follow one family in the `statistics` feed: `money and credit`,
`effective interest rates`, `capital issuance`, `mortgage lenders and administrators`, `uk international reserves`,
`external business of monetary financial institutions`, `consolidated worldwide claims`, `credit union`,
`banking sector regulatory capital`. In the `publications` feed, `working paper`, `weekly report` and
`monetary policy report` behave the same way.

#### Event types

`mpcAnnouncement`, `fpcAnnouncement`, `statisticalRelease`, `publication`, `speech`, `news`, `event`,
`bankRateChange`. One mode produces one type, except `releases`, where the type follows the feed.

#### What maxItems keeps

In `bankRate` the most recent changes survive, because a date-sorted cut would otherwise hand you 1975. In every other
mode the entries closest to today survive, in both directions — which is what a diary is asked for. Sorting happens
after that, so `sortOrder` never changes which rows you get, only the order they arrive in.

#### The onlyNew watcher

Each emitted row is remembered by its link plus its date in a named key-value store, under a key derived from mode,
feeds and keyword — two scheduled tasks with different filters keep separate histories. A date that moves therefore
counts as new, which is the point of watching a central-bank calendar. The first run writes everything it finds, and a
later run that finds nothing new ends successfully with zero rows instead of failing.

#### Times

The committee date pages print calendar dates and no clock time at all, so their rows carry `timeKnown: false` with
`eventDateTimeUtc` and `eventTimeLondon` left null — no invented 09:30. Feed entries are stamped in London time and the
Bank switches notation with the season (`+0100` in summer, `Z` in winter); both are converted to the same wall clock, so
a 09:30 release is `08:30Z` in September and `09:30Z` in January. An entry the Bank stamped `00:00:00` carries no
publication time either and says so. `eventDate` is always the London calendar day, the day the Bank itself prints.

### Examples

**The next UK rate decisions**

```json
{ "mode": "mpcDates", "maxItems": 20 }
```

**The financial-stability cycle, only what is still ahead**

```json
{ "mode": "fpcDates", "onlyUpcoming": true, "maxItems": 20 }
```

**Statistical releases of the last day, as a watcher**

```json
{ "mode": "releases", "feeds": ["statistics"], "sinceHours": 24, "onlyNew": true, "sortOrder": "latest", "maxItems": 50 }
```

**Money and Credit only, newest first**

```json
{ "mode": "releases", "feeds": ["statistics"], "query": "money and credit", "sortOrder": "latest", "maxItems": 10 }
```

**Bank Rate since 2015 for a model**

```json
{ "mode": "bankRate", "dateFrom": "2015-01-01", "sortOrder": "latest", "maxItems": 30 }
```

**Speeches and news of the past week, trimmed to four fields**

```json
{ "mode": "releases", "feeds": ["speeches", "news"], "sinceHours": 168, "sortOrder": "latest", "fields": ["eventDateTimeUtc", "eventType", "title", "detailUrl"], "maxItems": 40 }
```

### Output

One row per date. A real row from the run that produced this README (`mode: "mpcDates"`, run `SMIDuHEgpmcAdDqqj`):

```json
{
  "eventDate": "2026-11-05",
  "eventType": "mpcAnnouncement",
  "title": "November MPC Summary and minutes and November Monetary Policy Report",
  "isUpcoming": true,
  "daysUntil": 37,
  "timeKnown": false,
  "eventDateTimeUtc": null,
  "eventTimeLondon": null,
  "dayOfWeek": "Thursday",
  "committee": "MPC",
  "detailUrl": "https://www.bankofengland.co.uk/monetary-policy-summary-and-minutes/2026/november-2026",
  "summary": null,
  "sourceFeed": null,
  "url": "https://www.bankofengland.co.uk/monetary-policy/upcoming-mpc-dates",
  "fetchedAt": "2026-09-29T22:29:52.650Z",
  "dateConfirmed": true,
  "hasMinutes": true,
  "hasMonetaryPolicyReport": true,
  "bankRateAtFetchPercent": 3.75
}
```

A statistical release (`feeds: ["statistics"]`, run `K2EXhlc2GicTyi8cx`) and a rate change
(`mode: "bankRate"`, run `GxglBrNle1Yqthrue`) from the same verification, trimmed to the fields that differ:

```json
{
  "eventDate": "2026-09-29",
  "eventType": "statisticalRelease",
  "title": "Money and Credit - August 2026",
  "timeKnown": true,
  "eventDateTimeUtc": "2026-09-29T08:30:00.000Z",
  "eventTimeLondon": "09:30",
  "summary": "Our monthly Money and Credit statistical release is made up of three parts: broad money and credit, lending to individual and lending to businesses.",
  "sourceFeed": "statistics",
  "detailUrl": "https://www.bankofengland.co.uk/statistics/money-and-credit/2026/august-2026"
}
```

```json
{
  "eventDate": "2025-12-18",
  "eventType": "bankRateChange",
  "title": "Bank Rate cut to 3.75% (-25 bps)",
  "bankRatePercent": 3.75,
  "previousRatePercent": 4,
  "changeBps": -25,
  "changeDirection": "decrease",
  "url": "https://www.bankofengland.co.uk/boeapps/database/Bank-Rate.asp"
}
```

| Field | Type | Meaning |
|---|---|---|
| `eventDate` | string | The London calendar day of the event, `YYYY-MM-DD` |
| `eventType` | string | One of the [event types](#event-types) |
| `title` | string | What lands that day, as the Bank names it; for a rate change, the move in words |
| `isUpcoming` | boolean | Still ahead. With a published time, measured against that moment; a date-only entry counts as ahead for the whole of its day |
| `daysUntil` | number | Whole days from today to `eventDate`, negative once it has passed |
| `timeKnown` | boolean | Whether the source published a time of day at all |
| `eventDateTimeUtc` | string | null | The publication moment, ISO 8601 UTC; null when `timeKnown` is false |
| `eventTimeLondon` | string | null | The same moment as `HH:MM` London wall clock; null when `timeKnown` is false |
| `dayOfWeek` | string | Weekday name of `eventDate` |
| `committee` | string | null | `MPC`, `FPC`, or null for feed entries and rate changes |
| `detailUrl` | string | null | The page the entry points to — minutes, report, release, speech or event |
| `summary` | string | null | The standfirst the Bank syndicates with a feed entry, cut at 400 characters; null on the date pages |
| `sourceFeed` | string | null | Which feed the row came from, in `releases` mode |
| `url` | string | The page or feed that was fetched |
| `fetchedAt` | string | Fetch time, ISO 8601 UTC |
| `dateConfirmed` | boolean | `mpcDates`/`fpcDates`: false when the year's heading marks the dates as provisional |
| `hasMinutes` | boolean | `mpcDates`: the summary and minutes are published that day |
| `hasMonetaryPolicyReport` | boolean | `mpcDates`: a quarterly Monetary Policy Report lands with the decision |
| `bankRateAtFetchPercent` | number | null | `mpcDates`: the Bank Rate printed on the schedule page at fetch time |
| `hasFpcRecord` | boolean | `fpcDates`: the committee record is published that day |
| `hasFinancialStabilityReport` | boolean | `fpcDates`: a Financial Stability Report lands with it |
| `bankRatePercent` | number | `bankRate`: the level the change moved to, in percent |
| `previousRatePercent` | number | null | `bankRate`: the level before it; null for the oldest change in the table |
| `changeBps` | number | null | `bankRate`: signed move in basis points |
| `changeDirection` | string | null | `bankRate`: `increase` or `decrease` |

Every run also writes a `SUMMARY` record to its key-value store: requests made, entries read, what each filter dropped,
and — in `mpcDates` — the Bank Rate and the next announcement date the page prints.

Dataset views: **Calendar** (any mode), **Committee dates**, **Releases and speeches**, **Bank Rate changes**.

### Use it from code / agents

One run is one to five requests and finishes in seconds, so a synchronous call is fine for an agent or a request handler.

```bash
curl -X POST "https://api.apify.com/v2/acts/yadroo~boe-release-calendar/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"mode":"mpcDates","onlyUpcoming":true,"fields":["eventDate","dayOfWeek","hasMonetaryPolicyReport","daysUntil"],"maxItems":5}'
```

```js
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('yadroo/boe-release-calendar').call({ mode: 'bankRate', dateFrom: '2015-01-01', sortOrder: 'latest', maxItems: 30 });
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

```python
from apify_client import ApifyClient
client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("yadroo/boe-release-calendar").call(run_input={"mode": "releases", "feeds": ["statistics"], "sinceHours": 24, "sortOrder": "latest"})
items = client.dataset(run["defaultDatasetId"]).list_items().items
```

MCP: add `https://mcp.apify.com` to Claude / Cursor / any MCP client and call the `yadroo/boe-release-calendar` tool with
the same JSON input. Narrow the row with `fields` to keep a model's context small.

### Pricing

Pay per event: **$0.001 for starting a run** plus **$0.002 per dataset row** on the free tier (per-row price is lower on
paid tiers: $0.0018 bronze, $0.0016 silver, $0.0014 gold and above; the start event is flat). Every run is charged the
start event, including a watcher run that finds nothing — calendar runs are small, so that $0.001 is a visible share of
a tiny run.

| Run | Rows | Cost |
|---|---|---|
| MPC announcement days (`mpcDates`) | 16 | $0.001 + $0.032 = **$0.033** |
| FPC dates (`fpcDates`) | 8 | $0.001 + $0.016 = **$0.017** |
| A month of statistical releases (`releases`, `statistics`) | 30 | $0.001 + $0.060 = **$0.061** |
| Bank Rate since 2015 (`bankRate`) | 25 | $0.001 + $0.050 = **$0.051** |
| A daily watcher run with nothing new (`onlyNew`) | 0 | $0.001 + $0 = **$0.001** |

Compute is negligible in practice: 256 MB, no browser, one to five requests, a few seconds per run.

### Limits & FAQ

- **Dates, not figures.** The Bank publishes the schedule and the rate level; there is no actual, forecast or previous
  column anywhere in this source, and none in the output. The numbers live behind `detailUrl`.
- **No calendar of forthcoming statistical releases.** The Bank has no feed of what is *about* to be published: its
  filtered "upcoming" listings are filled in the browser and its two-week diary page is free prose with no per-item
  markup, so neither is used here. Future dates are therefore covered for the two committees and for booked events —
  past releases come from the feeds. Do not expect next month's Money and Credit date from this actor.
- **The committee pages hold the current and next year only.** Sixteen MPC dates and eight FPC dates on 2026-09-29.
  Earlier years are not on those pages, and `dateFrom` cannot bring them back.
- **No clock time on the committee pages.** Those rows say `timeKnown: false` rather than guessing an hour. The
  announcement has been at noon London for years, but the Bank does not print it on the schedule, so the actor does not
  either.
- **Feeds hold 50 entries each.** That is roughly eight months of statistics, three months of publications or news, ten
  months of speeches. Anything older is gone from the source; `dateFrom` narrows what is there, it cannot extend it.
- **The events feed mixes past and future.** It is the one place future dates appear, but most of its 50 entries are
  past. Use `onlyUpcoming: true` for the diary half.
- **Two HTML layouts.** The committee pages are parsed by shape — a year heading followed by a two-column table — not by
  CSS classes. A redesign that removes the tables makes the run fail with a message naming the page instead of quietly
  returning zero rows. The rate table is a legacy page and is matched by its own column headers.
- **robots.txt is honoured.** The Bank excludes its interactive database area and the site search; none of the four
  paths used here is excluded. Before reading the rate table the actor fetches `robots.txt` and stops with a clear
  message if that ever changes.
- **Politeness.** One request per page or feed, at most five per run, with backoff on 429 and 5xx and a normal
  User-Agent. There is no login, captcha or anti-bot wall on any of these paths.
- **Empty results are not silent.** A run whose filters match nothing ends with a message naming mode, keyword and
  window — except with `onlyNew`, where zero rows is the correct "nothing changed" answer.
- **Personal data.** The only names in the output are those of Bank officials inside the speech titles the Bank
  publishes itself. No contact details are collected.
- **Source and licence.** Data comes from the Bank of England: the
  [MPC date page](https://www.bankofengland.co.uk/monetary-policy/upcoming-mpc-dates), the
  [FPC date page](https://www.bankofengland.co.uk/financial-stability/upcoming-fpc-dates), the Bank's RSS feeds and the
  [Bank Rate table](https://www.bankofengland.co.uk/boeapps/database/Bank-Rate.asp). Reuse of the rate data is covered by
  the UK Open Government Licence; rows carry facts about the schedule and links, never the text of a publication.

***

Made by **Yadroo**. Sibling actors: [ons-release-calendar](https://apify.com/yadroo/ons-release-calendar),
[fed-fomc-calendar](https://apify.com/yadroo/fed-fomc-calendar),
[bls-release-calendar](https://apify.com/yadroo/bls-release-calendar),
[us-treasury-yields](https://apify.com/yadroo/us-treasury-yields),
[statcan-release-calendar](https://apify.com/yadroo/statcan-release-calendar).

# Actor input Schema

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

Four separate jobs. `mpcDates` reads the committee's published date list for the current and next year: one row per announcement day, flagged with whether a Monetary Policy Report lands with it. `fpcDates` does the same for the financial-stability committee. `releases` walks the Bank's own feeds and returns what was published (or, for events, what is booked) with the release moment to the minute. `bankRate` returns the rate-change table: one row per change since 1975 with the new level and the move in basis points.

## `feeds` (type: `array`):

Which of the Bank's five feeds to read. One feed is one request and carries its 50 most recent entries, so `statistics` reaches roughly eight months back while `speeches` covers a few weeks. `events` is the only feed whose entries are mostly in the future. Empty = all five. Used in `releases` mode.

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

Keep only feed entries whose title or summary contains this text, case-insensitive: "money and credit", "effective interest rates", "capital issuance", "mortgage lenders", "weekly report", "working paper". The release families that repeat every month are listed in README → Reference dictionaries. Empty = no keyword filter. Used in `releases` mode.

## `sinceHours` (type: `integer`):

Keep only feed entries whose moment falls inside the last N hours, counted in UTC. 24 for a daily watcher, 168 for a weekly digest. Empty = no time window. Entries dated in the future (booked events) are kept regardless. Used in `releases` mode.

## `onlyUpcoming` (type: `boolean`):

Drop rows whose date has already passed. Off by default, because the committee date pages carry the whole year and the released half of it is what you compare against. Works in every mode; in `bankRate` it leaves nothing, since every rate change is in the past.

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

Earliest event date, YYYY-MM-DD. In `bankRate` this is how you cut the history down to the period you study, e.g. 2020-01-01 for the pandemic cycle onwards. Leave empty for no lower bound.

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

Latest event date, YYYY-MM-DD. The committee pages reach to the end of next year, the feeds hold 50 entries each, and the rate table starts in January 1975; a window outside that returns fewer rows and the run message says what the actor saw.

## `onlyNew` (type: `boolean`):

Remember every emitted row (its link plus its date) in this actor's key-value store and write only rows that were absent or differently dated last time. A rescheduled announcement therefore counts as new, which is the point of watching a central-bank calendar. The first run writes everything it finds.

## `sortOrder` (type: `string`):

Order of the output rows. Which rows survive *Max rows* is decided per mode before sorting: the committee pages and the feeds keep the entries closest to today, the rate history keeps the most recent changes.

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

Stop after this many rows. The committee date pages hold 16 and 8 entries, a feed holds 50, the rate table about 350 changes.

## `fields` (type: `array`):

Keep only these fields, in this order, e.g. \["eventDate", "eventType", "title", "hasMonetaryPolicyReport"]. Empty = every field of the mode.

## Actor input object example

```json
{
  "mode": "mpcDates",
  "feeds": [
    "statistics",
    "publications"
  ],
  "query": "money and credit",
  "onlyUpcoming": false,
  "onlyNew": false,
  "sortOrder": "soonest",
  "maxItems": 25
}
```

# 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 = {
    "feeds": [
        "statistics",
        "publications"
    ],
    "query": "money and credit"
};

// Run the Actor and wait for it to finish
const run = await client.actor("yadroo/boe-release-calendar").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 = {
    "feeds": [
        "statistics",
        "publications",
    ],
    "query": "money and credit",
}

# Run the Actor and wait for it to finish
run = client.actor("yadroo/boe-release-calendar").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 '{
  "feeds": [
    "statistics",
    "publications"
  ],
  "query": "money and credit"
}' |
apify call yadroo/boe-release-calendar --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,yadroo/boe-release-calendar"
        }
    }
}
```

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/wM8a52Xel2sm4HHoS/builds/YWug81HaJvGaiMgeZ/openapi.json