# GLEIF LEI Records Scraper (Global Entities) (`knotty_mistveil/gleif-lei-records`) Actor

Every LEI record from the official GLEIF API: legal name, legal and HQ address, jurisdiction, legal form, national register number, LEI status, renewal dates.

- **URL**: https://apify.com/knotty\_mistveil/gleif-lei-records.md
- **Developed by:** [Jason](https://apify.com/knotty_mistveil) (community)
- **Categories:** Business, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$2.00 / 1,000 lei record returneds

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

## GLEIF LEI Records Scraper (Global Entities)

Pulls legal-entity records from **GLEIF**, the Global Legal Entity Identifier Foundation, through its official public **LEI Records API v1** (`api.gleif.org`). No API key, no account, no browser automation. You get one flat JSON record per entity with the LEI, the legal name and any former or transliterated names, the legal and headquarters addresses, the jurisdiction, the ISO 20275 legal form **resolved to its published name**, the entity category and status, the national business register **and the entity's number in it**, the LEI registration status with its initial-registration, last-update and next-renewal dates, the BIC, MIC and OpenCorporates cross-references, and flags for whether GLEIF holds a direct or ultimate parent - filtered by country, registration-date window, last-update window, entity status, LEI status, category, ELF legal form and keyword. On 8 September 2026 the API held **3,423,663 LEI records**, of which **1,964,760** were active entities with a current (ISSUED) LEI, and about **25,600 new LEIs are registered every 30 days** worldwide.

This is a bulk register feed, not a single-LEI lookup: it is built to answer "every entity registered in these countries since date X" and "every record that changed in the last N days", and it returns the complete window even when that window is larger than the 10,000 records GLEIF's paging allows in one query (see *Limits and freshness*).

### What you get

Every record contains:

| Field | Description |
| --- | --- |
| `id` | The 20-character LEI, e.g. `98450083CA3D5F41BK11` (same value as `lei`) |
| `source` | `gleif`, constant |
| `url` | `https://search.gleif.org/#/record/{LEI}` - the public record page on GLEIF's own search site |
| `lei` | The Legal Entity Identifier (ISO 17442) |
| `legalName` | The official registered name, exactly as the register holds it |
| `otherNames` | Previous legal names, trading names and alternative-language names, as an array |
| `transliteratedOtherNames` | ASCII transliterations of a non-Latin legal name, as an array (e.g. `["METSO JAPAN GK"]` for `メッツォジャパン合同会社`) |
| `country` | ISO 3166 alpha-2 country of the **legal** address - the field the Countries input filters on |
| `jurisdiction` | ISO 3166 code of the jurisdiction the entity was formed under (usually, but not always, the same as `country`) |
| `legalForm` | The ISO 20275 (ELF) legal form as a name - `Private Company Limited by Shares`, `Gesellschaft mit beschränkter Haftung`, `besloten vennootschap met beperkte aansprakelijkheid` - resolved from `legalFormCode` against GLEIF's own ELF list. See *Limits and freshness* for the placeholder cases |
| `legalFormCode` | The raw four-character ELF code, e.g. `IWZF`, `Y8W9`, `XTIQ` |
| `category` | `GENERAL`, `FUND`, `BRANCH`, `SOLE_PROPRIETOR`, `RESIDENT_GOVERNMENT_ENTITY` or `INTERNATIONAL_ORGANIZATION` |
| `subCategory` | For a government entity: `CENTRAL_GOVERNMENT`, `STATE_GOVERNMENT`, `LOCAL_GOVERNMENT` or `SOCIAL_SECURITY`; otherwise `null` |
| `entityStatus` | `ACTIVE` or `INACTIVE` - whether the entity itself still exists |
| `entityCreationDate` | When the entity was formed in its home register, e.g. `2024-04-26T00:00:00Z` |
| `entityExpirationDate` / `entityExpirationReason` | When and why the entity ceased (`DISSOLVED`, `CORPORATE_ACTION`, `OTHER`); `null` for a live entity |
| `legalAddress` | The legal address as one line (street lines, street number, unit) |
| `legalCity` / `legalRegion` / `legalPostalCode` | The rest of the legal address, in their own columns |
| `headquartersAddress` | The headquarters address as one line, in the same shape as `legalAddress` |
| `headquartersCity` / `headquartersRegion` / `headquartersPostalCode` / `headquartersCountry` | The rest of the headquarters address |
| `registrationAuthority` | The business register that validated the entity, as a name - `Accounting and Corporate Regulatory Authority (ACRA)`, `The Netherlands Chamber of Commerce`, `Ministry of Corporate Affairs` - resolved from `registrationAuthorityCode` against GLEIF's own RA list |
| `registrationAuthorityCode` | The raw RA code, e.g. `RA000523` |
| `registrationAuthorityId` | **The entity's own number in that register** - the Singapore UEN, the UK company number, the German HRB number, e.g. `202416632G` |
| `initialRegistrationDate` | When the LEI was first issued, e.g. `2026-09-05T05:27:37Z` |
| `lastUpdateDate` | When the LEI record was last revised |
| `nextRenewalDate` | When the LEI must next be renewed |
| `registrationStatus` | `ISSUED`, `LAPSED`, `ANNULLED`, `PENDING_TRANSFER`, `PENDING_ARCHIVAL`, `DUPLICATE`, `RETIRED` or `MERGED` |
| `managingLou` | The LEI of the Local Operating Unit that issued and maintains this LEI |
| `corroborationLevel` | `FULLY_CORROBORATED`, `PARTIALLY_CORROBORATED` or `ENTITY_SUPPLIED_ONLY` - how far the LOU verified the data against the register |
| `conformityFlag` | `CONFORMING`, `NON_CONFORMING` or `NOT_APPLICABLE` - GLEIF's own data-quality verdict on the record |
| `bic` | SWIFT BIC codes for this entity, as an array (11 of them for DBS Bank Ltd.) |
| `mic` | ISO 10383 Market Identifier Codes, as an array (`["XSES"]` for Singapore Exchange Limited) |
| `ocid` | The OpenCorporates company id, e.g. `sg/196800306E` |
| `hasDirectParent` / `hasUltimateParent` | Whether GLEIF holds a parent LEI for this entity (`false` means the entity filed a reporting exception instead; `null` means the API sent no relationship block) |
| `fetchedAt` | ISO timestamp of the run that produced the record |

The dataset has four views: **Overview** (registration date, name, country, city, category, legal form, statuses, register number, link), **Addresses** (both addresses in full), **Registration and renewal** (register, register number, dates, LOU, corroboration, conformity) and **Identifiers and ownership** (BIC, MIC, OpenCorporates id, other names, parent flags).

### Input

| Input | Type | Default | Description |
| --- | --- | --- | --- |
| `countries` | string\[] | all | Two-letter ISO 3166 codes matched against the **legal address** country, e.g. `["SG"]`, `["US","CA"]`. Several codes are ORed. |
| `daysBack` | integer | `30` | Look-back window in days on the initial LEI registration date, ending now. Ignored when `registeredFrom`/`registeredTo` are set, and ignored entirely when `updatedWithinDays` is set. Max 6,000, which reaches the first LEI ever issued (nothing in the register predates 1 January 2012). |
| `registeredFrom` | string | - | Start of the initial-registration window, `YYYY-MM-DD`, inclusive from 00:00:00 UTC. |
| `registeredTo` | string | now | End of the initial-registration window, `YYYY-MM-DD`, inclusive to 23:59:59 UTC. |
| `updatedWithinDays` | integer | - | **Turns the run into a change feed.** The window and the newest-first sort move to the LEI registration's last-update date, and `daysBack` is ignored. `registeredFrom`/`registeredTo`, if given, stay on as a second filter. |
| `entityStatus` | string | `ACTIVE` | `ACTIVE`, `INACTIVE`, or `any` to send no filter. |
| `registrationStatus` | string | `ISSUED` | `ISSUED`, `LAPSED`, `ANNULLED`, `PENDING_TRANSFER`, `PENDING_ARCHIVAL`, `DUPLICATE`, `RETIRED`, `MERGED`, or `any`. |
| `categories` | string\[] | all | `GENERAL`, `FUND`, `BRANCH`, `SOLE_PROPRIETOR`, `RESIDENT_GOVERNMENT_ENTITY`, `INTERNATIONAL_ORGANIZATION`. |
| `legalForms` | string\[] | all | ISO 20275 ELF codes, four characters each: `IWZF` Singapore private company limited by shares, `Y8W9` Singapore exempt private company, `XTIQ` US Delaware corporation. Several codes are ORed. |
| `keywords` | string\[] | none | Passed to GLEIF's full-text search, which covers every field of the LEI record including names and addresses. Terms are ORed by running one newest-first pass per term and skipping LEIs already delivered; a term containing spaces must match all of its words. |
| `resolveCodes` | boolean | `true` | Resolve `legalFormCode` and `registrationAuthorityCode` to their published names. Off, those two name columns fall back to the entity's own free text and then to the bare code. |
| `maxItems` | integer | `500` | Stop after this many records. You are charged per record delivered, so this is also the cost cap. Newest first, so a value below the window's volume drops the **oldest** records in the window. |

Example - every new Singapore company of the last 30 days, with its ACRA UEN:

```json
{ "countries": ["SG"], "daysBack": 30, "entityStatus": "ACTIVE", "registrationStatus": "ISSUED", "maxItems": 500 }
```

Example - a daily change feed for German and Dutch entities, run on a schedule:

```json
{ "countries": ["DE", "NL"], "updatedWithinDays": 2, "maxItems": 2000 }
```

Example - every investment fund registered in Luxembourg and Ireland this year:

```json
{ "countries": ["LU", "IE"], "categories": ["FUND"], "registeredFrom": "2026-01-01", "maxItems": 20000 }
```

Example - the fast bulk mode: everything registered worldwide in the last week, codes left unresolved:

```json
{ "daysBack": 7, "entityStatus": "any", "registrationStatus": "any", "resolveCodes": false, "maxItems": 10000 }
```

Bad input fails fast: an unknown country code, ELF code, category, status or malformed date stops the run with the validation message as its status, before any request is made.

### Output example

A real record from a live run on 8 September 2026 (`{"countries": ["SG"], "daysBack": 30, "maxItems": 5}`), unedited:

```json
{
  "id": "98450083CA3D5F41BK11",
  "source": "gleif",
  "url": "https://search.gleif.org/#/record/98450083CA3D5F41BK11",
  "lei": "98450083CA3D5F41BK11",
  "legalName": "HASHLABS PTE. LTD.",
  "otherNames": [],
  "transliteratedOtherNames": [],
  "country": "SG",
  "jurisdiction": "SG",
  "legalForm": "Exempt Private Company",
  "legalFormCode": "Y8W9",
  "category": "GENERAL",
  "subCategory": null,
  "entityStatus": "ACTIVE",
  "entityCreationDate": "2024-04-26T00:00:00Z",
  "entityExpirationDate": null,
  "entityExpirationReason": null,
  "legalAddress": "1 NORTH BRIDGE ROAD, #24-02, HIGH STREET CENTRE",
  "legalCity": "Singapore",
  "legalRegion": "SG-01",
  "legalPostalCode": "179094",
  "headquartersAddress": "1 NORTH BRIDGE ROAD, #24-02, HIGH STREET CENTRE",
  "headquartersCity": "Singapore",
  "headquartersRegion": "SG-01",
  "headquartersPostalCode": "179094",
  "headquartersCountry": "SG",
  "registrationAuthority": "Accounting and Corporate Regulatory Authority (ACRA)",
  "registrationAuthorityCode": "RA000523",
  "registrationAuthorityId": "202416632G",
  "initialRegistrationDate": "2026-09-05T05:27:37Z",
  "lastUpdateDate": "2026-09-05T05:27:37Z",
  "nextRenewalDate": "2027-09-05T05:27:40Z",
  "registrationStatus": "ISSUED",
  "managingLou": "529900T8BM49AURSDO55",
  "corroborationLevel": "FULLY_CORROBORATED",
  "conformityFlag": "CONFORMING",
  "bic": [],
  "mic": [],
  "ocid": null,
  "hasDirectParent": false,
  "hasUltimateParent": false,
  "fetchedAt": "2026-09-08T05:21:12.184Z"
}
```

A fund from the same run looks the same but carries `"category": "FUND"`, a `legalFormCode` of `8888` with the filer's own words in `legalForm` (`"Sub-Fund"`), and a `headquartersAddress` that starts `"C/O IFAST FINANCIAL PTE. LTD., ..."` - for example `254900H1CE3VNDDJW869`, "IFAST XTRACKERS NIKKEI 225 UCITS INDEX ETF". A bank carries the identifier arrays: `ATUEL7OJR5057F2PV266`, "DBS BANK LTD.", has eleven BICs (`DBSSSGSGXXX`, `DBSSHKHHXXX`, ...), `"ocid": "sg/196800306E"` and `hasDirectParent: true`.

Every run also writes a `SUMMARY` record to the key-value store with the resolved window and date field, the filters used, how many records GLEIF matched per keyword, the number of API requests and pages, the number of re-anchors and duplicates, the code-lookup counts, the Golden Copy publish date, and the two completeness flags `limitReached` and `windowExhausted` (see *Limits and freshness*).

### Pricing

Pay per result: **US$0.002 per LEI record delivered** (US$2 per 1,000 records). You are charged only for records pushed to the dataset; a run that returns nothing costs nothing. Runs on the Apify free plan are limited by the platform's free-tier usage allowance.

### Data source and licence

- Endpoint: `GET https://api.gleif.org/api/v1/lei-records`, with `https://api.gleif.org/api/v1/entity-legal-forms/{code}` and `https://api.gleif.org/api/v1/registration-authorities/{code}` for the two code lists. All are public and need no key or account. Documentation: <https://api.gleif.org/docs> and <https://www.gleif.org/en/lei-data/gleif-api> (read 8 September 2026).
- **Licence: CC0 1.0 Universal (public domain dedication).** GLEIF's LEI Data Terms of Use state that "The data available through the Access Service are provided under the CC0 licence", linking <https://creativecommons.org/publicdomain/zero/1.0/>. Terms read 8 September 2026 at <https://www.gleif.org/en/meta/lei-data-terms-of-use>. Commercial reuse is permitted and CC0 requires no attribution. (The URL `https://www.gleif.org/en/about/policies/gleif-data-licensing` that is sometimes cited for this returned HTTP 404 on 8 September 2026; the Terms of Use page above is the live source.)
- Two conditions in those Terms of Use are **not** waived by CC0 and do bind you: you must not create the impression that your product or service is provided, supported, authorised by or otherwise associated with GLEIF or any LOU, and you must contact GLEIF before using the GLEIF trademark or logo. Attributing the data as "Source: GLEIF" with a link to <https://www.gleif.org> is good practice and stays well inside both.
- GLEIF publishes the data "as is" and explicitly does not warrant that it is accurate or up to date: the LEI reference data is supplied by the entities themselves and validated by the issuing LOU to the degree recorded in `corroborationLevel`.
- **Personal data.** Most records are companies, but `SOLE_PROPRIETOR` records - 126,828 in the register on 8 September 2026, and 2,697 of the 25,600 registered in the previous 30 days - are natural persons trading in their own name, so their `legalName` is a person's name and their `legalAddress` is frequently a home address. A handful of `GENERAL` records also carry a founder's home address. GLEIF and the LOUs publish these lawfully as part of a public identifier system, but what you do with them downstream - marketing in particular - is your responsibility under the applicable regime (GDPR if you are processing EU or UK data subjects, and the equivalent local law elsewhere). Filter `categories` to exclude `SOLE_PROPRIETOR` if you want companies only. No email address or telephone number is published anywhere in this dataset.

### Limits and freshness

- **Volumes, measured 8 September 2026** against the API: **3,423,663** LEI records in total; **3,162,967** with `entityStatus` ACTIVE, **1,965,209** with `registrationStatus` ISSUED and **1,964,760** with both (this Actor's defaults). By category: 3,039,180 GENERAL, 248,710 FUND (200,082 of them active), 126,828 SOLE\_PROPRIETOR, 1,910 BRANCH. New registrations: **5,581 in the last 7 days** and about **25,600 in the last 30 days** worldwide - by country over those 30 days, India 7,965, United States 2,249, Germany 1,675, United Kingdom 1,216, Singapore 121. Changes: **44,310 records were updated in the 8 days** to 8 September, 3,308 of them in the last two. Nothing in the register predates 1 January 2012 (28,089 LEIs were registered during 2012), so `{"daysBack": 6000}` is a complete historical window.
- **The 10,000-record paging wall, and how this Actor gets past it.** GLEIF caps `page[size]` at 200 and refuses any request where `page[number] * page[size]` exceeds 10,000 ("Deep page-based pagination is not supported beyond 10000 results"). A plain pager therefore stops at 10,000 records per query - and 30 days of worldwide registrations is 25,600. This Actor reads newest-first and, on hitting the wall, moves the upper bound of its date filter to the oldest timestamp it has just read and restarts paging; GLEIF's range bounds are inclusive, so the boundary record comes back once more and is dropped by LEI. **Measured on a live run on 8 September 2026**: 10,400 worldwide records over a 30-day window took 53 API requests and 125 s across one re-anchor, and produced 10,400 distinct LEIs in strictly descending registration order with exactly 1 duplicate discarded and no gap. The `SUMMARY` record reports `reanchors` and `duplicates` for every run.
- **Size `maxItems` to the window, and check `windowExhausted`.** `maxItems` counts records delivered and the stream is newest-first, so a value below the window's volume drops the **oldest** records in it - but never silently. The run stops the moment the cap is filled and warns `maxItems (N) reached before the window was exhausted`, and the `SUMMARY` record carries `limitReached: true` with `windowExhausted: false`. `windowExhausted: true` is the guarantee that you hold the complete window: it is set only when every search pass reached the end of its result set with nothing left unread on a page and every record kept was actually delivered. The default 500 covers a 30-day window for most single countries; a 30-day worldwide window needs about 26,000.
- **Rate limit: 60 requests per minute per user**, as stated at <https://api.gleif.org/docs> (read 8 September 2026). The Actor paces every request - record pages and code lookups alike - at one per 1.05 s so it stays inside that on its own, and `fetchWithRetry` still retries 429 and 5xx responses with exponential back-off and honours `Retry-After`. As a safety net each search pass also stops after 3,000 record requests (about 600,000 records) and says so in the log.
- **Speed, measured 8 September 2026** on this machine, dominated entirely by that pacing: 500 records for one country with code resolution on took **21 s / 15 requests**; 500 worldwide with resolution on took **35 s / 27 requests** (the first page alone needed enough codes to trigger both list downloads); 500 worldwide with `resolveCodes: false` took **9 s / 3 requests**. Budget roughly one request per 200 records plus the code lookups.
- **How the code lists are resolved, and what it costs.** `legalFormCode` and `registrationAuthorityCode` are looked up one at a time and cached for the run, until a single page needs more than 25 unresolved ELF codes (or 10 authority codes), at which point the whole list is downloaded instead - 18 requests for 3,599 legal forms, 6 for 1,071 authorities - and every later page resolves for free. That threshold matters: a 10,400-record worldwide batch contained **408 distinct ELF codes and 352 distinct registration authorities**, which one-at-a-time would have cost 760 requests and 13 minutes. In a 500-record worldwide run with resolution on, every ELF code resolved to a name and 16 of 500 records had no registration authority at all.
- **Where `legalForm` and `registrationAuthority` are not controlled vocabulary.** ELF codes `8888` (legal form pending inclusion in the ISO 20275 list) and `9999` (not covered by it) carry no name, and code `RA999999` means "no registration authority available". For those the Actor publishes the entity's own free text instead, which is typed by the filer and is not normalised: 688 of the 10,400 records sampled used an ELF placeholder and 455 used `RA999999`, and a single Singapore batch of 500 contained `Sub-Fund`, `SUB-FUND`, `Sub-fund`, `Sub Fund` and `SUB FUND` as five spellings of one thing (and `Fund`, `FUND` and `fund` as three of another). Case-fold before grouping on those. When even the free text is missing, the column stays `null` rather than showing you a code that means nothing.
- **Field completeness, measured over the 10,400-record worldwide batch**: `legalName`, `legalAddress`, `legalCity`, `country`, `initialRegistrationDate` and `lastUpdateDate` were present on every record. `registrationAuthorityId` - the local register number - was missing on 500 (4.8%). The headquarters country differed from the legal country on 145 (1.4%). 1,218 (11.7%) carried an OpenCorporates id, 149 (1.4%) had a direct parent LEI on file, and none carried a BIC (BICs cluster on banks, which are a small share of new registrations). Missing values are the filer's, not the Actor's, and stay `null`.
- **Freshness.** The API is rebuilt from GLEIF's Golden Copy several times a day and stamps every response with the copy it is serving; each run stores that stamp as `goldenCopyPublishDate` in the `SUMMARY`, so you can tell a stale re-run from a fresh one. Measured 8 September 2026 at 05:20 UTC: the stamp was `2026-09-07T16:00:00Z`, the newest initial registration in the API was `2026-09-07T15:24:48Z` and the newest update `2026-09-07T16:59:33Z` - so expect something on the order of half a day between an LEI being issued and its appearing here. The exact publication cadence was not measured, so run an overlapping window (`daysBack: 3` daily, or `updatedWithinDays: 3`) rather than one that exactly abuts the previous run.
- **Every filter is applied by GLEIF, not after the fact.** Countries, categories, legal forms, both statuses and both date windows are sent as `filter[...]` parameters, so `matched` in the `SUMMARY` is the API's own count of the whole result set and you are never charged for records the Actor fetched and threw away. The only thing filtered locally is a repeated LEI. The one exception is `keywords`: the API takes a single full-text term per query, so each keyword gets its own pass and a cap reached before the last pass sets `windowExhausted: false`.
- **`country` is the legal address, not the jurisdiction.** GLEIF also exposes `entity.jurisdiction` (where the entity was formed) and an "any address" country filter that matches the headquarters and other addresses too; on 8 September 2026 Singapore had 14,224 records by legal address, 14,198 by jurisdiction and 16,093 by any address. This Actor filters on the legal address and publishes `jurisdiction` alongside so you can see where the two disagree.

### Use cases

- **New-company lead generation with a verified register number.** A scheduled daily run over your target countries returns entities within hours of their LEI being issued, each already carrying its national register id (`registrationAuthorityId`) plus a legal and a headquarters address - enough to enrich against a company register or a CRM without a name-matching step.
- **KYC, KYB and counterparty onboarding files.** `corroborationLevel`, `conformityFlag`, `registrationStatus` and `nextRenewalDate` say how well each record is evidenced and whether the LEI is current; `bic`, `mic` and `ocid` join it to payments, market and company-register data; `hasDirectParent`/`hasUltimateParent` flag the entities whose ownership you still need to walk.
- **Register monitoring and market research.** `updatedWithinDays` gives a daily diff of everything that changed - a renewal, a move, a name change, a lapse - and a full historical pull (`daysBack: 6000`) supports registration-trend analysis by country, legal form, category or issuing LOU back to the start of the Global LEI System in 2012.

### Support

Open an issue on the Actor's Issues tab on Apify Store. Replies within 14 days. Bug reports that name the run id and the input used are fixed fastest.

# Actor input Schema

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

Two-letter ISO 3166 codes matched against the entity's LEGAL address country, e.g. SG, US, GB, DE. Several codes are ORed. Empty = every country. Note that this is the legal address, not the headquarters address, and not the jurisdiction of formation.

## `daysBack` (type: `integer`):

Look-back window in days on the LEI's initial registration date, ending now. Ignored when Registered from / Registered to are set. The Global LEI System started issuing in 2012, so 5000 reaches the first record.

## `registeredFrom` (type: `string`):

Start of the initial-registration window, YYYY-MM-DD (inclusive, from 00:00:00 UTC). Overrides Days back. When Updated within days is set this becomes an extra filter on top of the update window.

## `registeredTo` (type: `string`):

End of the initial-registration window, YYYY-MM-DD (inclusive, to 23:59:59 UTC). Defaults to now.

## `updatedWithinDays` (type: `integer`):

Set this to watch records that CHANGED rather than records that are new: the run then windows and sorts on the LEI registration's last-update date instead of its initial registration date, and Days back is ignored. Registered from / Registered to still apply, as an extra filter. Empty = a new-registrations run.

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

The legal entity's own status. ACTIVE = the entity still exists; INACTIVE = it has been dissolved or merged away.

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

The status of the LEI registration itself. ISSUED = current and renewed on time; LAPSED = not renewed by its due date but still published; the rest are administrative end states.

## `categories` (type: `array`):

GLEIF entity categories. Empty = all categories.

## `legalForms` (type: `array`):

ISO 20275 Entity Legal Form codes, four characters each, e.g. Y8W9 (Singapore exempt private company), IWZF (Singapore private company limited by shares), XTIQ (US Delaware corporation). Several codes are ORed. Empty = all legal forms. The full list is at https://www.gleif.org/en/about-lei/code-lists/iso-20275-entity-legal-forms-code-list

## `keywords` (type: `array`):

Terms passed to GLEIF's full-text search, which covers every field of the LEI record including the legal name, other names and the addresses. Terms are ORed by running one newest-first pass per term and skipping LEIs already delivered. A term containing spaces is matched as all of its words. Empty = no keyword filter.

## `resolveCodes` (type: `boolean`):

Look the ELF legal-form code and the RA registration-authority code up in GLEIF's own code lists, so `legalForm` reads "Private Company Limited by Shares" instead of "IWZF" and `registrationAuthority` reads "Accounting and Corporate Regulatory Authority (ACRA)" instead of "RA000523". Codes are cached for the run and the whole list is downloaded once a run needs many of them. Turn this off to spend every request on records instead.

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

Stop after this many LEI records. You are charged per record delivered, so this is also the cost cap. Newest first, so a value below the window's volume drops the OLDEST records in the window. Measured 8 September 2026: 30 days of new registrations is about 25,600 worldwide, 2,249 for US, 1,675 for DE, 1,216 for GB and 121 for SG.

## Actor input object example

```json
{
  "countries": [],
  "daysBack": 30,
  "entityStatus": "ACTIVE",
  "registrationStatus": "ISSUED",
  "categories": [],
  "legalForms": [],
  "keywords": [],
  "resolveCodes": true,
  "maxItems": 500
}
```

# Actor output Schema

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

All LEI records returned by the run, one JSON object each. Append ?format=csv or ?format=xlsx to download a spreadsheet.

## `summary` (type: `string`):

Counts, the date window and filters used, how many records GLEIF matched, the API requests and code-list lookups spent, the Golden Copy publish date and the completeness flags, written at the end of the run.

# 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": [],
    "daysBack": 30,
    "entityStatus": "ACTIVE",
    "registrationStatus": "ISSUED",
    "categories": [],
    "legalForms": [],
    "keywords": [],
    "resolveCodes": true,
    "maxItems": 500
};

// Run the Actor and wait for it to finish
const run = await client.actor("knotty_mistveil/gleif-lei-records").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": [],
    "daysBack": 30,
    "entityStatus": "ACTIVE",
    "registrationStatus": "ISSUED",
    "categories": [],
    "legalForms": [],
    "keywords": [],
    "resolveCodes": True,
    "maxItems": 500,
}

# Run the Actor and wait for it to finish
run = client.actor("knotty_mistveil/gleif-lei-records").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 '{
  "countries": [],
  "daysBack": 30,
  "entityStatus": "ACTIVE",
  "registrationStatus": "ISSUED",
  "categories": [],
  "legalForms": [],
  "keywords": [],
  "resolveCodes": true,
  "maxItems": 500
}' |
apify call knotty_mistveil/gleif-lei-records --silent --output-dataset

```

## MCP server setup

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

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/4iUVcz3wKyOJeWUMp/builds/Zr6lT0Oe6gt8KfK89/openapi.json