# LEI Change Monitor: GLEIF Parent, Status, Renewal (`conserving_celerytop/gleif-ownership-change-monitor-api`) Actor

Monitor LEIs in the GLEIF Golden Copy and get one row per change since your last run: parent, ultimate parent, registration status, renewal date, legal name, legal address, jurisdiction. $5 per 1,000 changes, $0.10 per 1,000 LEIs checked. Independent tool, not affiliated with GLEIF.

- **URL**: https://apify.com/conserving_celerytop/gleif-ownership-change-monitor-api.md
- **Developed by:** [Don Mangu](https://apify.com/conserving_celerytop) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.50 / 1,000 change events

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

Use this LEI change monitor to watch legal entities in the GLEIF Golden Copy and get one row for every change since your last run. It reports a new direct or ultimate parent, a reporting exception that appears or disappears, a registration that lapses or is retired, annulled or marked duplicate, a renewal date that passes, and a changed legal name, legal address, jurisdiction or entity status. You pay $5.00 per 1,000 changes plus $0.10 per 1,000 LEIs checked. A quiet run of 100 LEIs costs one cent.

You need no login, no API key and no proxy. The Actor reads the public GLEIF API (CC0 data) and saves its own state in a named key-value store in your Apify account. It is an unofficial tool built by an independent developer. It is not affiliated with, endorsed by or operated by GLEIF.

### What this LEI change monitor returns

One row is one change of one LEI. The fields are:

- LEI and legal name: the 20-character identifier and the current legal name.
- Change type: one of 11 types, listed below.
- Previous value and new value: what the saved state said and what GLEIF says now. For a parent change these are parent LEIs. For a reporting exception they are the exception reasons, such as NATURAL_PERSONS or NO_KNOWN_PERSON, and an empty value means no exception is reported.
- Detected at: the time of the run that found the change.
- Source URL: the GLEIF API link of the record.
- Golden Copy date: the publish date of the GLEIF data that this run read.

The 11 change types are direct-parent-changed, ultimate-parent-changed, direct-parent-exception-changed, ultimate-parent-exception-changed, registration-status-changed, renewal-date-passed, next-renewal-date-changed, legal-name-changed, legal-address-changed, jurisdiction-changed and entity-status-changed. The registration status covers ISSUED, LAPSED, RETIRED, ANNULLED, DUPLICATE, MERGED and the pending states. The renewal-date-passed row appears once, when the next renewal date lies in the past while the registration still says ISSUED. The entity status is ACTIVE or INACTIVE.

Other row types are free: baseline (first sight of an LEI), snapshot, no-change, name-resolved, not-found and name-not-found.

#### How it differs from our Company Registry Search

[Company Registry Search](https://apify.com/conserving_celerytop/open-company-registries) looks up companies once, in GLEIF, Norway and Finland. This Actor keeps a watch list, remembers the last state of every LEI and reports only what changed.

### How to monitor LEIs, step by step

1. Open the Actor and go to Input.
2. Under LEIs, enter one LEI per line. Under Company names, enter legal names if you do not have the LEIs. The Actor picks the best match for each name and shows the LEI and a confidence note in a name-resolved row. Copy the LEI into the LEIs field once you have checked it.
3. Keep Mode on changes. Switch on Emit baseline for the first run if you want to see the starting state of every LEI. The first run only saves the baseline. It never reports changes.
4. Pick a Monitor name. The state of the watch list is saved under this name in the key-value store gleif-monitor-state.
5. Optional: pick Change types to report only some types. A type you leave out keeps its saved value, so a later run that selects it still reports the change. Switch off Only changes to also get one unchanged row for every other LEI. Switch off Include parents for a fast check of status, renewal, name, address and jurisdiction.
6. Click Start. Open the Changes view of the dataset, or download the rows as JSON, CSV or Excel, or read them through the Apify API.
7. For a daily watch, create a schedule with the same input and the same Monitor name. Each run compares the current GLEIF record with the state the previous run saved.

The Actor sends one request at a time, 1.1 seconds apart. GLEIF documents a limit of 60 requests per minute, so the Actor stays below it. The Actor reads up to 50 LEIs in one request. With Include parents on, it adds up to two requests per LEI for the direct and the ultimate parent. A measured run of 30 LEIs took 66 seconds, about 2.2 seconds per LEI. Plan about 4 minutes for 100 LEIs and about 37 minutes for 1,000 LEIs. Set the run timeout to two hours for lists above 1,500 LEIs. With Include parents off, 50 LEIs take about one second.

### LEI change monitor pricing

You pay per change and per LEI checked.

- Change event: $0.005 per change row, which is $5.00 per 1,000 changes. Discounts on higher Apify plans: $0.0045 (Bronze), $0.004 (Silver), $0.0035 (Gold).
- LEI checked: $0.0001 per LEI that the Actor read and compared, which is $0.10 per 1,000 LEIs. The price is the same on every plan.
- Actor start: $0.00005 per run.

Worked example: a watch list of 100 LEIs, checked once a day for 30 days. Each run costs 100 x $0.0001 + $0.00005 = $0.01005, so 30 runs cost $0.3015. If the list shows 6 changes in the month, they cost 6 x $0.005 = $0.03. The month costs $0.3315 (the 6 changes are an example, not a measured value). A run with no change costs the same $0.01005. Baseline, snapshot, unchanged, name-resolved and not-found rows are free. A LEI that GLEIF does not know is not charged. Set a maximum charge per run to cap the cost. When the maximum is reached, the Actor stops before the next LEI and leaves the saved state of the unchecked LEIs as it was.

### Input example

```json
{
  "leis": [
    "HWUPKR0MPOU8FGXBT394",
    "549300YX4S1LLSMK2627"
  ],
  "mode": "changes",
  "monitorName": "smoke"
}
```

The first run of this input saved the baseline. Before the second run, the saved state was edited by hand (a different legal name, status, parent, address, jurisdiction and so on), so the second run found 11 differences. The three rows below come from that real run against the live GLEIF API on 11 October 2026. The changes are test changes, not real events at the two companies.

### Output example

```json
[
  {
    "lei": "HWUPKR0MPOU8FGXBT394",
    "legalName": "Apple Inc.",
    "changeType": "registration-status-changed",
    "previousValue": "LAPSED",
    "newValue": "ISSUED",
    "detectedAt": "2026-10-11T08:43:11.702Z",
    "sourceUrl": "https://api.gleif.org/api/v1/lei-records/HWUPKR0MPOU8FGXBT394",
    "goldenCopyDate": "2026-10-11T00:00:00Z",
    "state": null
  },
  {
    "lei": "HWUPKR0MPOU8FGXBT394",
    "legalName": "Apple Inc.",
    "changeType": "legal-name-changed",
    "previousValue": "Apple Computer, Inc.",
    "newValue": "Apple Inc.",
    "detectedAt": "2026-10-11T08:43:11.702Z",
    "sourceUrl": "https://api.gleif.org/api/v1/lei-records/HWUPKR0MPOU8FGXBT394",
    "goldenCopyDate": "2026-10-11T00:00:00Z",
    "state": null
  },
  {
    "lei": "549300YX4S1LLSMK2627",
    "legalName": "APPLE ENERGY LLC",
    "changeType": "direct-parent-changed",
    "previousValue": "5493004QI6E3PJNCEB09",
    "newValue": "HWUPKR0MPOU8FGXBT394",
    "detectedAt": "2026-10-11T08:43:11.702Z",
    "sourceUrl": "https://api.gleif.org/api/v1/lei-records/549300YX4S1LLSMK2627",
    "goldenCopyDate": "2026-10-11T00:00:00Z",
    "state": null
  }
]
```

A baseline or snapshot row has the same fields. Its newValue holds a one-line summary, such as "registration ISSUED; entity ACTIVE; next renewal 2027-03-08T17:20:49Z; jurisdiction US-DE; direct parent: LEI HWUPKR0MPOU8FGXBT394; ultimate parent: LEI HWUPKR0MPOU8FGXBT394", and its state field holds the compared values.

### Run it every day

Use this to see each day which LEI records changed.

1. Put your LEIs in the list.
2. Keep **Only changes** (`onlyChanges`) on. It is on by default.
3. Give the watch list a **Monitor name** (`monitorName`). Use one name for each watch list and each set of change types.
4. Save the input as a task and add a daily schedule with the same input and the same Monitor name.

The first run saves a baseline. Each later run compares the current GLEIF record with the saved state and returns only the LEIs that changed. Example: a watch list of 100 LEIs checked once a day costs 100 x $0.0001 + $0.00005 = $0.01005 a day, plus $0.005 for each change.

### Related Actors

- [Company Registry Search](https://apify.com/conserving_celerytop/open-company-registries): one-time search in GLEIF, Norway and Finland by name or number.
- [Companies House API](https://apify.com/conserving_celerytop/uk-companies-house-api): UK company data with status and registered office.
- [Business Entity Search](https://apify.com/conserving_celerytop/us-state-open-business-registry-api): US state registries for Colorado and Connecticut.
- [Website Change Monitor](https://apify.com/conserving_celerytop/website-change-monitor): text diffs of public web pages.

### FAQ

#### Is it legal to read GLEIF data this way?

This is not legal advice. GLEIF publishes LEI data for free reuse. The GLEIF LEI Data Terms of Use (gleif.org/en/meta/lei-data-terms-of-use, section II.3) say: "The data available through the Access Service are provided under the CC0 licence". The GLEIF API documentation says: "Rate limiting is currently set at 60 requests, per minute, per user, for all users." The Actor stays below this limit and honours a Retry-After header. The terms also say the data is provided "AS IS" and "AS AVAILABLE", and that GLEIF does not warrant that it is accurate or up to date. Check critical facts in the GLEIF record before you act on them.

#### Does the output hold personal data?

No. LEI records describe legal entities. The Actor outputs company names, addresses of registered offices, identifiers and statuses. A reporting exception reason such as NATURAL_PERSONS is a category, not a name.

#### How fresh is the data?

The Actor reads the GLEIF Golden Copy through the API. Each row shows the goldenCopyDate of the data it read. A change that GLEIF published after your last run shows up in your next run.

#### How do the saved state and the baseline work?

The state of each LEI is saved in the named key-value store gleif-monitor-state of your account, one record per Monitor name. The first run for an LEI saves a baseline and reports no change. The state moves forward only after the rows of that LEI are saved. If a run stops early, the LEIs not yet checked keep their old state and show their changes in the next run. In rare cases of a crash between saving rows and saving state, a change row can appear twice.

#### How does name matching work?

The Actor asks GLEIF for records with the exact legal name and falls back to a full text search. It prefers a record with registration status ISSUED and entity status ACTIVE. The confidence note says high (one exact match), medium (several records share the exact name) or low (no exact match). The GLEIF fuzzy completion endpoint returned no results in tests on 11 October 2026, so the Actor does not use it. Enter the LEI when a name is ambiguous.

#### What is not covered?

Headquarters address changes, parent names, child entities, successor entities, fund relationships and the history of earlier changes. The Actor compares the saved state with the current state, so two changes between runs that cancel each other produce no row.

#### A request failed. What happens?

A 403 stops the run at once. A 429 or 5xx is retried up to 3 times with growing waits, and a long Retry-After ends the run. A LEI whose parents could not be read keeps its old state and is not charged. If nothing could be read, the run ends with an error and charges nothing. Run again later.

# Actor input Schema

## `leis` (type: `array`):

Enter one 20-character LEI per line. The Actor checks the format and the check digits before any request. Add up to 2,000 LEIs per run.

## `companyNames` (type: `array`):

Enter one legal name per line. The Actor looks up the best matching LEI and adds it to the list. A row of type name-resolved shows the LEI it picked and a confidence note. Enter the LEI instead when several companies share a name.

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

Pick changes to compare with the state saved by the previous run. Pick snapshot to read the current state of each LEI. Snapshot leaves the saved state as it is.

## `changeTypes` (type: `array`):

Pick the change types to report. Leave the list empty to report all types. A type left out keeps its stored value, so a later run that selects it still reports the change.

## `onlyChanges` (type: `boolean`):

Return only LEIs with a change. Switch it off to also get one unchanged row for every other LEI. Unchanged rows are free.

## `emitBaseline` (type: `boolean`):

Return one baseline row with the current state for every LEI that the monitor sees for the first time. Baseline rows are free.

## `monitorName` (type: `string`):

Enter a short name for this watch list, using letters, digits, dots, hyphens and underscores. The state is saved in the named key-value store gleif-monitor-state under this name. Use one name for each watch list and each set of change types.

## `includeParents` (type: `boolean`):

Check the direct parent, the ultimate parent and their reporting exceptions. This adds up to two requests per LEI. Switch it off for a fast check of status, renewal, name, address and jurisdiction at 50 LEIs per request.

## Actor input object example

```json
{
  "leis": [
    "HWUPKR0MPOU8FGXBT394",
    "549300YX4S1LLSMK2627"
  ],
  "mode": "snapshot",
  "onlyChanges": true,
  "emitBaseline": false,
  "monitorName": "default",
  "includeParents": true
}
```

# Actor output Schema

## `changes` (type: `string`):

No description

## `stats` (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 = {
    "leis": [
        "HWUPKR0MPOU8FGXBT394",
        "549300YX4S1LLSMK2627"
    ],
    "mode": "snapshot"
};

// Run the Actor and wait for it to finish
const run = await client.actor("conserving_celerytop/gleif-ownership-change-monitor-api").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 = {
    "leis": [
        "HWUPKR0MPOU8FGXBT394",
        "549300YX4S1LLSMK2627",
    ],
    "mode": "snapshot",
}

# Run the Actor and wait for it to finish
run = client.actor("conserving_celerytop/gleif-ownership-change-monitor-api").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 '{
  "leis": [
    "HWUPKR0MPOU8FGXBT394",
    "549300YX4S1LLSMK2627"
  ],
  "mode": "snapshot"
}' |
apify call conserving_celerytop/gleif-ownership-change-monitor-api --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,conserving_celerytop/gleif-ownership-change-monitor-api"
        }
    }
}
```

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/O9cEJbwXXqV9glRol/builds/AWxFm5cKs76LdDeca/openapi.json