# GLEIF LEI Lookup: Legal Entity Identifier API (`accountable_eel/gleif-lei-lookup`) Actor

Look up any Legal Entity Identifier (LEI) against GLEIF's own official, free public API: legal name, entity and registration status, jurisdiction, legal form, registered address, and BIC/SWIFT codes. No API key, no scraping. Charged once per LEI that resolves; an invalid code costs nothing.

- **URL**: https://apify.com/accountable\_eel/gleif-lei-lookup.md
- **Developed by:** [Adrian Voss](https://apify.com/accountable_eel) (community)
- **Categories:** Lead generation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 1,000 successful lookups

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## GLEIF LEI Lookup — Legal Entity Identifier API

Looks up a company's Legal Entity Identifier (LEI) against [GLEIF](https://www.gleif.org)'s own official, free, public registry and returns the entity's legal name, entity and registration status, jurisdiction, legal form, registered address, and any BIC/SWIFT codes GLEIF has linked to it. You paste in one or more 20-character LEI codes; each one comes back as a flat row built from GLEIF's own record, or a clean miss if the code doesn't resolve to anything. No API key, no scraping — this calls GLEIF's REST API directly.

### Who it's for

The accountable\_eel catalogue sells company intelligence columns for outbound. Each actor takes a
list of domains or company identifiers and returns one flat, stably-named row per input —
firmographics, registry IDs, tech stack, email route, hiring activity — the shape a Clay table, an
n8n workflow, or an AI agent can consume without post-processing. Pricing is pay-per-event and
per-domain: a few tenths of a cent for a row that was actually found, and nothing for a
miss, so a list that doesn't enrich costs you next to nothing. Where an official source exists —
VIES, GLEIF, SEC EDGAR, Brønnøysund, PRH, RDAP — it is queried directly instead of scraped. No
seat licence, no monthly minimum, no credit system to decode.

For GLEIF specifically: this is for anyone who already has a list of LEI codes — pulled from
invoices, ISO 20022 payment messages, a KYC file, or a counterparty database — and needs the
entity record behind each code without opening GLEIF's search page one code at a time.

### Why this one

- Queries GLEIF's own API directly — the same registration data used for regulatory reporting and
  counterparty due diligence, not a scrape or a cached mirror of it.
- Returns the registration lifecycle fields (`registrationStatus`, `initialRegistrationDate`,
  `nextRenewalDate`) alongside the entity record, so you can flag lapsed or soon-to-expire
  registrations in the same pass instead of a second lookup.
- Handles thousands of LEI codes in one run with configurable concurrency — GLEIF's own web search
  is one code at a time.
- A code that doesn't resolve — malformed, mistyped, or never registered — is reported as
  `found: false` and is never billed.
- Output is one flat row per LEI, field names fixed, ready to paste into a spreadsheet or feed
  straight into a workflow tool with no reshaping.
- Jurisdiction and legal form come back as structured codes (ISO jurisdiction, GLEIF ELF), not
  free-text guesses — useful when you need to bucket entities by country or entity type
  programmatically rather than parsing an address string.

### What you get

One row per LEI code you submit. Every field below comes straight through from GLEIF's own record
— nothing is inferred or supplemented from another source.

| Field | Type | Description |
|---|---|---|
| `query` | string | The LEI code you submitted, as submitted. |
| `found` | boolean | `true` if GLEIF returned a matching record, `false` for a miss. |
| `status` | string | `OK` for a resolved LEI; a short reason code when nothing matched. |
| `lei` | string | The 20-character LEI code, as recorded by GLEIF. |
| `legalName` | string | The entity's registered legal name. |
| `entityStatus` | string | Entity status, e.g. `ACTIVE` or `INACTIVE`. |
| `legalForm` | string | GLEIF ELF (Entity Legal Form) code for the entity's legal structure. |
| `jurisdiction` | string | ISO jurisdiction code the entity is registered in. |
| `legalAddress` | object | Registered legal address — address lines, city, region, country, postal code. |
| `registrationStatus` | string | LEI registration status, e.g. `ISSUED`, `LAPSED`, `PENDING_TRANSFER`. |
| `initialRegistrationDate` | date (ISO 8601) | When the LEI was first registered. |
| `nextRenewalDate` | date (ISO 8601) | When the LEI registration is next due for renewal. |
| `bic` | array of strings | BIC/SWIFT codes GLEIF has linked to the entity, if any — often empty. |
| `scrapedAt` | date (ISO 8601) | When this actor fetched the record. |

`onlyFound` (input option) drops the miss rows if you only want resolved entities in your dataset.
`columns` lets you request a subset of the fields above — useful when you're paying per source
elsewhere in the catalogue and want a lean payload here too.

Two fields are worth distinguishing up front: `entityStatus` describes the entity itself (is the
company `ACTIVE` or `INACTIVE`), while `registrationStatus` describes the LEI record's own
lifecycle (`ISSUED`, `LAPSED`, `PENDING_TRANSFER`, and similar). An entity can be perfectly
active while its LEI registration has lapsed because nobody renewed it — that combination is
exactly what `registrationStatus` and `nextRenewalDate` together are for.

### Price

$3 per 1,000 LEI codes, plus a $0.00005 start fee. Misses (`found:false`) are never charged.

That's $0.003 per LEI that actually resolves, plus a flat $0.00005 charge once per run for the
actor start — not per code. Run 1,000 LEI codes through this actor and, if every single one
resolves, you pay **about $3**. The same 1,000 rows through a credit-based enrichment platform
runs **$80–$400**. A code that doesn't resolve costs nothing at all, so a messy list — typos,
duplicates, codes that were never issued — doesn't inflate the bill.

### How to use

1. **In the Apify Console.** Open the actor page and click **Start** — the `leiCodes` field is already pre-filled with a working example. Results land in the run's dataset as soon as each item is found.
2. **Via the API.** Call it directly with a POST request — no Console needed once you have an API token:
   ```bash
   curl "https://api.apify.com/v2/acts/accountable_eel~gleif-lei-lookup/run-sync-get-dataset-items?token=<YOUR_TOKEN>" \
     -X POST \
     -H "Content-Type: application/json" \
     -d '{"leiCodes":["5493001KJTIIGC8Y1R12"]}'
   ```
3. **On a schedule.** Save this actor as an Apify **Task** with the input you want, then add a **Schedule** (hourly, daily, weekly) so it runs on its own — no server of your own required.

1) Paste your LEI codes into `leiCodes`, one per line — the actor uppercases and trims whitespace
   automatically, so `5493001kjtiigc8y1r12` and `5493001KJTIIGC8Y1R12` both work.
