LEI Lookup: Legal Entity Identifier records from the Global LEI Index (CC0)

You get Legal Entity Identifier (LEI) records from the Global LEI Index, one fixed row per entity.

A row holds the LEI, legal name, other names, category, legal form, jurisdiction, entity and registration status, dates, registration number, and the legal and headquarters address down to city only. For a recognised sole proprietor, or an arrangement named after a person (a settlement, a family or will trust, "estate of"), the names, registration number and addresses are withheld (null, or [] for other names) and listed in withheld; in name and status searches those entities are left out and counted. A company whose name contains a person's name is returned as published, and the sole-proprietor and arrangement tests can miss a person. The record link opens the source record, which we do not filter.

Free-plan prices: $0.002 per entity returned ($0.004 with the parents or ISIN-count add-on), $0.02 per change in watch mode, no start fee. Bronze, Silver and Gold plans pay less. LEIs not found, LEIs refused as invalid, and searches with no results are not charged.

Mode	You give	A question it answers
lei	leis: up to 1,000 LEIs	Is LEI 2138002P5RNKC5W2JZ46 still ISSUED, and what is its legal name and next renewal date?
name	name, optionally country and status	Which ISSUED entities with "Tesco" in their legal name have a legal address in GB? (first 10 by default, up to 200 with maxItems)
status	status and country, optionally category	Which GB funds have a LAPSED LEI? (first 100 by default, up to 10,000 with maxItems)
watch	watchId and leis	Which of my 500 supplier LEIs lapsed, went past renewal or were renamed since yesterday?
children	leis: 1 to 20 root LEIs, optionally relation	Which entities report Bloomberg L.P. as their direct parent to GLEIF? (first 100 by default, up to 4,000 with maxItems)

One row, from the default run:

lei	legalName	registrationStatus	entityStatus	jurisdiction	legalForm	legalAddress	nextRenewalDate
2138002P5RNKC5W2JZ46	TESCO PLC	ISSUED	ACTIVE	GB	B6ES	{"country": "GB", "region": "GB-HRT", "city": "WELWYN GARDEN CITY"}	2027-01-10T00:00:00Z

A default run looks up one LEI and costs $0.002. A name search that returns its default 10 rows costs $0.02; a status search at its default 100 rows costs $0.20. Add up to 1,000 LEIs to the leis list to look up more, at $0.002 for each one found; to search by name or status instead, see Modes.

When to use it, and when not to

Use it to:

• check whether a LEI is still ISSUED, and read its legal name, status, legal form, city-level address and next renewal date;
• find the LEI of an entity from its legal name, and confirm it;
• list entities by status, country and category (for example, GB funds whose LEI has lapsed).

Do not use it:

• to find who owns an entity: shareholdings are not returned, only the parents (add-on) and children (children mode) reported to GLEIF, one level at a time;
• for credit, risk or sanctions checks;
• for individuals: details of recognised sole proprietors are withheld, but a person's name can still appear inside another entity's legal name;
• to treat a name search as proof: a name match is a lead. Rows with matchType: "similar" are near matches that you must confirm against the legal name, country and LEI before relying on them.

What you get

One row per entity, the same fields in every mode. A missing value is null (or [] for lists), never an absent key.

Field	Type	Meaning
lei	string	The 20-character LEI
legalName	string or null	Legal name. null when withheld
otherNames	array of strings	Other and transliterated names. [] when withheld
category	string or null	Entity category, e.g. GENERAL, FUND, SOLE_PROPRIETOR
subCategory	string or null	Entity sub-category
legalForm	string or null	Legal form code (ISO 20275 ELF code)
jurisdiction	string or null	Legal jurisdiction
entityStatus	string or null	ACTIVE or INACTIVE
registrationStatus	string or null	LEI registration status, e.g. ISSUED, LAPSED, MERGED
corroborationLevel	string or null	How well the registration data is corroborated
initialRegistrationDate	string or null	When the LEI was first registered
lastUpdateDate	string or null	When the record was last updated
nextRenewalDate	string or null	When the LEI is next due for renewal
managingLou	string or null	LEI of the issuer that manages this LEI
registeredAt	string or null	Code of the business register the entity is registered in
registeredAs	string or null	The entity's number in that register. null when withheld
legalAddress	object or null	{country, region, city} only. null when withheld
headquartersAddress	object or null	{country, region, city} only. null when withheld
successorLei	string or null	LEI of the successor entity, if any
expirationReason	string or null	Why the entity's record expired, if it did
bic	array of strings	BIC codes linked to the LEI
conformityFlag	string or null	The record's conformity flag
matchType	string	lei, name, similar, status or children: how the row was found
soleProprietor	boolean	true when the entity's category is SOLE_PROPRIETOR or its legal form is a sole-trader form
withheld	array of strings	Fields withheld because the entity is a recognised sole proprietor or an arrangement named after a person (see Privacy). [] otherwise
recordUrl	string	The API record for this LEI
goldenCopyDate	string or null	Publish date of the daily Golden Copy the row was read from

