# UK Short Selling Positions (`spookyweb/uk-short-selling-positions`) Actor

🏷️ From $0.60 / 1K | Every net short position the FCA publishes against a UK listed company: the percentage shorted, the ISIN, the position date and the reportable share class. Filter by company, ISIN, size and date. Includes the archive of named position holders to 9 July 2026.

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

## Pricing

from $0.60 / 1,000 positions

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?

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 Short Selling Positions

### 🔍 What does UK Short Selling Positions do?

It reads the **Financial Conduct Authority's net short position register** and returns it as clean, typed rows. You get **which UK listed company is being shorted, by what percentage of its issued share capital, on what date**, refreshed every working day. The fastest way to try it is to press Start with nothing filled in, which returns the whole current register in about a second.

Three files sit behind it and you choose between them with one field. **Current** is every position open right now. **Historic** is every position that has closed or dropped out of scope since 2022. **Named holders** is the FCA's archive of individual disclosures, which runs from 31 October 2012 to 9 July 2026 and carries the fund name against each position.

No account, no API key, no cookie and no browser. The FCA publishes all of it openly and this Actor reads it directly.

### 📊 What data can I extract?

Every row carries the same 25 fields whichever file it came from, so a current row and an archive row line up in the same spreadsheet.

| Field | Type | What it holds |
|---|---|---|
| `dataset` | string | Which FCA file the row came from: `current`, `historic` or `disclosures` |
| `positionHolder` | string | The named fund holding the position. Present only on archive rows, null on aggregated rows |
| `companyName` | string | The company being shorted, as the FCA publishes its name |
| `isin` | string | ISIN of the shorted share, upper cased with spacing removed |
| `positionPercent` | number | Net short position as a percentage of issued share capital, to two decimals |
| `positionDate` | string | The date the position was held, as `YYYY-MM-DD` |
| `positionDateRaw` | string | The date exactly as published, day first for the CSVs and an Excel serial for the archive |
| `becameHistoricDate` | string | When an aggregated position stopped being current, `YYYY-MM-DD` |
| `becameHistoricDateRaw` | string | The same date exactly as published |
| `daysHeldBeforeHistoric` | number | Calendar days between the position date and the date it became historic |
| `daysSincePositionDate` | number | Calendar days from the position date to the moment of the run |
| `positionClosed` | boolean | True where a holder notified a position of zero. Null on aggregated rows |
| `isAggregated` | boolean | True where the row sums every holder, false where it is one named holder |
| `isCurrent` | boolean | True only for positions open now |
| `disclosureRegime` | string | `SSR 2025 aggregated` or `pre-SSR 2025 individual` |
| `reportableShare` | boolean | Whether the ISIN is on the FCA's current UK reportable shares list. Null if that list could not be read |
| `reportableShareClass` | string | `Main` or `Other Class of Shares` |
| `reportableShareAddedDate` | string | When the share was added to the reportable shares list, `YYYY-MM-DD` |
| `reportableShareAddedDateRaw` | string | The same date exactly as published |
| `reportableShareCompanyName` | string | The company name as spelled on the reportable shares list |
| `sourceUrl` | string | The FCA file the row was read from |
| `sourceLastModified` | string | When the FCA last republished that file, ISO 8601 |
| `sourceUpdatedDaily` | boolean | Whether that file is still republished every working day |
| `sourceComplete` | boolean | Whether the FCA file was read in full on this run |
| `retrievedAt` | string | When the row was collected, ISO 8601 |

Any field can be null. The FCA leaves gaps and a guess in place of a gap is worse than the gap.

### 💡 Why track net short positions?

**Short interest screens.** Pull the current register sorted by size and the most heavily shorted UK companies are the first rows. On the day this was written the top of the list ran Vistry Group at 19.98%, Ibstock at 18.26% and Capita at 13.67%.

**Position building.** Set the percentage band to 1 to 2 and you get the companies where short interest is real but not yet a headline. Run it daily and the moves in and out of that band are your signal.

**Company monitoring.** Filter to one ISIN and schedule it. Investor relations teams get the aggregate against their own stock in a row, dated, with no manual download.

**Story research.** The historic file carries every aggregated position back to 2022 with the date it closed, so you can reconstruct how short interest in a company moved through an event.

**Fund histories.** The named holders archive answers what a specific fund was short and when, across 602 funds, 921 securities and 108,850 disclosures. Filter to one holder to see everything it ever disclosed in the UK.

**Reconciliation.** Every row carries the ISIN and the FCA's own publication timestamp, so a position file can be joined against the register without matching on company names that are spelled three ways.

