# GLEIF LEI Records Scraper (`parseforge/gleif-lei-records-scraper`) Actor

Collects Legal Entity Identifier records from the public GLEIF index by search filters or direct LEI code lookup. Each row returns the legal name, registered address, entity and registration statuses, and optional parent and ISIN relationships.

- **URL**: https://apify.com/parseforge/gleif-lei-records-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Lead generation, Automation, Business
- **Stats:** 5 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.75 / 1,000 result items

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?

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

[![ParseForge](https://raw.githubusercontent.com/ParseForge/apify-assets/main/banner-v4.webp)](https://apify.com/parseforge?fpr=vmoqkp)

### GLEIF LEI Records Scraper

**Scrape the complete GLEIF LEI company records index by legal name, country, jurisdiction, or LEI code, up to a million records per run.** Every record returns the full legal name, registered address, entity status, LEI lifecycle, and optional parent and ISIN relationships. Export to CSV, JSON, Excel, or XML.

The Global LEI Index is the only open, standardized registry of legal entities worldwide, but its web search and API require pagination and rate-limit handling. This Actor reads the public GLEIF API directly, letting you filter by exact legal name, country, jurisdiction, entity status, or LEI code, and returns each matching record in one flat, consistent schema. No API key or registration needed.

| Who uses it | What they scrape GLEIF for |
|---|---|
| Compliance officers | Verify the legal identity and current registration status of a counterparty before onboarding. |
| Financial analysts | Map the ultimate parent and ownership structure of a fund or issuer for risk exposure reports. |
| Data providers | Build a local mirror of the global LEI index filtered by jurisdiction for a KYC product. |
| Procurement teams | Check that a supplier's legal entity is active and registered in the expected country. |

### What it does

This Actor collects Legal Entity Identifier records from the GLEIF index by search filters or direct LEI code lookup, and returns each entity as a flat row with its registration details, addresses, and optional corporate hierarchy.

- 🔎 **Search the index:** filter by exact legal name, free-text query, country, jurisdiction, entity status, registration status, entity category, legal form, BIC, or ISIN.
- 🎯 **Look up by LEI code:** fetch a single complete record instantly using its 20-character Legal Entity Identifier.
- 🏢 **Corporate hierarchy enrichment:** optionally pull each record's direct parent, ultimate parent, and issued ISINs for full ownership transparency.
- 📊 **Flat, fixed schema:** every record lands as one row with legal name, addresses, LEI, statuses, and dates, ready for CSV, JSON, Excel, or XML export.

Results export to CSV, JSON, Excel, or XML, or straight from the API.

### What you can do with GLEIF data

**🛡️ Automate counterparty due diligence.**

A compliance team runs the Actor daily with a list of legal names and the 'Issued' registration status filter to confirm every new client has a current, active LEI before the onboarding meeting.

**🌍 Map a fund's global ownership chain.**

An analyst looks up a fund by its LEI code with 'Fetch parents & ISINs' enabled to trace the direct and ultimate parent entities and list every ISIN the fund issues, all in one dataset.

**🏛️ Build a jurisdiction-specific entity registry.**

A data provider runs the Actor with jurisdiction code 'US-DE' and entity category 'GENERAL' to collect every active Delaware company in the LEI index for a commercial KYC database.

**🏦 Identify all entities linked to a BIC.**

A treasury department searches by a SWIFT/BIC code to find the exact legal entity behind a bank identifier before settling a cross-border payment.

### Why choose this scraper

| | What you get |
|---|---|
| **No API key or registration** | Reads the public GLEIF API directly with no app registration, OAuth, or rate-limit management on your side. |
| **Global coverage, local filters** | Filter 200+ countries by ISO-2 code and sub-national jurisdictions by ISO 3166-2 code, from US-DE to FR-75. |
| **Full entity lifecycle** | See both the legal status (Active, Inactive) and the LEI registration status (Issued, Lapsed, Merged, Annulled, and more). |
| **Parent and ISIN enrichment** | Optionally resolve each record's direct and ultimate parent, plus any issued ISINs, in the same run. |
| **Up to one million records** | Collect a handful of test records or pull a full filtered index slice in one long run. |

### How it compares

This Actor collects raw LEI records with full search filters and optional hierarchy enrichment, while the GLEIF LEI Lookup actor adds a risk-scoring decision layer on top of the same data.

| Feature | ParseForge | GLEIF LEI Lookup - Counterparty Decision Engine |
|---|---|---|
| Search by exact legal name | Yes | Yes |
| Filter by country and jurisdiction | Yes | Not listed |
| Filter by entity and registration status | Yes | Not listed |
| Fetch direct and ultimate parent entities | Yes | Not listed |
| Fetch issued ISINs per record | Yes | Not listed |
| Risk scoring and onboarding verdict | Not listed | Yes |

### Configure the run

Drive the Actor from a free-text query, an exact legal name, or a single LEI code, and combine country, jurisdiction, entity status, registration status, entity category, legal form, BIC, or ISIN filters to narrow the global index before records reach your dataset. The Input tab lists every parameter.

A first run with the defaults:

```json
{
 "maxItems": 10,
 "mode": "search",
 "query": "google"
}
```

A larger pull:

```json
{
 "maxItems": 200,
 "mode": "search",
 "query": "google"
}
```

### Pricing

Pay-per-result: **$0.005 per result** collected. You pay only for the results written to your dataset.

| Results collected | Approximate cost |
|---|---|
| 100 results | $0.50 |
| 1,000 results | $5.00 |
| 10,000 results | $50.00 |

**Optional ownership and ISINs:** with `fetchRelationships` on, each record that comes back with a direct parent, an ultimate parent or ISIN codes adds an `entity-relationships` event at **$0.005** ($5 per 1,000). Leave it off and you pay only the per-result price above.

New Apify accounts start with $5 in free credit.

### Free users

Free-plan runs return up to 10 results as a preview. [Upgrade your Apify plan](https://console.apify.com/sign-up?fpr=vmoqkp) to collect up to 1,000,000 results per run.

### Run it

1. [Create a free Apify account with $5 in credit](https://console.apify.com/sign-up?fpr=vmoqkp).
2. Open the [GLEIF LEI Records Scraper](https://apify.com/parseforge/gleif-lei-records-scraper?fpr=vmoqkp).
3. Set your inputs and any filters, then click **Start**.
4. Export the results as CSV, Excel, JSON, or XML from the **Dataset** tab.

Run it programmatically through the [Apify API](https://docs.apify.com/api/v2) (`run-sync-get-dataset-items`) or the [ApifyClient](https://docs.apify.com/api/client/js) for JavaScript and Python.

### Use with AI agents (MCP)

Give an AI agent live access to GLEIF through the Model Context Protocol. Add the Actor to Claude, Cursor, or any MCP client:

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=parseforge/gleif-lei-records-scraper"
```

Then prompt it in plain language to run the scraper and read back the results.

### Troubleshooting

**Why am I getting no results for a company I know exists?**

The free-text 'Company name or LEI code' field does a broad match, but for an exact hit use the 'Legal Name (exact)' field with the full legal name as registered in the LEI index, for example 'GOOGLE LLC' instead of 'Google'. Also check that your country or status filters are not too restrictive.

**The run is slow when I enable 'Fetch parents & ISINs'.**

This is expected. Enabling enrichment adds one or more extra API calls per LEI record to resolve the direct parent, ultimate parent, and ISINs. Reduce the 'Maximum LEI records' or disable enrichment if you only need the core entity data.

**I get a 'Not found' error in Lookup mode.**

Confirm the LEI code is exactly 20 characters with no extra spaces or dashes. The GLEIF system is case-insensitive, but the code must be a valid, issued LEI. Try searching by legal name instead to verify the correct LEI.

**My jurisdiction filter returns no records.**

Jurisdiction codes follow ISO 3166-2 format. Use 'US-DE' not 'Delaware', and 'FR-75' not 'Paris'. Country-level codes like 'US' or 'GB' also work. Check the GLEIF documentation for the exact code if unsure.

### FAQ

| Question | Answer |
|---|---|
| What is an LEI and why would I scrape it? | A Legal Entity Identifier is a 20-character global ID that uniquely identifies a legal entity participating in financial transactions. Scraping LEI records gives you the official legal name, registered address, and current status of a company, fund, or government entity for KYC, compliance, and risk management. |
| Do I need a GLEIF API key to use this Actor? | No. This Actor reads the public GLEIF API endpoints that do not require authentication. You can start scraping immediately without any registration or key. |
| How do I search for a company by its exact legal name? | Set the mode to 'Search the index' and enter the full legal name in the 'Legal Name (exact)' field, for example 'GOOGLE LLC'. This overrides the free-text query and returns only records whose legal name matches exactly. |
| Can I filter by country or jurisdiction? | Yes. Use the 'Country' field with a two-letter ISO 3166-1 alpha-2 code like 'US', 'GB', or 'DE'. For sub-national jurisdictions, use the 'Jurisdiction Code' field with an ISO 3166-2 code like 'US-DE' for Delaware or 'FR-75' for Paris. |
| What does 'Fetch parents & ISINs' do? | When enabled, the Actor makes additional API calls for each LEI record to retrieve its direct parent, ultimate parent, and any ISINs the entity issues. This adds extra time per record but gives you the full corporate hierarchy and securities identifiers in one dataset. |
| How many records can I collect in one run? | You can set the 'Maximum LEI records' from 1 up to 1,000,000. The Actor stops when it reaches your limit or when the filtered index has no more matching records. |
| What is the difference between Entity Status and Registration Status? | Entity Status reflects the legal state of the company itself (Active or Inactive). Registration Status reflects the lifecycle of the LEI record in the GLEIF system (Issued, Lapsed, Merged, Annulled, etc.). A company can be legally Active while its LEI registration has Lapsed. |
| Can I look up a single LEI code directly? | Yes. Switch the mode to 'Look up by LEI code' and paste the 20-character LEI into the dedicated field. The Actor fetches that single record instantly without any search filters. |
| What export formats are supported? | You can export your dataset in CSV, JSON, Excel, or XML directly from the Apify platform run results. |
| How do I find the LEI for a company I already know? | Use the 'Search the index' mode with the 'Legal Name (exact)' field. The first record returned will contain the 20-character LEI code you can then use for lookups or enrichment. |

### Related actors

Browse the full [ParseForge collection](https://apify.com/parseforge?fpr=vmoqkp) for more scrapers.

🆘 **Need help?** Email parseforge@protonmail.com with your run ID, your input, and what you expected.

⚠️ **Disclaimer.** This Actor is unofficial and is not affiliated with, endorsed by, or sponsored by Global Legal Entity Identifier Foundation. It collects only publicly available data. You are responsible for using the collected data in compliance with the source's terms of service and applicable data-protection laws, including GDPR, CCPA, and PIPL. Do not use it to collect personal data unlawfully.

# Actor input Schema

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

How many LEI records to collect per run.

## `mode` (type: `string`):

Search the global index by any combination of filters, or look up a single record by LEI code.

## `query` (type: `string`):

Free-text query matched across legal name, addresses and former names. Used in Search mode when 'Legal Name' is empty.

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

Exact legal-name filter. Overrides the free-text query when supplied. Example: 'GOOGLE LLC'.

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

Filter to records whose registered-address country matches this two-letter code (US, GB, DE, FR, JP, ...). Covers 200+ countries; supply the standard ISO-2 code.

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

Filter by jurisdiction code, e.g. US-DE (Delaware), US-CA (California), GB, DE, FR-75. Country-level codes (US, GB) or sub-national codes (US-DE) both work.

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

Current legal status of the entity.

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

Lifecycle status of the LEI registration itself.

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

Type of entity reported in the global index.

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

4-character Entity Legal Form code (ISO 20275). Example: HZEH (US Delaware LLC), R85P (Belgium NV), V9QP (France SAS).

## `bic` (type: `string`):

Look up an entity by its 8 or 11-character SWIFT/BIC code (banks and financial institutions).

## `isin` (type: `string`):

Look up entities that issue the given 12-character ISIN (securities identifier).

## `leiCode` (type: `string`):

Required in Lookup mode. The 20-character Legal Entity Identifier (e.g. 7ZW8QJWVPR4P1J1KQY45 for GOOGLE LLC).

## `fetchRelationships` (type: `boolean`):

Pull each record's direct parent, ultimate parent, and any issued ISINs (adds extra requests per record).

## Actor input object example

```json
{
  "maxItems": 10,
  "mode": "search",
  "query": "google",
  "fetchRelationships": false
}
```

# Actor output Schema

## `overview` (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 = {
    "maxItems": 10,
    "mode": "search",
    "query": "google"
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/gleif-lei-records-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 = {
    "maxItems": 10,
    "mode": "search",
    "query": "google",
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/gleif-lei-records-scraper").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 '{
  "maxItems": 10,
  "mode": "search",
  "query": "google"
}' |
apify call parseforge/gleif-lei-records-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,parseforge/gleif-lei-records-scraper"
        }
    }
}
```

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/0PE3CKSpjsNSbBQnB/builds/F6tfKg7kaIjjKUmQG/openapi.json