> ## 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. # The Lender borrower > One borrower of a lender: the key, a company's name, the investor behind it, the loans from this lender, other lenders used, and churn. Early access: while the developer tier is in beta, the API serves this route to Investorlift's team and trusted partners. Investorlift will restrict the route further before it opens to every key. One row of [`GET /v1/lenders/{id}/borrowers`](/api-reference/endpoints/lenders-borrowers): one borrower of one lender, counted over every instrument of the lender that names the borrower. ## A borrower is a key `borrower_key` is 12 hex characters, hashed from the borrower's folded name with the dataset's salt. It is the same key on every lender's rows and in every market. It is never a name, it is not reversible, and it is stable across data refreshes. You compare borrowers across lenders with this key: `other_lender_ids[]` and, since 0.19.0, `other_lenders[]` on this row, and `competing_lenders` on the profile. The [loan row](/api-reference/objects/lender-loan) carries the same value in `borrower_keys[]`. Where the borrower comes from: the names a recorded mortgage carries. On an open lien that names none, the borrower is the parcel's owner of record (`borrower_match: OWNER_OF_RECORD`). That applies when the owner held the parcel on the recording date and no sale followed. `borrower_match` says how the registry resolved the key: * `DEAL`: the deed link ties the loan to a deal whose investor has a member with the key. * `ENTITY_NAME` or `PERSON_NAME`: a company or a person that is a member of exactly one registered investor. * `PARTY`: a name on a recorded deed that belongs to no investor. * `MORTGAGE_ONLY`: a name on no deed. * `OWNER_OF_RECORD`: the parcel's owner of record, as above. `investor` is the registered investor the key belongs to, as a stub. The stub carries the id, the registry name, the kinds, the scale and the size. Its id opens the [investor profile](/api-reference/objects/investor). The profile's `financing` block lists every lender the investor borrows from. ## What the counts are * `n_loans`, `n_loans_12m` and `n_loans_24m` count the lender's instruments that carry the key, once per instrument across the open-lien and recorded-history tables. `volume_24m` sums the priced ones of the window, with amounts above \$5,000,000 left out. The recorded history names borrowers and sees about one open loan in five. The open-lien table names none. So a borrower is known on a minority of the book, and every count here is a floor. `borrowers.borrower_measured_share` on the profile says how much of the book. * `first_loan_on` and `last_loan_on` are the oldest and newest recording. The first is a floor of a history that keeps five slots per parcel. * `n_lenders_used_24m` and `other_lender_ids[]` are the lenders the borrower took a loan from in the window. The count includes this lender, and the list excludes it. The list has most loans first, at most ten. `other_lenders[]` (since 0.19.0) is the same list with each lender as a stub (`id`, `name`, `lender_class`, `is_hard_money`), in the same order. The API reads the stubs from the registry at request time. An id the registry no longer serves stays in the id array and is absent here. * On a registry built before the borrower match, the route itself answers [`422 lenders_unavailable`](/guides/concepts/errors#lenders_unavailable). So the API serves neither array there. * `n_deals_financed` counts the registered investor's purchases whose purchase loan was this lender's and named this borrower. ## Churn is a lower bound `churned` is true when three conditions hold. The borrower's last loan here is 12 to 36 months before `as_of`. A later loan from another lender is in the recorded history. This lender holds no open lien recorded after it on any parcel of the borrower's investor group. `moved_to_lender_id` is the lender of the first later loan elsewhere. On a feed that sees one loan in five, that is a lower bound of leaving and an upper bound of nothing. A borrower who stayed reads as gone only when this lender's later loan is in neither table. A borrower who left can read as one who stayed. `churn_measured` is false when the group holds open lien positions the history does not carry. An example is a bridge borrower whose later loans the history cannot see. Then the history cannot show churn, and `churned` is never true there. Every row is dated: `as_of` is the registry's slice date, and `meta.dated[]` on the response names the `lenders` and `financing` blocks. ## Contact data `name` is the borrower's name as the recorded mortgages write it: upper case, the most frequent spelling. When the borrower is a company (`is_entity`), the name is a business name on a recorded instrument, and the API serves it to every key. When the borrower is a person (`is_person`) or a trust, this host does not serve the name. This host also does not serve `party_key`, the folded name the registry keys people by. Both are null, with `contact_redacted: true`. The API serves the investor's registry name in `investor.name` as the registry serves it on every deal row. A person's name is never on a list result over MCP. ## Related topics - [The twenty-six tools](/mcp/tools.md) - [Changelog](/changelog.md) - [API reference](/api-reference/introduction.md) - [Worked examples](/mcp/examples.md) - [List one lender's borrowers](/api-reference/endpoints/lenders-borrowers.md)