> ## Documentation Index
> Fetch the complete documentation index at: https://developers.investorlift.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Who is this lender?

> One lender under one id from any spelling: profile, limits, loans, borrowers, margins, the hard-money lenders active in one ZIP and the ZIPs it leads.

<Note>
  Early access: while the developer tier is in beta, the API serves the routes on this page to Investorlift's team and trusted partners. Investorlift will restrict them further before they open to every key.
</Note>

Every recorded mortgage names a lender. Since 0.14.0 every lender of record carries a stable id (`len_` plus 12
hex). The id is the same under every spelling the instruments use, and in every market. Kiavi is the worked case.
The county recorded its loans under five spellings: KIAVI FUNDING INC, KIAVI FUNDING LLC, LENDINGHOME FUNDING CORP,
LENDINGHOME FUNDING CORPORATION and LENDING HOME FUNDING CORPORATION. The registry folds the five into one lender.

Read two limits before any number. **The registry is a snapshot** as of `meta.coverage[].lenders.as_of`, with
recordings through `meta.coverage[].lenders.recordings_through`. `meta.dated[]` says so on every response, and
[dated data](/guides/concepts/dated-data) explains the stamp. The registry covers **the counties in
`meta.coverage[].lenders.counties`**. [Counties, cities and ZIP codes](/coverage/places) lists them.

**The recorded history captures about one open loan in five** (`coverage.history_capture_share`). So every count
here is over the union of the open liens and the history, and a history count is a floor. A bridge lender is the
most undercounted lender of all, because its loans are short and the borrower pays them off before the next slice.
Compare Kiavi with the other hard-money lenders, not with a bank.

## Find the lender