2) Leave `maxConcurrency` at its default for a first run, or raise it for a large batch — GLEIF's
   API has no meaningful rate limit for reasonable request volumes.
3) Run it. Each code becomes one row in the dataset: a resolved entity record, or a clean
   `found: false` miss that costs nothing.
4) Pull the results via the Apify API, an integration, or the Console's dataset export (CSV, JSON,
   Excel) and join it back to whatever list the LEI codes came from.
5) If you're screening for compliance gaps rather than just enriching a table, filter the results
   on `registrationStatus` and `nextRenewalDate` afterward — those two fields, not `entityStatus`,
   are what tell you whether the LEI itself needs attention.

### Input

```json
{
  "leiCodes": [
    "5493001KJTIIGC8Y1R12"
  ]
}
```

One 20-character LEI code per line. Accepted formats: 5493001KJTIIGC8Y1R12, 5493001kjtiigc8y1r12.

`leiCodes` is a list of 20-character LEI codes to look up — one per line, e.g.
`5493001KJTIIGC8Y1R12`. `maxConcurrency` controls how many LEIs are checked in parallel, and
`proxyConfiguration` defaults to Apify Proxy (GLEIF's API has no bot protection, so this rarely
matters in practice).

### Sample output

| query | found | status | lei | legalName | entityStatus | legalForm | jurisdiction | legalAddress | registrationStatus | initialRegistrationDate | nextRenewalDate | bic | scrapedAt |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| 5493001KJTIIGC8Y1R12 | true | OK | 5493001KJTIIGC8Y1R12 | Bloomberg Finance L.P. | ACTIVE | T91T | US-DE | {"addressLines":\["C/O Corporation Service Company","251 Little Falls Drive"],"city":"Wilmington","region":"US-DE","country":"US","postalCode":"19808"} | ISSUED | 2012-12-06T20:55:22Z | 2027-01-25T16:50:02Z | \[] | 2026-08-31T06:01:09.714Z |