Modes

By LEI

{
  "mode": "lei",
  "leis": ["2138002P5RNKC5W2JZ46", "5493001KJTIIGC8Y1R12"]
}

• 1 to 1,000 LEIs per run, read 200 at a time. Duplicates are looked up once.
• Each LEI is checked as ISO 17442 (20 characters, valid check digits) before any request. A bad one is refused on its own, listed in RUN_SUMMARY.refused, and costs nothing; the rest are looked up.
• Rows come back in input order. An LEI the source does not know gives no row and no charge, and is listed in RUN_SUMMARY.notFound.

By name

{
  "mode": "name",
  "name": "Tesco PLC",
  "country": "GB",
  "status": "ISSUED",
  "maxItems": 10
}

• name: 2 to 255 characters. It matches the words in a legal name, not the exact string. Characters other than letters, digits, &, ., ' and - are turned into spaces.
• country (optional): two-letter ISO 3166 code of the legal address. status (optional): defaults to ISSUED; ANY for all.
• maxItems: default 10, at most 200.
• If nothing matches, similar names are tried and the rows are marked matchType: "similar", filtered by the same status and country. Otherwise matchType is name.
• Recognised sole proprietors and arrangements named after a person are left out and counted in RUN_SUMMARY.withheldPersons, so fewer rows than maxItems can come back.

By registration status

{
  "mode": "status",
  "status": "LAPSED",
  "country": "GB",
  "category": "FUND",
  "maxItems": 25
}

• status and country are both required, so a run cannot page the whole world. status is one of ISSUED, LAPSED, ANNULLED, PENDING_TRANSFER, PENDING_ARCHIVAL, DUPLICATE, MERGED, RETIRED.
• category (optional): GENERAL, BRANCH, FUND, RESIDENT_GOVERNMENT_ENTITY or INTERNATIONAL_ORGANIZATION. Recognised sole proprietors are left out.
• maxItems: default 100, at most 10,000. The source does not page past 10,000 results; if that limit is reached, RUN_SUMMARY.depthCapped is true.
• Rows are sorted by LEI, so the same input on the same data gives the same order. Recognised sole proprietors and arrangements named after a person are left out and counted in RUN_SUMMARY.withheldPersons.

Children

{
  "mode": "children",
  "leis": ["549300B56MD0ZC402L06"],
  "relation": "direct",
  "maxItems": 100
}

