Lending

The lending sub-module covers the full loan lifecycle: application intake, underwriting, decisioning, origination, amortization, and payment servicing. All endpoints live under /banking/loans/*. Loans use the platform's bank accounts for disbursement and payments — the borrower must have a holderId and at least one active account.

Lifecycle

application created → submitted → decided (approved/denied)
                                       ↓ (if approved)
                                   originated → active → paid_off
                                                    ↓
                                                 default

Each step is a separate endpoint, so underwriting can pause for human review or external data pulls between submission and decision.

Applications

Create

{
  "borrowerId": "holder_abc",
  "borrowerType": "individual",
  "requestedAmount": 25000.00,
  "purpose": "home_improvement",
  "termMonths": 60,
  "annualIncome": 95000.00,
  "monthlyDebt": 1200.00,
  "employmentStatus": "employed"
}

Application fields are open-ended — the schema accepts the underwriting inputs your decisioning logic needs. Common fields: requested amount, term, purpose, income, debt, employment, plus credit-bureau pull metadata.

Get

Returns the full application with status, decision factors, and any submitted documents.

Submit

Locks the application from further edits and signals it's ready for review. Triggers any configured automation (credit pull, fraud check, manual review queue assignment).

Decide

{
  "approved": true,
  "approvedAmount": 20000.00,
  "approvedRate": 8.5,
  "approvedTermMonths": 60,
  "conditions": ["Provide 60-day bank statements"]
}

For a denial:

{
  "approved": false,
  "denialReason": "Insufficient income relative to requested amount"
}

Decisioning is a deliberate human step in the API — the platform does not auto-decide. Your underwriting service (or staff) calls this endpoint with the outcome. conditions are stipulations the borrower must satisfy before origination.

Originate

{
  "disbursementAccountId": "acc_borrower_checking",
  "firstPaymentDate": "2026-06-01"
}

Creates the loan record from the approved application. The platform:

1. Posts a journal entry crediting the borrower's account and debiting Loans Receivable.
2. Generates the amortization schedule based on approved amount, rate, and term.
3. Sets the first payment date and computes monthly payment.

After origination, the application is sealed. Loan changes go through the loan endpoints below.

Loans

Get

Returns: principal balance, interest rate, term, monthly payment, total paid to date, current status (active, current, late, default, paid_off).

List by borrower

?status=active. Returns all loans for a holder.

Schedule

Returns the full amortization schedule — every scheduled payment with its principal/interest split, running balance, and due date. Generated at origination using standard amortization (equal monthly payments, declining interest portion).

Next payment

Returns the next unpaid scheduled payment. Use this to drive a "Pay your bill" UI.

Payoff amount

Returns the total cost to close out the loan today: remaining principal + accrued interest to the request date. Use this for early-payoff flows.

Payments

Regular payment

{
  "amount": 412.85,
  "sourceAccountId": "acc_borrower_checking",
  "paymentMethod": "ach"
}

Processes a payment from the borrower's account. The platform splits the amount across interest, then principal, then any fees, per the schedule. Excess goes to next-payment-due unless explicitly tagged as an extra principal payment.

Extra principal payment

{
  "amount": 1000.00,
  "sourceAccountId": "acc_borrower_checking"
}

Applies the full amount to principal, shortening the loan term. The schedule is regenerated forward — subsequent payments stay the same monthly amount but the maturity date moves earlier.

Stats

Portfolio totals: outstanding balance, count by status, average rate, delinquency metrics. Useful for ops dashboards.

Underwriting hooks

The platform does not bundle a credit decisioning engine. To plug yours in:

1. 1

   Listen for application submission

   Subscribe to the application-submitted event via Automation.

2. 2

   Run your decisioning

   Pull credit data, run scorecard, verify income — whatever your model requires.

3. 3

   Call decide

   POST /banking/loans/applications/:id/decide with the outcome.

For staff-driven manual underwriting, an admin UI calls the same endpoint. Either path works.

Default and collections

A loan moves to late after a missed payment, then to default after the configured DPD threshold (typically 90 days). The platform tracks status transitions but does not run collections itself — write-offs, recoveries, and charge-offs are accounting decisions you make on your books and post via the ledger.

What's not included

The lending module is the operational core — application, schedule, payment processing. It does not bundle:

• Credit-bureau pulls (use a third-party service, store the result with the application).
• Income verification (Plaid, Argyle, etc.).
• E-signature for loan documents (DocuSign, Dropbox Sign, etc.).
• Promissory note generation (template engine of your choice).

Wire those into the application flow before calling decide.