# UK FCA Warning List (`spookyweb/uk-fca-warning-list`) Actor

Scrapes the FCA Warning List of unauthorised firms. Returns firm and trading names, addresses, phones, emails, websites and the date published, and for a clone firm the authorised firm it impersonates with its Firm Reference Number.

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

## Pricing

from $0.60 / 1,000 warnings

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 FCA Warning List

### 🔍 What does UK FCA Warning List do?

**UK FCA Warning List** scrapes the [Financial Conduct Authority's Warning List of unauthorised firms](https://www.fca.org.uk/consumers/warning-list-unauthorised-firms) and returns it as structured rows. These are the firms and individuals the FCA has **warned the public about**: unauthorised operators, scams, and **clone firms** impersonating genuine authorised businesses. The easiest way to try it is to leave the search box empty, set **Max entries** to 20 and press Start, which returns the twenty most recently updated warnings.

The list holds more than **18,000 entries** and the FCA adds to it most working days. UK FCA Warning List reads the FCA's own published pages over plain HTTP and returns every field the FCA publishes against an entry, including the field that matters most on a clone: **which authorised firm is being impersonated, and its Firm Reference Number**.

The FCA site sits behind Cloudflare and decides by IP address. Measured from an Apify container: an unproxied request is refused, and so is every datacentre address, while **UK residential addresses are served normally**. The Actor therefore runs through **Apify Residential proxy in the United Kingdom by default**, and picks a working exit with a cheap probe before it starts. You do not have to configure anything for this, but it is why a proxy is not optional here.

This Actor reproduces the FCA's published Warning List and adds nothing to it. Every name, address, telephone number, email address and website in the output is text the FCA has itself published on `fca.org.uk`. The Actor makes no assessment of any firm or person, draws no inference beyond what the page states, and never marks an entry as anything the FCA has not marked it as.

### 📊 What data can I extract?

One row per Warning List entry.

| Field | Type | What it holds |
|---|---|---|
| `firmName` | string | Name of the unauthorised firm or individual, with the clone label and list badge removed |
| `publishedName` | string | The page heading exactly as the FCA prints it, including any clone label |
| `tradingNames` | array | Every name the entry is filed under. The FCA writes them into one heading separated by a slash and they are split back out |
| `listingFlag` | string | The badge the list prints beside a name, `new` or `updated`, or null |
| `isClone` | boolean | Whether the FCA describes the entry as a clone of a genuine authorised firm. Null when the warning page was not read |
| `clonedFirms` | array | The authorised firms being impersonated, each with `firmName`, `firmReferenceNumber`, `address`, `telephone`, `emails` and `website` as the FCA publishes them |
| `clonedFirmNames` | array | Names of the authorised firms being impersonated, flattened for joining |
| `clonedFirmReferenceNumbers` | array | Firm Reference Numbers of those authorised firms, for joining to the FCA Register |
| `addresses` | array | Addresses the unauthorised firm has been using |
| `telephones` | array | Telephone numbers as published |
| `mobiles` | array | Mobile numbers, where the page lists them separately |
| `faxNumbers` | array | Fax numbers, which appear on older entries only |
| `emails` | array | Email addresses as published, decoded from the obfuscation the FCA site applies to them |
| `websites` | array | Websites and domains as published |
| `socialMediaDetails` | string | Social media handles the FCA lists, in the FCA's own wording |
| `otherInformation` | string | Any extra note the FCA prints under Other Information |
| `datePublished` | string | When the FCA first published the warning, ISO 8601 |
| `dateUpdated` | string | When the FCA last updated the warning, ISO 8601 |
| `warningUrl` | string | The public FCA warning page the row was read from |
| `slug` | string | The FCA's own URL slug, stable across runs and usable as a key |
| `nodeId` | string | The FCA site's internal content id for the page |
| `retrievedAt` | string | When the row was collected, ISO 8601 |

Every field is nullable, because the FCA does not publish every field for every entry. Some entries carry a name and nothing else.

### 💡 Why scrape the FCA Warning List?

**Payee screening.** Check a payee name, domain or email address against the names, websites and addresses the FCA has published warnings about, before a payment leaves an account.

**Clone detection.** A clone firm entry names the genuine authorised firm the fraudsters are copying and gives its Firm Reference Number. That turns "is this the real Barclays Wealth" into a lookup with an answer, because the impersonated firm is its own field rather than a phrase buried in a name string.

**Onboarding and KYC checks.** Run a prospective customer, counterparty or introducer against the whole list, and keep the `warningUrl` so the check can be evidenced later.

**Change monitoring.** Filter by **Published from** and schedule a daily run to capture only warnings added since yesterday, so a fraud team sees new entries the day the FCA publishes them.

**Domain and brand watch.** The `websites` and `emails` fields carry the domains fraudsters are using. Filtering these for a brand name surfaces the sites impersonating it.

**Building a screening list.** Pull the whole list once, then top it up with a scheduled date filtered run, and hold it alongside the FCA Register so an unauthorised firm and an authorised one can be told apart in one query.

### 🚀 How do I use UK FCA Warning List?

1. Click **Try for free** and sign in to Apify, or open the Actor from your Console.
2. Leave **Search the Warning List** empty to walk the whole list, or type a firm name, a domain or a keyword to narrow it.
3. Set **Max entries** to the number of rows you want back. Each entry returned is one billable result.
4. Turn on **Clone firms only** if you only want entries where a genuine authorised firm is being impersonated.
5. Set **Published from** to a date such as `2026-01-01` to capture only recent warnings, which is the right setting for a scheduled monitoring run.
6. Press **Start**, and download the results as JSON, CSV, Excel or XML, or read them through the API.

The run finishes with a **Run summary** record giving the search that ran, how many entries the Warning List held for it, how many were read and saved, and why the run stopped.

### ⬇️ Input

| Field | Type | Default | What it does |
|---|---|---|---|
| `search` | string | empty | Text matched against the names on the Warning List. Empty walks the whole list |
| `startsWith` | string | empty | Keep only entries whose name begins with this letter, using the FCA's own A to Z control |
| `cloneOnly` | boolean | `false` | Keep only clone firms. Read from each warning page, so it turns warning details on |
| `publishedFrom` | string | none | Keep warnings first published on or after this date, `YYYY-MM-DD` |
| `publishedTo` | string | none | Keep warnings first published on or before this date, `YYYY-MM-DD`, inclusive of the whole day |
| `sortBy` | string | `updated` | Order the list by date updated, date published, or firm name |
| `sortOrder` | string | `desc` | Newest or Z to A first, or oldest or A to Z first |
| `fetchWarningDetails` | boolean | `true` | Open each firm's own page for contact details and clone information |
| `maxResults` | integer | `100` | Hard cap on entries returned, up to 500 |
| `maxRecordsScanned` | integer | `400` | Safety stop on how many entries are read while trying to fill the cap |
| `proxyConfiguration` | object | Apify Residential, GB | Which proxy the run goes through. The default is the only setting measured to work |

A date that cannot be read as a date, a `startsWith` that is not a single letter, or a window whose start is after its end **stops the run with a message naming the field**. A filter is never accepted and quietly ignored, because a search that silently ran without the filter you asked for returns the wrong answer with full confidence.

```json
{
  "search": "capital",
  "cloneOnly": true,
  "publishedFrom": "2026-01-01",
  "maxResults": 100,
  "fetchWarningDetails": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"],
    "apifyProxyCountry": "GB"
  }
}
```

### ⬆️ Output

#### Table view

| Firm | Clone | Impersonating | Websites | Published |
|---|---|---|---|---|
| capitalrisefinancelimited.com | true | CapitalRise Finance Limited | capitalrisefinancelimited.com | 2026-08-10 |
| hanfcl.com | true | HANLEY FINANCIAL CONSULTANTS LIMITED | https://hanfcl.com | 2026-08-14 |
| SABITCIFT HISSE | false | | www.sabitcift-hisse.ltd | 2026-08-14 |

The dataset ships two views. **Warning List entries** is the general view. **Clone firms** puts the impersonated authorised firm and its Firm Reference Number in the front columns, which is the shape a screening join wants.

#### JSON

```json
{
  "firmName": "capitalrisefinancelimited.com",
  "publishedName": "capitalrisefinancelimited.com (Clone of FCA authorised firm)",
  "tradingNames": ["capitalrisefinancelimited.com"],
  "listingFlag": "new",
  "isClone": true,
  "clonedFirms": [
    {
      "firmName": "CapitalRise Finance Limited",
      "firmReferenceNumber": "816789",
      "address": "33 Cavendish Square, London, W1G 0PW, UNITED KINGDOM",
      "telephone": "+4402038692620",
      "emails": ["compliance@capitalrise.com"],
      "website": "https://www.capitalrise.com/"
    }
  ],
  "clonedFirmNames": ["CapitalRise Finance Limited"],
  "clonedFirmReferenceNumbers": ["816789"],
  "addresses": [],
  "telephones": [],
  "mobiles": [],
  "faxNumbers": [],
  "emails": ["support@capitalrisefinancelimited.com"],
  "websites": ["capitalrisefinancelimited.com"],
  "socialMediaDetails": null,
  "otherInformation": null,
  "datePublished": "2026-08-10T16:35:06.000Z",
  "dateUpdated": "2026-08-10T15:32:00.000Z",
  "warningUrl": "https://www.fca.org.uk/news/warnings/capitalrisefinancelimitedcom-clone-fca-authorised-firm",
  "slug": "capitalrisefinancelimitedcom-clone-fca-authorised-firm",
  "nodeId": "172956",
  "retrievedAt": "2026-08-16T16:11:20.605Z"
}
```

### 👥 How clone firm entries work

A clone firm is a fraudster using the name, address, Firm Reference Number or website of a genuine authorised business to look legitimate. The FCA publishes these as their own kind of entry, with two blocks of details: the ones the fraudsters are using, and the correct ones belonging to the real firm.

UK FCA Warning List keeps those two apart. The fraudster's details go in `addresses`, `telephones`, `emails` and `websites`. The real firm's details go in `clonedFirms`, with its `firmReferenceNumber`, which is the key you can join to the FCA Register.

Two honest limits:

- **Not every clone names an FCA authorised firm.** Some entries are clones of a company registered at Companies House or incorporated overseas, and those carry no Firm Reference Number because the impersonated business was never FCA authorised. On those, `isClone` is `true` and `clonedFirms` is empty.
- **The oldest entries have no clone block at all.** The FCA has used three page layouts over the years and the earliest wrote the clone status into the name instead. Those entries are still marked `isClone: true`, from the name, but there is nothing structured to put in `clonedFirms`.

Where the warning page was never read, because **Fetch full warning details** was turned off, `isClone` is `null` rather than `false`. An entry nothing has classified is not an entry known not to be a clone, and the output says so.

### 🗂️ Coverage and freshness

The Warning List held **18,589 entries** when this Actor was last verified against it. The FCA adds entries most working days and updates existing ones, and both dates are in the output, so a monitoring run can key off whichever it needs.

Entries stay on the list after publication. The FCA states that a firm's absence from the Warning List does not mean it is authorised, and the Actor says the same when a search returns nothing. To check whether a firm **is** authorised, that is a separate register.

Some entries carry very little. The FCA has published entries naming a firm with no address, telephone number, email or website at all. Those come back as valid rows with empty arrays, because that is what the FCA published. What does not come back is a row invented from a page the Actor could not read: a warning page whose details block is missing is **skipped, counted in the run summary as unreadable, and not charged for**.

### ⏱️ Run behaviour and limits

- **Paging stops on the FCA's own count**, the "Displaying 1 to 100 of 18,589" the list prints on every page, or on the absence of its next link. It never stops because a page arrived shorter than expected, which is also what a partly failed response looks like.
- **A run that hits its time limit stops cleanly** and keeps everything already collected, saying so in the log and the run summary.
- **A failure part way through keeps the rows already saved** and finishes. Only a run that collected nothing at all is a failed run, and the log says which of the two happened.
- **An empty result is a successful run**, not an error. A firm that is not on the Warning List is a real and often welcome answer.
- The Actor is deliberately polite: one request at a time, a pause between requests, and a backoff that honours `Retry-After` on rate limiting and server errors.
- **A blocked address is fixed by a different address**, so a 401, 403, 407, 429 or 5xx rotates to a fresh residential exit and backs off, rather than retrying into the same wall. The exit session is pinned for the whole crawl and salted with the run id, so the FCA sees one visitor walking the pages and a later run never inherits an address that already died.

#### Measured throughput

Read from real Apify runs on 16 August 2026, at 512 MB through Apify Residential GB:

| Mode | Rows | Runtime | Rows per minute |
|---|---|---|---|
| Full warning details | 100 | 163 s | about 37 |
| Listing only, `fetchWarningDetails: false` | 100 | 5 s | about 1,200 |
| Full details, the default try it input | 20 | 38 s | about 32 |

A full detail run is paced by the FCA's own response time over a residential hop, roughly 1.6 seconds per entry. The 500 entry ceiling therefore needs a run timeout above the 300 second default. Set one, or split the work by date window or first letter, and the Actor will stop cleanly at whatever limit it meets and keep what it collected.

### 💰 How much does it cost?

UK FCA Warning List runs on **pay per event**. You are charged for each Warning List entry saved to the dataset, plus Apify's standard Actor start event, and for nothing else. The current price per entry is shown on this Actor's listing page and in the Console before you run it, so a run that saves 100 entries is 100 charges at that price.

Nothing is charged for an entry the Actor could not read and therefore did not save, and nothing is charged for a search that matched nothing. Charging happens **before** rows are written, and only the rows that were charged for are written, so a run that reaches your per run cost cap stops there rather than delivering untracked extra rows.

Because the Actor needs no browser it runs on **512 MB**, which keeps the start event to a single charge. Leaving the memory setting alone is the cheapest way to run it.

**Platform usage is not billed to you.** Under pay per event the compute and the residential proxy traffic a run consumes come out of the price of the entries, not out of your Apify usage. The figures below are here so the two modes can be compared honestly, and so the numbers can be checked rather than taken on trust.

Measured on 17 August 2026 against the pages the Actor actually requests:

| Mode | Transfer per 100 entries | Compute per 100 entries | Cost to run 100 entries |
|---|---|---|---|
| Full warning details | 4.8 MB | 0.023 compute units | about $0.043 |
| Listing only, `fetchWarningDetails: false` | 56 KB | 0.0007 compute units | about $0.0006 |

A warning page is a heavy Drupal document: 47 KB over the wire, against 558 bytes for the same entry's row in the listing. So full details is about **85 times the transfer** of reading the listing alone. The cost column is that transfer at Apify Residential's $8 per GB, plus compute at $0.20 per compute unit for 512 MB held over the 163 seconds and 5 seconds the two modes were measured at. Every input to it is in the table or the run log.

If you only need names, dates and warning URLs, turning **Fetch full warning details** off makes a run almost free to execute and about thirty times faster. If you need the contact details and the cloned firm, leave it on and the transfer is the price of the data.

### 🔌 Integrations

UK FCA Warning List is an Apify Actor, so it comes with the platform around it:

- **[Schedules](https://docs.apify.com/platform/schedules)** to run it daily with a `publishedFrom` date and capture new warnings automatically.
- **[Webhooks](https://docs.apify.com/platform/integrations/webhooks)** to fire when a run finishes, so a new clone entry can raise an alert in your own system.
- **[Integrations](https://docs.apify.com/platform/integrations)** with Make, Zapier, Slack, Google Sheets, Airtable and others, without writing code.
- **[Monitoring](https://docs.apify.com/platform/monitoring)** to alert you if a scheduled run fails or returns fewer rows than usual.
- **[MCP](https://docs.apify.com/platform/integrations/mcp)** so an AI agent can call the Actor as a tool and screen a name as part of a wider task.

### 🔗 Using UK FCA Warning List with the Apify API

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

```bash
curl -X POST "https://api.apify.com/v2/acts/spookyweb~uk-fca-warning-list/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "search": "capital",
    "cloneOnly": true,
    "maxResults": 50
  }'
```

With the JavaScript client:

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

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

const run = await client.actor('spookyweb/uk-fca-warning-list').call({
  publishedFrom: '2026-01-01',
  cloneOnly: true,
  maxResults: 200,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
for (const entry of items) {
  console.log(entry.firmName, 'impersonating', entry.clonedFirmNames.join(', '));
}
```

With the Python client:

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")

run = client.actor("spookyweb/uk-fca-warning-list").call(run_input={
    "search": "barclays",
    "maxResults": 50,
})

for entry in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(entry["firmName"], entry["websites"])
```

See the [Apify API reference](https://docs.apify.com/api/v2) for the full set of endpoints.

### ❓ FAQ

#### Do I need an FCA API key or account?

No. The FCA Warning List is published as ordinary web pages and UK FCA Warning List reads them over plain HTTP. It does need a UK residential proxy, which Apify provides and the Actor is already configured to use.

#### Why does it need a proxy?

Because the FCA site is behind Cloudflare and decides by IP address. Measured from an Apify container, an unproxied request came back 403 three times out of three and the Apify datacentre pool came back 403 six sessions out of six, while Apify Residential in the United Kingdom came back 200 six sessions out of six. The proxy is not there to hide anything, it is there because a datacentre address cannot read the page at all.

#### Can I use my own proxy?

Yes. Put your own settings in **Proxy configuration**. It has to be an address the FCA serves, which in practice means UK residential. You can also turn the proxy off, and the Actor will say plainly in the log that the run will very probably collect nothing.

#### Why is a run slower than I expected?

Each warning page is fetched one at a time through a residential hop, which costs roughly 1.6 seconds per entry. That pacing is deliberate: it keeps the Actor polite to a regulator's website. Turn **Fetch full warning details** off if you only need names and dates, and the same 100 entries come back in about five seconds.

#### What is a clone firm?

A fraudster using the name, address, Firm Reference Number or website of a genuine authorised business so that their approach looks legitimate. The FCA publishes the details being misused alongside the correct details of the real firm, and this Actor keeps the two in separate fields.

#### If a firm is not on the Warning List, is it safe?

No, and the FCA says so itself. The Warning List records firms the FCA has published a warning about. Absence from it is not authorisation. Checking whether a firm is authorised is a different question and a different register.

#### How current is the data?

Each run reads the FCA's pages live at the moment it runs, so it is as current as the FCA's own website. The output carries both the date the FCA first published a warning and the date it last updated it.

#### How do I capture only new warnings?

Set `publishedFrom` to the date you last ran it and schedule the Actor daily. Setting that field also sorts the list newest first so the run stops as soon as it passes your date, which keeps a monitoring run small.

#### Can I search for a specific firm or domain?

Yes. Put the firm name or domain in `search`. The search runs against the names on the Warning List, so a domain will match where the FCA has filed the entry under that domain, which it often does.

#### Why is `isClone` sometimes null?

Because clone status is only on a firm's own warning page. If you turn **Fetch full warning details** off, entries come back from the list alone and have not been classified, so the field is `null` rather than a `false` that would look like a checked answer.

#### What happens if a search returns nothing?

The run succeeds with zero rows and says so in the log. It is not treated as an error, because a firm not appearing on the Warning List is a real answer.

#### Can I get every entry in one run?

The per run cap is 500 entries. At roughly 1.6 seconds per entry with full details that is about 13 minutes, so raise the run timeout above the 300 second default if you want the full 500 in one go. To take the whole list of more than 18,000 entries, run it in date windows using `publishedFrom` and `publishedTo`, or by letter using `startsWith`.

### ⚖️ Is it legal to scrape the FCA Warning List?

The FCA Warning List is published by the Financial Conduct Authority on its public website for the express purpose of warning consumers and firms, with no login, paywall or access restriction. Reading published public pages is generally lawful, and UK FCA Warning List reads only pages any visitor can open, at a deliberately modest request rate.

This Actor reproduces the FCA's published list without addition. It does not editorialise, does not rank or score any firm or person, and does not assert anything the FCA has not itself published. The entries name firms and sometimes individuals in connection with alleged wrongdoing, and the FCA is the sole source and author of those statements.

The output contains information about named businesses and, in some entries, named individuals, so it can constitute personal data under UK GDPR. You are the controller of any copy you keep. Have a lawful basis for processing it, keep it accurate and current by re-running rather than relying on an old export, and use it for the purpose the FCA published it for. If you make a decision about a person on the strength of a Warning List entry, verify it against the FCA's own page first, which is why `warningUrl` is in every row.

This is not legal advice. Take your own if you are unsure how it applies to what you are building.

### 👍 Your feedback

Found a page the parser reads wrongly, or need a field the FCA publishes that is not in the output? Open an issue on the **Issues** tab of this Actor and it will be looked at. If you need a variant of this Actor built for a specific screening workflow, say so in an issue and it can be quoted.

### 🔎 You might also like

- [UK FCA Enforcement Notices](https://apify.com/spookyweb/uk-fca-enforcement-notices) for firms that were authorised and were then fined, censured or banned.
- [UK FCA Register](https://apify.com/spookyweb/uk-fca-register) for the firms and individuals that **are** authorised, which is the register to check when the Warning List returns nothing.
- [UK Disqualified Directors](https://apify.com/spookyweb/uk-disqualified-directors) for the Companies House register of people banned from running a company.
- [UK Court Listings](https://apify.com/spookyweb/uk-court-listings) for cases coming up in the courts.
- [UK Business Risk Report](https://apify.com/spookyweb/uk-business-risk-report) for a combined view of a company's public risk signals.
- [Website Contact Scraper](https://apify.com/spookyweb/website-contact-scraper) for pulling emails, phones and social links off a domain you are investigating.

# Actor input Schema

## `search` (type: `string`):

Text to match against the names on the FCA Warning List, for example barclays, crypto or a firm you have been asked to pay. Leave it empty to walk the whole list, which is the right setting when you want everything published in a date window.

## `startsWith` (type: `string`):

Keep only entries whose name begins with this letter, using the A to Z control the FCA publishes on the list itself. Leave it on Any letter for everything. It combines with the search box, so B plus barclays returns only the Barclays entries filed under B.

## `cloneOnly` (type: `boolean`):

Keep only clone firms, meaning entries where fraudsters are impersonating a genuine authorised business. These are the entries that name the authorised firm being copied and its Firm Reference Number. Read from each firm's own warning page, so it turns warning details on.

## `publishedFrom` (type: `string`):

Keep only warnings the FCA first published on or after this date, written as YYYY-MM-DD, for example 2026-01-01. Anything that cannot be read as a date stops the run with a message rather than being ignored. Setting this sorts the list newest first so the run can stop as soon as it passes the date.

## `publishedTo` (type: `string`):

Keep only warnings the FCA first published on or before this date, written as YYYY-MM-DD, for example 2026-06-30. The whole of the day named is included. Anything that cannot be read as a date stops the run with a message rather than being ignored.

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

Which column the FCA list is ordered by before the run reads it, using the sort links the list publishes. Date updated is the FCA's own default. Setting a published from date overrides this to date published, because that is what lets the run stop early.

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

Whether to read the FCA list newest first or oldest first, or A to Z rather than Z to A when sorting by firm name. Newest first is the FCA's own default and is what you want for monitoring new warnings.

## `fetchWarningDetails` (type: `boolean`):

Open each firm's own warning page to collect the address, phone, email, website, social media handles and, for a clone, the authorised firm being impersonated. Leave it on. Turning it off returns names and dates only, and costs one request per firm less.

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

Hard cap on how many Warning List entries a run returns. Each entry saved is one billable result. The ceiling is 500 because reading one warning page each is roughly what fits inside a comfortable run, and a run that runs out of time stops cleanly and keeps everything collected.

## `maxRecordsScanned` (type: `integer`):

Safety stop on how many Warning List entries a run reads before it gives up on filling the result cap. It matters when cloneOnly is set, because roughly one entry in twelve is a clone, so returning 100 clones means reading about 1,200 entries. Reading an entry it then skips is cheap: the clone relationship is published in the listing name, so a non-clone is dropped without ever loading its page.

## `proxyConfiguration` (type: `object`):

Which proxy the run goes through. The FCA site sits behind Cloudflare and answers 403 to Apify datacentre addresses, so this defaults to Apify Residential in the United Kingdom, which is what it answers 200 to. Change it only if you have your own proxy that the site accepts.

## Actor input object example

```json
{
  "search": "capital",
  "startsWith": "",
  "cloneOnly": false,
  "sortBy": "updated",
  "sortOrder": "desc",
  "fetchWarningDetails": true,
  "maxResults": 50,
  "maxRecordsScanned": 1500,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "GB"
  }
}
```

# Actor output Schema

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

One row per firm or individual on the FCA Warning List, with the contact details published against it and, for a clone, the authorised firm it impersonates.

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

The search that ran, how many entries the Warning List held for it, how many were read and saved, and why the run stopped.

# 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 = {
    "search": "capital",
    "maxResults": 50,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "GB"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("spookyweb/uk-fca-warning-list").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 = {
    "search": "capital",
    "maxResults": 50,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "GB",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("spookyweb/uk-fca-warning-list").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 '{
  "search": "capital",
  "maxResults": 50,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "GB"
  }
}' |
apify call spookyweb/uk-fca-warning-list --silent --output-dataset

```

## MCP server setup

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

```

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/QYeI35gvyCGLocvSJ/builds/x71DALMMnkrjduVRE/openapi.json