# UK Company Distress Check: Status, Filings, Insolvency (`accountable_eel/uk-company-distress-check`) Actor

Check if a UK company is insolvent or in distress. One row per company number: Companies House status, overdue accounts, charges, insolvency cases and Gazette insolvency notices, with a distress level. No API key needed. Unknown numbers are never charged.

- **URL**: https://apify.com/accountable_eel/uk-company-distress-check.md
- **Developed by:** [Adriana Voss](https://apify.com/accountable_eel) (community)
- **Categories:** Lead generation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 company checkeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## UK Company Distress Check: Status, Filings, Insolvency

Paste a list of UK company numbers and get one row per company that answers a single question:
**is this company insolvent or heading that way?** Each row reads the company's Companies House
record (status, overdue accounts and confirmation statement, registered charges, insolvency cases)
and searches The Gazette for insolvency notices against it, then folds the two into a
`distressLevel` of `high`, `medium` or `none` with the flags behind it. The quickest way to check
if a UK company is insolvent for a whole list at once. No API key, no account, no browser.

### Who it's for

- **Credit controllers and finance teams** checking customers before extending terms, and
  re-checking the debtor book every month.
- **Procurement and supplier-risk teams** screening a vendor list for companies that are in
  liquidation, in administration or about to be struck off.
- **Landlords, lenders and insurers** checking a counterparty's outstanding charges and
  insolvency history before signing.
- **Insolvency, turnaround and M\&A advisers** finding the companies in a portfolio or a sector
  list that show early signs: overdue filings, a strike-off proposal, a winding-up petition.
- **Sales and RevOps teams** removing dissolved and insolvent companies from a CRM export.

### What you get

One flat row per company:

| What | Columns |
| --- | --- |
| The answer | `distressLevel`, `distressFlags` |
| The company | `companyNumber`, `companyName`, `companyStatus`, `companyStatusText`, `companyType`, `dateOfCreation`, `dateOfCessation`, `previousCompanyNames` |
| Filings | `accountsNextDueDate`, `accountsOverdue`, `lastAccountsMadeUpTo`, `confirmationStatementNextDueDate`, `confirmationStatementOverdue`, `strikeOffProposed` |
| Insolvency cases at Companies House | `hasInsolvencyHistory`, `insolvencyCaseCount`, `latestInsolvencyCaseType`, `insolvencyCases` |
| Charges (mortgages and other security) | `chargesTotal`, `chargesOutstanding`, `chargesSatisfied`, `chargesPartSatisfied`, `latestChargeCreatedOn` |
| Gazette insolvency notices | `gazetteNoticeCount`, `latestGazetteNoticeDate`, `latestGazetteNoticeType`, `gazetteNotices` |
| Evidence | `checksRun`, `checkNotes`, `source`, `sourceUrl`, `gazetteSearchUrl`, `scrapedAt` |

Two example rows, shortened. Read on 2026-10-11:

| companyNumber | companyName | distressLevel | companyStatus | accountsOverdue | insolvencyCaseCount | latestInsolvencyCaseType | chargesOutstanding | gazetteNoticeCount | latestGazetteNoticeType |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| 00365335 | WL REALISATIONS (2023) LIMITED | high | liquidation | true | 2 | Creditors voluntary liquidation | 7 | 3 | Appointment of Liquidators |
| 00445790 | TESCO PLC | none | active | false | 0 | | | 0 | |

The first company traded as Wilko until 2023; `previousCompanyNames` carries that, and the Gazette
notices published under the old name are matched to it.

#### The flags and the level

`distressFlags` is drawn from a fixed set, and `distressLevel` is computed from it by a rule you
can read rather than a score you have to trust.

| Flag | Fires when |
| --- | --- |
| `INSOLVENCY_STATUS` | The Companies House status is liquidation, administration, receivership, voluntary arrangement or insolvency proceedings |
| `COMPANY_DISSOLVED` | The company is dissolved, closed or removed from the register |
| `STRIKE_OFF_PROPOSED` | The status carries an active proposal to strike the company off |
| `ACCOUNTS_OVERDUE` | Companies House marks the annual accounts overdue |
| `CONFIRMATION_STATEMENT_OVERDUE` | Companies House marks the confirmation statement overdue |
| `INSOLVENCY_CASE_ON_RECORD` | The register lists at least one insolvency case, current or past |
| `GAZETTE_INSOLVENCY_NOTICE` | The Gazette has at least one corporate insolvency notice for this company |
| `GAZETTE_WINDING_UP_PETITION` | One of those notices is a petition to wind the company up |
| `GAZETTE_WINDING_UP_ORDER` | One of those notices is a winding-up order |
| `GAZETTE_NOTICE_LAST_12_MONTHS` | A Gazette insolvency notice was published in the last 365 days |

**The rule.** `high` when any of `INSOLVENCY_STATUS`, `COMPANY_DISSOLVED`, `STRIKE_OFF_PROPOSED` or
`GAZETTE_NOTICE_LAST_12_MONTHS` is present. `medium` for any other flag. `none` for no flag.

Two rules the flags obey:

1. **A check that could not run never raises a flag.** If the Gazette could not be read, the
   Gazette columns are empty and no Gazette flag fires. `checksRun` lists what answered.
2. **Empty is not zero.** `chargesTotal` is empty when the register printed no count, and 0 only
   when the source said zero. `checkNotes` says in plain English why anything is empty.

Registered charges are reported but are not a flag: most healthy companies with a bank loan have
outstanding charges.

### How to use UK Company Distress Check

1. **In the Apify Console.** Open the actor page and click **Start** — the `companyNumbers` field is already pre-filled with a working example. Results land in the run's dataset as soon as each item is found.
2. **Via the API.** Call it directly with a POST request — no Console needed once you have an API token:
   ```bash
   curl "https://api.apify.com/v2/acts/accountable_eel~uk-company-distress-check/run-sync-get-dataset-items?token=<YOUR_TOKEN>" \
     -X POST \
     -H "Content-Type: application/json" \
     -d '{"companyNumbers":["00365335","00445790"]}'
   ```
3. **On a schedule.** Save this actor as an Apify **Task** with the input you want, then add a **Schedule** (hourly, daily, weekly) so it runs on its own — no server of your own required.

### Input

```json
{
  "companyNumbers": [
    "00365335",
    "00445790"
  ]
}
```

One Companies House company number per line, e.g. 00445790 or SC012345. Leading zeros may be left off, and a Companies House company page URL works too. Each company gets one row: status, overdue filings, charges, insolvency cases and any Gazette insolvency notice, with a distress level. No key needed. Accepted formats: 00445790, SC012345, 445790, https://find-and-update.company-information.service.gov.uk/company/00445790.

### Output

| query | found | status | companyNumber | companyName | distressLevel | distressFlags | companyStatus | companyStatusText | companyType | dateOfCreation | dateOfCessation | accountsNextDueDate | accountsOverdue | lastAccountsMadeUpTo | confirmationStatementNextDueDate | confirmationStatementOverdue | strikeOffProposed | hasInsolvencyHistory | insolvencyCaseCount | latestInsolvencyCaseType | insolvencyCases | chargesTotal | chargesOutstanding | chargesSatisfied | chargesPartSatisfied | latestChargeCreatedOn | gazetteNoticeCount | latestGazetteNoticeDate | latestGazetteNoticeType | gazetteNotices | previousCompanyNames | checksRun | checkNotes | source | sourceUrl | gazetteSearchUrl | scrapedAt |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| 00365335 | true | OK | <company number> | <company name> | <distress level> | <distress flags> | <status> | <status as printed> | <company type> | <incorporated on> | <dissolved on> | <accounts due by> | <accounts overdue> | <last accounts made up to> | <confirmation statement due by> | <confirmation statement overdue> | <strike-off proposed> | <insolvency history> | <insolvency cases> | <latest insolvency case> | \<insolvency cases (list)> | <charges registered> | <charges outstanding> | <charges satisfied> | <charges part satisfied> | <latest charge created> | <gazette insolvency notices> | <latest gazette notice> | <latest gazette notice type> | \<gazette notices (list)> | <previous names> | <checks run> | <notes> | <companies house route> | <companies house page> | <gazette search> | 1970-01-01T00:00:00.000Z |

A company number that Companies House does not know, a number in the wrong format, a duplicate and
a company whose page could not be read each come back as a row with `"found": false`, a `status`
(`NOT_FOUND`, `BAD_FORMAT`, `DUPLICATE`, `BLOCKED`) and a `message` that says why. They are never
charged.

### Example runs

Three inputs that need no key of any kind and return rows as they stand. Paste one into the Input
tab and press Start.

**1. Is this company insolvent? One in liquidation next to a healthy one**

```json
{
  "companyNumbers": ["00365335", "00445790"]
}
```

**2. A supplier list, numbers pasted as a spreadsheet gives them (leading zeros lost, one Scottish)**

```json
{
  "companyNumbers": ["445790", "365335", "SC004276"],
  "onlyFound": true
}
```

**3. A long list, fast: Companies House only, without the Gazette search**

```json
{
  "companyNumbers": ["00365335", "00445790", "00000006"],
  "includeGazette": false,
  "maxConcurrency": 5
}
```

### Pricing

Pay-per-event. A flat per-run fee covers session/proxy warmup; each independent
source is billed under its own event, only when that source actually returns
data — see `.actor/pay_per_event.json` for exact prices. A miss is never
charged.

You pay once per company whose Companies House record was read, and nothing else:

- A healthy company with no flags is a result and is charged. That answer is what you came for.
- An unknown number, a badly formed number and a company whose page could not be read are free.
- A number listed twice is checked and charged once.
- The Gazette search is included in the price. If the Gazette could not be read, the row still
  carries the full Companies House answer and says so in `checkNotes`.

### Use it from Clay, n8n, Make, or an AI agent

This actor runs synchronously over plain HTTP — call it directly from a script, a workflow tool, or an AI agent, no Apify Console needed once you have an API token.

```bash
curl "https://api.apify.com/v2/acts/accountable_eel~uk-company-distress-check/run-sync-get-dataset-items?token=<YOUR_TOKEN>" \
  -X POST \
  -H "Content-Type: application/json" \
  -d '{"companyNumbers":["00365335","00445790"]}'
```

**n8n.** Add an HTTP Request node: Method `POST`, URL `https://api.apify.com/v2/acts/accountable_eel~uk-company-distress-check/run-sync-get-dataset-items?token=<YOUR_TOKEN>`, Body Content Type `JSON`, JSON Body `{"companyNumbers":["00365335","00445790"]}` (swap in an expression from an earlier node for a real value).

**Clay.** Add an "HTTP API" column: Method `POST`, URL `https://api.apify.com/v2/acts/accountable_eel~uk-company-distress-check/run-sync-get-dataset-items?token=<YOUR_TOKEN>`, Body `{"companyNumbers":["{{UK company}}"]}`, mapping the row's UK company into the `companyNumbers` array.

**MCP.** In Claude, Cursor, or any MCP client with the Apify MCP server, ask for "check if UK company is insolvent" — the agent will find and run this actor.

### Where the data comes from

- **Companies House**, the UK's official company register. Without a key the actor reads the
  public register: the company's overview page, its Charges page and, when the company has
  insolvency history, its Insolvency page. With your own free Companies House API key it reads
  the same three records from the Companies House API instead. `source` says which route a row
  used.
- **The Gazette**, the UK's official public record, where insolvency notices must be published:
  winding-up petitions and orders, appointments of administrators and liquidators, creditors'
  meetings. The actor runs one search of the insolvency notices for the company number and keeps
  the corporate notices whose company name is the company's current or a previous name.

Both are published under the Open Government Licence.

### Limits, stated plainly

- **This is a register check, not a credit score.** It reports what the two official sources
  say today. It does not read accounts, estimate the chance of failure or say whether a company
  can pay you.
- **Overdue filings are a signal, not proof.** Many small companies file late and trade for
  years. Once a company is in liquidation or administration its filings are usually overdue as a
  matter of course; `checkNotes` says so on those rows.
- **A winding-up petition appears in the Gazette only once it is advertised**, which is at least
  a week after it is presented, and a petition that is paid off is never advertised.
- **The Gazette search matches on company number and name.** A notice that prints neither the
  number nor one of the company's names is not found. Notices that carry the number under a
  different name are left out and counted in `checkNotes`; `gazetteSearchUrl` opens the same
  search for a manual look.
- **The Gazette asks for 10 seconds between requests.** With the Gazette check on, a run takes
  about 10 seconds per company whatever the concurrency: 100 companies take about 17 minutes.
  Turn `includeGazette` off for speed.
- **Charge counts come from the register's Charges page.** When that page prints no count the
  charge columns are empty rather than 0. `latestChargeCreatedOn` looks at the newest page of
  charges only.
- **Insolvency practitioners, officers and persons entitled to a charge are not returned.**
- **Personal insolvency is out of scope.** Bankruptcy and other notices about individuals are
  dropped before anything is returned. This actor is about companies.
- **With your own API key**, Companies House allows 600 requests per 5 minutes on that key, and a
  company takes up to three. If the key is refused or its limit is reached, the row is read from
  the public register and says so.

### Data & privacy

The actor reads official public records about companies. It returns no data about individuals: no
officers, no persons with significant control, no insolvency practitioners, no personal
insolvency notices. An API key, if you give one, is used for the run's requests to Companies
House only, is never written to a row or a log, and nothing is stored between runs.

### FAQ

**Do I need a Companies House API key?**
No. Leave the key empty and the actor reads the public register. A key is worth adding only if
you already have one and want the answer to come from the API.

**What does `distressLevel: none` mean?**
That none of the flags fired in the checks listed in `checksRun`. It is not a statement that the
company is financially sound.

**A company is `high` but still trading. Is that a mistake?**
Companies trade through administration and through a proposal to strike off that is later
withdrawn. The flag says what the register says; `companyStatusText`, `insolvencyCases` and
`gazetteNotices` carry the detail.

**Can I run this every week over the same list?**
Yes. Save the input as a task and add a schedule. Each run returns the current state of every
company; compare `distressLevel` and `distressFlags` with the previous run's dataset to see what
changed.

**I only have company names, not numbers.**
Run Companies House Search first: it turns a name into company numbers, and its `companyNumber`
column pastes straight into this actor.

### Related actors

- **Companies House Search** to turn company names into company numbers.
- **Companies House UK Lookup** for the full register profile: address, SIC codes, company type.
- **UK Insolvency Notice Alerts** to be told when a new insolvency notice is published, across
  all companies or a watchlist.
- **Vendor Due Diligence** for suppliers outside the UK: registry, VAT, LEI and domain checks.
- **UK Company Incorporation Alert** for newly registered companies.

# Actor input Schema

## `companyNumbers` (type: `array`):

One Companies House company number per line, e.g. 00445790 or SC012345. Leading zeros may be left off, and a Companies House company page URL works too. Each company gets one row: status, overdue filings, charges, insolvency cases and any Gazette insolvency notice, with a distress level. No key needed. Accepted formats: 00445790, SC012345, 445790, https://find-and-update.company-information.service.gov.uk/company/00445790. You're only charged for the ones we actually find — a miss costs nothing.

## `testRun` (type: `boolean`):

Turn this on to test your input on a small sample before running the full list. Turn it off to process everything.

## `onlyFound` (type: `boolean`):

Only keep rows where something was actually found. Misses are always free, whether or not you show them here.

## `includeKeywords` (type: `array`):

Optional. Only keep results that mention at least one of these words (e.g. a job title, a city, a product name). Leave empty to keep everything.

## `excludeKeywords` (type: `array`):

Optional. Drop any result that mentions one of these words. Leave empty to skip nothing.

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

Optional. Stop the run once this many results have been found — useful for a quick, cheap sample. Leave blank for no limit.

## `columns` (type: `array`):

Choose which pieces of information to include in each result row. All are included by default.

## `apiKey` (type: `string`):

Leave empty: the actor reads the public Companies House register and needs no key. With your own key the same record is read from the Companies House API instead (600 requests per 5 minutes, your own quota). A free key is issued at once at developer.company-information.service.gov.uk when you register a REST application. The key is used for this run only and never appears in a row.

## `includeGazette` (type: `boolean`):

On by default. The Gazette asks for 10 seconds between requests, so each company adds 10 seconds to the run. Turn it off for a long list when Companies House status, filings, charges and insolvency cases are enough.

## `maxConcurrency` (type: `integer`):

Parallel requests. Keep conservative — this target has no browser fallback, so getting blocked costs more than slow-and-steady.

## Actor input object example

```json
{
  "companyNumbers": [
    "00365335",
    "00445790"
  ],
  "testRun": false,
  "onlyFound": false,
  "includeKeywords": [],
  "excludeKeywords": [],
  "columns": [
    "companyNumber",
    "companyName",
    "distressLevel",
    "distressFlags",
    "companyStatus",
    "companyStatusText",
    "companyType",
    "dateOfCreation",
    "dateOfCessation",
    "accountsNextDueDate",
    "accountsOverdue",
    "lastAccountsMadeUpTo",
    "confirmationStatementNextDueDate",
    "confirmationStatementOverdue",
    "strikeOffProposed",
    "hasInsolvencyHistory",
    "insolvencyCaseCount",
    "latestInsolvencyCaseType",
    "insolvencyCases",
    "chargesTotal",
    "chargesOutstanding",
    "chargesSatisfied",
    "chargesPartSatisfied",
    "latestChargeCreatedOn",
    "gazetteNoticeCount",
    "latestGazetteNoticeDate",
    "latestGazetteNoticeType",
    "gazetteNotices",
    "previousCompanyNames",
    "checksRun",
    "checkNotes",
    "source",
    "sourceUrl",
    "gazetteSearchUrl"
  ],
  "includeGazette": true,
  "maxConcurrency": 3
}
```

# 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 = {
    "companyNumbers": [
        "00365335",
        "00445790"
    ],
    "includeKeywords": [],
    "excludeKeywords": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("accountable_eel/uk-company-distress-check").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 = {
    "companyNumbers": [
        "00365335",
        "00445790",
    ],
    "includeKeywords": [],
    "excludeKeywords": [],
}

# Run the Actor and wait for it to finish
run = client.actor("accountable_eel/uk-company-distress-check").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 '{
  "companyNumbers": [
    "00365335",
    "00445790"
  ],
  "includeKeywords": [],
  "excludeKeywords": []
}' |
apify call accountable_eel/uk-company-distress-check --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,accountable_eel/uk-company-distress-check"
        }
    }
}
```

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/Ea0j1Tlkwizce07QX/builds/U2SbWNjBSXB7pGeu7/openapi.json
