# Global Legal Entity Lookup (`thesjostrandproject/global-lei-lookup`) Actor

Look up legal entities by LEI, name, country, legal form or registration status and get clean, structured records from the open LEI index API. No login, no scraping, no sole proprietors. Pay per record.

- **URL**: https://apify.com/thesjostrandproject/global-lei-lookup.md
- **Developed by:** [The Sjöstrand Project](https://apify.com/thesjostrandproject) (community)
- **Categories:** Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$3.00 / 1,000 entity 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?

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

## Global Legal Entity Lookup

### What this Actor returns

Look up legal entities by their LEI (Legal Entity Identifier), by name, by country, by legal form or by registration status, and get one clean, typed record per entity. Every record has the same 14 fields, and a value the entity does not have is `null`, never a missing key.

- `lei`, `legal_entity_label`, `entity_category`: the identifier, the registered legal name and the kind of entity
- `legal_form_code`, `jurisdiction`, `national_registry_id`: its legal form, where it is registered and its business register number
- `headquarters_country`, `headquarters_city`, `headquarters_postcode`: where its headquarters are, down to the postcode and no further
- `registration_status`, `initial_registration_date`, `last_update_date`, `next_renewal_date`: the state of its LEI registration
- `managing_lou`: the LEI of the issuing unit that manages the registration

The Actor reads the open LEI index API and nothing else. It does not scrape any website, and there is no login.

### Who it helps

- **Compliance, onboarding and finance teams**, who want to check an LEI or find the LEI of a company and see whether its registration is current, ready for a spreadsheet or a CRM.
- **Analysts and developers** who want tidy legal-entity data for research or their own checks, through the Apify API, without writing their own client for the source.

### Quick start

1. Open the Input tab and leave the defaults as they are. They look up one fixed LEI, so a first run returns exactly one record.
2. Press Start. The default run costs about $0.003: one record at $0.003, plus Apify's tiny start event (see What it costs). Try it on this one record first.
3. Open the Output tab, check the record, then clear the LEI and set your own name, country, legal form or status.

### Input

| Field | What it does | Default |
|---|---|---|
| Legal name | Words to look for in the entity's legal name. A record matches when its name holds the word anywhere in the name, in any letter case, so `Volvo` finds both `VOLVO AUTO INDIA PRIVATE LIMITED` and `601 Volvo Parkway, L.L.C.`. Letters, digits, spaces and `& . ' + -` only. | empty |
| LEI | One or more 20-character LEIs, separated by commas (up to 50). | `5493001KJTIIGC8Y1R12` |
| Country | Two-letter codes like `DE` or `SE`, separated by commas. Matches the entity's registered (legal) address. | empty |
| Legal form code | 4-character legal form codes like `T91T`, separated by commas. | empty |
| Registration status | `ISSUED`, `LAPSED`, `ANNULLED`, `PENDING_TRANSFER`, `PENDING_ARCHIVAL`, `DUPLICATE`, `RETIRED` or `MERGED`, separated by commas. | empty |
| Maximum records | How many records to return at most, from 1 to 1000. | 10 |

Give at least one filter. The filters combine: a record must match all of the filled-in ones, and several codes inside one filter mean any of them. Because the default LEI is filled in, clear it when you search by name or country. Results come in LEI order.

### Output

One record per entity. The record below is what the default input returned on 12 October 2026, unchanged.

```json
{
  "lei": "5493001KJTIIGC8Y1R12",
  "legal_entity_label": "Bloomberg Finance L.P.",
  "entity_category": "GENERAL",
  "legal_form_code": "T91T",
  "jurisdiction": "US-DE",
  "headquarters_country": "US",
  "headquarters_city": "New York",
  "headquarters_postcode": "10022",
  "registration_status": "ISSUED",
  "initial_registration_date": "2012-12-06",
  "last_update_date": "2026-01-05",
  "next_renewal_date": "2027-01-25",
  "managing_lou": "5493001KJTIIGC8Y1R12",
  "national_registry_id": "4348344"
}
```

### What it costs

You pay for one event, **Entity record**, at $0.003 per record returned. Apify also adds its standard run-start event, $0.00005 per start for an Actor run with up to 1 GB of memory; it is the platform's own event, not ours. The default run of one record costs about $0.003. Records the Actor leaves out (see below) are never charged.

For example, a search that returns 200 entities costs $0.60. If your Apify plan includes monthly credit, a small run draws on that credit.

If the source cannot be reached or keeps answering with errors, the run stops with a clear status message, and only the records already returned are charged.

### Limits and honest notes

- **No sole proprietors.** A sole proprietor is a natural person, so the Actor leaves those records out. It also leaves out any record whose name holds an email address or a phone number, and any record with no category, registration status or name.
- **No street addresses and no ownership links.** Only the headquarters country, city and postcode are output. The legal address, street lines, parent and child relationships and other names are not.
- **The country filter uses the legal address.** The `headquarters_country` field in the output can differ from the country you filtered on.
- **Up to 1000 records per run.** For more, split the search by country or legal form.
- **Pace.** The source's documented limit is 60 requests per minute. The Actor sends at most one request every two seconds and waits as long as the source asks when it is busy.
- **Freshness** follows the source. `last_update_date` is the date the LEI record was last updated at the source.
- **Funds and branches named after a person can appear.** Only records the source marks as sole proprietors are left out, so a fund or branch with a person's name in its legal name can still be output.
- **A match on a name is a starting point.** Check the LEI, the country and the register number before you rely on a record.

### Questions

**Why did my run return fewer records than I asked for?**
Either fewer entities matched, or some were left out because they were sole proprietors or lacked a name, a category or a registration status, or held contact details in their name. You were not charged for those.

**What does the run say when something is wrong?**
It says what it found and what to try. "Give at least one of: an LEI, a name, a country, a legal form or a registration status" means every filter was empty: fill one in. A message about an LEI, a country, a legal form or a status names the field to fix and shows the right shape. "Could not be reached" or "kept answering" means the source is busy; wait a few minutes and run again.

**How do I find the LEI of a company?**
Clear the LEI field, type words from its name, and add its country. Look at the `legal_entity_label`, the headquarters city and the `national_registry_id` to pick the right one.

**What does a lapsed registration mean?**
`LAPSED` means the entity did not renew its LEI in time. The record is still in the index, so you can see when it was last updated.

**Can I run it on a schedule?**
Yes, with the Apify scheduler or the API. Each run is independent and charged per record returned.

### Data source and AI note

Data source: the GLEIF LEI Index (the Global LEI Index), released under the CC0 1.0 public-domain licence. The records are output as the source gives them, with no added data. `last_update_date` is the date the record was last updated at the source, taken from its `lastUpdateDate` field; the records have no source_updated_at field.

This tool is not affiliated with, endorsed by or sponsored by GLEIF or any Local Operating Unit.

This tool was built with the help of AI coding assistants.

### Help

Questions, a record that looks wrong, or an idea for a field: please open an issue on the Issues tab. Thank you for the report; every one is read.

# Actor input Schema

## `name` (type: `string`):

Words of the entity's legal name to look for, like Acme Trading. Letters, digits, spaces and & . ' + - only. Leave empty to search by the other filters.

## `lei` (type: `string`):

One or more 20-character Legal Entity Identifiers, separated by commas, like 5493001KJTIIGC8Y1R12. The default looks up one fixed entity so a first run always returns a record. Clear it to search by name or the other filters.

## `country` (type: `string`):

Only entities whose registered (legal) address is in these countries, as two-letter codes like DE or SE, separated by commas. Leave empty for any.

## `legalForm` (type: `string`):

Only entities with these legal form codes, 4 characters like T91T, separated by commas. The codes come from the ISO 20275 list. Leave empty for any.

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

Only LEI registrations with these statuses, separated by commas: ISSUED (current), LAPSED, ANNULLED, PENDING_TRANSFER, PENDING_ARCHIVAL, DUPLICATE, RETIRED or MERGED. Leave empty for any.

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

How many records to return at most, from 1 to 1000. You pay only for records returned.

## Actor input object example

```json
{
  "name": "",
  "lei": "5493001KJTIIGC8Y1R12",
  "country": "",
  "legalForm": "",
  "registrationStatus": "",
  "maxItems": 10
}
```

# Actor output Schema

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

The legal entity records of this run, one per entity, with the 14 fields described in the dataset schema (LEI, name, category, legal form, jurisdiction, headquarters country, city and postcode, registration status and dates, issuing unit, register number).

# 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 = {
    "name": "",
    "lei": "5493001KJTIIGC8Y1R12",
    "country": "",
    "legalForm": "",
    "registrationStatus": "",
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("thesjostrandproject/global-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 = {
    "name": "",
    "lei": "5493001KJTIIGC8Y1R12",
    "country": "",
    "legalForm": "",
    "registrationStatus": "",
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("thesjostrandproject/global-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 '{
  "name": "",
  "lei": "5493001KJTIIGC8Y1R12",
  "country": "",
  "legalForm": "",
  "registrationStatus": "",
  "maxItems": 10
}' |
apify call thesjostrandproject/global-lei-lookup --silent --output-dataset

```

## MCP server setup

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