# UK Company Due-Diligence + AI Risk Summary (EN/RU/AR) (`mikhail_k/company-due-diligence`) Actor

Looks up UK Companies House records (officers, persons with significant control, insolvency/charges history) and produces a plain-English due-diligence risk summary grounded in the registry facts, with optional Russian and Arabic translations.

- **URL**: https://apify.com/mikhail\_k/company-due-diligence.md
- **Developed by:** [Mikhail K](https://apify.com/mikhail_k) (community)
- **Categories:** Business, AI
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 raw company records

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?

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 Company Due-Diligence + AI Risk Summary (EN/RU/AR/ZH)

Look up a UK company on the official Companies House register and get a
structured due-diligence record: current officers, persons with significant
control (beneficial ownership), insolvency/charges history — plus a
plain-English risk summary grounded in those facts, with optional Russian,
Arabic, and Chinese translations for cross-border analysts and compliance teams.

Raw registry data is free on Companies House. The product here is the
analysis layer: instead of a raw JSON dump of officers and filings, you get
a clean due-diligence record with a written risk read, in a dataset you can
pipe anywhere (Sheets, Slack, your own KYC workflow).

### What it does

1. Resolves each input to a UK company number — pass an exact number
   (e.g. `00006400`) or a company name to search.
2. Pulls the current company profile, officers, and persons with significant
   control from the official Companies House API.
3. Produces a plain-English risk summary and up to 5 key due-diligence flags
   (e.g. insolvency history, recent name changes, concentrated ownership) —
   grounded ONLY in the registry facts, never invented.
4. Self-checks its own output (record counts, field fill rates) and **fails
   loudly** instead of silently returning broken data.

### Input example

```json
{
    "companyNumbers": ["00006400"],
    "companyNames": ["Tesco"],
    "includeOfficers": true,
    "includePSC": true,
    "maxItems": 20,
    "enrich": true,
    "targetLangs": ["en"]
}
```

### Output example

```json
{
    "companyName": "TESCO PLC",
    "companyNumber": "00445790",
    "companyStatus": "active",
    "companyType": "plc",
    "incorporationDate": "1947-11-27",
    "jurisdiction": "england-wales",
    "registeredOfficeAddress": "Tesco House, Shire Park, Kestrel Way, Welwyn Garden City, AL7 1GA, United Kingdom",
    "hasInsolvencyHistory": false,
    "hasCharges": true,
    "officers": [
        {"name": "SMITH, John", "role": "director", "appointedOn": "2020-01-15", "nationality": "British"}
    ],
    "personsWithSignificantControl": [
        {"name": "Example Holdings Ltd", "natureOfControl": ["ownership-of-shares-75-to-100-percent"]}
    ],
    "summary": "Tesco PLC is an active UK public limited company incorporated in 1947, with no insolvency history but registered charges on file. Ownership is concentrated under a single corporate controlling entity holding 75-100% of shares.",
    "keyRisks": ["Concentrated single-entity ownership (75-100%)", "Registered charges on file"]
}
```

### Why this actor (vs. raw registry wrappers)

- **Analysis, not a raw dump** — a written risk read grounded in the facts, not just a JSON list of officers.
- **Multilingual** — RU/AR risk summaries for cross-border due-diligence teams; plain registry-wrapper actors don't do this.
- **Reliability by design** — official API, polite rate limiting with backoff, and a self-check that fails loudly if extraction silently degrades.
- **Clean legality** — Companies House data is published under the Open Government Licence v3.0, which explicitly permits commercial use.

### Pricing

Pay-per-event:

- **$0.005 per raw company record** — profile, officers, and PSC data, no AI enrichment.
- **$0.02 per AI-enriched risk summary** — plain-English summary and key risk flags, plus any requested translations.

You're charged the enriched-record price only when `enrich: true` and a
summary is actually produced. No enrichment, no charge beyond the raw record.

### Use cases

**Vet a UK supplier before signing a contract.** Check current status,
insolvency history, and registered charges in one call — a 2-minute
pre-contract check instead of a manual Companies House search:

```json
{ "companyNames": ["Tesco"], "includeOfficers": true, "includePSC": true, "enrich": true, "targetLangs": ["en"] }
```

**Verify beneficial ownership before a KYC/AML sign-off.** Pull the current
persons-with-significant-control record and get a risk summary flagging
concentrated ownership or recent structural changes:

```json
{ "companyNumbers": ["00445790"], "includePSC": true, "enrich": true }
```

**Run due diligence on a shortlist of acquisition targets** in one batch,
with a Russian-language risk summary for a CIS-based investment committee:

```json
{ "companyNumbers": ["00006400", "00445790", "01624297"], "enrich": true, "targetLangs": ["ru"] }
```

**Screen a company for a recent name change or dormant/dissolved status**
before extending trade credit — a red flag `keyRisks` entries surface
automatically when present in the registry facts:

```json
{ "companyNames": ["Example Holdings Ltd"], "maxItems": 1, "enrich": true }
```

### FAQ

**Can I look up a company by name instead of number?** Yes — `companyNames`
does a best-match search; verify the returned `companyNumber` matches the
company you intended, since name search can be ambiguous.

**Does this cover non-UK companies?** Not yet — this actor covers the UK
Companies House register only.

**How fresh is the data?** Pulled live from Companies House's official API on
every run.

# Actor input Schema

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

Exact UK Companies House company numbers, e.g. 00006400. Preferred over name search when you know the number.

## `companyNames` (type: `array`):

Company names to search for (best-match lookup against the Companies House register). Less precise than companyNumbers -- verify the returned companyNumber matches the intended company.

## `includeOfficers` (type: `boolean`):

Fetch current and former directors/officers for each company.

## `includePSC` (type: `boolean`):

Fetch persons/entities with significant control (beneficial ownership) for each company.

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

Maximum number of companies to process across all inputs.

## `enrich` (type: `boolean`):

Add a plain-English risk summary grounded in the registry data (insolvency history, charges, control structure), with optional translations.

## `targetLangs` (type: `array`):

Languages for the risk summary. English is always produced; add Russian, Arabic, and/or Chinese for translated summaries.

## Actor input object example

```json
{
  "companyNames": [
    "Tesco"
  ],
  "includeOfficers": true,
  "includePSC": true,
  "maxItems": 20,
  "enrich": true,
  "targetLangs": [
    "en"
  ]
}
```

# Actor output Schema

## `companies` (type: `string`):

One row per company: registry profile, officers, PSC, and AI risk 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 = {
    "companyNames": [
        "Tesco"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("mikhail_k/company-due-diligence").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 = { "companyNames": ["Tesco"] }

# Run the Actor and wait for it to finish
run = client.actor("mikhail_k/company-due-diligence").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 '{
  "companyNames": [
    "Tesco"
  ]
}' |
apify call mikhail_k/company-due-diligence --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,mikhail_k/company-due-diligence"
        }
    }
}

```

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/MJXBAn9ddSJq1axSj/builds/QRR9c1ueNyaVl0wJQ/openapi.json