# GLEIF LEI Scraper (`logiover/gleif-lei-scraper`) Actor

Scrape global legal entities from the official GLEIF LEI database — no login, no API key, no blocking. 3.3M+ entities worldwide with legal name, address, jurisdiction, legal form, status and registration data. Filter by country and status. Tens of thousands per run.

- **URL**: https://apify.com/logiover/gleif-lei-scraper.md
- **Developed by:** [Logiover](https://apify.com/logiover) (community)
- **Categories:** Lead generation, Automation
- **Stats:** 7 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.50 / 1,000 results

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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 Scraper — Global Legal Entity Identifier Data to JSON/CSV/Excel

![GLEIF LEI Scraper](https://apify-image-uploads-prod.s3.us-east-1.amazonaws.com/GjS6nQ8qauOdq9KGy-actor-Tloh6DAtW6lAk2f59-9ZVWc0n6C7-10532535.png)

Scrape **global legal entities** straight from the **official [GLEIF API](https://www.gleif.org)** — the worldwide Legal Entity Identifier (LEI) database. This **GLEIF LEI scraper** extracts legal name, addresses, jurisdiction, legal form, status and registration data for **3.3M+ entities** across every country, and exports it to JSON, CSV or Excel. **No login, no API key, no blocking.**

The LEI is the global standard for identifying legal entities in financial transactions, used worldwide for KYC, AML and due diligence. Because this Actor reads the official GLEIF API, results are reliable and don't break — and one run can return tens of thousands of entities, filtered by country, status and category.

### ✨ What this Actor does / Key features

- **Official GLEIF API** — 100% reliable, never blocked, no fragile HTML parsing.
- **No API key, no login** — just configure and run.
- **Global coverage** — 3.3M+ legal entities across every jurisdiction worldwide.
- **Filter by country** — scrape one or more ISO country codes, or leave empty for the full global database.
- **Filter by status & category** — narrow to `ACTIVE` / `INACTIVE` entities and by category (`GENERAL`, `FUND`, `BRANCH`, `SOLE_PROPRIETOR`, …).
- **Rich entity data** — legal name, other names, legal form, category, status, jurisdiction, full legal and HQ addresses, registration dates, next renewal date and managing LOU.
- **Scales to tens of thousands per run** — set `maxRecords` to cap the run or `0` to pull everything matching.
- **Structured, export-ready output** — flat JSON records, perfect for JSON, CSV, Excel, databases or BI tools.

### 🔍 Input

| Field | Type | Description |
|-------|------|-------------|
| `countries` | array | ISO country codes to scrape, e.g. `US`, `GB`, `DE`, `TR`. Leave empty to scrape the full global database. |
| `entityStatus` | string (enum) | Filter by entity status: `ACTIVE`, `INACTIVE`, or empty for all. |
| `entityCategory` | string | Filter by entity category, e.g. `GENERAL`, `FUND`, `BRANCH`, `SOLE_PROPRIETOR`. Leave empty for all. |
| `maxRecords` | integer | Maximum legal entities to save. `0` = all matching (the full database has 3.3M+ entities). Minimum `0`. |

### 🚀 Example input

```json
{
  "countries": ["US", "GB", "DE"],
  "entityStatus": "ACTIVE",
  "maxRecords": 10000
}
````

Scrape all active funds in a single country:

```json
{
  "countries": ["LU"],
  "entityStatus": "ACTIVE",
  "entityCategory": "FUND",
  "maxRecords": 0
}
```

### 📦 Output

Each item in the dataset is one legal entity from the GLEIF LEI database. Output is flat, structured JSON — easy to export to CSV or Excel or push into a database.

| Field | Description |
|-------|-------------|
| `lei` | The 20-character Legal Entity Identifier code. |
| `legalName` | Official registered legal name of the entity. |
| `otherNames` | Array of other / alternative names for the entity. |
| `legalForm` | Legal form of the entity (e.g. LLC, GmbH, PLC). |
| `category` | Entity category (e.g. `GENERAL`, `FUND`, `BRANCH`). |
| `subCategory` | Entity sub-category, where applicable. |
| `status` | Entity operational status (`ACTIVE` / `INACTIVE`). |
| `jurisdiction` | Legal jurisdiction the entity is registered in. |
| `registeredAs` | The entity's registration number in its home registry. |
| `legalAddressLine` | Street address line of the legal address. |
| `legalAddressCity` | City of the legal address. |
| `legalAddressRegion` | Region / state of the legal address. |
| `legalAddressCountry` | Country of the legal address. |
| `legalAddressPostalCode` | Postal code of the legal address. |
| `hqAddressCity` | City of the headquarters address. |
| `hqAddressCountry` | Country of the headquarters address. |
| `registrationStatus` | LEI registration status (e.g. `ISSUED`, `LAPSED`). |
| `initialRegistrationDate` | Date the LEI was first registered. |
| `lastUpdateDate` | Date the LEI record was last updated. |
| `nextRenewalDate` | Date the LEI is next due for renewal. |
| `managingLou` | The Local Operating Unit (LOU) managing this LEI. |
| `scrapedAt` | ISO timestamp of when the record was scraped. |

#### Example output record

```json
{
  "lei": "5493001KJTIIGC8Y1R12",
  "legalName": "Example Holdings PLC",
  "otherNames": ["Example Group"],
  "legalForm": "PUBLIC LIMITED COMPANY",
  "category": "GENERAL",
  "status": "ACTIVE",
  "jurisdiction": "GB",
  "registeredAs": "01234567",
  "legalAddressLine": "1 Example Street",
  "legalAddressCity": "London",
  "legalAddressCountry": "GB",
  "legalAddressPostalCode": "EC1A 1AA",
  "registrationStatus": "ISSUED",
  "initialRegistrationDate": "2014-06-12",
  "lastUpdateDate": "2026-04-30",
  "nextRenewalDate": "2027-06-12",
  "managingLou": "EVK05KS7XY1DEII3R011",
  "scrapedAt": "2026-05-15T08:30:00.000Z"
}
```

### 💡 Use cases

- **KYC / AML compliance** — build and refresh entity-verification datasets for onboarding and screening.
- **B2B data enrichment** — match and enrich company records with authoritative LEI identifiers and addresses.
- **Risk & due diligence** — screen counterparties and map corporate structures by jurisdiction and category.
- **Financial research & analytics** — analyze the global registered-entity landscape by country, legal form and status.
- **RegTech & fintech products** — power entity-lookup and verification features with bulk LEI data.
- **Sales & lead generation** — source registered companies by country and category with verified legal addresses.

### ❓ Frequently Asked Questions

**Do I need a GLEIF API key or login?**
No. The Actor uses the public GLEIF API, which is accessible without an API key, account or login.

**Is it legal to scrape LEI data?**
Yes. GLEIF publishes LEI data as a free, open, public good for global use. You are responsible for complying with GLEIF's terms and applicable law in how you use it.

**How many entities can I get?**
The full database has 3.3M+ legal entities. Set `maxRecords` to `0` to pull everything matching your filters, or a smaller number for a faster, capped run. For very large extractions, filter by country to keep runs manageable.

**Can I filter by country, status or entity type?**
Yes. Use `countries` for one or more ISO country codes, `entityStatus` for `ACTIVE` / `INACTIVE`, and `entityCategory` for category (`GENERAL`, `FUND`, `BRANCH`, `SOLE_PROPRIETOR`, etc.).

**What is an LEI?**
The Legal Entity Identifier is a 20-character code that uniquely identifies a legally distinct entity participating in financial transactions — the global standard used for KYC, AML and regulatory reporting.

**How fresh is the data and can I schedule it?**
GLEIF entity records update constantly. Schedule the Actor on Apify to run on any interval for an always-current legal-entity dataset.

**What output formats are supported?**
Results are stored in an Apify dataset and can be exported to JSON, CSV, Excel or XML, or pulled via the Apify API.

### ⏰ Scheduling & integration

Schedule this Actor on Apify to run daily or weekly for an always-fresh global legal-entity database. Export results to JSON, CSV or Excel, pull them through the Apify API, or connect the dataset to Google Sheets, webhooks or your KYC, CRM and compliance pipelines.

# Actor input Schema

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

ISO country codes to scrape, e.g. 'US', 'GB', 'DE', 'TR'. Leave empty to scrape the full global database.

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

Filter by entity status, e.g. 'ACTIVE', 'INACTIVE'. Leave empty for all.

## `entityCategory` (type: `string`):

Filter by entity category, e.g. 'GENERAL', 'FUND', 'BRANCH', 'SOLE\_PROPRIETOR'. Leave empty for all.

## `maxRecords` (type: `integer`):

Maximum legal entities to save. 0 = all matching (the full database has 3.3M+ entities).

## Actor input object example

```json
{
  "countries": [],
  "entityStatus": "",
  "entityCategory": "",
  "maxRecords": 200
}
```

# Actor output Schema

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

lei

## `legalName` (type: `string`):

legalName

## `category` (type: `string`):

category

## `status` (type: `string`):

status

## `jurisdiction` (type: `string`):

jurisdiction

## `legalAddressCity` (type: `string`):

legalAddressCity

## `legalAddressCountry` (type: `string`):

legalAddressCountry

## `lastUpdateDate` (type: `string`):

lastUpdateDate

# 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 = {
    "countries": [],
    "maxRecords": 200
};

// Run the Actor and wait for it to finish
const run = await client.actor("logiover/gleif-lei-scraper").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 = {
    "countries": [],
    "maxRecords": 200,
}

# Run the Actor and wait for it to finish
run = client.actor("logiover/gleif-lei-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "countries": [],
  "maxRecords": 200
}' |
apify call logiover/gleif-lei-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=logiover/gleif-lei-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "GLEIF LEI Scraper",
        "description": "Scrape global legal entities from the official GLEIF LEI database — no login, no API key, no blocking. 3.3M+ entities worldwide with legal name, address, jurisdiction, legal form, status and registration data. Filter by country and status. Tens of thousands per run.",
        "version": "1.0",
        "x-build-id": "JUMdxjS7sTborTrv4"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/logiover~gleif-lei-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-logiover-gleif-lei-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/logiover~gleif-lei-scraper/runs": {
            "post": {
                "operationId": "runs-sync-logiover-gleif-lei-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/logiover~gleif-lei-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-logiover-gleif-lei-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "countries": {
                        "title": "Countries",
                        "type": "array",
                        "description": "ISO country codes to scrape, e.g. 'US', 'GB', 'DE', 'TR'. Leave empty to scrape the full global database.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "entityStatus": {
                        "title": "Entity Status",
                        "enum": [
                            "",
                            "ACTIVE",
                            "INACTIVE"
                        ],
                        "type": "string",
                        "description": "Filter by entity status, e.g. 'ACTIVE', 'INACTIVE'. Leave empty for all.",
                        "default": ""
                    },
                    "entityCategory": {
                        "title": "Entity Category",
                        "type": "string",
                        "description": "Filter by entity category, e.g. 'GENERAL', 'FUND', 'BRANCH', 'SOLE_PROPRIETOR'. Leave empty for all.",
                        "default": ""
                    },
                    "maxRecords": {
                        "title": "Max Records",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum legal entities to save. 0 = all matching (the full database has 3.3M+ entities)."
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