### 🚀 How do I use UK Short Selling Positions?

1. Click **Try for free**, or add the Actor to your Apify account.
2. Leave every field empty for the whole current register, which is about 420 positions.
3. Or pick a file with **Which FCA file to read**: current positions, historic positions or the named holder archive.
4. Narrow it down with a company name, an ISIN, a percentage band or a date window. The filters combine.
5. Choose a **Sort order**. Largest position first is the short interest screen.
6. Press **Start**. A current run finishes in about a second.
7. Take the results from the **Storage** tab as JSON, CSV, Excel or XML, or through the API.
8. Set a schedule for a daily refresh. The FCA republishes each working day from 12:00 London time.

### ⬇️ Input

| Field | Type | Default | What it does |
|---|---|---|---|
| `dataset` | string | `current` | Which FCA file to read: `current`, `historic` or `disclosures` |
| `company` | string | empty | Keep companies whose name contains this text, case insensitive |
| `isin` | string | empty | Keep one exact security by ISIN |
| `positionHolder` | string | empty | Keep disclosures whose named holder contains this text. Archive only |
| `minPositionPercent` | string | empty | Keep positions at or above this percentage |
| `maxPositionPercent` | string | empty | Keep positions at or below this percentage |
| `positionDateFrom` | string | empty | Earliest position date, `YYYY-MM-DD`, inclusive |
| `positionDateTo` | string | empty | Latest position date, `YYYY-MM-DD`, inclusive |
| `includeClosedPositions` | boolean | `true` | Keep the zero percent rows that mark a closure |
| `reportableSharesOnly` | boolean | `false` | Keep only shares still on the FCA reportable shares list |
| `sortBy` | string | `percentDesc` | `percentDesc`, `percentAsc`, `dateDesc`, `dateAsc`, `company` or `holder` |
| `maxResults` | integer | `1000` | Hard cap on rows saved, which is also the cap on run cost |

Every filter is optional and they all combine. An example that pulls the large positions opened in August 2026:

```json
{
  "dataset": "current",
  "minPositionPercent": "5",
  "positionDateFrom": "2026-08-01",
  "sortBy": "percentDesc",
  "maxResults": 1000
}
```

And one that pulls a single fund's whole disclosure history in one company:

```json
{
  "dataset": "disclosures",
  "positionHolder": "marshall wace",
  "company": "ocado",
  "sortBy": "dateDesc",
  "maxResults": 1000
}
```

### ⬆️ Output

#### Table view

| Company | ISIN | Short % | Position date | Holder | Days old | Open now |
|---|---|---|---|---|---|---|
| Vistry Group PLC | GB0001859296 | 19.98 | 2026-08-12 | null | 4 | true |
| IBSTOCK PLC | GB00BYXJC278 | 18.26 | 2026-08-12 | null | 4 | true |
| CAPITA PLC | GB00BPCT7534 | 13.67 | 2026-08-12 | null | 4 | true |
| OCADO GROUP PLC | GB00B3MBS747 | 12.09 | 2026-08-13 | null | 3 | true |

#### JSON

```json
{
  "dataset": "current",
  "positionHolder": null,
  "companyName": "OCADO GROUP PLC",
  "isin": "GB00B3MBS747",
  "positionPercent": 12.09,
  "positionDate": "2026-08-13",
  "positionDateRaw": "13/08/2026",
  "becameHistoricDate": null,
  "becameHistoricDateRaw": null,
  "daysHeldBeforeHistoric": null,
  "daysSincePositionDate": 3,
  "positionClosed": null,
  "isAggregated": true,
  "isCurrent": true,
  "disclosureRegime": "SSR 2025 aggregated",
  "reportableShare": true,
  "reportableShareClass": "Main",
  "reportableShareAddedDate": "2026-07-13",
  "reportableShareAddedDateRaw": "13/07/2026",
  "reportableShareCompanyName": "OCADO GROUP PLC",
  "sourceUrl": "https://www.fca.org.uk/publication/documents/aggregated-current-net-short-positions.csv",
  "sourceLastModified": "2026-08-14T10:50:57.000Z",
  "sourceUpdatedDaily": true,
  "sourceComplete": true,
  "retrievedAt": "2026-08-16T15:48:13.358Z"
}
```

### 📅 What the FCA actually publishes, and what it does not

This matters more than any feature in the list above, because the UK regime changed in 2026 and a lot of writing about UK short selling is now out of date.