• Lists the subsidiaries reported to GLEIF under each root LEI: one row per child entity, the same row lei mode gives for that entity (with matchType children), plus the fields below.
• leis: 1 to 20 root LEIs, checked as in lei mode (a bad one is refused on its own and costs nothing). An unknown root is listed in RUN_SUMMARY.notFound; a root with no children gives no row and costs nothing.
• relation: direct (default; the root is the child's direct parent), ultimate (the root is its ultimate parent) or both. With both a child that is both is one row, relation direct with alsoUltimate true, charged once.
• maxItems: default 100, at most 4,000, across all roots. A run reads at most 20 pages of 200 children, shared between the roots: each root is kept at least 20 ÷ (number of roots) pages, rounded down (20 roots: 1 page each; 3 roots: 6 each), and pages a root does not need go to the roots after it. Roots are read in the order you give them, and maxItems is filled in that order. RUN_SUMMARY.roots says for each root how many children GLEIF lists (total), how many were returned, and whether maxItems (truncatedByMaxItems) or the page limit (truncatedByBudget) cut it short. A root cut short is not read again later in the same run: run it again on its own to read more of it.
• One level only: a child's own children are not read. includeParents and includeIsinCount are refused in this mode; run lei mode on the child LEIs for them.
• Recognised sole proprietors and arrangements named after a person are left out, not charged, and counted in RUN_SUMMARY.withheldPersons.
• Each child row is charged entity ($0.002 on the Free plan), as in lei mode. A child listed under two of your roots (for example a subsidiary of both a parent and its own parent) is two rows and two charges, one under each root.

Field	Type	Meaning
rootLei	string	The root LEI you gave. A child listed under two of your roots is two rows, one under each, and is charged twice
relation	string	direct or ultimate: how the child is related to the root. With relation: both, ultimate means the child was not seen in the root's direct list as read this run; if that list was not read in full (the page limit or an error), it can still be a direct child
alsoUltimate	boolean or null	With relation: both, on a direct row: true when the child is also an ultimate child of the root, false when it is not, null when the ultimate list could not be read in full. null on every other row

These fields exist only in children mode.

Parents and ISIN count (optional add-on)

In lei, name and status modes, set includeParents and/or includeIsinCount to add to each row:

Field	Meaning
directParentLei, directParentName	The direct parent's LEI and legal name. null when none is reported, when the parent is a person (see below) or when the row was left plain (an add-on answer could not be read)
ultimateParentLei, ultimateParentName	The same for the ultimate parent
parentStatus	{direct, ultimate}. Each is REPORTED, NOT_REPORTED, PARENT_WITHHELD, or the reason code of the reporting exception GLEIF holds instead of a parent (for example NON_CONSOLIDATING). null when the row was left plain (an add-on answer could not be read)
isinCount	How many ISINs GLEIF links to the LEI. The codes are not output. 0 when GLEIF links none. null when the row was left plain (an add-on answer could not be read)
enriched	true when every add-on you asked for was answered and at least one answer needed a request of its own. This is the row charged as entity_enriched

These fields exist only when you ask for an add-on.

• Cost: a row with enriched true is charged as entity_enriched ($0.004) instead of entity ($0.002), never both. A row that is not enriched is charged entity. Nothing extra is charged for a row that GLEIF's answers did not complete (every add-on field is then null), or for a row where there was nothing to read.
• maxEnriched (default 100, at most 600; it counts across a restart of the same run) is how many entities in the run may be enriched; the rest come back plain. Each enriched entity needs up to 3 more requests to GLEIF (direct parent, ultimate parent, ISIN count) at one request every 1.5 seconds, so 100 take up to about 7.5 minutes more. An enriched run may take up to an hour; give the run a timeout at least that long.
• When a row counts as enriched: every add-on you asked for has an answer, and at least one of them needed a request of its own. When the record's own links show nothing to read (for example no isins link gives isinCount 0, or no parent links give NOT_REPORTED), the fields are filled from the record already held, enriched is false and the row is charged entity only (RUN_SUMMARY.enrichment.answeredWithoutRequest counts them). A linked resource that cannot be read (an error, or a 404 for something the links say exists) leaves the row plain with the add-on fields null, charged entity.
• A rate-limit refusal (HTTP 429 or 503) stops enrichment at once. The rows already read are returned plain and charged entity, and the LEIs left plain are listed in RUN_SUMMARY.retryAfter.leis.
• People: a sole proprietor, or an arrangement named after a person, is never enriched and no request is made for it. If a parent is a person, neither its LEI nor its name is output: parentStatus says PARENT_WITHHELD. The free text of a reporting exception is never read. Only a parent's LEI and legal name are read.
• In watch mode, includeParents reports parent changes (parentChanged, see Watch mode); includeIsinCount is ignored there.

Watch mode

Report what changed in a list of LEIs since the last run. The first run records the starting state and returns nothing; every later run with the same watchId returns one row per change.

{
  "mode": "watch",
  "watchId": "my-suppliers",
  "leis": ["2138002P5RNKC5W2JZ46", "5493001KJTIIGC8Y1R12"]
}

First run: no rows, nothing charged. RUN_SUMMARY.baseline says what was recorded, for example {"watched": 2, "alreadyLapsed": 0, "alreadyOverdue": 0, "notWatched": 0, "notFound": 0, "complete": true}. complete is false when some LEIs could not be read (an error or a rate-limit refusal), or, with includeParents, when a rate-limit refusal or the time limit stopped the parent reads before every watched LEI's parents were read; LEIs left over maxEnriched do not make it false (their parents are read on later runs). Run it again on a schedule (daily is enough: the source updates daily) with the same watchId and the same list.

• watchId (required): a name of your choice, 1 to 40 characters of a-z, 0-9 and - (not first or last). The saved state is a key-value store named lei-watch-<watchId> in your own account, created by the Actor on the first run. Use a new watchId to start again from a new baseline; delete the store to forget the state.
• leis: 1 to 1,000 LEIs, checked as in lei mode. An LEI you add to the list later is recorded as a new starting state with no row. An LEI you leave out is forgotten (counted in RUN_SUMMARY.droppedFromWatch).
• Events, one row each, in input order:

event	Reported when	oldValue	newValue
lapsed	The registration status became LAPSED	The previous status	LAPSED
renewalOverdue	The renewal date has passed and the status is not LAPSED. Reported once for each renewal date	The renewal date that has passed	The current status, for example ISSUED
renamed	The legal name changed	The previous legal name	The current legal name
parentChanged	Only with includeParents: true. The direct parent's LEI, the ultimate parent's LEI, or either parentStatus value changed. One row per LEI, however many of them changed	The previous parents, as an object: directParentLei, directParentName, ultimateParentLei, ultimateParentName, parentStatus	The current parents, the same object

• A change row has lei, legalName (current), event, oldValue, newValue, observedAt (when the run saw it, UTC), goldenCopyDate and recordUrl. Nothing else.
• An LEI that was already lapsed or already past its renewal date at the first run is not reported; it is counted in the baseline. Only changes after the baseline are reported.
• Parents (includeParents: true): each run reads watched LEIs' direct and ultimate parents exactly as the add-on does (the same requests, one request every 1.5 seconds; see Parents and ISIN count), and compares them with the saved state. A run reads parents for at most maxEnriched LEIs (at most 600), and stops reading them at its 25-minute time limit (about 500 LEIs at 2 requests each). It reads them in rotation: LEIs whose parents were never read first, then those read longest ago. So with a list longer than one run can read, every LEI's parents are read within a few runs (1,000 LEIs with maxEnriched 500 or more: within 3 runs); a parent change is reported on the run that reads it.
  • The first run with includeParents records the parents with no parentChanged row and no charge for them, whether it is the watch's first run or a later run of a watch made without it (RUN_SUMMARY.parents.baseline counts them). An LEI added to the list later is recorded the same way.
  • A parent that is a person is never output, as in the add-on: that side is PARENT_WITHHELD with its LEI and name null, in both oldValue and newValue, and its LEI and name are not saved. One person parent replaced by another is therefore not reported.
  • A parent renamed under the same LEI is not a parent change (the saved name is updated with no row).
  • An LEI whose parents could not be read this run (an error, a rate-limit refusal, the time limit, maxEnriched reached, or your spending limit) keeps its saved parents and gives no parentChanged row; it is counted in RUN_SUMMARY.parents.notRead, is read first on the next run, and a change is reported on the run that reads it. A stop while reading parents is reported in RUN_SUMMARY.parents.stoppedBy (and parents.retryAfter), not in the run's own stoppedBy.
  • The parent requests are not charged: a watch run charges only change rows, never entity_enriched. A run without includeParents neither reads nor changes the saved parents.
  • The saved parents make the saved state larger. Measured in the saved format (JSON, UTF-8), an LEI takes 81 to 121 bytes without parents (a 20- to 60-character name), and its parents add 128 bytes (NOT_REPORTED on both sides), 138 bytes (a reporting exception on both sides) or 272 bytes (two reported parents with 60-character names); 29 of those bytes are the date the parents were last read. A name in a script that takes 3 bytes a character costs up to 3 times as much: two such 60-character parent names add 512 bytes. So 1,000 LEIs with parents take about 220,000 to 400,000 bytes (about 630,000 at most), under the 1,000,000-byte cap below. A change held unreported adds 132 bytes (renamed, 30-character name) to about 370 bytes (parentChanged to two reported parents with 60-character names), so a run holding many unreported changes at once can reach the cap; the run then ends ledgerFull as described below.
• Cost: you pay per change row returned, as the change event ($0.02 on the Free plan). The first run, runs with no change, LEIs not found and LEIs refused as invalid cost nothing. A change is charged only after its row is stored, and never twice: if a run is restarted or fails part-way, rows already stored are not returned or charged again, and the ones not stored are reported on the next run. If your spending limit is reached, the changes not yet reported are reported on the next run (RUN_SUMMARY.deferred). A watch run whose maximum charge per run (maxTotalChargeUsd) is below the price of one change ($0.02 on the Free plan) stops before reading anything (RUN_SUMMARY.stoppedBy is spending-limit).
• People are never watched. Sole proprietors and arrangements named after a person are not read for changes and not stored, not even their names; they are counted in RUN_SUMMARY.notWatched. An LEI that becomes one later is dropped from the watch without a row.
• Only one run of a watchId works at a time: a second run started while the first is running ends at once (status locked) with nothing read or charged.
• The saved state is capped at 1,000,000 bytes. If a list would pass it, the run stops before saving or charging, RUN_SUMMARY.status is ledgerFull, and nothing is dropped from the saved state: watch fewer LEIs or use a second watchId.

Privacy: sole proprietors and arrangements named after a person are withheld

A sole proprietor is a person trading under their own name: a record with category SOLE_PROPRIETOR, or one registered under a sole-trader legal form (98 ISO 20275 codes, such as an eingetragener Kaufmann, an eenmanszaak or an entreprise individuelle), even if its category says GENERAL. The same goes for legal arrangements named after a person: settlements; family, will, discretionary and life-interest trusts; and "estate of". Organisations whose names merely include "Trust" (charities, trust companies) are not caught by this rule.

• lei mode: the row keeps the LEI, the statuses and the dates, so you can still check that the LEI is valid and read its status. legalName, otherNames, registeredAs, legalAddress and headquartersAddress are null (or []) and are listed in withheld. These rows are returned and charged like any other.
• name, status and children modes: these entities are left out of the results and counted in RUN_SUMMARY.withheldPersons.
• Addresses for everyone are country, region and city only. No street, number or postcode is ever read.

Pricing

Pay per event.

Event	Charged	Price
entity	Each row returned	$0.002
entity_enriched	Each row returned with every add-on you asked for answered (parents and/or ISIN count), at least one needing a request of its own, instead of entity	$0.004
change	Each change row returned in watch mode, parentChanged included	$0.02

Prices shown are Free-plan prices. Bronze, Silver and Gold plans pay less per event (Apify Store tier discounts); Apify shows your price before a run.

There is no start fee. The pricing check refuses to start a run unless the events it can charge are priced. LEIs not found, LEIs refused as invalid and searches with no results cost nothing. A run looking up 1,000 LEIs that are all found costs $2.00, a status search that returns the 10,000-row maximum costs $20.00, and a children run at its ceiling of 4,000 rows costs $8.00 (at $0.002 each). Cap spend with maxItems and with Apify's maximum-charge setting on the run; if your limit is reached the run stops reading and the summary reports chargeLimitReached.

Run summary

Every run writes a RUN_SUMMARY record to its key-value store, and the run's status message says in one line what happened. Main fields:

Field	Meaning
status	ok, or refused (input rejected, reason says why; the run ends as succeeded and nothing is read or charged; only a pricing set up wrongly makes it fail). Watch mode can also end locked, lockLost, ledgerVersion or ledgerFull, all with nothing charged
mode, maxItems	The mode run; maxItems in name, status and children modes
pushed, found	Rows returned
withheldPersons	lei mode: rows returned with personal details withheld. Name, status and children modes: sole proprietors and person-named arrangements left out
requested, notFound, refused, unavailable	lei and children modes: LEIs given; LEIs the source does not know; invalid LEIs with the reason; LEIs not read because of an error (lei mode: or a stop)
relation, roots, pages, maxPages, pageBudgetReached	Children mode: the relation asked for; for each root rootLei, total (children GLEIF lists, per relation read; null if not read), returned, withheldPersons, truncatedByMaxItems, truncatedByBudget and incomplete; pages read and the limit a run; true if that limit cut the reading
alreadyDelivered	Rows skipped because a restarted run's dataset already held them (not charged again)
matchType	Name mode: name or similar
fuzzyItems, fuzzyLinked	Name mode, when similar names were tried: how many suggestions GLEIF returned, and how many of them could be looked up by LEI, counted before the lookup's batch limit and before the status and country filters (otherwise null)
notes	Name mode: plain-text notes when similar names were tried but gave nothing to look up ("GLEIF suggested no similar names", or "GLEIF suggested similar names but none could be looked up; try again later or search an exact name"); also shown in the run's status message
storedBeforeRestart	Only when the platform restarted the run: how many rows an earlier start of the same run had already returned (they are not returned or charged again)
incomplete	Name, status and children modes: true if the search stopped before it could finish (children mode: for any root, other than by maxItems)
depthCapped	Status mode: true if the 10,000-result limit was reached
firstRun, baseline, baselined, unchanged	Watch mode: whether this run was the baseline, the counts it recorded, LEIs newly recorded as a starting state, and LEIs compared with no change
events, emitted, deferred	Watch mode: change rows by event, rows returned, and changes held over to the next run because your spending limit was reached
notWatched, droppedFromWatch, pendingRecovered, pendingUnverified, ledger, ledgerFull	Watch mode: people left out; LEIs no longer in the list; the settling of a crashed or restarted run (rows delivered and rows to report again; unverified = taken as delivered so nothing is charged twice); the saved state's size; true if it would pass the cap
parents	Watch mode with includeParents only: maxEnriched; read (LEIs whose parents were read); baseline (parents recorded for the first time, no row); unchanged; changed (parentChanged rows found); notRead (saved parents kept) and notReadBy (overLimit, stopped, spendingLimit, unavailable); answeredWithoutRequest; stoppedBy (refused, deadline or budget) and retryAfter ({seconds, until, leis}) when the parent requests were stopped. Separate from the run's own stoppedBy and retryAfter
retryAfter	null, or {seconds, until, leis} after a rate-limit refusal: retry after until. leis lists the LEIs still to look up (lei mode), the roots not read in full (children mode), and the LEIs left plain when enrichment was stopped
enrichment, pushedEnriched	With an add-on: what was asked for, maxEnriched, how many rows were enriched and how many were not (people, overLimit, stopped, spendingLimit, unavailable); how many rows were charged as entity_enriched
stoppedBy	null, refused, deadline or spending-limit
payPerEvent, chargeLimitReached	Charging state
api	Request statistics
goldenCopyDate	Golden Copy date of the data read

Data and licence

• Data is from the Global LEI Index published by GLEIF through its API, under CC0 per GLEIF's LEI Data Terms of Use. No attribution is required; the source is credited here as a courtesy. CC0 applies to the dataset's copyright; it does not remove data-protection duties for personal data.
• This Actor is not affiliated with, or endorsed by, GLEIF or any LEI issuer.
• Removal and objection: email info@yappman.com with the LEI (20 characters); if you don't have it, tell us the product and the name as it appears. We will reply within one month.
• The data is the daily Golden Copy. Each row's goldenCopyDate says which one it was read from.
• recordUrl is the API record for the LEI.
• Not included: children beyond one level, the ISIN codes (only a count, on request), a parent's record beyond its LEI and name, and history.
• Source data only. No proxies are used.

Limits

• lei mode and watch mode: 1 to 1,000 LEIs per run.
• name mode: up to 200 results.
• status mode: up to 10,000 results (the source's depth limit), and country is required.
• children mode: 1 to 20 root LEIs, up to 4,000 rows and 20 pages of 200 children a run.
• Pacing: at most one request every 1.5 seconds.
• A rate-limit refusal (HTTP 429 or 503) stops the run's requests at once; there is no retry loop. Rows already read are returned and charged. What was not read is listed in RUN_SUMMARY.retryAfter (and unavailable in lei mode) with no charge, and the run itself ends normally, so a script or agent can read the summary and retry after until.
• The run stops requesting after 10 minutes and reports what it could not read. With an add-on the limit is 10 minutes plus 4.5 seconds for each entity you allow in maxEnriched, at most an hour; a watch run with includeParents, at most 25 minutes, so that it always ends inside its 30-minute lock.
• The input takes no URLs, headers or query strings: the Actor builds every request itself.

What changed

• 0.1.14 (4 Nov 2026): children mode lists the subsidiaries GLEIF reports under up to 20 LEIs (direct, ultimate or both), one row per root and child, charged as entity. Prices in this README now match the live pricing from 4 Nov 2026: $0.002 per entity and $0.004 per enriched entity on the Free plan ($0.02 per watch change, unchanged).
• 4 Nov 2026 (the first build after 0.1.13): watch mode reads parents with includeParents: true and reports parentChanged rows (see Watch mode). Without includeParents, watch runs are unchanged.
  • If this build is rolled back to 0.1.13 and later rolled forward again: 0.1.13 does not read parents, and it keeps the saved parents unchanged. So a parent change that happened while 0.1.13 was running is reported once, on the first run with includeParents after the roll-forward, and charged once as change. Also, if a run of this build was interrupted after storing a parentChanged row but before saving it as reported, and the next run of that watch is 0.1.13, 0.1.13 cannot settle that row. The same change is then reported, and charged, a second time after the roll-forward.

About

From Yappman Data, a trading name of Abley-Yapp Consulting Limited. Contact: info@yappman.com.