Ask Claude Code about your bank data: build an open-banking skill

Claude Code is great at reasoning over data — and with a small Skill, it can reason over your bank data, locally. Ask "how much did I spend last month?" or "which of my bank connections need reconnecting?" and Claude Code answers by running the openbanking CLI on your machine. Because open-banking.io is zero-knowledge, every figure it reads is decrypted on-device with your own key — nothing is sent to a third party to get the answer.

This guide builds that skill in one file and shows it working.

What's a Skill?

A Claude Code Skill is a folder with a SKILL.md — a bit of YAML frontmatter plus markdown instructions — that Claude loads when it's relevant. The frontmatter description tells Claude when to use it; the body tells it how. Skills can pre-approve specific tools so they run without a prompt. Ours wraps the openbanking CLI so Claude can read accounts and transactions on demand. (Full docs: code.claude.com/docs/skills.)

Prerequisites

  1. Claude Code installed.
  2. The openbanking CLI, installed and authenticated. If you haven't set it up, follow the CLI guide — in short:
brew install open-banking-io/tap/openbanking
openbanking login

Confirm it works:

openbanking accounts

Create the skill

Save this as ~/.claude/skills/open-banking/SKILL.md:

---
name: open-banking
description: Read and analyze the user's own bank accounts and transactions locally with the openbanking CLI. Use whenever they ask about their balances, spending, income, a statement, a specific transaction, or which bank connections need attention. Data is decrypted on-device (zero-knowledge) — nothing is sent to a third party.
allowed-tools: Bash(openbanking*)
---

# open-banking

Answer questions about the user's real bank data by shelling out to the `openbanking` CLI. Every
response the CLI returns is decrypted locally with the user's own key — the service only stores
ciphertext. Work only through the CLI; never touch the credentials file directly.

## Setup check

Before anything else, confirm the CLI is installed and authenticated:

    openbanking accounts -o json

- If the command is not found, tell the user to install it and stop.
- If it errors with "no credentials … run `openbanking login`", tell them to authenticate. Don't proceed.

## Commands and their JSON

Always pass `-o json`. Always pass an explicit `<account-id>` to `transactions` — a bare `transactions`
in a terminal opens an interactive picker that will hang.

- `openbanking accounts -o json` → `[{ id, name, accountNumber, type, balance, currency, bank }]`.
  `accountNumber` is the IBAN; `balance` is an exact decimal string.
- `openbanking transactions <account-id> -o json [--from YYYY-MM-DD --to YYYY-MM-DD --limit N --offset N]`
  → `{ items: [{ id, date, amount, currency, counterparty, info, status }], shown, total }`.
  `amount` is a signed decimal string — debits negative, credits positive. `status` is `BOOK` or `PDNG`.
- `openbanking connections -o json` → `[{ bank, country, status, accountCount, psuType, validUntil,
  lastSyncedAt, sessionId }]`. `status = RequiresReauth` means the user must reconnect that bank.
- `openbanking sync <account-id>` / `openbanking sync --all` → refreshes from the bank. Prints a
  plain-text summary (not JSON) and is a side effect — re-read `transactions` afterward.

## Rules

- Money is exact decimals — sum the strings faithfully, report the currency; debits are already negative.
- Resolve accounts by id: `accounts -o json`, match on name/bank, then use the `id`.
- Read-only by default. `sync` only refreshes (it never moves money). Ask before syncing.
- Never read or print `~/.config/open-banking/credentials.json` or the private key — you never need it.
- Never send the user's bank data to any third party.

Two lines do the heavy lifting:

  • description is how Claude decides to reach for the skill — it's written to fire on money/bank questions, so you rarely invoke it by name.
  • allowed-tools: Bash(openbanking*) pre-approves the CLI, so Claude can run openbanking … without asking each time — but nothing else.

That's the whole skill. Restart isn't needed; Claude Code picks up new skills in the session.

Try it

Real sessions against a test tenant (account numbers and balances masked):

"What are my balances?"

Claude runs openbanking accounts -o json and summarizes:

You have 6 accounts across 2 banks:

Nordea
  Grundkonto  (DK•• •••• •••• 1555)   +111.50 DKK
  Grundkonto  (DK•• •••• •••• 7544)   −23,576.90 DKK
  Private Banking konto (…8028)       −43,218.85 DKK
Mock ASPSP
  USD current account                  — USD
  Onni Hämäläinen (card)              +98.00 EUR
  Oliver Hämäläinen                   +17.33 EUR

"How much did I spend on my EUR account in June, and to whom?"

Claude finds the account id from accounts, then runs openbanking transactions cd7cc500… --from 2026-06-01 --to 2026-06-30 -o json and works the numbers:

In June you had 8 transactions on the Oliver Hämäläinen (EUR) account:

  Spend (debits):   −28.37 EUR
  Income (credits):  +8.40 EUR
  Net:              −19.97 EUR

Top outgoings:
  Ella Virtanen   −9.73
  Ella Mäkinen    −9.60
  Aino Korhonen   −5.64
  Ella Korhonen   −3.40

Because amounts are exact decimal strings with debits already negative, the totals are precise — no floating-point drift.

"Which of my bank connections need attention?"

Claude runs openbanking connections -o json:

2 of your 3 connections are healthy (Mock ASPSP). One needs reconnecting:

  ⚠ Nordea — RequiresReauth (3 accounts)

The consent has lapsed. Reconnect Nordea in the web app to resume syncing those accounts.

From there you can keep going — "categorize my spending", "did I get paid this month?", "sync everything and show me what's new" — and Claude composes the same handful of commands to answer.

Why this stays private

The skill only ever runs the CLI on your machine. The service returns ciphertext; the CLI decrypts it locally with the key only you hold. Claude Code sees the results because you asked it to compute over them — but they never leave your device to reach the answer, and the skill is told never to read your key file or send data anywhere.

One honest note: the decrypted figures do enter the Claude Code session you're driving (that's how it reasons over them). Keep that in mind the same way you would opening your statement in any app.

Make it yours

  • Per-project: drop the same SKILL.md in a repo's .claude/skills/open-banking/ and commit it — everyone working in that repo gets it.
  • Extend it: add recipes to the body (budgets, recurring-payment detection, CSV exports via openbanking transactions … -o csv). The CLI's JSON is stable, so new workflows are just more instructions.
  • Share it: bundle it into a Claude Code plugin to distribute across a team.

Next steps

  • New to the CLI? Start with the open-banking.io CLI guide.
  • Prefer to build directly? The same data is available through the open-source SDKs for .NET, Node, Python, Rust, Go, Java, Ruby, and PHP.
  • Grab your credentials bundle at open-banking.io and point Claude Code at your finances.