**Current and historic positions are anonymous.** The Short Selling Regulations 2025 took effect on 13 July 2026. Since then the FCA publishes the **aggregate** net short position in each company and states plainly that individual positions are anonymised and not disclosed. So `positionHolder` is null on every current and historic row, and it is null because the information does not exist rather than because this Actor failed to find it. Asking for a holder search against those files finishes the run with the reason in its status message and an empty dataset, instead of quietly returning everything.

**The named holder archive is history and it stops.** The FCA still hosts the individual disclosure report from the previous regime. It runs from 31 October 2012 to 9 July 2026, holds 108,850 disclosures from 602 funds across 921 securities, and it will not grow again. This Actor reads it in full and says on every row that it is not updated daily. It is the right source for a fund history and the wrong source for what is short today.

**Positions are published on a T+2 basis.** A position dated today appears in the register two working days later, so the freshest `positionDate` you will see is a couple of days behind. That is the FCA's schedule, not a lag in this Actor.

**The reporting floor is 0.2%.** Anything smaller is not notifiable and is not in the register at any threshold you set.

**A position of 0% is a closure.** In the named holder archive a zero row is how a fund told the FCA it had closed out, which is why those rows exist and why `includeClosedPositions` is a switch rather than a cleanup.

**Dates are read as day first.** The FCA writes `10/08/2026` and means 10 August. This Actor parses the calendar by hand rather than handing the string to a date parser, which would read it as 8 October. Your own date filters go in as `YYYY-MM-DD`, and a day first date is rejected with an explanation rather than guessed at.

### 🧮 Coverage, limits and memory

| File | Rows today | Republished | Named holders |
|---|---|---|---|
| Current aggregated positions | 420 | every working day from 12:00 | no |
| Historic aggregated positions | 2,948 | every working day from 12:00 | no |
| Named holder archive | 108,850 | no, frozen at 10 July 2026 | yes |
| UK reportable shares list | 1,381 | monthly, first working day | not applicable |

The reportable shares list is read on every run to fill the `reportableShare` columns. If it cannot be read the run carries on and those five columns are null, because an unchecked share is not the same as a share that is out of scope.

The named holder archive is a 3.1MB workbook whose worksheet expands to 25MB. This Actor streams it and never holds it whole, and it keeps only the rows your `maxResults` asked for. At the default 128MB of memory it comfortably returns about 25,000 archive rows. To pull all 108,850 in one run, raise the run memory to 512MB. A current or historic run needs nothing above 128MB at any setting.

### ⏱️ 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.

| Positions returned | Typical run time |
|---|---|
| 50, filtered out of the current register | about 3 seconds |
| 420, the whole current register | 2 to 5 seconds |
| 3,960, the whole historic file | about 5 seconds |
| 92,060, the named holder archive at 512 MB | about 7 minutes |

The first three rows are all the same shape of work. The FCA publishes current and historic positions as **one small file each**, so a run is a single download followed by filtering and sorting in memory. Four thousand rows therefore cost barely more than four hundred, and filters for company, ISIN, holder, percentage band or date do not slow a run down at all, because the file was already read.

The named holder archive is the exception and the last row is why. It is a 3.1 MB workbook whose worksheet expands to about 25 MB, streamed row by row rather than held whole, and at the top end that is minutes rather than seconds. Cap it with `maxResults` if you only want the top of the archive, and see the memory note in the coverage section above before pulling all of it. On the other three files the first few seconds of any run are the container starting rather than the work, which is most of the run.

A run is never silently stuck. The download and the row count are both logged, and positions are written to the dataset in batches as they are prepared rather than held back to the end. A filter 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 (1,000 positions takes about 1 minute). 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?

You are charged per position saved, and the charge happens **before** the rows are handed over, so you never receive rows you were not billed for and you are never billed for rows you did not receive. If your run cost cap runs out part way through a batch, the run keeps what was paid for, says so in the log and finishes successfully.

`maxResults` is therefore the cost control. Set it to 50 and a run can never cost more than 50 positions plus the run start, whatever you filter on.

Some worked examples at the current price. A daily monitor on one company returns 1 row. A whole current register run returns about 420. A full historic pull returns 2,948. Check the pricing panel on this Actor's page for the live per position price and the discount tiers, because that panel is the only figure that is guaranteed to be today's.

### 🔌 Integrations

Schedule the Actor to run every working day at 12:30 London time and the current register lands in the same dataset every day with no manual download. Connect it to Google Sheets, Airtable, Zapier, Make or Slack from the **Integrations** tab, or send a webhook on run completion so a position crossing a threshold reaches you rather than waiting to be checked. Results are available as JSON, CSV, Excel, XML and RSS through the Apify API, and Apify's monitoring will tell you if a run ever fails.

