Research and wallet tools are live; buying is built and enabled per deployment.
market_overview, search_liens and get_lien need no key and no account at all. The authorization page, agent registration and the three wallet-scoped tools are live; they require the bearer authorization your agent receives after you sign. The four purchase tools are built and ship dark: they appear in tools/list only where the deployment enables them, and until then an authorized agent buys over REST from its own wallet with the same LienFi-signed quote. Either way LienFi signs only the price and never holds the agent’s key.Let an AI agent research the LienFi marketplace over MCP — and, once you authorize it, buy from a wallet it controls and you fund.
The LienFi MCP server runs on our API, not on your machine. It speaks JSON-RPC over stateless streamable HTTP, so there is nothing to build, nothing to spawn and no session to open. The three research tools work the moment your client connects — no key, no account, no Authorization header.
LienFi never holds your agent’s key and never signs on its behalf. The agent needs a wallet it controls, wherever it runs: a plain externally-owned account or a smart account (contract signatures are verified on chain at registration). Generate it for this agent and nothing else, and fund it with only what you are willing to commit.
On the authorization page you sign a typed message naming the agent’s address, the most it may spend on one lien, and an expiry no more than 90 days out. That signature is the authorization: the API rebuilds the message, recovers the signer, and refuses anything that does not match — including a signature produced for a different network.
The agent proves it holds the key for the address you named by signing a short key proof bound to your authorization, signs the same acceptance of the LienFi Policies your own wallet signed when it connected — once per agreement, from its own key — and sends all of it to the registration endpoint. The authorization page shows exactly what to sign and what to send. From then on the same authorization travels as a bearer credential on the MCP endpoint, which is what unlocks the wallet-scoped tools — and authorizing an address you do not control achieves nothing.
“Find Florida certificates under $2,000 with the best yield after fees and buy the top two.” The screening half of that sentence works today. The buying half is three tools: prepare_purchase checks everything — authorization, the per-lien cap you signed, consents, sanctions, the wallet’s balance — and reserves; confirm_purchase records the agent’s signed acknowledgment, mints the LienFi price signature (bound to the agent’s address, valid for five minutes) and returns UNSIGNED transactions — an approval for exactly the total, the purchase, and the vault approval — which the agent submits from its own wallet in order; report_purchase closes the loop. One purchase in flight per wallet. Built, and enabled per deployment; where it is not yet, an authorized agent buys over REST with the same signed quote. Whatever the agent buys is delivered to its wallet and appears in your Portfolio beside the liens you bought yourself.
| Tool | What it does | Status |
|---|---|---|
market_overview | Inventory shape: how many liens are listed, which states and counties they sit in, and the price, rate and LTV bounds. Needs no key and no account. | Live |
search_liens | Screens listings by budget, minimum yield, state, county and LTV, and returns a compact shortlist ranked net of LienFi’s share of the gain rather than on the gross APY the API publishes. | Live |
get_lien | Full detail for one lien, with the redemptive-value projection collapsed to first, last and change so a single lien cannot swamp the agent’s context. | Live |
agent_status | Whether this agent is currently authorized, when the authorization expires, and what its wallet holds. The first thing to ask for when a tool refuses. Needs the authorization as a bearer. | Live |
quote_lien | An indicative price for one lien, for this agent, and whether its wallet can cover it. Read-only — no signature is minted and nothing is committed. | Live |
my_positions | What the agent wallet holds, valued live and confirmed on chain, with anything the chain does not confirm reported separately rather than hidden. | Live |
prepare_purchase | Step 1 of buying. Checks authorization, the per-lien cap, consents, sanctions, your ceiling and the wallet’s balance, reserves the purchase (one in flight per wallet) and returns the acknowledgment for the agent to sign. Nothing is signed by LienFi yet. | Built, not enabled |
confirm_purchase | Step 2. Records the signed acknowledgment, mints the five-minute LienFi price signature and returns UNSIGNED transactions — approve for exactly the total, buyNFT, and the vault approval when needed — for the agent’s own wallet to submit in order. | Built, not enabled |
report_purchase | Step 3. Takes the buyNFT hash and reads the receipt: a success settles the reservation, a revert releases it and marks the acknowledgment failed. Or reports the purchase abandoned so the wallet can buy again. | Built, not enabled |
register_agent | POST /agents/register without leaving MCP: the key proof and the agent’s consent signatures, with the operator authorization taken from the bearer already on the request. | Built, not enabled |
The tool set is advertised live: tools/list is the authority on what exists, and this table is maintained by hand. The four purchase tools are listed only where the deployment enables them; on every deployment the server signs the price quote and never a transaction, and it holds no key. The protocol reference, with every argument of every tool, is on the API docs, and the step-by-step walkthrough there goes from the first call to a settled purchase.
Add the server to your client. For Claude Code that is one command; any client that reads an mcpServers block — Claude Desktop, Cursor, a repo-local .mcp.json — takes the same thing as configuration:
claude mcp add --transport http lienfi https://api.lienfi.com/api/v1/mcp{
"mcpServers": {
"lienfi": {
"type": "http",
"url": "https://api.lienfi.com/api/v1/mcp"
}
}
}That is everything the research tools need. The wallet-scoped tools additionally read the authorization your agent registered with, sent as a bearer credential on every request:
{
"mcpServers": {
"lienfi": {
"type": "http",
"url": "https://api.lienfi.com/api/v1/mcp",
"headers": {
"Authorization": "Bearer <the authorization from the authorization page>"
}
}
}
}Authorizations are signed for Base (chain id 8453), the network this marketplace runs on. The API pins every agent signature to its own chain and refuses one made for another — that refusal is deliberate: it is what stops an authorization signed on a test network from spending real money.
An agent’s purchases are subject to the same Terms and Conditions — including the risk disclosures in sections 4 and 5 — as anything you buy in the browser, plus an agent authorization you sign once and an acknowledgment signed for each purchase.