Skip to content
Back to search

bankmcp

BankMCP™: your AI can now read your bank. Self-hosted, read-only MCP server for your own bank accounts via open banking (Enable Banking). Standard MCP; tested with Claude and Ollama.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/noskillish--bankmcp/badge.svg)](/listings/noskillish--bankmcp)

HTML

<a href="/listings/noskillish--bankmcp"><img src="/api/listings/noskillish--bankmcp/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

Two ways to run it. Both need a free Enable Banking account and about ten minutes.

- **On your own machine** for Claude Desktop, Claude Code, Cursor and other desktop MCP clients. Nothing to deploy, no password. - **On a small server** when you want it in claude.ai or on your phone.

On your own machine

The server and its state live on your computer, and no AI vendor or app maker sees your data. The bank connection is not on your computer: it goes through Enable Banking, as described above.

Requires [Node 24](https://nodejs.org) or newer. Add BankMCP™ to your client:

Claude Code:

claude mcp add bankmcp -- npx -y bankmcp

Claude Desktop: download [bankmcp.mcpb](https://github.com/noskillish/bankmcp/releases/latest/download/bankmcp.mcpb) and open it; Claude Desktop installs it as an extension. Or add it by hand in `claude_desktop_config.json`:

{ "mcpServers": { "bankmcp": { "command": "npx", "args": ["-y", "bankmcp"] } } }

Cursor and others: the same command, `npx -y bankmcp`, as a stdio server.

Then ask your assistant anything about your bank. It will answer with a localhost address. Open it: the setup page lists the values to register an application at Enable Banking, then takes the application id and the key file. Your browser will warn once about the certificate on localhost, which the server made for itself because Enable Banking requires https for the bank redirect. Continue past it. Say "connect my bank" and log in at your bank.

To avoid the warning altogether, use a certificate your browser already trusts: [mkcert](https://github.com/FiloSottile/mkcert) makes one with `mkcert localhost 127.0.0.1`; point `TLS_CERT_PATH` and `TLS_KEY_PATH` at the two files and the server uses them instead of generating its own. BankMCP™ itself does not touch your system's trust store.

State lives in `~/.bankmcp`. Delete the folder to forget everything.

On a server

1. Deploy

Any container host works. The server needs a persistent volume at `/data` and a public https address; it asks you for everything else in the browser. A prebuilt image is published on every release: `ghcr.io/noskillish/bankmcp` (built by [GitHub Actions](.github/workflows/image.yml) from the tagged source, `linux/amd64` and `linux/arm64`).

**Railway:** [![Deploy on Railway](https://railway.com/button.svg)](https://railway.com/new/template/bankmcp?utm_medium=integration&utm_source=button&utm_campaign=bankmcp) deploys the published image with a volume at `/data` and a domain, nothing to fill in. Or by hand: New Project, Deploy from GitHub repo, pick this repo, add a volume mounted at `/data` and generate a domain (Settings, Networking, port 8080). The server learns its own address from Railway.

**Fly.io:** three commands from a checkout, using [fly.toml](fly.toml):

fly launch --copy-config --no-deploy   # pick an app name and region
fly volumes create data --size 1
fly deploy

**Render:** [![Deploy to Render](https://render.com/images/deploy-to-render-button.svg)](https://render.com/deploy?repo=https://github.com/noskillish/bankmcp) uses [render.yaml](render.yaml). Render's persistent disks need a paid instance.

**Docker on your own box:**

docker run -d --name bankmcp --restart unless-stopped \
  -p 8080:8080 -v bankmcp-data:/data ghcr.io/noskillish/bankmcp:latest

or `docker compose up -d` with [compose.yaml](compose.yaml). Then put a TLS terminator in front (Caddy needs two lines: `YOUR-HOST { reverse_proxy localhost:8080 }`) and set `BASE_URL` to the public address. The server binds every interface by default. When the proxy runs on the same machine, set `BIND_HOST=127.0.0.1` so nothing else on the local network reaches the login and setup pages.

Open the address. A fresh server shows a setup page.

2. Register an Enable Banking application

The setup page can do this for you. Enter the email of your Enable Banking account (or the one you want to create it with) and press *Send me the

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

.claude-plugin/marketplace.json · Manifest · 31 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. {
  2. "name": "bank",
  3. "owner": {
  4. "name": "Nils Smed",
  5. "url": "https://github.com/noskillish"
  6. },
  7. "metadata": {
  8. "description": "BankMCP™: ask your AI assistant about your own bank accounts. Read-only, self-hosted, on PSD2 open banking via Enable Banking. Works with any MCP client.",
  9. "version": "0.1.1"
  10. },
  11. "plugins": [
  12. {
  13. "name": "bank",
  14. "source": "./plugin",
  15. "description": "BankMCP™ for Claude Code: /bank:setup walks you through installing it locally, /bank:deploy through hosting it; plus a skill with account mapping, categorisation rules and a monthly review format.",
  16. "version": "0.1.1",
  17. "author": {
  18. "name": "Nils Smed"
  19. },
  20. "homepage": "https://github.com/noskillish/bankmcp",
  21. "license": "MIT",
  22. "keywords": [
  23. "banking",
  24. "personal-finance",
  25. "psd2",
  26. "enable-banking"
  27. ],
  28. "category": "productivity"
  29. }
  30. ]
  31. }
README.md · README · 389 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. # BankMCP™
  2. **Your AI now reads your bank.** Ask it anything about your accounts. Read-only, self-hosted, one user. Standard MCP; tested with Claude and Ollama.
  3. BankMCP™ is not a bank. It is a small open-source server you host yourself
  4. (npm package `bankmcp`). It connects to your banks
  5. through [Enable Banking](https://enablebanking.com), which wraps 2,700+
  6. European banks in one PSD2 API, and exposes them to any MCP client as a
  7. connector. Read-only, no payments, no third party holding your data.
  8. > "Has the invoice from Acme been paid?" · "What did we spend on groceries in
  9. > August?" · "Which subscriptions am I paying for, and what do they cost per
  10. > year?" · "Tell me when my balance drops below 5,000."
  11. ## How it works
  12. ```
  13. Your assistant ──OAuth──▶ your BankMCP™ server ──JWT──▶ Enable Banking ──PSD2──▶ your bank
  14. ```
  15. - **Your assistant** (Claude, ChatGPT, Cursor, or any MCP client) talks to
  16. your server as a connector. You sign in once with a password; tokens handle
  17. the rest.
  18. - **Your server** holds the Enable Banking application key, the bank consents
  19. and your account ids. It does not store balances or transactions and sends no
  20. telemetry.
  21. - **Enable Banking** is the licensed provider between your server and your
  22. bank. Every balance and transaction you ask for passes through their
  23. servers on the way to yours; they do not store it, and they do not see your
  24. bank credentials, since you log in at your bank's own site. This hop is how
  25. PSD2 works and is the one part of the chain that is not on your machine.
  26. ## Setup
  27. Two ways to run it. Both need a free Enable Banking account and about ten
  28. minutes.
  29. - **On your own machine** for Claude Desktop, Claude Code, Cursor and other
  30. desktop MCP clients. Nothing to deploy, no password.
  31. - **On a small server** when you want it in claude.ai or on your phone.
  32. ### On your own machine
  33. The server and its state live on your computer, and no AI vendor or app
  34. maker sees your data. The bank connection is not on your computer: it goes
  35. through Enable Banking, as described above.
  36. Requires [Node 24](https://nodejs.org) or newer. Add BankMCP™ to your client:
  37. Claude Code:
  38. ```bash
  39. claude mcp add bankmcp -- npx -y bankmcp
  40. ```
  41. Claude Desktop: download
  42. [bankmcp.mcpb](https://github.com/noskillish/bankmcp/releases/latest/download/bankmcp.mcpb)
  43. and open it; Claude Desktop installs it as an extension. Or add it by hand in
  44. `claude_desktop_config.json`:
  45. ```json
  46. { "mcpServers": { "bankmcp": { "command": "npx", "args": ["-y", "bankmcp"] } } }
  47. ```
  48. Cursor and others: the same command, `npx -y bankmcp`, as a stdio server.
  49. Then ask your assistant anything about your bank. It will answer with a
  50. localhost address. Open it: the setup page lists the values to register an
  51. application at Enable Banking, then takes the application id and the key file.
  52. Your browser will warn once about the certificate on localhost, which the
  53. server made for itself because Enable Banking requires https for the bank
  54. redirect. Continue past it. Say "connect my bank" and log in at your bank.
  55. To avoid the warning altogether, use a certificate your browser already
  56. trusts: [mkcert](https://github.com/FiloSottile/mkcert) makes one with
  57. `mkcert localhost 127.0.0.1`; point `TLS_CERT_PATH` and `TLS_KEY_PATH` at the
  58. two files and the server uses them instead of generating its own. BankMCP™
  59. itself does not touch your system's trust store.
  60. State lives in `~/.bankmcp`. Delete the folder to forget everything.
  61. ### On a server
  62. #### 1. Deploy
  63. Any container host works. The server needs a persistent volume at `/data`
  64. and a public https address; it asks you for everything else in the browser.
  65. A prebuilt image is published on every release:
  66. `ghcr.io/noskillish/bankmcp` (built by [GitHub Actions](.github/workflows/image.yml)
  67. from the tagged source, `linux/amd64` and `linux/arm64`).
  68. **Railway:** [![Deploy on Railway](https://railway.com/button.svg)](https://railway.com/new/template/bankmcp?utm_medium=integration&utm_source=button&utm_campaign=bankmcp)
  69. deploys the published image with a volume at `/data` and a domain, nothing
  70. to fill in. Or by hand: New Project, Deploy from GitHub repo, pick this
  71. repo, add a volume mounted at `/data` and generate a domain (Settings,
  72. Networking, port 8080). The server learns its own address from Railway.
  73. **Fly.io:** three commands from a checkout, using [fly.toml](fly.toml):
  74. ```bash
  75. fly launch --copy-config --no-deploy # pick an app name and region
  76. fly volumes create data --size 1
  77. fly deploy
  78. ```
  79. **Render:** [![Deploy to Render](https://render.com/images/deploy-to-render-button.svg)](https://render.com/deploy?repo=https://github.com/noskillish/bankmcp)
  80. uses [render.yaml](render.yaml). Render's persistent disks need a paid
  81. instance.
  82. **Docker on your own box:**
  83. ```bash
  84. docker run -d --name bankmcp --restart unless-stopped \
  85. -p 8080:8080 -v bankmcp-data:/data ghcr.io/noskillish/bankmcp:latest
  86. ```
  87. or `docker compose up -d` with [compose.yaml](compose.yaml). Then put a TLS
  88. terminator in front (Caddy needs two lines:
  89. `YOUR-HOST { reverse_proxy localhost:8080 }`) and set `BASE_URL` to the
  90. public address. The server binds every interface by default. When the proxy
  91. runs on the same machine, set `BIND_HOST=127.0.0.1` so nothing else on the local
  92. network reaches the login and setup pages.
  93. Open the address. A fresh server shows a setup page.
  94. #### 2. Register an Enable Banking application
  95. The setup page can do this for you. Enter the email of your Enable Banking
  96. account (or the one you want to create it with) and press *Send me the
  97. sign-in link*. Enable Banking emails you a one-time link; paste it on the
  98. next page. Your server signs in with it once, creates the application with
  99. the right redirect and policy addresses, generates the key pair and stores
  100. the id and the key. The sign-in is not kept. On a local server the click on
  101. the link does the same without pasting.
  102. Or by hand: the setup page lists the exact values Enable Banking's form asks
  103. for, with Copy buttons. At <https://enablebanking.com/cp/applications> create
  104. an application with them, keep *generate private key* selected, and save. A
  105. `.pem` file downloads once; that is the key. Paste the application id and
  106. choose the `.pem` file on the setup page. Before anything is stored, the id
  107. and key are checked against Enable Banking.
  108. Either way: **Production** for your real accounts, **Sandbox** for test data.
  109. A production application for your own accounts is activated once in the
  110. Control Panel with *Activate by linking accounts*; see *Going live* below.
  111. #### 3. Finish setup
  112. Choose a password of twelve characters or more. A *Ready* page then shows
  113. what was checked: the application, whether its redirect URL is registered and
  114. whether it is active, and the connector address to copy.
  115. Prefer configuration by environment? Set these and the setup page does not
  116. appear:
  117. #### 4. Add the connector in your assistant
  118. In claude.ai (or the desktop app): **Settings → Connectors → Add custom
  119. connector**. Name it `BankMCP™`, paste `https://YOUR-HOST/mcp`, save, then click
  120. **Connect**. Your server shows a password page; enter the admin password. That
  121. is the only login you will do.
  122. In Claude Code:
  123. ```bash
  124. claude mcp add --transport http bank https://YOUR-HOST/mcp
  125. ```
  126. then run `/mcp` inside Claude Code to sign in.
  127. Other MCP clients (ChatGPT, Mistral Le Chat, Cursor, VS Code) work the same
  128. way: add the URL as a remote MCP server, sign in with the password. Tested
  129. with Claude, Claude Code and Ollama; the others follow the same standard.
  130. A client whose domain is not in `ALLOWED_REDIRECT_HOSTS` needs adding there.
  131. #### 5. Connect your bank
  132. In your assistant, say **"connect my bank"** (or use the `connect-bank` prompt). It
  133. looks up your bank, gives you a link, you log in at the bank and approve, and
  134. the accounts appear. Consents last up to 180 days; you are told when one
  135. is about to expire and the same conversation renews it.
  136. Give accounts labels ("Everyday", "Joint expenses", "Mortgage") when it
  137. suggests them. Every tool accepts labels instead of ids.
  138. ## Going live with your own accounts
  139. Enable Banking's production environment normally requires a contract, but it
  140. has a **restricted mode** for accessing *your own* accounts, explicitly allowed
  141. for individual non-commercial use. After registering a Production application:
  142. 1. On the (Inactive) application click **Activate by linking accounts**.
  143. 2. Log in at your bank and approve. Repeat for each bank you want.
  144. 3. The application becomes active and the API returns only the accounts you
  145. linked this way.
  146. Read the *Restriction of Use* section of Enable Banking's
  147. [Terms of Service](https://enablebanking.com/terms-of-service/) before you
  148. rely on it: restricted mode is for your own accounts, not for offering a
  149. service to others. This project does not change those terms.
  150. ## What you get
  151. **Tools** (all read-only):
  152. | Tool | What it does |
  153. |---|---|
  154. | `list_banks`, `start_consent`, `consent_status`, `disconnect_bank` | connect and manage banks |
  155. | `list_accounts`, `set_account_label` | accounts with booked balances; your own names for them |
  156. | `get_balances` | booked and available balance for one account |
  157. | `get_transactions` | signed amounts, one counterparty, one description; paginated |
  158. | `search_transactions` | find a merchant or invoice number across all accounts; whole-word matches |
  159. | `monthly_summary` | money in and out per month, transfers between your own accounts left out |
  160. | `create_watch`, `list_watches`, `delete_watch`, `check_watches` | background rules with webhook notifications |
  161. | `attest_account` | **off by default**; a signed yes/no that an IBAN is yours, for a third party you are proving an account to — see [ATTESTATION.md](ATTESTATION.md) |
  162. **Prompts**: `connect-bank`, `monthly-summary`, `build-budget`,
  163. `savings-scan`, `subscription-audit`, `unusual-transactions`.
  164. **Watches** run on the server. Rules: balance below or above an amount, a
  165. single debit over an amount, an incoming or outgoing payment matching a name,
  166. and "tell me if this payment has not arrived by this date". Accounts are
  167. checked at most four times a day, the PSD2 limit for unattended access.
  168. Notifications go to `NOTIFY_WEBHOOK_URL` as a Slack message or a JSON POST.
  169. Enable Banking's own webhooks cover payment initiation only, so account data
  170. is polled. There is no way around that under PSD2.
  171. ## Claude Code plugin
  172. The repository is also a Claude Code plugin marketplace. The `bank` plugin
  173. brings three skills: `/bank:setup` walks you through installing BankMCP™ on
  174. your machine, `/bank:deploy` through hosting it, and `bank` encodes how to work
  175. with the data: an account map, categorisation rules, the monthly review format
  176. and when to create watches.
  177. Point it at your server, then install:
  178. ```bash
  179. export OPENBANK_URL=https://YOUR-HOST/mcp # put this in your shell profile
  180. ```
  181. ```
  182. /plugin marketplace add noskillish/bankmcp
  183. /plugin install bank@bank
  184. ```
  185. Then `/mcp`, select `bank`, Authenticate, and enter your password. No
  186. organisation admin is involved; plugins are per user.
  187. The skill lives at [plugin/skills/bank/SKILL.md](plugin/skills/bank/SKILL.md).
  188. Copy it into your own skills to fill in the account map and your merchant
  189. rules. The server stays generic; your rules stay yours.
  190. ## Local models (experimental)
  191. The server does not care which model asks. `npm run chat` bridges an
  192. [Ollama](https://ollama.com) model to the same tools over stdio, so no AI
  193. vendor sees a transaction:
  194. ```bash
  195. ollama pull qwen3:8b
  196. npm run chat -- "what's my balance?"
  197. ```
  198. Measured on a MacBook Air with 24 GB: correct per-account balances, a wrong
  199. total, ten minutes per answer. An 8B model is not yet trustworthy with money;
  200. a 30B-class model on a machine with a real GPU is where it gets useful. Any
  201. MCP client with tool calling (LM Studio, Goose, Jan) can also point at
  202. `node src/stdio.ts` directly. Enable Banking still sits between you and the
  203. bank either way; that part is regulated and unavoidable.
  204. ## Security notes
  205. - The server is a complete OAuth 2.1 authorization server with one user.
  206. Discovery, dynamic client registration and PKCE come from the MCP SDK;
  207. tokens are stored hashed; five wrong passwords lock an address out for
  208. fifteen minutes, and twenty from all addresses together lock sign-in for
  209. everyone for fifteen minutes. Assistants that are already connected keep
  210. working during a lock.
  211. - State is one JSON file in `DATA_DIR`: consents, account ids, watches (with
  212. the ids of transactions that already fired) and OAuth tokens. Balances and
  213. transactions are not written to disk. Your assistant keeps the
  214. conversation as any chat does, and a watch notification carries the matched
  215. transaction to your webhook. Back the file up if you care about not
  216. re-consenting; delete it to forget everything.
  217. - Only clients that redirect back to a known MCP client domain (Claude,
  218. ChatGPT, Mistral, Cursor, VS Code) or localhost can register
  219. (`ALLOWED_REDIRECT_HOSTS`), which stops a phishing link from routing your sign-in to
  220. another site. Using a client not on the list? Add its domain. The sign-in page also names the host you will
  221. be sent back to.
  222. - Notifications go to one destination only: the `NOTIFY_WEBHOOK_URL` the
  223. operator sets on the host, and it must be https. A watch cannot name its own
  224. webhook, so a client or an assistant that has been talked into it cannot
  225. point transaction data at another address or at something inside the
  226. server's network.
  227. - Where the checks are, for anyone reading the code: every `/mcp` request
  228. passes `requireBearerAuth` in `src/app.ts` before any tool runs; tokens are
  229. issued and verified by `SingleUserProvider` in `src/auth.ts`, after the
  230. password check in `completeLogin`. There is one user, so a valid token is the
  231. whole authorisation and the tools carry no further per-user checks. In local
  232. mode (`npx bankmcp`) there is no OAuth: the client on your machine talks to
  233. the server over stdio, and whoever can run processes on that machine can use
  234. it.
  235. - Transaction descriptions and counterparty names are written by other people,
  236. for example whoever sent you a payment. The server tells assistants to treat
  237. them as data, not as instructions. An assistant can still be misled by them.
  238. - Anyone with the admin password can read your accounts. Use a long one.
  239. Every successful sign-in is logged and, if `NOTIFY_WEBHOOK_URL` is set,
  240. sent to you as a message. A sign-in you did not make is your alarm.
  241. - Forgot the password? Set `ADMIN_PASSWORD` (or `ADMIN_PASSWORD_HASH`) on the
  242. host and restart; the environment wins over the value stored at setup.
  243. - Changing `ADMIN_PASSWORD_HASH` (or `ADMIN_PASSWORD`) and restarting logs
  244. every client out. That is the kill switch. Revoking the consents at your
  245. bank, or deleting the state file, is the step beyond it.
  246. - There are no payment tools. Payments need a licensed PISP and a very
  247. different security model, so they are out of scope.
  248. ## Commands
  249. ```bash
  250. npm start # http server (reads env from the environment)
  251. npm run dev # same, with reload and .env
  252. npm run check # verify config and the Enable Banking application
  253. npm run hash-password # produce ADMIN_PASSWORD_HASH
  254. npm run watch -- --force # run all watches once, print what fired
  255. npm test # unit tests (node:test)
  256. npm run typecheck
  257. sh scripts/build-mcpb.sh # Claude Desktop bundle → dist/bankmcp.mcpb
  258. npm run banks # refresh docs/banks/banks.json from Enable Banking's bank list
  259. npm run site # build the subpages of the landing page into docs/
  260. ```
  261. Requires Node 24 or newer (runs TypeScript directly, no build step).
  262. ## Layout
  263. ```
  264. src/stdio.ts entry point for npx bankmcp: stdio server plus the localhost https side
  265. src/server.ts entry point for a hosted deployment: OAuth, /mcp, callback, status page
  266. src/app.ts the Express app shared by both entry points
  267. src/local.ts localhost https server and self-signed certificate for local mode
  268. src/mcp.ts McpServer factory (tools, prompts, instructions)
  269. src/tools.ts the MCP tools
  270. src/prompts.ts the MCP prompts
  271. src/watcher.ts background rule checks and notifications
  272. src/auth.ts single-user OAuth provider
  273. src/setup.ts first-run setup: validates and stores id, key and password
  274. src/pages.ts the HTML pages: setup, sign-in, connected, status, privacy, terms
  275. src/config.ts environment and data-directory configuration
  276. src/enablebanking.ts JWT signing and a thin typed API client
  277. src/store.ts the JSON state file
  278. src/data.ts shaping balances and transactions for an assistant
  279. src/cli.ts check, hash-password, watch
  280. bin/bankmcp.js the npx entry; dispatches to stdio or cli
  281. scripts/ build-mcpb.sh (Claude Desktop bundle), banks.ts and site.ts (landing subpages), local-chat.ts (Ollama bridge)
  282. plugin/ Claude Code plugin: setup and deploy skills, bank skill
  283. docs/ landing page (GitHub Pages, bankmcp.dk); docs/banks holds the bank list and its pages
  284. ```
  285. ## What this is, and is not
  286. BankMCP™ is software, not a service. There is no hosted BankMCP™, no account to sign
  287. up for, and nobody but you handles your server, your key or your bank
  288. consents. Each person who uses it deploys their own copy and is the sole
  289. operator of that copy: they register their own Enable Banking application,
  290. accept Enable Banking's terms themselves, and are responsible for their own
  291. hosting, password and security.
  292. The authors publish the code and nothing else. They do not run any instance
  293. for others, receive no data, and are not affiliated with Enable Banking,
  294. Anthropic or any bank. BankMCP™ is not a bank, does not hold money, and gives no
  295. financial advice.
  296. Attestations (`ATTESTATION_ENABLED`, off by default) do not change any of
  297. this. They add no payment initiation and widen no consent: the bank calls
  298. underneath are the same balance reads `get_balances` already makes, and a
  299. third party who asks learns a yes or a no about one IBAN they already knew.
  300. Whether sharing that with a particular service suits your Enable Banking
  301. terms is your decision as the operator, as everything else here is.
  302. **Use at your own risk.** If you deploy it, you own that deployment and its
  303. security. The software is provided as is, without warranty of any kind, and
  304. the authors accept no liability for how it is used or for any loss that
  305. follows. MIT licence below.
  306. ## License
  307. MIT

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.