For AI agents and the people who run them

Your AI can call the verified student-loan engine.

Finology Software’s federal loan engine is parity-verified against a reference oracle and kept current with the rules in effect since July 1, 2026 (RAP, the new Standard plan, IBR, ICR, the closures of SAVE and PAYE). It is callable three ways, all self-serve. No sales call, no demo, no meeting; support is by email.

Rules as of the date stamped in every answer (asOf). Figures are for education; tax on forgiven balances is an estimate at today’s brackets.

Three ways in

Free · no key

MCP server (local)

Three tools for any MCP client: compare every federal repayment plan a loan can elect, estimate a RAP payment, and compare married-filing-jointly against separately. Every answer volunteers the second number, the one nobody asked for.

npx -y @finology/mcp-server

Or, with no process at all: the same tools over streamable HTTP, still no key: https://mcp.finology.tech/free

Registry: tech.finology/student-loan · source · MIT · no math in the package, every number comes from the engine.

Keyed · answer of record

MCP server (remote)

The same engine over streamable HTTP, for products and agents that need a traceable answer. Every answer is persisted with its rule version and an inputs hash before it is served; if it cannot be recorded, it is not served.

URL   https://mcp.finology.tech/mcp
Auth  X-Api-Key: fk_...   (or Authorization: Bearer fk_...)

Registry: tech.finology/verified-engine · server card

Keyed · REST

Public API

For anything that is not an MCP client. Same engine, same records.

POST https://api.finology.tech/v1/comparison
POST https://api.finology.tech/v1/projection
POST https://api.finology.tech/v1/plan-eligibility
GET  https://api.finology.tech/v1/plan-types
GET  https://api.finology.tech/v1/me         (verify a key)

Header X-Api-Key on every request. Developer notes · auth.md

Get a key in one call

Sandbox keys are issued instantly, without a human. 25 calls a month, valid 30 days, shown once.

curl -X POST https://api.finology.tech/v1/keys/sandbox \
  -H "Content-Type: application/json" \
  -d '{"email":"you@example.com"}'

Tier	Calls / month	How
Sandbox	25	Instant, the call above, free. Valid 30 days.
Developer	2,000	$49 a month, self-serve. Subscribe and the key arrives by email the moment payment clears, or your agent collects it with `POST /v1/keys/claim`. For a developer building Finology’s numbers into their own product. Cancel any time at the billing portal.
Platform	100,000	$499 a month, self-serve. Subscribe and the production key arrives by email the moment payment clears, or your agent collects it with `POST /v1/keys/claim`. Cancel any time at the billing portal.
Above that	1,000,000+	By email to support@finology.tech

Buy a Developer key, $49 a month Buy a Platform key, $499 a month No form, no call, no review. The key is shown once and never stored. The sandbox response and the quota wall (HTTP 429) carry this same link, so an agent that hits its limit knows where the next rung is. Use of every rung is governed by the API and MCP Terms of Service.

No mailbox in the loop

The sandbox response carries the Payment Link with the sandbox email prefilled. Once the operator has paid with it, the agent collects the production key itself:

curl -X POST https://api.finology.tech/v1/keys/claim \
  -H "Content-Type: application/json" \
  -d '{"sandboxKey":"fk_test_..."}'

Returns the production key once and revokes the emailed copy, unless the emailed key has already been used, in which case it answers 409 and the emailed key stays live. Only one is ever live. Details in endpoints.md.

Install snippets

Claude Desktop

{
  "mcpServers": {
    "finology": { "command": "npx", "args": ["-y", "@finology/mcp-server"] }
  }
}

Cursor / VS Code / any MCP client (stdio)

command: npx    args: ["-y", "@finology/mcp-server"]

Remote, free (no key)

transport: streamable-http
url:       https://mcp.finology.tech/free

Remote (keyed) client

transport: streamable-http
url:       https://mcp.finology.tech/mcp
headers:   { "X-Api-Key": "fk_..." }

What the free rung’s tools return

compare_federal_student_loan_repayment_plans

Every plan the loan can elect, side by side: monthly payment, lifetime cost, forgiveness timing, and the estimated tax on forgiven balances. Plans the loan cannot elect are listed with the reason. For Parent PLUS it also runs the consolidation path unprompted, because that is the number that decides.