<CodeGroup>
  ```bash curl theme={null}
  curl "https://api.investorlift.com/v1/lenders/search?q=LendingHome&market=phx" \
    -H "Authorization: Bearer $GM_API_KEY"
  ```

  ```javascript Node.js theme={null}
  const params = new URLSearchParams({ q: "LendingHome", market: "phx" });
  const res = await fetch(`https://api.investorlift.com/v1/lenders/search?${params}`, {
    headers: { Authorization: `Bearer ${process.env.GM_API_KEY}` },
  });
  if (!res.ok) throw new Error(`${res.status} ${await res.text()}`);
  const body = await res.json();
  ```

  ```python Python theme={null}
  import os

  import requests

  r = requests.get(
      "https://api.investorlift.com/v1/lenders/search",
      params={"q": "LendingHome", "market": "phx"},
      headers={"Authorization": f"Bearer {os.environ['GM_API_KEY']}"},
      timeout=30,
  )
  r.raise_for_status()
  body = r.json()
  ```
</CodeGroup>

The hit carries `name` KIAVI FUNDING INC, `matched_name` LENDINGHOME FUNDING CORP and `match: tokens`. The spelling
you searched is one of the lender's, and the id is the lender's. `is_hard_money` is true by name
(`hard_money_basis: NAME`), and `lender_class` reads NONBANK. A search for "Kiavi Funding, Inc." matches `exact`.
Case, punctuation and the entity suffix never matter.

## Read the profile

<CodeGroup>
  ```bash curl theme={null}
  curl "https://api.investorlift.com/v1/lenders/len_d2028f0766fc" \
    -H "Authorization: Bearer $GM_API_KEY"
  ```

  ```javascript Node.js theme={null}
  const res = await fetch("https://api.investorlift.com/v1/lenders/len_d2028f0766fc", {
    headers: { Authorization: `Bearer ${process.env.GM_API_KEY}` },
  });
  if (!res.ok) throw new Error(`${res.status} ${await res.text()}`);
  const body = await res.json();
  ```

  ```python Python theme={null}
  import os

  import requests

  r = requests.get(
      "https://api.investorlift.com/v1/lenders/len_d2028f0766fc",
      headers={"Authorization": f"Bearer {os.environ['GM_API_KEY']}"},
      timeout=30,
  )
  r.raise_for_status()
  body = r.json()
  ```
</CodeGroup>

`names[]` lists the five spellings, the display name first. `former_names[]` lists the three the dictionary retired
under the rename. `markets[]` carries one profile, Phoenix. In it:

* `n_loans_24m` is the origination count over the 24 months to `as_of`, counted once across both tables.
  `n_in_history_24m` is what the history holds, and it is smaller. `n_open_liens` and `open_balance` are the open
  book at the slice date. The balance is after the exclusions that [the Lender object](/api-reference/objects/lender)
  lists.
* `rankings.rank_24m` and `share_24m` place the lender among every lender of the market. `rank_hard_money_24m` and
  `share_of_hard_money_24m` place it among the hard-money lenders. That comparison is the valid one.
* `terms` says what it lends: the amount quartiles over the window, and the rate and term figures. Beside the rate
  and term figures it says how much of the book carries a rate or a term. On a bridge lender's book a term is on
  about one row in ten (`term.share_term_known`). So the term bands and `product_proxy` describe a minority, and the
  API serves them with that share beside them.
* `geography.by_zip` and `concentration_top3_zips` say where. `by_month` gives the lender's count against the
  market's each month, with its rank. The last month is `partial`.
* `by_purpose_24m` splits the window by what the deeds say each loan did (`PURCHASE`, `NOT_PURCHASE`, `UNKNOWN`).
  `rankings.rank_purchase_24m` places the lender by its purchase-money loans. `terms.loan_to_price` is the loan
  against the deed price on those loans. A median above 1 is a rehab holdback on top of the price. The three blocks
  below say who borrows and what the loans financed.
* Since 0.19.0 `rankings` also counts the places the lender leads: `n_zips_ranked_first_24m` and
  `n_cities_ranked_first_24m`. Those are the ZIPs and cities where two facts hold. The lender recorded 10 or more
  loans there in the window, and it ranks first there among every lender of the market. `takebacks` says what it
  took back at foreclosure since 2016, by instrument, with `is_auction_lender`. The take-backs are deeds from the
  county's records, never delinquency. The block is null as a whole where the market has no take-back join
  (`takebacks_measured`).
* `summary` is one paragraph written from those numbers at build time. It never quotes a margin.

## List the loans

<CodeGroup>
  ```bash curl theme={null}
  curl "https://api.investorlift.com/v1/lenders/len_d2028f0766fc/loans?recorded_from=2026-01-01" \
    -H "Authorization: Bearer $GM_API_KEY"
  ```

  ```javascript Node.js theme={null}
  const params = new URLSearchParams({ recorded_from: "2026-01-01" });
  const res = await fetch(`https://api.investorlift.com/v1/lenders/len_d2028f0766fc/loans?${params}`, {
    headers: { Authorization: `Bearer ${process.env.GM_API_KEY}` },
  });
  if (!res.ok) throw new Error(`${res.status} ${await res.text()}`);
  const body = await res.json();
  ```

  ```python Python theme={null}
  import os

  import requests

  r = requests.get(
      "https://api.investorlift.com/v1/lenders/len_d2028f0766fc/loans",
      params={"recorded_from": "2026-01-01"},
      headers={"Authorization": f"Bearer {os.environ['GM_API_KEY']}"},
      timeout=30,
  )
  r.raise_for_status()
  body = r.json()
  ```
</CodeGroup>

The list puts the newest recording first, one row per instrument. The row is the open row where the instrument has
one, else its recorded slot (`source`, `in_both`). Each row carries the parcel, and `property_id` opens
[its financing block](/api-reference/endpoints/properties-financing). It also carries the amount, balance, rate, term
and maturity as filed, and `product`, `term_band` and `product_proxy` read from them. A row with
`term_band: UNKNOWN` carries no proxy. `lender_name_as_recorded` is the spelling on that instrument.

The borrowers of a recorded row are a contact field, and this host does not put them on the row. The same request
with `Accept: text/csv` returns the whole window as `lender-len_d2028f0766fc-loans.csv` from Growth, up to 50,000
rows. [The CSV section](/api-reference/endpoints/lenders-loans#csv) has the details. Because of the `recorded_from`
window, the API can answer this request for the busiest lenders too.

Since 0.16.0 each row also says what the deeds know about it:

* `purpose` is `PURCHASE` when a priced deed on the parcel is dated in the 45 days up to the recording. The deeds
  decide it, never the file's label.
* `deed` with `loan_to_price` is on such a row.
* `deal` names the investor purchase linked to the loan. It says if this loan is the purchase loan, and what the
  deeds show came next.
* `outcome` is `RESOLVED_BY_RESALE`, `REFINANCED`, `OPEN` or `UNKNOWN`. It is a performance proxy read from the deed
  chain, never a payment history.
* The borrowers are keys and investor ids.

`purpose=PURCHASE` keeps the purchase-money loans. `deal_kind=flip` keeps the ones that funded a flip. `investor_id=`
keeps the loans of one investor.

Since 0.19.0 a row also says if a take-back deed followed it: `foreclosed`, with the instrument and the deed date.
`outcome` reads `FORECLOSED` on a loan tied to a deal. `foreclosed=true` keeps those rows. `cell=` or a point with
`radius_miles` keeps the rows in one hex cell or around a point. The API resolves the geometry to the cells whose
centre lies inside it, so its edge is a hex boundary, not the circle.

## Who borrows, and what the flips made

The profile's three linkage blocks answer the questions a lender customer asks first. `borrowers` says how many
borrowers the lender has (`n_borrowers`, `n_borrowers_24m`). It says how many resolve to a registered investor, how
many repeat, how many are new this year, and how many churned (`n_churned_12m`). A churned borrower's last loan here
is 12 to 36 months old. The borrower took a later loan elsewhere, with none of this lender's open liens after it.

**Churn is a lower bound of leaving and an upper bound of nothing.** The recorded history sees about one loan in
five. So a borrower who stayed can read as gone only when this lender's later loan is in neither table.
`churn_measured` says if the API can read churn at all.

`top_borrowers[]` lists the ten largest by key. A company's name is beside its key, and the list never shows a
person's name (`person_names_redacted`). `competing_lenders[]` lists the ten lenders that share the most borrowers
with this one.

`investor_lending` says how much of the book funds registered investors. It carries `share_investor_loans_24m`, the
investors by kind, and `is_investor_lender` when half or more of the window goes to them. It also says which deals
the lender's loans financed, by what occurred on them, and names the ten largest investors. `by_outcome_24m` and
`median_months_to_payoff` say what became of the captured loans.

`flips_financed` is the margin block. It counts the flips bought in the last three years whose purchase loan was this
lender's. `capture_share` is that count against the flips by investors who borrow from it elsewhere. The block also
carries the lender's share of every flip the slice can attribute. It carries `median_gross_profit` with its
quartiles, `median_spread_ratio`, `median_hold_days` and `median_loan_to_price` where 20 or more of those flips
resold with both prices.

**Under 20 the margins are null.** A gross profit is never net of rehab or costs. The capture behind all of it is
partial. The open-lien table sees about one purchase loan in five on holdings and one in fifteen on flips. Every
block is null where its input does not exist for the market (`purchase_measured`, `investor_lending_measured`,
`flips_measured`, `borrowers_measured`).

<CodeGroup>
  ```bash curl theme={null}
  curl "https://api.investorlift.com/v1/lenders/len_d2028f0766fc/borrowers?registered_only=true" \
    -H "Authorization: Bearer $GM_API_KEY"
  ```

  ```javascript Node.js theme={null}
  const params = new URLSearchParams({ registered_only: "true" });
  const res = await fetch(`https://api.investorlift.com/v1/lenders/len_d2028f0766fc/borrowers?${params}`, {
    headers: { Authorization: `Bearer ${process.env.GM_API_KEY}` },
  });
  if (!res.ok) throw new Error(`${res.status} ${await res.text()}`);
  const body = await res.json();
  ```

  ```python Python theme={null}
  import os

  import requests

  r = requests.get(
      "https://api.investorlift.com/v1/lenders/len_d2028f0766fc/borrowers",
      params={"registered_only": "true"},
      headers={"Authorization": f"Bearer {os.environ['GM_API_KEY']}"},
      timeout=30,
  )
  r.raise_for_status()
  body = r.json()
  ```
</CodeGroup>

[`GET /v1/lenders/{id}/borrowers`](/api-reference/endpoints/lenders-borrowers) lists every borrower, most loans in the
window first. Each row carries:

* `borrower_key`: a salted hash of the folded name, the same key on every lender's rows.
* `name`, for a company.
* `investor`: the registered investor behind the key. Its id opens [its profile](/api-reference/endpoints/investors-get),
  whose `financing` block lists every lender it borrows from.
* The loans and volume from this lender.
* `other_lender_ids[]`.
* The churn triple.

`registered_only=true` keeps the registered investors. `churned=true` keeps the churned borrowers. `q=` finds a company
by name. `period=all` counts the whole history instead of the window. This host does not serve a person borrower's
name. The row carries `name` null with `contact_redacted: true`, and the API serves the key and the investor.

## Who lends to flippers in 85032

<CodeGroup>
  ```bash curl theme={null}
  curl "https://api.investorlift.com/v1/lenders?market=phx&zip=85032&hard_money=true" \
    -H "Authorization: Bearer $GM_API_KEY"
  ```

  ```javascript Node.js theme={null}
  const params = new URLSearchParams({ market: "phx", zip: "85032", hard_money: "true" });
  const res = await fetch(`https://api.investorlift.com/v1/lenders?${params}`, {
    headers: { Authorization: `Bearer ${process.env.GM_API_KEY}` },
  });
  if (!res.ok) throw new Error(`${res.status} ${await res.text()}`);
  const body = await res.json();
  ```

  ```python Python theme={null}
  import os

  import requests

  r = requests.get(
      "https://api.investorlift.com/v1/lenders",
      params={"market": "phx", "zip": "85032", "hard_money": "true"},
      headers={"Authorization": f"Bearer {os.environ['GM_API_KEY']}"},
      timeout=30,
  )
  r.raise_for_status()
  body = r.json()
  ```
</CodeGroup>

The list shows the hard-money lenders active in the ZIP over the window, most loans first. Each row carries `n` (its
loans there), `share` (of every lender's loans there), `n_first_lien`, `volume` and `last_recorded_on`. `rank` is the
position in this list. Without `hard_money=true` the banks and mortgage companies lead the same list. The list hides
persons and government lenders unless you ask for them. A ZIP outside the counties the registry covers answers
[`422 outside_coverage`](/guides/concepts/errors#outside_coverage) and names the covered counties, never an empty page.

Since 0.19.0 `period=` picks the window: `12m`, `all`, a year such as `2025`, or a month such as `2026-05`, beside the
default `24m`. So the same call with `period=2026-05` is the ZIP's ranking for one month, and twelve such calls are
its monthly series. A point with `radius_miles` in place of the ZIP ranks the lenders around it. The row's
`in_geometry` says how many hex cells the circle became.

## Which ZIPs does this lender lead

<CodeGroup>
  ```bash curl theme={null}
  curl "https://api.investorlift.com/v1/lenders/len_d2028f0766fc/rankings?market=phx&group_by=zip&min_n=10" \
    -H "Authorization: Bearer $GM_API_KEY"
  ```

  ```javascript Node.js theme={null}
  const params = new URLSearchParams({ market: "phx", group_by: "zip", min_n: "10" });
  const res = await fetch(`https://api.investorlift.com/v1/lenders/len_d2028f0766fc/rankings?${params}`, {
    headers: { Authorization: `Bearer ${process.env.GM_API_KEY}` },
  });
  if (!res.ok) throw new Error(`${res.status} ${await res.text()}`);
  const body = await res.json();
  ```

  ```python Python theme={null}
  import os

  import requests

  r = requests.get(
      "https://api.investorlift.com/v1/lenders/len_d2028f0766fc/rankings",
      params={"market": "phx", "group_by": "zip", "min_n": 10},
      headers={"Authorization": f"Bearer {os.environ['GM_API_KEY']}"},
      timeout=30,
  )
  r.raise_for_status()
  body = r.json()
  ```
</CodeGroup>

[`GET /v1/lenders/{id}/rankings`](/api-reference/endpoints/lenders-rankings) (since 0.19.0) is the ZIP list seen
from the lender's side. It returns one [bucket](/api-reference/objects/lender-ranking-bucket) per ZIP where the
lender recorded 10 or more loans over the window, most loans first. Each bucket carries the lender's `n` and `volume`
there. It also carries its `rank` and `share` among every lender of the market in that ZIP, persons and government
included. The buckets with `rank: 1` are the ZIPs the profile's `n_zips_ranked_first_24m` counts. The `summary` says
how many ZIP codes the lender ranks first in, from the same number.

`group_by=city` and `group_by=county` do the same by place. `group_by=cell&res=8` does it by hex cell, for the
profile's map, and [`GET /v1/lenders/{id}/cells`](/api-reference/endpoints/lenders-cells) gives the counts alone.
`group_by=month&period=all` is the lender's 36-month series against the whole market, every month present, the last
`partial`. A registry built before the place rankings answers
[`422 lenders_unavailable`](/guides/concepts/errors#lenders_unavailable) here and serves the three ranked-first
counts as null.

## The rules behind the numbers

Lender names are business records of the loan, and the API serves them in full to every key, whatever the class.
Nothing in any delivery carries a lender's phone or email. A company borrower's name on a recorded instrument is a
business record, and the API serves it the same way. This host does not serve a person borrower's name, and a
profile or a list over MCP never carries it. A lender whose name reads INDIVIDUAL or PRIVATE has a profile only above
the person gate. The lists and searches hide such a lender unless `include_persons=true`.

No lender route has a price in the beta. The API charges no credits for any of them.

A market with no published lender registry answers
[`422 lenders_unavailable`](/guides/concepts/errors#lenders_unavailable) on the seven routes. A registry built
before the deed link answers the same on the borrowers route and on the purpose, outcome and investor filters. A
registry built before the place rankings answers the same on the rankings and cells routes. It also answers the same
on a `period` other than `24m`, on a geometry, and on `cell` and `foreclosed`. `meta.coverage[].lenders` is null
where the market has no registry. Where it has one, the block carries the `*_measured` flags.


## Related topics

- [Find a lender](/api-reference/endpoints/lenders-search.md)
- [List one lender's borrowers](/api-reference/endpoints/lenders-borrowers.md)
- [Get one lender](/api-reference/endpoints/lenders-get.md)
- [Rank the lenders of a market or a place](/api-reference/endpoints/lenders-list.md)
- [List one lender's loans](/api-reference/endpoints/lenders-loans.md)