> ## 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: the profile, its limits, the loans and the borrowers.

<Note>
  **Early access.** The API serves every early-access route and tool to every key at 0 credits during the beta.
  Investorlift can restrict them later. Investorlift aims to give 30 days of email notice before it restricts them
  ([Developer Agreement 12.3](/guides/terms)), and the [changelog](/changelog) records the change.
</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 several spellings, KIAVI FUNDING INC and LENDINGHOME FUNDING CORP among them.
The registry folds them 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>
  ```typescript TypeScript theme={null}
  import { GodMode } from "@investorlift/godmode";

  const gm = new GodMode(); // reads GM_API_KEY
  const body = await gm.lenders.search({ q: "LendingHome", market: "phx" });
  ```

  ```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()
  ```

  ```bash CLI theme={null}
  investorlift lenders search --q LendingHome --market phx
  ```
</CodeGroup>

The recorded hits: Kiavi under its former spelling at the `tokens` level, and a second lender at the `trigram` level.

```json theme={null}
{
  "data": [
    {
      "id": "len_d2028f0766fc",
      "market": "phx",
      "name": "KIAVI FUNDING INC",
      "matched_name": "LENDINGHOME FUNDING CORP",
      "lender_class": "NONBANK",
      "is_hard_money": true,
      "n_loans_24m": 222,
      "n_open_liens": 332,
      "open_balance": 102099717,
      "last_recording_date": "2026-06-10",
      "rank_24m": 176,
      "match": "tokens",
      "similarity": null,
      "as_of": "2026-06-25",
      "dated": true
    },
    {
      "id": "len_472c64d43ea7",
      "market": "phx",
      "name": "HOME LENDING LLC",
      "matched_name": "HOME LENDING LLC",
      "lender_class": "NONBANK",
      "is_hard_money": false,
      "n_loans_24m": 0,
      "n_open_liens": 0,
      "open_balance": 0,
      "last_recording_date": "2006-11-06",
      "rank_24m": null,
      "match": "trigram",
      "similarity": 0.5555555820465088,
      "as_of": "2026-06-25",
      "dated": true
    }
  ],
  "page": {
    "next_cursor": null,
    "limit": 3,
    "returned": 2,
    "capped": false
  }
}
```

The first 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, and `lender_class`
reads NONBANK. A search for "Kiavi Funding, Inc." matches `exact`. Case, punctuation and the entity suffix never
matter. The second hit matched at `trigram`, the fuzzy level, and `similarity` says how close.

## Read the profile

<CodeGroup>
  ```typescript TypeScript theme={null}
  import { GodMode } from "@investorlift/godmode";

  const gm = new GodMode(); // reads GM_API_KEY
  const body = await gm.lenders.get("len_d2028f0766fc");
  ```

  ```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()
  ```

  ```bash CLI theme={null}
  investorlift lenders get len_d2028f0766fc
  ```
</CodeGroup>

The recorded profile, cut to the identity and the first market's counts and rankings:

```json theme={null}
{
  "data": {
    "id": "len_d2028f0766fc",
    "name": "KIAVI FUNDING INC",
    "names": [
      "KIAVI FUNDING INC",
      "KIAVI FUNDING LLC",
      "LENDINGHOME FUNDING CORP",
      "LENDINGHOME FUNDING CORPORATION",
      "LENDING HOME FUNDING CORPORATION",
      "LENDING HOME FUNDING CORP"
    ],
    "lender_class": "NONBANK",
    "is_hard_money": true,
    "hard_money_basis": "BOTH",
    "n_markets": 2,
    "markets": [
      {
        "market": "phx",
        "former_names": [
          "LENDINGHOME FUNDING CORP",
          "LENDINGHOME FUNDING CORPORATION",
          "LENDING HOME FUNDING CORPORATION"
        ],
        "n_loans_24m": 222,
        "n_in_history_24m": 56,
        "n_open_liens": 332,
        "rankings": {
          "rank_24m": 176,
          "share_24m": 0.000856,
          "rank_by_volume_24m": 150,
          "rank_in_class_24m": 123,
          "rank_hard_money_24m": 5,
          "share_of_hard_money_24m": 0.046202,
          "rank_purchase_24m": 108,
          "share_by_volume_24m": 0.001196,
          "n_zips_ranked_first_24m": 0,
          "n_cities_ranked_first_24m": 0,
          "n_counties_ranked_first_24m": null
        },
        "as_of": "2026-06-25",
        "recordings_through": "2026-06-11"
      }
    ]
  }
}
```

`names[]` lists every spelling, the display name first. `markets[]` carries one profile per market the lender lends
in, and each carries its own `former_names[]`, the spellings the dictionary retired under a rename. In a market
profile:

* `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

A lender that lends in more than one loaded market needs `market=` on its lists. Without it the API answers
`400 market_required` and names the markets.

<CodeGroup>
  ```typescript TypeScript theme={null}
  import { GodMode } from "@investorlift/godmode";

  const gm = new GodMode(); // reads GM_API_KEY
  const body = await gm.lenders.loans("len_d2028f0766fc", { market: "phx", recorded_from: "2026-01-01" });
  ```

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

  ```javascript Node.js theme={null}
  const params = new URLSearchParams({ market: "phx", 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={"market": "phx", "recorded_from": "2026-01-01"},
      headers={"Authorization": f"Bearer {os.environ['GM_API_KEY']}"},
      timeout=30,
  )
  r.raise_for_status()
  body = r.json()
  ```

  ```bash CLI theme={null}
  investorlift lenders loans len_d2028f0766fc --market phx --recorded-from 2026-01-01
  ```
</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 recorded example of this route asked for the newest 2 rows without a window. Its first row, cut to the
instrument and what the deeds say about it:

```json theme={null}
{
  "data": [
    {
      "property_id": "prop_cd126a2a572234fa8abfe853fc2ec706",
      "address_short": "16647 W Saguaro Ln",
      "city": "SURPRISE",
      "source": "RECORDED",
      "position": 2,
      "in_both": false,
      "lender_name_as_recorded": "KIAVI FUNDING INC",
      "recording_date": "2026-06-10",
      "loan_amount": 374900,
      "term_months": 360,
      "term_band": "GE_360M",
      "product": "CONSTRUCTION",
      "product_proxy": "RENTAL_TERM",
      "purpose": "PURCHASE",
      "deed": {
        "dt": "2026-05-05",
        "price": 280000,
        "loan_to_price": 1.3389
      },
      "deal": null,
      "outcome": null,
      "investor_id": "inv_22038fe8a6b7"
    }
  ]
}
```

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>
  ```typescript TypeScript theme={null}
  import { GodMode } from "@investorlift/godmode";

  const gm = new GodMode(); // reads GM_API_KEY
  const body = await gm.lenders.borrowers("len_d2028f0766fc", { market: "phx", registered_only: "true" });
  ```

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

  ```javascript Node.js theme={null}
  const params = new URLSearchParams({ market: "phx", 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={"market": "phx", "registered_only": "true"},
      headers={"Authorization": f"Bearer {os.environ['GM_API_KEY']}"},
      timeout=30,
  )
  r.raise_for_status()
  body = r.json()
  ```

  ```bash CLI theme={null}
  investorlift lenders borrowers len_d2028f0766fc --market phx --registered-only true
  ```
</CodeGroup>

[`GET /v1/lenders/{id}/borrowers`](/api-reference/endpoints/lenders-borrowers) lists every borrower, most loans in the
window first. The recorded example asked for 2 rows. Its first row, cut to the borrower, the loans and the churn
triple:

```json theme={null}
{
  "data": [
    {
      "borrower_key": "722461175d36",
      "name": "LR PROPERTIES LLC",
      "investor": {
        "id": "inv_63c4b7a3aa67",
        "name": "LR PROPERTIES LLC",
        "kind": "BUILDER"
      },
      "is_entity": true,
      "borrower_match": "ENTITY_NAME",
      "n_loans_24m": 14,
      "volume_24m": 3325950,
      "last_loan_on": "2026-05-12",
      "other_lender_ids": [
        "len_28c85b9d7495",
        "len_6b0c46c8812e",
        "len_e28e16f5bdfd"
      ],
      "churned": false,
      "churn_measured": true,
      "moved_to_lender_id": null
    }
  ]
}
```

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.

## 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`.

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. 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.

## Where to go next

<CardGroup cols={2}>
  <Card title="Who lends to flippers in a ZIP?" icon="map-location-dot" href="/guides/walkthroughs/lenders-in-a-zip">
    The hard-money lenders active in one ZIP, and the ZIPs one lender leads.
  </Card>

  <Card title="GET /v1/lenders/{id}" icon="code" href="/api-reference/endpoints/lenders-get">
    Every field of the lender profile and its market blocks, generated from the code.
  </Card>
</CardGroup>


## Related topics

- [Find a lender](/api-reference/endpoints/lenders-search.md)
- [Who lends to flippers in a ZIP?](/guides/walkthroughs/lenders-in-a-zip.md)
- [Get one lender](/api-reference/endpoints/lenders-get.md)
- [List one lender's borrowers](/api-reference/endpoints/lenders-borrowers.md)
- [List one lender's loans](/api-reference/endpoints/lenders-loans.md)