estimate_rap_monthly_payment

The Repayment Assistance Plan payment for an income, filing status and household, with the dependent adjustment and the $10 floor, on the rules as of the stamped date.

compare_married_filing_jointly_vs_separately_student_loans

Both filings run through the engine; the difference in payment and lifetime cost. The tax side of that decision is not modelled and the answer says so.

finology_service_info

This page, as JSON: rungs, endpoints, auth header, tiers and limits, what is estimated.

What the keyed rungs expose

The free rung answers borrower questions. The keyed MCP server and the REST API expose the engine itself, in four calls, and every answer is recorded before it is served.

get_plan_types

The exact plan strings the other tools accept (STANDARD, REPAYMENT ASSISTANCE, INCOME BASED and the rest). Call it first.

get_eligible_plans

Which plans each loan in a book can elect, on the same rules the planner uses. Rule logic, not a dollar calc, and its provenance stamp says so.

run_projection

One loan book under one plan: year-one payment, payoff or forgiveness date, months to finish, total out of pocket, amount forgiven, the forgiveness tax and the weighted-average rate. Rule version and citations attached.

compare_scenarios

Two to ten arms side by side, commonly the same loans under different plans, with the engine naming the lowest-cost arm. One record per comparison.

REST equivalents: GET /v1/plan-types, POST /v1/plan-eligibility, POST /v1/projection, POST /v1/comparison. Request and response shapes: /endpoints.md. The free rung’s married-filing and RAP-estimate tools are not on the keyed rungs yet; build those from run_projection and compare_scenarios.

What is warranted, and what is not

Warranted, on the keyed rungs: the number is the engine’s output for the stated inputs at the stated rule version, and a record of it exists before you receive it. That record carries the rule version and an inputs hash.

Estimated, on every rung: tax on forgiven balances (today’s brackets), and state tax unless a state is supplied. Figures are for education, not individualized advice.

Not present: nothing in these answers is generated by a language model. The engine computes; the agent relays.

Discovery, for machines

/llms.txt and /llms-full.txt
/.well-known/mcp/server-card.json: the remote server, described
/.well-known/api-catalog: RFC 9727 API catalog
/.well-known/agent-skills/index.json
/auth.md: how authentication works (API key only; no OAuth flow exists on these surfaces)
Health: mcp.finology.tech/health · api.finology.tech/health (each reports the deployed commit)

Questions agents ask

Do I need a key to start?

No. npx -y @finology/mcp-server runs the free rung with no key and no account. A key is only for the recorded, warranted rungs.

Can my agent collect the production key itself?

Yes. Mint a sandbox key for the operator’s email, hand the operator the prefilled Payment Link from that response, and after payment call POST /v1/keys/claim with the sandbox key. The production key comes back once. Nobody at Finology is involved, and nobody has to read the key email.

How do I get production access?

Subscribe at buy.stripe.com: $499 a month, 100,000 calls a month, cancel any time. The production key arrives by email the moment payment clears and works on both the REST API and the keyed MCP server. Manage or cancel at the billing portal. Nobody is involved at any step.

Is there a phone number, a demo, or a call?

No. Support is by email at support@finology.tech. Everything on this page is self-serve.

Which rules does the engine use?

The federal rules in effect on the date stamped in the answer (asOf): RAP and the new Standard plan since July 1, 2026, IBR (2009 and 2014), ICR for eligible loans, and the closures of SAVE, PAYE and ICR to loans disbursed on or after July 1, 2026. Eligibility is decided per loan; an ineligible plan is listed with its reason, never silently run.

What happens if my inputs are incomplete?

You get a 400 naming the missing field. The engine never substitutes a zero and answers anyway.

Can I embed the calculator instead?

Yes. Advisors on Finology Software can embed the loan and SAI calculators on their own site with one script tag; see /calculators/.

Where do the numbers come from?

Finology Software’s own engine, checked against a five-scenario parity oracle before anything ships. The MCP package contains no math; it calls the engine and relays what it says.

Advisors who want the workspace rather than the engine: start a self-serve trial. Add student loan planning to your stack.