For example, looking up `5493001KJTIIGC8Y1R12` returns a record like this:

```json
{
  "query": "5493001KJTIIGC8Y1R12",
  "found": true,
  "data": {
    "lei": "5493001KJTIIGC8Y1R12",
    "legalName": "Bloomberg Finance L.P.",
    "status": "ACTIVE",
    "legalForm": "8888",
    "jurisdiction": "US-DE",
    "legalAddress": {
      "addressLines": ["731 Lexington Avenue"],
      "city": "New York",
      "region": "US-NY",
      "country": "US",
      "postalCode": "10022"
    },
    "registrationStatus": "ISSUED",
    "initialRegistrationDate": "2012-06-06T15:00:00.000Z",
    "nextRenewalDate": "2026-05-30T09:23:00.000Z",
    "bic": []
  },
  "scrapedAt": "2026-08-21T10:15:00.000Z"
}
```

A row with `"found": false` means GLEIF's API returned zero results for that code — an invalid,
malformed, or unregistered LEI — and it is never charged.

### Use it from Clay, n8n, Make, or an AI agent

This actor runs synchronously over plain HTTP — call it directly from a script, a workflow tool, or an AI agent, no Apify Console needed once you have an API token.

```bash
curl "https://api.apify.com/v2/acts/accountable_eel~gleif-lei-lookup/run-sync-get-dataset-items?token=<YOUR_TOKEN>" \
  -X POST \
  -H "Content-Type: application/json" \
  -d '{"leiCodes":["5493001KJTIIGC8Y1R12"]}'
```

**n8n.** Add an HTTP Request node: Method `POST`, URL `https://api.apify.com/v2/acts/accountable_eel~gleif-lei-lookup/run-sync-get-dataset-items?token=<YOUR_TOKEN>`, Body Content Type `JSON`, JSON Body `{"leiCodes":["5493001KJTIIGC8Y1R12"]}` (swap in an expression from an earlier node for a real value).

**Clay.** Add an "HTTP API" column: Method `POST`, URL `https://api.apify.com/v2/acts/accountable_eel~gleif-lei-lookup/run-sync-get-dataset-items?token=<YOUR_TOKEN>`, Body `{"leiCodes":["{{LEI code}}"]}`, mapping the row's LEI code into the `leiCodes` array.

**MCP.** In Claude, Cursor, or any MCP client with the Apify MCP server, ask for "GLEIF LEI Lookup | Apify" — the agent will find and run this actor.

### Tips

- Use `onlyFound` if you only want resolved entities in the output — useful when you're joining the
  dataset back onto a table and don't want miss rows to overwrite good data.
- Check `registrationStatus` and `nextRenewalDate` together to flag entities whose LEI has lapsed
  or is about to — a lapsed LEI often means a compliance filing is overdue on the entity's side.
