# UK Company Registry Status & Filing Signals (`asunoki/uk-company-status-signals`) Actor

Check UK companies by number in official Companies House monthly data: status, overdue accounts and confirmation statements at the data date, insolvency-related status, charges and name-mismatch warnings. No officer data. Compare with your own earlier results to see what changed.

- **URL**: https://apify.com/asunoki/uk-company-status-signals.md
- **Developed by:** [Seisuke Nagahara](https://apify.com/asunoki) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 company founds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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 Registry Status & Filing Signals

Check UK companies by **company number** against the official Companies House **monthly data file**. For each number you get one flat JSON row: register status, whether accounts and the confirmation statement were **overdue at the data date**, insolvency-related status, registered charges, last filing dates, a name check against the registered and previous names, and optional comparison with rows from your own earlier run.

> **This is a monthly snapshot, not real-time register data.** Every row states the date its data is valid for. Anything that happened after that date (a filing, a status change, a dissolution) is not visible. Use it for screening and monitoring lists of companies, not for a point-in-time check of a single company.

It reports **register facts** and, separately, **rule-based signals** computed from them. It is **not** a credit report, a rating, or a recommendation about any company.

### What you get

- **Status:** Active, strike-off proposed, liquidation, administration, voluntary arrangement, receivership (as shown in the monthly file).
- **Filing signals at the data date:** accounts and confirmation statement overdue or not, with the due date and days overdue, plus a clear flag when a due date fell *after* the data date (unknown without a live check).
- **Charges:** registered, outstanding, part-satisfied and satisfied counts.
- **Name check:** give the name you hold; the row tells you if it matches the registered name, a previous name, or differs.
- **Change detection:** paste an earlier run's rows as `baseline` to see what changed between two data dates.
- **Evidence on every row:** data date, source file date and URL, file checksum, licence and attribution, source page URL, and caveats.
- **Fast and cheap at volume:** thousands of company numbers in seconds, no API key, no proxies.

### Typical uses

- Re-check a supplier, customer or portfolio list every month for status changes and overdue filings.
- Clean a CRM list: confirm that a number and a name belong together before you contact or invoice.
- Feed an AI agent a compact, well-labelled record with its data date and limits.
- Compare this month's rows with last month's to list companies whose status or filing position changed.

### How to use

1. Open the Input tab and add company numbers to `companies` (`"00445790"`, `"SC123456"`), or objects `{"companyNumber": "00445790", "companyName": "Tesco PLC"}`.
2. Run it (the default 512 MB is enough; a run takes seconds).
3. Read `lookupStatus` first, then `dataFreshness`, then `attention` and `inferences`. Export the dataset as JSON, CSV or Excel, or call it from the API or an MCP client.

### Data date and freshness

- `evidence.snapshotAsOf` is the data date: the end of the month before Companies House published the file (the October 2026 file is valid for **30 September 2026**).
- `evidence.sourceFileDate` is the file's own date; `evidence.indexBuiltAt` is when this Actor build converted it; `evidence.sourceFileUrl` and `evidence.sourceFileSha256` identify the exact file.
- `dataFreshness.status`: `current` (up to 45 days after the data date), `aging` (46 to 75 days: a newer file may exist) or `outdated` (over 75 days). **Rows from an outdated build are returned for reference only and are not charged.** `dataFreshness.newerSnapshotPublished` tells you if Companies House has already published a newer file than the one in this build.
- Overdue flags refer to the **data date**, not to today. About four in a hundred companies showed a changed status or newer filings two weeks after the data date in our own comparison with the live register.

### What each field means

| Question | Where | Kind |
|---|---|---|
| What does the register say? | `companyStatus`, `registerFacts`, `chargesSignals`, `filingSignals` | fact (at the data date) |
| Were filings overdue at the data date? | `accountsOverdue`, `confirmationStatementOverdue` | computed from register due dates |
| Is the status insolvency-related? | `insolvencySignals.statusIndicatesInsolvencyProcess` | fact (status value only) |
| Does my name match? | `nameCheck.result`: `match`, `previous_name`, `differs`, `not_provided` | computed |
| What do the rules flag? | `inferences[]` and `attention.level` | inference |
| What changed since my earlier run? | `changesSinceBaseline` | computed, only when comparable |

`attention.level` is `none_flagged`, `review` or `alert`. **`none_flagged` is not an all-clear, and `Active` is not a statement about solvency or suitability:** it means only that none of the listed rules fired on month-old data.

### Lookup results

`FOUND`, `NOT_IN_SNAPSHOT`, `AMBIGUOUS_NAME`, `INVALID_NUMBER`.

- **`NOT_IN_SNAPSHOT` does not mean the company does not exist or was dissolved.** The file lists live companies only. The number may belong to a dissolved company, to a company incorporated after the data date, or be mistyped. In our check, 12 of 13 numbers missing from the file were dissolved companies and 1 did not exist; the Actor never says which.
- A name on its own is used only when it is an **exact, unique** match among live companies; otherwise you get `AMBIGUOUS_NAME` with candidates or `NOT_IN_SNAPSHOT`. Always confirm the number before relying on a name-only match.
- Rows are returned in company-number order for speed; `inputPosition` is the position in your input.

### Compare with an earlier run (`baseline`)

Paste the dataset items of an earlier run into `baseline` (or give `baselineDatasetId` of your own dataset). A row lists changes only if the baseline row exists for that number, was produced by this Actor, and has an **earlier data date**. Otherwise `changesSinceBaseline.comparable` is `false` with the reason; the same data date means there is no new information. Nothing is stored between runs and nothing is shared between users. The first useful comparison is possible once a second monthly data date exists.

### Example output (real register data, abridged)

```json
{
  "lookupStatus": "FOUND",
  "companyNumber": "00445790",
  "companyName": "TESCO PLC",
  "companyStatus": {
    "value": "active",
    "label": "Active",
    "detail": null
  },
  "nameCheck": {
    "provided": null,
    "result": "not_provided"
  },
  "accountsOverdue": {
    "value": false,
    "asOf": "2026-09-30",
    "nextDue": "2027-08-26",
    "daysOverdue": 0,
    "dueDatePassedSinceDataDate": false
  },
  "confirmationStatementOverdue": {
    "value": false,
    "asOf": "2026-09-30",
    "nextDue": "2027-07-02",
    "daysOverdue": 0,
    "dueDatePassedSinceDataDate": false
  },
  "chargesSignals": {
    "total": 9,
    "outstanding": 2,
    "partSatisfied": 0,
    "satisfied": 7
  },
  "filingSignals": {
    "lastAccountsMadeUpTo": "2026-02-28",
    "accountsCategory": "GROUP",
    "lastConfirmationStatement": "2026-06-18"
  },
  "inferences": [
    {
      "code": "OUTSTANDING_CHARGES_REGISTERED",
      "level": "info",
      "basis": "fact",
      "text": "2 charge(s) registered as outstanding. Charges are common in normal lending; this is information, not a warning."
    }
  ],
  "attention": {
    "level": "none_flagged",
    "meaning": "Count of rule-based signals in register data. \"none_flagged\" does not mean the company is safe, solvent or a suitable counterparty."
  },
  "evidence": {
    "source": "Companies House Free Company Data Product (monthly snapshot)",
    "snapshotAsOf": "2026-09-30",
    "sourceFileDate": "2026-10-01",
    "sourceFileUrl": "https://download.companieshouse.gov.uk/BasicCompanyDataAsOneFile-2026-10-01.zip",
    "licence": "Open Government Licence v3.0",
    "attribution": "Contains public sector information licensed under the Open Government Licence v3.0. Source: Companies House."
  },
  "dataFreshness": {
    "snapshotAsOf": "2026-09-30",
    "ageDays": 16,
    "status": "current",
    "newerSnapshotPublished": false
  },
  "sourceUrls": [
    "https://find-and-update.company-information.service.gov.uk/company/00445790"
  ]
}
```

### Not included in this version

No live Companies House API access, no insolvency case details, no filing history, and **no officer, shareholder or beneficial-owner data** (no names, dates of birth or addresses of people).

### For AI agents and MCP clients

Tool description: *"Look up UK companies by company number in the official Companies House monthly data. Returns register status, overdue-filing flags at the data date, insolvency-related status, charges and a name-match check, each with the data date, sources and caveats. Monthly data; signals only, never a credit rating or approval."*

Guide for agents: read `dataFreshness` first and tell the user the data date. Treat `AMBIGUOUS_NAME` and `NOT_IN_SNAPSHOT` as "unknown", never as "dissolved" or "does not exist". If `nameCheck.result` is `differs`, stop and ask which entity is meant. Escalate `attention.level = alert` to a person. Do not describe a company as safe, healthy or approved because nothing is flagged, and do not present month-old data as current.

### Pricing (pay per event)

| Event | Price |
|---|---|
| Company found (`company-signals`) | **$0.002** per company |
| Actor start | $0.00005 |

You are charged only when a company is found for your number (or an exact unique name match), for example $0.20 for 100 companies and $2.00 for 1,000. **Not charged:** `NOT_IN_SNAPSHOT`, `AMBIGUOUS_NAME`, `INVALID_NUMBER`, rows from an outdated build, and rows after a spending limit. If you set a maximum charge per run and it is reached, the run stops writing rows and `SUMMARY` shows `limitHit: true`. A restarted run skips finished rows and never charges them twice (the small start event can be charged again). There is no per-dataset-item price.

### Source, licence and attribution

Data: Companies House Free Company Data Product (monthly file), Crown copyright, published under the **Open Government Licence v3.0**. *Contains public sector information licensed under the Open Government Licence v3.0. Source: Companies House.* Companies House states that it imposes no rules on how register information is used and that you are responsible for complying with data-protection, copyright and other law. The monthly file is provided free of charge and without support. This Actor is not affiliated with or endorsed by Companies House. It does not scrape the Companies House search website and does not use its API (it only reads the public download page to tell you whether a newer monthly file exists).

### FAQ

**Is this real-time?** No. It is the monthly file; see the data date on every row.

**Can I look up a company by name?** Only as an exact, unique match among live companies, with a warning to confirm the number. Supply the number whenever you can.

**Does it give directors or owners?** No, by design.

**Will it tell me whether to trade with a company?** No. It shows register status and rule-based filing signals as of the data date. Use other sources and your own judgement for decisions.

# Actor input Schema

## `companies` (type: `array`):

UK companies to check. Each entry is a company number ("00000006", "SC123456") or an object {"companyNumber": "...", "companyName": "..."}. Give the number whenever you have it; if you also give the name you hold, the row says whether it matches the registered or a previous name. A name on its own is used only when it is an exact, unique match among live companies; otherwise you get candidates to confirm.

## `baseline` (type: `array`):

Rows from an earlier run of this Actor (paste the dataset items). Changes are reported only when the baseline comes from an earlier data date than this run. Nothing is stored by the Actor; the comparison uses only what you provide.

## `baselineDatasetId` (type: `string`):

Alternative to pasting: the ID of a dataset from your own earlier run.

## `maxCompanies` (type: `integer`):

Upper limit for this run. Lookups are fast (thousands per second).

## Actor input object example

```json
{
  "companies": [
    {
      "companyNumber": "00445790",
      "companyName": "Tesco PLC"
    },
    {
      "companyNumber": "03782379"
    }
  ],
  "maxCompanies": 1000
}
```

# Actor output Schema

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

All rows: lookupStatus, companyStatus, overdue filing signals at the data date, insolvency-related status, charges, name check, inferences, attention level, evidence with data date and licence, caveats.

## `overview` (type: `string`):

Compact table view of the same rows.

## `summary` (type: `string`):

Data date, source file date, freshness status, whether a newer monthly file exists, lookup counts and charged companies (key-value store record SUMMARY).

# 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 = {
    "companies": [
        {
            "companyNumber": "00445790",
            "companyName": "Tesco PLC"
        },
        {
            "companyNumber": "03782379"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("asunoki/uk-company-status-signals").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 = { "companies": [
        {
            "companyNumber": "00445790",
            "companyName": "Tesco PLC",
        },
        { "companyNumber": "03782379" },
    ] }

# Run the Actor and wait for it to finish
run = client.actor("asunoki/uk-company-status-signals").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 '{
  "companies": [
    {
      "companyNumber": "00445790",
      "companyName": "Tesco PLC"
    },
    {
      "companyNumber": "03782379"
    }
  ]
}' |
apify call asunoki/uk-company-status-signals --silent --output-dataset

```

## MCP server setup

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

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/E3bRgLb2xCcRD3NT8/builds/NhILKAIwvfguvfw4f/openapi.json