The Actor also has a full output schema and runs on limited permissions, so an AI agent can discover it and chain it through the Apify MCP server without any wiring.

### 🔗 Using UK Short Selling Positions 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-short-selling-positions/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"dataset":"current","minPositionPercent":"5","sortBy":"percentDesc","maxResults":100}'
```

Or start it and collect the dataset later:

```bash
curl -X POST "https://api.apify.com/v2/acts/spookyweb~uk-short-selling-positions/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"dataset":"disclosures","positionHolder":"marshall wace","maxResults":5000}'
```

```bash
curl "https://api.apify.com/v2/datasets/DATASET_ID/items?token=YOUR_TOKEN&format=csv"
```

In JavaScript with the Apify client:

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

const client = new ApifyClient({ token: 'YOUR_TOKEN' });
const run = await client.actor('spookyweb/uk-short-selling-positions').call({
  dataset: 'current',
  isin: 'GB00B3MBS747',
  sortBy: 'dateDesc',
  maxResults: 50,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### ❓ FAQ

#### Who is short a particular UK company right now?

Nobody can tell you, and neither can any other source, because the FCA stopped publishing it. Under the Short Selling Regulations 2025 only the **aggregate** short position in a company is published. Set `dataset` to `current` and an ISIN to get that aggregate. For named funds you need the archive, which ends on 9 July 2026.

#### How often does the data update?

The FCA republishes the current and historic files every working day from 12:00 London time, and this Actor reads them live on every run. The `sourceLastModified` field on each row tells you exactly when the FCA last touched the file it came from.

#### Why is my position date a few days old?

Positions are published on a T+2 basis, so a position held on Monday appears in the register on Wednesday at the earliest. The `daysSincePositionDate` field makes the gap explicit on every row.

#### Why is positionHolder null?

Because the row came from an aggregated file, where the identity is not published. Set `dataset` to `disclosures` for named holders. If you set a holder search against an aggregated file the run stops and explains this rather than returning unfiltered rows.

#### Can I get the whole named holder archive in one run?

Yes. Set `dataset` to `disclosures` and `maxResults` to `200000`, and raise the run memory to 512MB. All 108,850 disclosures come back in one dataset.

#### What does a 0% position mean?

It is a closure. A fund notifies the FCA that its position has fallen to zero, and that notification is published like any other. Those rows are marked with `positionClosed` set to true, and `includeClosedPositions` turns them off.

#### Why does an ISIN sometimes show reportableShare as false?

Because the share is no longer on the FCA's current UK reportable shares list, usually because the company delisted or moved out of scope. It is common in the archive and rare in the current file. Where the list could not be read at all the field is null rather than false.

#### Does it need an API key or an account with the FCA?

No. Every file this Actor reads is published openly by the FCA with no key, no registration and no cookie.

#### Do I need a proxy?

No. This is a plain HTTP read of static published files and it uses no proxy and no browser.

#### What happens if my filters match nothing?

The run succeeds with zero rows and the log tells you which filter to widen. A search that legitimately matches nothing is an answer, not a failure, so a scheduled monitor will not alert you over a quiet day.

#### Which UK companies are the most shorted?

Run it with no filters and `sortBy` set to `percentDesc`. The first rows are the answer for that day, and because you get the date on every row you can tell how fresh each number is.

### ⚖️ Is it legal to collect FCA short position data?

The FCA publishes this data specifically so it can be used. The aggregate net short position report, the historic report and the UK reportable shares list are all official public disclosures under the UK short selling regime, published in machine readable formats on the FCA website with no access control. This Actor reads those published files exactly as a browser would, adds no authentication and bypasses nothing.

The FCA site is subject to Crown copyright, which permits reuse. There is no personal data in the aggregated files at all. The named holder archive contains firm names that the FCA itself published for public disclosure, which is the entire purpose of a disclosure regime, and a small number of individual names disclosed under the same rules. Nothing is inferred, enriched or joined against anything the FCA did not publish.

As always, what you do with financial data is your responsibility. If you are acting on it, check the FCA's own [notification and disclosure page](https://www.fca.org.uk/markets/short-selling/notification-disclosure-net-short-positions) for the current regime and the publication schedule.

### 👍 Your feedback

Found a bug, or want a field that is not here? Open an issue on the **Issues** tab of this Actor and it will be read. If you need a different UK regulatory or company dataset scraped and turned into an API, say so there too, because that is exactly the kind of thing this account builds.

### 🔎 You might also like

- [UK Takeover Bid Tracker](https://apify.com/spookyweb/uk-takeover-disclosures), which returns every UK company currently under a takeover bid with the named bidders, the securities in play and the Rule 2.6 deadline. Short positions and live bids join cleanly on the ISIN.
- [Company Email Finder](https://apify.com/spookyweb/company-email-finder), for finding work email addresses from a company domain.
- [Website Contact Scraper](https://apify.com/spookyweb/website-contact-scraper), for pulling emails, phone numbers and social links off any website.

# Actor input Schema

## `dataset` (type: `string`):

Current positions are the ones open now, republished by the FCA every working day from 12:00 London time. Historic positions are the ones that have already closed or stopped being reportable, back to 2022. Named holders is the archive of individual disclosures made before the Short Selling Regulations 2025, which ends on 9 July 2026 and never grows again.

## `company` (type: `string`):

Keep only positions in companies whose name contains this text, matched case insensitively. Part of a name is enough, so "ocado" finds OCADO GROUP PLC. Leave it empty to get every company in the file, which is how a whole market scan is run.

## `isin` (type: `string`):

Keep only positions in this exact security, given as its twelve character ISIN. Spacing and case are normalised for you, for example GB00B3MBS747 for Ocado Group. This is the field to use when joining FCA positions onto your own holdings file.

## `positionHolder` (type: `string`):

Keep only disclosures whose named holder contains this text, matched case insensitively, for example "marshall wace". This only works with the named holders archive, because current positions are anonymous by law, and the run is stopped with an explanation if you set it against a current or historic search.

## `minPositionPercent` (type: `string`):

Keep only positions at or above this percentage of the company's issued share capital, written as a plain number such as 0.5 or 5. The FCA reporting floor is 0.2, so leaving this empty returns everything on the file. Setting it to 5 isolates the very large bets against a company.

## `maxPositionPercent` (type: `string`):

Keep only positions at or below this percentage of the company's issued share capital, written as a plain number such as 2. Pair it with the minimum to pull one band, for example everything between 1 and 2 percent, which is where a position that is building often sits.

## `positionDateFrom` (type: `string`):

Earliest position date to include, written as YYYY-MM-DD. The bound is inclusive. A UK style date such as 10/08/2026 is rejected with an explanation rather than guessed at, because it reads as 10 August to the FCA and as 8 October to a date parser.

## `positionDateTo` (type: `string`):

Latest position date to include, written as YYYY-MM-DD. The bound is inclusive. Use the two bounds together to pull one month of the register, or use this one alone to find the positions that have been left untouched the longest.

## `includeClosedPositions` (type: `boolean`):

A holder closes a position by notifying the FCA that it has fallen to zero, and those zero rows exist in the named holders archive. Turn this off to keep only the disclosures where a real position was open. It has no effect on the aggregated files, which never publish a zero.

## `reportableSharesOnly` (type: `boolean`):

Keep only securities that are on the FCA's current UK reportable shares list, which is the register of shares in scope of the short selling rules today. It cuts the delisted and out of scope companies out of the historic archive and leaves the ones still trading.

## `sortBy` (type: `string`):

How to order the positions before the maximum is applied. Largest position first puts the most shorted companies at the top, which is the order a short interest screen wants. Sorting by holder groups an archive search by fund.

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

Hard cap on the rows saved, which is also the cap on what the run can cost. The current file holds about 420 positions and the historic file about 2,900, so the default returns both of them whole with room to spare.

## Actor input object example

```json
{
  "dataset": "current",
  "includeClosedPositions": true,
  "reportableSharesOnly": false,
  "sortBy": "percentDesc",
  "maxResults": 1000
}
```

# Actor output Schema

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

Every matching net short position from the FCA register, one row per company for the aggregated files and one row per disclosure for the named holder archive.

# 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 = {
    "dataset": "current",
    "sortBy": "percentDesc",
    "maxResults": 1000
};

// Run the Actor and wait for it to finish
const run = await client.actor("spookyweb/uk-short-selling-positions").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 = {
    "dataset": "current",
    "sortBy": "percentDesc",
    "maxResults": 1000,
}

# Run the Actor and wait for it to finish
run = client.actor("spookyweb/uk-short-selling-positions").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 '{
  "dataset": "current",
  "sortBy": "percentDesc",
  "maxResults": 1000
}' |
apify call spookyweb/uk-short-selling-positions --silent --output-dataset

```

## MCP server setup

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

```

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/b9uKvnP67UONbNWMV/builds/tR0Ve2Mpg48DLjj3h/openapi.json