# Company Registry Lookup (GLEIF, UK, France) (`jetlaunch/company-registry-lookup`) Actor

Look up or match companies in the GLEIF LEI register, UK Companies House and the French company register. Company-level data only.

- **URL**: https://apify.com/jetlaunch/company-registry-lookup.md
- **Developed by:** [Chris O'Byrne](https://apify.com/jetlaunch) (community)
- **Categories:** Business, Developer tools, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $20.00 / 1,000 entity match searches

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

### Company Registry Lookup (GLEIF, UK, France)

This Actor looks up and matches companies in three public registers and returns one clean, company-level record format:

- **GLEIF**, the global Legal Entity Identifier (LEI) register. No key needed.
- **The French company register**, through the French government company search API (Sirene and RNE data). No key needed.
- **UK Companies House**, through its public API. This one needs your own free API key (see below).

It has two modes:

1. **Entity match** searches one or many company names across every enabled register and returns ranked matches with a 0 to 100 name score.
2. **Entity lookup** returns the full record for an identifier (an LEI, a UK company number, a French SIREN or SIRET) or for a company name.

Company-level fields only. The Actor never reads or returns officers, directors, persons with significant control, sole traders or any non-public French unit.

This is a data lookup tool. It is not KYC, sanctions, AML or compliance screening, and it does not check ownership, officers or watch lists.

#### Who is it for

- Data and operations teams who need to clean up a list of company names and attach a registry identifier to each.
- Sales, finance and procurement teams who want the legal name, registered address, status and incorporation date for a company.
- Developers who want one JSON shape for GLEIF, Companies House and the French register instead of three different APIs.

#### What you get

| Field | Meaning |
|---|---|
| `legal_name`, `other_names` | Registered legal name, and other or previous names where the source publishes them |
| `identifier`, `identifier_type`, `lei`, `uk_company_number`, `fr_siren` | Identifiers in the source register |
| `jurisdiction`, `country` | Where the company is registered |
| `registered_address`, `address_text` | Registered address, structured and as one line (GLEIF also gives a headquarters address) |
| `status`, `status_raw` | Normalized status (active, inactive, other, unknown) and the source's own value |
| `incorporation_date`, `dissolution_date` | Dates in YYYY-MM-DD where published |
| `legal_form_code`, `legal_form` | GLEIF ELF code, INSEE legal category code, or UK company type with a plain-language label |
| `industry_codes` | UK SIC 2007 codes, French NAF codes. GLEIF publishes none. |
| `parents`, `children` | GLEIF direct and ultimate parent, direct child count and a list, where GLEIF publishes them |
| `filings` | UK only: number of filings in the Companies House filing history |
| `establishments` | France only: establishment counts and employee band code |
| `match_score`, `rank` | Match mode only |

GLEIF and French legal forms are returned as codes. They are not translated into text.

#### Input

| Field | Meaning |
|---|---|
| `mode` | `entity-match` or `entity-lookup` |
| `queries` | One name or identifier per line. Up to 200 in match mode, 500 in lookup mode. |
| `includeGleif`, `includeFrance` | On by default. No key needed. |
| `includeUk`, `companiesHouseApiKey` | Off by default. Needs your own free key. |
| `maxMatches`, `minScore` | Match mode: how many matches per name (default 10) and the lowest score kept (default 40) |
| `matchesPerName` | Lookup mode with a name: how many best matches to return in full (default 1) |
| `includeRelationships`, `maxChildren`, `includeFilingCounts` | Lookup mode extras |

In lookup mode the Actor recognizes the identifier type from its shape: 20 characters with valid LEI check digits, 9 digits for a SIREN, 14 digits for a SIRET, 6 to 8 digits or a letter prefix (such as SC123456) for a UK company number. Anything else is treated as a company name.

Example input (this is the default prefill):

```json
{
    "mode": "entity-match",
    "queries": ["Siemens"],
    "includeGleif": true,
    "includeFrance": true,
    "includeUk": false,
    "maxMatches": 10
}
```

#### Getting a Companies House key

Register at developer.company-information.service.gov.uk, create an application of type API key, and paste the key into the secret input field. The key is stored encrypted, is used only for requests to Companies House, and is never written to the output or the log. Without a key, the UK source is skipped, the run continues with the other sources, and nothing is charged for the UK source.

#### Output

One dataset row per match, per entity, or per query that returned nothing (a `notice` row with a code and message, never charged). This is a real match row from a platform run:

```json
{
    "record_type": "match",
    "query": "Siemens",
    "rank": 2,
    "match_score": 100,
    "source": "france",
    "identifier": "562016774",
    "identifier_type": "SIREN",
    "legal_name": "SIEMENS S.A.S",
    "jurisdiction": "FR",
    "address_text": "16 PLACE DE L'IRIS, COURBEVOIE, 92400, FRANCE",
    "status": "active",
    "incorporation_date": "1956-01-01",
    "legal_form_code": "5710",
    "industry_codes": [{ "scheme": "NAF rev. 2 (2008)", "code": "26.30Z", "role": "main" }],
    "size_category": "GE",
    "source_url": "https://annuaire-entreprises.data.gouv.fr/entreprise/562016774",
    "data_licence": "Licence Ouverte 2.0 (Sirene open data)"
}
```

A GLEIF lookup of `W38RGI023J3WT1HWRP32` returns Siemens Aktiengesellschaft with its registered address in Munich, the registration authority and number, the LEI renewal date, and 460 direct children (the first ones listed).

#### How matching works

Names are compared after removing case, accents, punctuation and legal-form words such as Ltd, SAS, AG and Aktiengesellschaft. Identical names score 100. Otherwise the score is the larger of a word overlap score and a character similarity score, with a small bonus when the candidate starts with your words. Equal scores are ordered by status (active first), then by each register's own relevance order, so results alternate between registers. Many companies share a name across countries, so a score of 100 is a name match, not proof that two records are the same company.

#### Pricing

Pay per event. You pay only for results, never for failed or empty queries.

| Event | Price | When it is charged |
|---|---|---|
| Entity match search | $0.02 | Once per name that returns at least one match, whatever the number of matches |
| Entity lookup | $0.01 | Once per entity record returned in lookup mode |

Platform usage is included in these prices. Set a maximum cost per run in the Apify run options and the Actor will stop before going over it.

#### Data sources, licences and rate limits

- **GLEIF** (api.gleif.org). The LEI Data Terms of Use state that the data are provided under CC0. The terms also say you may not imply that your product is provided, supported or authorized by GLEIF. No rate limit is stated in the GLEIF documentation reviewed for this Actor, so the Actor makes at most about one request per second to be safe.
- **French company register** (recherche-entreprises.api.gouv.fr). The service lists a limit of 7 calls per second and no key; the Actor uses about 3 per second. The underlying Sirene dataset is published on data.gouv.fr under Licence Ouverte 2.0. The API does not return non-diffusible units, and the Actor also drops sole traders (entrepreneurs individuels) and any unit not marked fully diffusible.
- **UK Companies House** (api.company-information.service.gov.uk). Requires an API key. Companies House documents a limit of 600 requests per 5 minutes per application and says it can ban applications that exceed or bypass it. The Actor stays at about 85 requests per minute and retries politely on 429. You are responsible for following the Companies House API terms for your key. The registered office address of a small UK company can be a private address; it is part of the public register and is returned as company data.

The Actor uses only these official APIs. It does not bypass any login, CAPTCHA or rate limit.

#### FAQ

**Does it return directors or owners?** No. Officers, directors and persons with significant control are excluded by design.

**Why is a UK result missing?** The UK source needs `includeUk` switched on and your own key. Check the notice rows for the reason.

**Why does the same company appear twice?** A company can have a GLEIF record and a national register record. They are separate rows with their own identifiers.

**Can I look up by company number in GLEIF?** GLEIF is queried by LEI or by name. Use the French or UK source for national numbers.

**How fresh is the data?** The Actor queries the live APIs on each run. GLEIF publishes its data in daily files, so a very recent change may take a day to appear.

#### Limitations

- Name search quality depends on each register's search. Very common names return many equal-score matches; raise `minScore` or add a distinguishing word.
- GLEIF parent and child relationships exist only where the company has reported them.
- GLEIF has no industry codes. French legal forms and GLEIF legal forms are codes.
- The UK path was tested live with a Companies House key in October 2026: name matching, lookups by company number (including Scottish SC numbers), filing counts and not-found notices all worked.

#### Support

Use the Issues tab of this Actor for questions and bug reports.

This Actor is not affiliated with or endorsed by GLEIF, the Global Legal Entity Identifier Foundation, Companies House, the UK government, the French government, INSEE or data.gouv.fr. Names are used only to describe the data sources.

# Actor input Schema

## `mode` (type: `string`):

Entity match searches each company name across the enabled registers and returns ranked matches (billed once per name that returns results). Entity lookup returns the full record for each identifier or name (billed per entity returned).

## `queries` (type: `array`):

One entry per line. In match mode each entry is a company name. In lookup mode each entry can be an LEI (20 characters), a UK company number (for example 00000006 or SC123456), a French SIREN (9 digits) or SIRET (14 digits), or a company name. Up to 200 names in match mode, 500 entries in lookup mode.

## `includeGleif` (type: `boolean`):

Search and look up legal entities with a Legal Entity Identifier. No key needed. GLEIF data is published under CC0.

## `includeFrance` (type: `boolean`):

Search and look up French companies through the government company search API (data from Sirene and the RNE). No key needed. Sole traders and non-public units are never returned.

## `includeUk` (type: `boolean`):

Search and look up UK companies. This needs your own free Companies House API key below. Without a key this source is skipped and nothing is charged for it.

## `companiesHouseApiKey` (type: `string`):

Your own free key from developer.company-information.service.gov.uk (register an API key application). It is stored encrypted, used only for requests to Companies House and never written to the output. The Actor is limited to 600 requests per 5 minutes per key, which is the Companies House limit.

## `maxMatches` (type: `integer`):

Match mode only. How many ranked matches to return for each name across all registers.

## `minScore` (type: `integer`):

Name similarity from 0 to 100. A score of 100 means the names are identical once case, accents, punctuation and legal-form words such as Ltd, SAS or AG are ignored. Matches below this score are dropped.

## `matchesPerName` (type: `integer`):

Lookup mode only. When an entry is a company name, return the full record for this many best matches. Each entity returned is billed.

## `includeRelationships` (type: `boolean`):

Lookup mode only. Add direct parent, ultimate parent and direct children for GLEIF records. Makes the lookup slower (three extra requests per GLEIF record).

## `maxChildren` (type: `integer`):

Lookup mode only. How many direct children to list per GLEIF record. The total count is always given.

## `includeFilingCounts` (type: `boolean`):

Lookup mode only. Add the number of filings on the Companies House filing history (one extra request per UK company).

## Actor input object example

```json
{
  "mode": "entity-match",
  "queries": [
    "Siemens"
  ],
  "includeGleif": true,
  "includeFrance": true,
  "includeUk": false,
  "maxMatches": 10,
  "minScore": 40,
  "matchesPerName": 1,
  "includeRelationships": true,
  "maxChildren": 10,
  "includeFilingCounts": true
}
```

# Actor output Schema

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

Entity records for lookups, ranked matches for match searches, and notices for queries that returned nothing.

# 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 = {
    "mode": "entity-match",
    "queries": [
        "Siemens"
    ],
    "includeGleif": true,
    "includeFrance": true,
    "includeUk": false,
    "maxMatches": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("jetlaunch/company-registry-lookup").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 = {
    "mode": "entity-match",
    "queries": ["Siemens"],
    "includeGleif": True,
    "includeFrance": True,
    "includeUk": False,
    "maxMatches": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("jetlaunch/company-registry-lookup").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 '{
  "mode": "entity-match",
  "queries": [
    "Siemens"
  ],
  "includeGleif": true,
  "includeFrance": true,
  "includeUk": false,
  "maxMatches": 10
}' |
apify call jetlaunch/company-registry-lookup --silent --output-dataset

```

## MCP server setup

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

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/Y6zUufFU0bN6cq5dL/builds/umV4a6xwDR8VCKOqo/openapi.json