# LEI Company Search & New Registrations (GLEIF data) (`bircolabots/lei-company-data`) Actor

Search 3M+ companies in the global LEI registry by name, country, legal form or status, get newly registered companies, or look up LEI codes in bulk. Parent companies optional. Fast, no API key, no personal data.

- **URL**: https://apify.com/bircolabots/lei-company-data.md
- **Developed by:** [Cicero Millen](https://apify.com/bircolabots) (community)
- **Categories:** Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 1,000 companies

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

## LEI Company Search & New Registrations (GLEIF data)

Search the **global Legal Entity Identifier (LEI) registry**, more than **3 million companies, funds and other legal
entities in 200+ countries**, and get the results as a clean table you can download as Excel, CSV or JSON or send to
your own tools.

- ⚡ **Fast and cheap:** reads the official public GLEIF API directly. No browser, no proxies, no API key.
- 🆕 **New registrations feed:** get every company that received an LEI in the last N days, by country. Schedule it
  daily for a stream of new companies.
- 📋 **Bulk lookup:** paste up to 10,000 LEI codes and get the current record of each one (KYC / AML refresh).
- 🏢 **Parent companies:** optionally add the direct and ultimate parent (name and LEI) of every company.
- 🌍 **No 1,000-record limit:** collect up to 100,000 companies in one run.
- 🔒 **No personal data:** sole proprietors are never returned. Only legal entity data.
- 💶 **Pay only for results:** you pay per company saved, and you can cap the cost of every run.

### How it works

1. Type a **company name** (or any text such as a city or a registration number), or leave it empty.
2. Pick **filters**: countries, "LEI issued in the last N days", company status, LEI status, category, legal form.
   Or paste a list of **LEI codes** to look them up in bulk.
3. Click **Start**. Companies appear in the **Output** tab as a table, ready to export or to send to Google Sheets,
   Make, Zapier, n8n or your own API.

### What data you get

One row per legal entity:

| Field | What it contains |
|---|---|
| `lei` | Legal Entity Identifier (20 characters) |
| `legalName`, `otherNames` | Legal name and previous / trading / translated names |
| `legalForm`, `legalFormOther` | ISO 20275 legal form code (e.g. `2HBR` = German GmbH) and free-text form |
| `category`, `subCategory` | `GENERAL`, `FUND`, `BRANCH`, `INTERNATIONAL_ORGANIZATION`, `RESIDENT_GOVERNMENT_ENTITY` |
| `entityStatus` | `ACTIVE` or `INACTIVE` |
| `registrationStatus` | LEI status: `ISSUED`, `LAPSED`, `RETIRED`, ... |
| `jurisdiction` | Legal jurisdiction (e.g. `DE`, `US-DE`) |
| `legalAddress`, `legalCity`, `legalRegion`, `legalPostalCode`, `legalCountry` | Registered (legal) address |
| `hqAddress`, `hqCity`, `hqRegion`, `hqPostalCode`, `hqCountry` | Headquarters address |
| `registrationNumber`, `registrationAuthorityId` | National company number and the business register it comes from |
| `entityCreationDate` | Date the company was founded, when known |
| `initialRegistrationDate`, `lastUpdateDate`, `nextRenewalDate` | LEI dates |
| `corroborationLevel`, `managingLou` | How the data was validated and which LEI issuer manages it |
| `bic` | BIC / SWIFT codes linked to the LEI, when any |
| `directParentLei`, `directParentName`, `ultimateParentLei`, `ultimateParentName` | Parent companies (only with "Include parent companies") |
| `url` | Link to the record on search.gleif.org |
| `scrapedAt` | Time of the run (UTC) |

Fields the registry does not provide for an entity are `null`.

### Use cases

- **KYC / AML and compliance:** verify counterparties, refresh LEI records in bulk, spot lapsed LEIs.
- **Lead generation:** new companies, funds and subsidiaries by country, every day.
- **Corporate structure research:** who owns whom, with direct and ultimate parents.
- **Financial data teams:** map LEIs to names, addresses, national registration numbers and BIC codes.
- **CRM and data enrichment:** clean legal names and registered addresses for your customer list.

### Input examples

**Companies named "siemens" in Germany**

```json
{
    "companyName": "siemens",
    "countries": ["DE"],
    "maxItems": 200
}
```

**All companies in the UK that got an LEI in the last 7 days**

```json
{
    "registeredWithinDays": 7,
    "countries": ["GB"],
    "maxItems": 5000
}
```

**New funds in Luxembourg and Ireland, last 30 days**

```json
{
    "registeredWithinDays": 30,
    "countries": ["LU", "IE"],
    "categories": ["FUND"],
    "maxItems": 5000
}
```

**German GmbHs whose LEI has lapsed (not renewed)**

```json
{
    "countries": ["DE"],
    "legalForms": ["2HBR"],
    "registrationStatus": "LAPSED",
    "maxItems": 1000
}
```

**Bulk lookup with parent companies**

```json
{
    "leiCodes": ["529900YDAG61JYILJZ53", "W38RGI023J3WT1HWRP32"],
    "includeParents": true
}
```

#### All input fields

| Field | Description | Default |
|---|---|---|
| `companyName` | Words of the legal name | empty |
| `fullText` | Free text over every field (name, address, city, registration number...) | empty |
| `countries` | ISO country codes of the legal address, e.g. `DE`, `GB` | all |
| `registeredWithinDays` | Only entities whose LEI was first issued in the last N days (1–3650) | no filter |
| `entityStatus` | `ACTIVE`, `INACTIVE` or `ANY` | `ACTIVE` |
| `registrationStatus` | `ANY`, `ISSUED`, `LAPSED`, `RETIRED`, `ANNULLED`, `PENDING_TRANSFER`, `PENDING_ARCHIVAL`, `DUPLICATE` | `ANY` |
| `categories` | `GENERAL`, `FUND`, `BRANCH`, `INTERNATIONAL_ORGANIZATION`, `RESIDENT_GOVERNMENT_ENTITY` | all |
| `legalForms` | ISO 20275 legal form codes, e.g. `2HBR` | all |
| `leiCodes` | Up to 10,000 LEI codes for bulk lookup (search fields are then ignored) | empty |
| `includeParents` | Add direct and ultimate parent; limited to 500 companies per run | `false` |
| `maxItems` | Maximum number of companies to save (1–100,000); not used in bulk lookup | 100 |

**Tip:** to find the city of a company, use `fullText` together with `countries`, e.g. `"fullText": "Rotterdam"` and
`"countries": ["NL"]`. The registry has no exact city filter.

### Output example

```json
{
    "lei": "529900YDAG61JYILJZ53",
    "legalName": "Siemens",
    "otherNames": "Siemens Proprietary Limited; Siemens",
    "legalForm": "GQVQ",
    "legalFormOther": null,
    "category": "GENERAL",
    "subCategory": null,
    "entityStatus": "ACTIVE",
    "registrationStatus": "ISSUED",
    "jurisdiction": "ZA",
    "legalAddress": "300, Janadel Avenue",
    "legalCity": "Midrand",
    "legalRegion": "ZA-GP",
    "legalPostalCode": "1685",
    "legalCountry": "ZA",
    "hqAddress": "300, Janadel Avenue",
    "hqCity": "Midrand",
    "hqRegion": "ZA-GP",
    "hqPostalCode": "1685",
    "hqCountry": "ZA",
    "registrationNumber": "1923/007514/07",
    "registrationAuthorityId": "RA000531",
    "entityCreationDate": "1923-05-15",
    "initialRegistrationDate": "2022-03-16",
    "lastUpdateDate": "2026-03-04",
    "nextRenewalDate": "2027-03-16",
    "corroborationLevel": "FULLY_CORROBORATED",
    "managingLou": "5299000J2N45DDNE4Y28",
    "bic": null,
    "directParentLei": "W38RGI023J3WT1HWRP32",
    "directParentName": "Siemens Aktiengesellschaft",
    "ultimateParentLei": "W38RGI023J3WT1HWRP32",
    "ultimateParentName": "Siemens Aktiengesellschaft",
    "url": "https://search.gleif.org/#/record/529900YDAG61JYILJZ53",
    "scrapedAt": "2026-10-09T12:00:00+00:00"
}
```

### Pricing and cost

Pay per event, you only pay for what you get:

| Event | Price |
|---|---|
| Company saved to the dataset | **$0.0015** per company ($1.50 per 1,000 companies) |
| Run start | $0.00005 per run |

Examples: **100 companies ≈ $0.15**, **1,000 companies ≈ $1.50**. Set **Maximum cost per run** in the run options to cap
your spending; the Actor stops when the cap is reached and keeps the companies already saved.

### Schedule it and connect it

- **Daily new companies:** create a task with `registeredWithinDays: 1` (or 2, to be safe) and your countries, and add a
  **Schedule** in Apify Console. The registry is updated every day.
- **Integrations:** send results automatically to Google Sheets, Slack, Make, Zapier, n8n or any webhook using Apify
  integrations.
- **API:** run the Actor and download results from your own code with the Apify API or the Python / JavaScript clients.

### Limits

- The GLEIF API allows about 60 requests per minute. The Actor respects it: about 10,000 companies per minute in search
  mode, and about 25 companies per minute with "Include parent companies".
- Only entities that have an LEI are included. Small local businesses often have no LEI.
- There is no exact city filter in the registry; use `fullText` with `countries`.
- Data comes as published in the LEI registry by the entities and their LEI issuers.

### FAQ

**Where does the data come from?**
From the public LEI registry published by the Global Legal Entity Identifier Foundation (GLEIF) under the CC0 licence.
This Actor is an independent tool and is **not affiliated with, endorsed or provided by GLEIF**.

**Does it collect personal data?**
No. Sole proprietors are excluded on purpose, and the output is a fixed list of legal entity fields.

**Do I need an API key or a proxy?**
No. The GLEIF API is public and free.

**Why did I get fewer companies than `maxItems`?**
Your search has fewer results than that. Try fewer filters, another name or a longer date range.

**How do I monitor new companies every day?**
Use `registeredWithinDays: 1` or `2` with your countries and schedule the Actor daily. Duplicates between days can be
removed by the `lei` field.

### Support

Found a bug or need a field or filter? Open an issue in the **Issues** tab. I read all of them.

# Actor input Schema

## `companyName` (type: `string`):

Words of the legal name, e.g. "siemens" or "deutsche bank". Leave empty to list companies by the filters below.

## `fullText` (type: `string`):

Free-text search over every field of the record, e.g. a city like "Rotterdam" or a national registration number.

## `countries` (type: `array`):

Two-letter ISO country codes of the legal address, e.g. "DE", "GB", "US". Leave empty for all countries.

## `registeredWithinDays` (type: `integer`):

New-registrations feed: only companies whose LEI was first issued in the last N days. Schedule the Actor daily with 1 or 2 days to get new companies every day. Leave empty for no date filter.

## `entityStatus` (type: `string`):

Legal status of the company itself.

## `registrationStatus` (type: `string`):

Status of the LEI registration. "Lapsed" means the company did not renew its LEI - useful for compliance and outreach.

## `categories` (type: `array`):

Leave empty for all categories. Sole proprietors are never returned (personal data).

## `legalForms` (type: `array`):

ISO 20275 Entity Legal Form codes (4 characters), e.g. "2HBR" for German GmbH. The code list is published by GLEIF. Leave empty for all legal forms.

## `leiCodes` (type: `array`):

Bulk lookup: paste up to 10,000 LEI codes (20 characters each). When this list is filled, the search fields and filters above are ignored and every valid code is looked up.

## `includeParents` (type: `boolean`):

Add the direct and ultimate parent company (name and LEI) to each result. Needs 2 extra requests per company, so runs with this option are limited to 500 companies and take longer.

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

Stop after this many companies. You pay per company saved, so this also caps the cost. Not used in bulk lookup mode.

## Actor input object example

```json
{
  "companyName": "siemens",
  "countries": [
    "DE"
  ],
  "entityStatus": "ACTIVE",
  "registrationStatus": "ANY",
  "includeParents": false,
  "maxItems": 100
}
```

# Actor output Schema

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

No description

## `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 = {
    "companyName": "siemens",
    "countries": [
        "DE"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("bircolabots/lei-company-data").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 = {
    "companyName": "siemens",
    "countries": ["DE"],
}

# Run the Actor and wait for it to finish
run = client.actor("bircolabots/lei-company-data").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 '{
  "companyName": "siemens",
  "countries": [
    "DE"
  ]
}' |
apify call bircolabots/lei-company-data --silent --output-dataset

```

## MCP server setup

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

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/74PDCYaagd2WMUqzL/builds/UXkAbA5KkPu9rIhsT/openapi.json