# LEI Lookup — GLEIF Identity & Ownership Records (`sourcerow/lei-lookup`) Actor

Resolve any company to its Legal Entity Identifier and official registry record — 3.4 million entities from GLEIF, by LEI code or by name, with parent ownership and listed securities.

- **URL**: https://apify.com/sourcerow/lei-lookup.md
- **Developed by:** [SourceRow](https://apify.com/sourcerow) (community)
- **Categories:**
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$4.00 / 1,000 entity resolveds

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

Resolve a company name or an LEI code to its official identity record: legal
name, legal form, jurisdiction, registry number, registered address, ownership
and listed securities. 3.4 million entities from the global register banks and
regulators use.

### What it does

The Legal Entity Identifier is a 20-character code that identifies a company
unambiguously anywhere in the world. Behind each code sits a record checked
against a national business register and re-validated annually. GLEIF, the
foundation that runs the system, publishes all of it as open data.

Supply LEI codes, company names, or a pasted list of both. The Actor determines
which is which — a 20-character alphanumeric string is looked up as a code,
anything else is searched as a name — and returns one row per query with 39
fields on every row.

### What you get

39 fields per row, including `lei`, `legal_name`, `entity_status`, `legal_form`,
`jurisdiction`, `registered_as`, the registered and headquarters addresses,
`registration_status`, `next_renewal_date`, `ultimate_parent_name`,
`successor_lei`, `isins_count` and `matched_by`.

The table view shows 13 of them; all 39 are in the JSON, CSV and Excel
downloads.

### Input

| Field | Meaning |
|---|---|
| `leis` | LEI codes, 20 characters each. |
| `names` | Company names to search. |
| `queriesText` | A pasted list of either, one per line. |
| `includeRelationships` | Fetch the ownership tree. Off by default. |
| `maxEntities` | Stop after this many. `0` removes the cap. |

```json
{
  "queriesText": "549300RIVY5EX8RCON76\nUbisecure Oy",
  "includeRelationships": false,
  "maxEntities": 100
}
```

### Sample output

One record, relationships off:

```json
{
  "query": "549300RIVY5EX8RCON76",
  "matched_by": "lei",
  "lei": "549300RIVY5EX8RCON76",
  "legal_name": "FERRARI N.V.",
  "entity_status": "ACTIVE",
  "legal_form": "B5PM",
  "jurisdiction": "NL",
  "registered_as": "64060977",
  "legal_city": "Maranello",
  "legal_country": "NL",
  "ultimate_parent_name": null,
  "isins_count": 0,
  "issues": ""
}
```

### Pricing

| Event | Per 1,000 | Notes |
|---|---|---|
| Entity resolved | $4.00 | Queries that find nothing are not charged |

There is no start fee and no per-row dataset fee.

### What it does not do

**Not every company has an LEI.** Roughly 3.4 million do, concentrated in
businesses that trade securities or derivatives. A small local company usually
does not, and that is what `not_found` means. For general company data, use a
national register instead.

**`legal_form` is an ELF code, not a name.** GLEIF publishes the code — `B5PM`,
`DKUW` — and does not include the readable form in the record. Resolving it
requires the separate ELF code list, which this Actor does not carry.

**A name is not a unique key.** Rows found by name return the best match rather
than choosing between several candidates. `matched_by` states how each row was
found, and name matches deserve a human check before they are acted on.

**An LEI can outlive the company.** A dissolved or merged entity keeps its code.
`entity_status`, `registration_status` and `successor_lei` are the fields that
say so, and `issues` flags `entity_not_active` and `superseded_by_successor`.

### Notes

Send codes rather than names where available. Codes are exact and are resolved
ten at a time in a single request; names are searched individually.

Leave `includeRelationships` off unless the ownership tree is needed. It triples
the number of requests and most records have no parent to report.

Check `issues` before treating a record as current. The company may still hold
an LEI while no longer being the company you expect.

GLEIF republishes daily. Every run queries the live API and stamps
`retrieved_at` on each row.

### Support

Open the **Issues** tab with the specific LEI or name and the `matched_by` and
`issues` values from the row.

### Licence and attribution

Data from the Global Legal Entity Identifier Foundation (GLEIF), published under
CC0 1.0 as open data. Queried live on every run; nothing is stored or
redistributed.

# Actor input Schema

## `leis` (type: `array`):

Legal Entity Identifiers to resolve, 20 characters each.

## `names` (type: `array`):

Legal names to search for. The best match is returned.

## `queriesText` (type: `string`):

Paste a list here instead of filling the fields above. Codes and names can be mixed; each line is sorted automatically.

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

Also fetch the direct parent, the ultimate parent and any ISIN codes. Three extra requests per entity, so it makes the run slower.

## `maxEntities` (type: `integer`):

Stop after this many lookups. **0 removes the cap.**

## Actor input object example

```json
{
  "leis": [
    "549300RIVY5EX8RCON76",
    "529900T8BM49AURSDO55"
  ],
  "names": [],
  "includeRelationships": false,
  "maxEntities": 100
}
```

# Actor output Schema

## `entities` (type: `string`):

No description

## `summary` (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 = {
    "leis": [
        "549300RIVY5EX8RCON76",
        "529900T8BM49AURSDO55"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("sourcerow/lei-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 = { "leis": [
        "549300RIVY5EX8RCON76",
        "529900T8BM49AURSDO55",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("sourcerow/lei-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 '{
  "leis": [
    "549300RIVY5EX8RCON76",
    "529900T8BM49AURSDO55"
  ]
}' |
apify call sourcerow/lei-lookup --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,sourcerow/lei-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/xeSQAPl22hcNgcFgy/builds/rFvi8zLSAKMuhXZns/openapi.json