- `legalForm` is a GLEIF ELF code, not a plain-language string (e.g. `8888` for a US LLP). Join it
  against [GLEIF's public ELF code list](https://www.gleif.org/en/about-lei/code-lists/iso-20275-entity-legal-forms-code-list) if you need the readable name.
- `bic` comes back empty for most non-financial entities — it's only populated for entities GLEIF
  has linked to SWIFT/BIC codes, mainly banks and financial institutions.
- If your source list has raw company names instead of LEI codes, you won't get a match here —
  this actor takes an LEI as input, it does not search by name. Get the LEI first (GLEIF's own
  search, or a registry lookup that returns one) and feed the code in.
- `legalAddress` comes back as an object, not a single string — if you're pushing rows into a flat
  spreadsheet or CRM field, decide up front whether you want the whole object, just `city` and
  `country`, or a concatenated line, and shape the mapping on your side accordingly.

### vs. alternatives

| | What it costs | What you get | Trade-off |
|---|---|---|---|
| **This actor** (`gleif-lei-lookup`) | $0.003 per LEI that resolves (less on paid tiers), $0.00005 actor start, nothing for a miss | One flat row per LEI — legal name, entity and registration status, jurisdiction, legal form, registered address, BIC codes, registration lifecycle dates | Takes an LEI as input, not a company name — it doesn't search GLEIF for you, it resolves codes you already have. |
| **GLEIF directly** | Free | The same data, from the same source | It's the same source — this actor exists for the batch: hundreds or thousands of codes in, one row per code out, retries and concurrency handled, in the format your table already reads. One code, once? Use GLEIF's own search page. |
| **Clay** | $0.08–$0.40 per enriched row in credits, on top of a seat | A whole enrichment workspace — waterfalls across dozens of providers, plus the table and the sequencing around it | If you want one place that does everything and you're not counting rows, that's Clay. This is one column, priced per column, callable *from* Clay via its HTTP step. |
| Doing it yourself | Your time + handling GLEIF's pagination, retry logic, and mapping ELF codes to readable legal forms | The same data | You still have to write and maintain the request loop, the concurrency limiting, and the found/not-found branching this actor already does. |

Prices for third-party tools are their published list prices as of August 2026 and are not tracked
here — check the vendor before relying on the comparison. GLEIF's own registry search is genuinely
free and returns the same underlying record — the reason to use this actor instead is entirely
about volume: a few LEI codes, use the portal; a few hundred or thousand, run this once instead of
clicking through GLEIF's page for each one.

### FAQ

**What happens if an LEI doesn't resolve?** It comes back as a normal dataset row with
`found: false` and a `status` explaining why nothing matched (invalid format, unregistered, or
malformed code). It is never charged — you only pay for codes that resolve to a real record.

**Are there rate limits?** GLEIF's public API doesn't impose a meaningful rate limit for
reasonable batch sizes. `maxConcurrency` controls how many requests this actor sends in parallel;
raise it for large runs, lower it if you want to be gentler on shared infrastructure.

**How fresh is the data?** Every run queries GLEIF's live API — nothing is cached or stored
between runs. `scrapedAt` on each row is the timestamp of that specific request, so the data is as
current as GLEIF's own registry at the moment you ran it.

**Does this need proxies?** `proxyConfiguration` defaults to Apify Proxy, but GLEIF's LEI API has
no bot protection, so it rarely matters. You can turn proxying off if you'd rather not route
through it.

**Is looking up LEI data a GDPR problem?** No — an LEI identifies a legal entity (a company,
fund, or other organization), not a natural person. The registry fields returned here — legal
name, registered address, jurisdiction — are the same public B2B registration data GLEIF itself
publishes for regulatory and counterparty-verification purposes.

**Can I schedule this to re-check LEIs periodically?** Yes, via an Apify schedule on this actor,
run against the same list of codes. There's no delta/diff feature built in — each run returns the
full current record for every code, so compare `registrationStatus` and `nextRenewalDate` against
your last run's output yourself if you want to catch changes.

**Can an AI agent call this directly?** Yes. Any MCP client connected to the Apify MCP server can
find and run this actor by name ("GLEIF LEI Lookup"), or you can call the Apify API directly — see
the integrations section above.

**Does it deduplicate LEI codes in my list?** No — if the same code appears twice in `leiCodes`,
you get two rows and are charged for each resolved lookup. Deduplicate before you submit if your
source list has repeats, since GLEIF's record for a given LEI doesn't change between two calls in
the same run.

**Can I look up a company by name instead of an LEI code?** Not with this actor — it resolves
codes you already have, it doesn't search GLEIF by name. If you're starting from company names,
you need a source that returns an LEI first (GLEIF's own search UI, or a provider that maps names
to identifiers), then feed the resulting codes in here for the full record.

**What is an LEI actually used for?** It's a 20-character identifier that uniquely names a legal
entity participating in financial transactions — used for regulatory trade and transaction
reporting (e.g. under EMIR, MiFID II, Dodd-Frank), KYC and AML onboarding, and verifying who you're
actually transacting with before a payment or contract goes through. This actor resolves codes you
already have; it doesn't assign new ones.

### Related actors

- [Company Registry Unified Lookup](https://apify.com/accountable_eel/company-registry-unified-lookup)
- [EU VAT Validator](https://apify.com/accountable_eel/eu-vat-validator)
- [SEC EDGAR Company Lookup](https://apify.com/accountable_eel/sec-edgar-company-lookup)

# Actor input Schema

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

One 20-character LEI code per line. Accepted formats: 5493001KJTIIGC8Y1R12, 5493001kjtiigc8y1r12. You're only charged for the ones we actually find — a miss costs nothing.

## `testRun` (type: `boolean`):

Turn this on to test your input on a small sample before running the full list. Turn it off to process everything.

## `onlyFound` (type: `boolean`):

Only keep rows where something was actually found. Misses are always free, whether or not you show them here.

## `includeKeywords` (type: `array`):

Optional. Only keep results that mention at least one of these words (e.g. a job title, a city, a product name). Leave empty to keep everything.

## `excludeKeywords` (type: `array`):

Optional. Drop any result that mentions one of these words. Leave empty to skip nothing.

## `maxResults` (type: `integer`):

Optional. Stop the run once this many results have been found — useful for a quick, cheap sample. Leave blank for no limit.

## `columns` (type: `array`):

Choose which pieces of information to include in each result row. All are included by default.

## `maxConcurrency` (type: `integer`):

Parallel requests. Keep conservative — this target has no browser fallback, so getting blocked costs more than slow-and-steady.

## `proxyConfiguration` (type: `object`):

Apify Proxy config. Residential recommended for anti-bot-sensitive targets.

## Actor input object example

```json
{
  "leiCodes": [
    "5493001KJTIIGC8Y1R12"
  ],
  "testRun": false,
  "onlyFound": false,
  "includeKeywords": [],
  "excludeKeywords": [],
  "columns": [
    "lei",
    "legalName",
    "entityStatus",
    "legalForm",
    "jurisdiction",
    "legalAddress",
    "registrationStatus",
    "initialRegistrationDate",
    "nextRenewalDate",
    "bic"
  ],
  "maxConcurrency": 5,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `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 = {
    "leiCodes": [
        "5493001KJTIIGC8Y1R12"
    ],
    "includeKeywords": [],
    "excludeKeywords": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("accountable_eel/gleif-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 = {
    "leiCodes": ["5493001KJTIIGC8Y1R12"],
    "includeKeywords": [],
    "excludeKeywords": [],
}

# Run the Actor and wait for it to finish
run = client.actor("accountable_eel/gleif-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 '{
  "leiCodes": [
    "5493001KJTIIGC8Y1R12"
  ],
  "includeKeywords": [],
  "excludeKeywords": []
}' |
apify call accountable_eel/gleif-lei-lookup --silent --output-dataset

```

## MCP server setup

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