F
licenseNot graded
qualityD
maintenanceThis server implements the Model Context Protocol to facilitate meaningful interaction and understanding development between humans and AI through structured tools and progressive interaction patterns.
57
-
bankstatementparser-mcp
This server lets an MCP agent inspect, parse, validate, and summarize inline bank statement payloads across several financial formats.
List supported statement format identifiers (
camt,pain001,csv,ofx,qfx,mt940).Detect a statement’s format from inline content plus a filename hint.
Parse a statement into structured transaction rows and a summary, with an optional row limit.
Validate whether a statement parses cleanly without returning transaction rows or raising on parse errors.
Summarize only balances, totals, currency, and other summary fields without per-transaction detail.
Work entirely with inline content, not server filesystem paths.
Allows parsing of SWIFT MT940 bank statements to extract transactions and balances.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@bankstatementparser-mcp Read and summarize this bank statement"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
Contents
Getting started
What is bankstatementparser-mcp? — the problem it solves
The ISO 20022 MCP Suite — the four coordinated servers and when to use each
Install — PyPI, virtualenv, Docker
Quick start — register with Claude Desktop in 30 seconds
Transports — stdio, streamable HTTP (2026-07-28 and 2025-11-25) and SSE from one command line
Library reference
Tools — the five tools, one resource, one prompt
Using the tools — call them in-process from Python
Operational
When not to use bankstatementparser-mcp — honest boundaries
Development — gates, make targets
Security — sandboxing posture
Documentation — examples, guides
Contributing — how to get changes in
License — Apache-2.0
Related MCP server: MCP Toolkit Server
What is bankstatementparser-mcp?
The Model Context Protocol (MCP) is
an open standard that lets AI agents discover and call external tools in
a uniform way. bankstatementparser-mcp is the MCP server that turns the
bankstatementparser
library into first-class agent tools — so an assistant can read,
validate, and summarise bank statements in formats such as ISO 20022
CAMT.053, SWIFT MT940, OFX/QFX, and CSV directly from a conversation.
Every tool is a thin wrapper over the bankstatementparser parser core
(create_parser, detect_statement_format), so the results behave
identically to the CLI. Because an MCP client does not share the
server's filesystem, the tools take inline statement content (plus a
filename hint) and materialise it in a private temporary file for the
duration of a single call. Tools return JSON-serialisable data.
Concern | How bankstatementparser-mcp handles it |
Transport | stdio by default; |
Input model | Inline content + filename hint; no shared filesystem required |
Format fidelity | Tools delegate to |
Format detection |
|
Validation |
|
Isolation | Each call writes to a private temp file that is deleted on exit |
The ISO 20022 MCP Suite
bankstatementparser-mcp is the ingestion layer of eight coordinated,
vendor-neutral MCP servers that together cover the ISO 20022
bank-statement workflow and the November 2026 structured-address
cutover — statement depth, whole-catalogue routing, reconciliation,
multi-format ingestion, and address remediation. Dependency ranges are kept
aligned across the suite, so the servers co-install cleanly in a single
Python environment: start with one, add the rest as your workflow grows.
Server | Scope | Surface | Install | Use it when |
ISO 20022 | 24 MCP tools · 4 prompts · 3 resources |
| You work with bank-to-customer statements end to end — the suite's flagship | |
Unified gateway: | 7 meta-tools |
| You want one entry point to every message family | |
Matches expected | 7 MCP tools |
| You need explainable statement/payment reconciliation | |
Multi-format statement ingestion: ISO 20022 CAMT.053 and pain.001, SWIFT MT940, OFX/QFX, CSV | 5 MCP tools · 1 prompt · 1 resource |
| Your statements arrive in mixed or legacy formats — this package | |
ISO 20022 postal-address classification, assessment & remediation for the November 2026 structured-address cutover, plus a high-level orchestration layer — readiness scoring, clearing-profile linting, and audit evidence ( | 9 MCP tools |
| You need debtor/creditor addresses cliff-ready ahead of 14 Nov 2026 | |
Orchestration gateway: detect → structurally validate → clearing-profile lint → readiness score, plus automated remediation and | 4 MCP tools |
| You want one high-level readiness / orchestration entry point over the suite | |
Manages, validates and serves bank-specific clearing profiles / rule packs (CBPR+, SEPA_Instant, FedNow, Generic); premium rule-pack entitlement gating | 4 MCP tools |
| You lint payments against your own institution's market practice | |
Compiles readiness findings, remediation diffs and simulated responses into a sealed, Ed25519-signable audit evidence pack | 6 MCP tools |
| You need tamper-evident audit / certification artifacts |
In one line each: camt053-mcp is the bank-statement flagship
(deepest camt.05x surface, stdio + authenticated streamable HTTP);
iso20022-mcp is the generic message toolkit (a handful of verbs
over the whole catalogue); reconcile-mcp is the reconciliation
workflow (did the money we expected actually arrive?);
bankstatementparser-mcp is the ingestion layer (many formats in,
one transaction shape out); and structured-address-fix-mcp is the
postal-address specialist (debtor/creditor addresses cliff-ready for the
Nov 2026 cutover).
Install
Channel | Command | Notes |
PyPI |
| Pulls in |
Source |
| For development |
Docker (GHCR) |
| Multi-arch (linux/amd64, linux/arm64); runs |
Requires Python 3.10 or later. Works on macOS, Linux, and Windows.
python -m venv venv
source venv/bin/activate # macOS/Linux
venv\Scripts\activate # Windows
python -m pip install -U bankstatementparser-mcpQuick start
Register the server with any MCP client (Claude Desktop shown):
{
"mcpServers": {
"bankstatementparser": { "command": "bankstatementparser-mcp" }
}
}That's it. Restart the client and the tools are available to the agent.
By default the server speaks JSON-RPC over stdin/stdout — it is meant to be launched by an MCP client, not used interactively. For a shared deployment, see Transports.
Transports
One command line, three transports:
Command | Transport | Endpoint | Protocol revisions |
| stdio | the client spawns the process | 2026-07-28, 2025-11-25 |
| Streamable HTTP |
| 2026-07-28 (stateless, |
| HTTP+SSE (2024-11-05) |
| for clients that still expect the older transport |
--host and --port change the bind address (defaults 127.0.0.1 and
8000). The HTTP transports carry no authentication of their own: bind
loopback, or put the server behind a gateway you trust before binding a
routable address. Every release is verified over streamable HTTP with
passmcp in both protocol
eras and over SSE with the MCP SDK client; see
ADR 0001.
{
"mcpServers": {
"bankstatementparser": { "url": "http://127.0.0.1:8000/mcp" }
}
}Tools
All tools delegate to the bankstatementparser parser core, so they
behave identically to the library.
list_supported_formats— List every bank statement format the parser can readdetect_format— Detect which statement format an inline payload isparse_statement— Parse a statement into structured transactions plus a summaryvalidate_statement— Dry-run check whether a statement parses cleanlysummarize_statement— Return only the statement summary (no per-transaction rows)
Plus one resource and one prompt:
Resource
bankstatementparser://formats— Read-only catalogue of supported formats and their file extensionsPrompt
analyze_statement— Guided multi-step prompt that walks an agent through reading and reconciling a statement
Supported formats: camt (ISO 20022 CAMT.053, .xml), pain001
(ISO 20022 pain.001, .xml), csv (.csv), ofx (.ofx), qfx
(.qfx), and mt940 (SWIFT MT940, .mt940 / .sta).
Using the tools
The tools are plain functions on the bankstatementparser_mcp.server
module, so you can call them in-process:
from bankstatementparser_mcp.server import (
detect_format,
parse_statement,
summarize_statement,
)
csv = (
"date,description,amount,currency,balance\n"
"2023-01-02,Salary,500.00,EUR,1500.00\n"
"2023-01-03,Groceries,-40.50,EUR,1459.50\n"
)
# 1. Detect the format from the filename hint + content.
print(detect_format(csv, "statement.csv"))
# -> csv
# 2. Parse the statement into structured rows + a summary.
parsed = parse_statement(csv, "statement.csv")
print(parsed["transaction_count"], parsed["columns"])
# 3. Read just the opening/closing balances.
print(summarize_statement(csv, "statement.csv"))The resource and prompt are plain functions too: formats_resource
backs bankstatementparser://formats, and analyze_statement returns
the guided multi-step prompt.
from bankstatementparser_mcp.server import (
analyze_statement,
formats_resource,
)
print(formats_resource()) # the supported-formats catalogue
print(analyze_statement("statement.csv")) # the guided analysis promptSee the examples/ folder for runnable walkthroughs,
including 04_resource_and_prompt.py.
When not to use bankstatementparser-mcp
You're not driving an MCP-aware agent. Use the
bankstatementparserCLI or library directly — it exposes the same surface with less indirection.You need to parse files already on disk in bulk. The library's CLI reads paths directly and avoids the inline-content round-trip the MCP tools use.
Development
bankstatementparser-mcp uses Poetry and
mise.
git clone https://github.com/sebastienrousseau/bankstatementparser-mcp.git
cd bankstatementparser-mcp
mise install
poetry installA Makefile orchestrates the quality gates (kept in lockstep with CI):
Target | What it runs |
| All gates (REQUIRED before commit) |
|
|
|
|
|
|
|
|
Current state (v0.0.29): 100% line + branch coverage against a 100%
enforced floor, mypy --strict clean, interrogate 100%.
Security
No persistent filesystem writes from tools. Each call writes the inline content to a private temporary file that is deleted as soon as the call returns.
Validation failures from
validate_statementare returned as structured{"is_valid": false, "error": ...}payloads — never as stack traces.Dependencies are pinned via
poetry.lockand audited bypip-auditand Bandit in CI.
To report a vulnerability, please use GitHub private vulnerability reporting rather than a public issue.
Documentation
Runnable examples:
examples/Release history: CHANGELOG.md
MCP specification: modelcontextprotocol.io
Contributing
Contributions are welcome — see the
contributing instructions.
Thanks to all the
contributors
who have helped build bankstatementparser-mcp.
Related MCP Servers
The four core servers of the ISO 20022 MCP Suite are compared in The ISO 20022 MCP Suite above. The wider family — open-source, Apache-2.0 licensed MCP servers for banking and financial-services AI agents — also includes:
Server | Purpose |
Generate & validate ISO 20022 pain.001 payment files (v03–v12, pain.008, SEPA) with rulebook checks | |
Generate, validate, parse & scheme-check ISO 20022 pacs.008 FI-to-FI credit transfers + Nov-2026 address linting | |
Generate & validate ISO 20022 acmt account-management messages | |
Lossless YAML 1.2 parsing, formatting & validation (Rust, 100% spec compliance) |
MCP Registry
mcp-name: io.github.sebastienrousseau/bankstatementparser-mcp
Ecosystem
bankstatementparser is part of a modular financial ecosystem. Optional companion packages provide specialized loaders, writers, AI agents, language servers, and transport protocol adapters:
Package | GitHub Repository | PyPI | Role | Description |
|
| Core Engine | Unified parser for CAMT (052/053), PAIN.001, CSV, OFX, QFX, MT940, and PDF statements | |
|
| AI Protocol | Model Context Protocol (MCP) server exposing statement tools to LLMs & AI agents | |
|
| Developer Tooling | Language Server Protocol (LSP) with live SWIFT MT940 statement validation & diagnostics | |
|
| Transport | Automated bank statement retrieval over EBICS 3.0 ( | |
|
| Output Writer | Formats and exports parsed banking transactions into styled Microsoft Excel ( | |
|
| Output Writer | Serializes transactions into standard Quicken Interchange Format ( | |
|
| Output Writer | Serializes transactions into standard Open Financial Exchange ( | |
|
| Output Writer | Exports transactions to SWIFT MT940 customer statements and MT942 interim reports | |
|
| Input Loader | Parses BAI2 cash-management and account balance statements | |
|
| Input Loader | Parses SWIFT MT942 interim transaction reports with credit/debit summary reconciliation | |
|
| Input Loader | Parses French CFONB 120 / AFB120 120-byte fixed-width banking statement files | |
|
| Input Loader | Ingests ISO 20022 CAMT.054 real-time debit/credit notification stream XML | |
|
| Input Loader | Ingests ISO 20022 SEPA PAIN.002 payment status reports and PAIN.008 direct debit mandates | |
|
| Input Loader | Parses UK BACS Standard 18 / Faster Payments 106-byte fixed-width transmission files |
License
Licensed under the Apache License, Version 2.0. Any contribution submitted for inclusion shall be licensed as above, without additional terms.
Available Tools
5 toolsdetect_formatDetect statement formatARead-onlyIdempotent
Detect which bank statement format an inline payload is.
Use this when you hold statement text but do not yet know its format,
to resolve the ``format`` identifier from the content plus filename
hint. Once the format is known, call ``parse_statement`` to read the
transactions instead of calling this again.
Args:
content: The raw statement text.
filename: Original filename; its extension is the primary hint.
Returns:
The detected format identifier.
Raises:
ToolError: If the format cannot be detected.
Inputs: content (required), filename. Returns: result
list_supported_formatsList supported statement formatsARead-onlyIdempotent
List every bank statement format identifier this server can parse.
Use this first to discover the valid ``format`` strings before calling
``detect_format`` or ``parse_statement``. For the file extensions and a
human-readable description of each format, read the
``bankstatementparser://formats`` resource instead.
Returns:
The supported format identifiers.
Inputs: no named parameters. Returns: result
parse_statementParse statement transactions and summaryARead-onlyIdempotent
Parse an inline statement payload into transaction rows and a summary.
Use this to read the full transaction detail plus the statement
balances from a payload. When you only need the balances/totals use
``summarize_statement`` instead, and to merely confirm a payload parses
without returning any rows use ``validate_statement``.
Args:
content: The raw statement text.
filename: Original filename; its extension selects the format
when ``format`` is omitted.
format: Explicit format override.
limit: Optional cap on returned transaction rows.
Returns:
A dict with the resolved ``format``, ``columns``, full
``transaction_count``, the (possibly truncated) ``transactions``
as row dicts, and the statement ``summary``.
Raises:
ToolError: If the format is unsupported, cannot be detected, or
the payload does not parse.
Inputs: content (required), limit, format, filename. Returns: object
summarize_statementSummarize statement balancesARead-onlyIdempotent
Summarize an inline statement's balances and totals only.
Use this when you need just the opening/closing balances, currency, and
other summary fields without the per-transaction rows. For the full
transaction detail alongside the summary, use ``parse_statement``
instead.
Args:
content: The raw statement text.
filename: Original filename; its extension selects the format.
format: Explicit format override.
Returns:
The summary record with Decimal values stringified.
Raises:
ToolError: If the format is unsupported, cannot be detected, or
the payload does not parse.
Inputs: content (required), format, filename. Returns: object
validate_statementValidate statement (dry run)ARead-onlyIdempotent
Dry-run parse an inline statement to check it parses cleanly.
Use this to confirm a payload is well-formed and parseable before
committing to a full read; it returns a structured pass/fail with the
transaction count but never the rows themselves, and never raises on a
parse error. To actually read the transactions use ``parse_statement``.
Args:
content: The raw statement text.
filename: Original filename; its extension selects the format.
format: Explicit format override.
Returns:
A dict with ``is_valid``, the resolved ``format``, the
``transaction_count`` on success, and an ``error`` on failure.
Inputs: content (required), format, filename. Returns: object
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
A4.4/5.0
Scored across 5 tools
Disambiguation4/5
Each tool targets a distinct action (detect, parse, summarize, list, validate), and descriptions explicitly cross-reference each other to steer selection. Minor overlap exists because parse_statement also resolves formats and validate_statement is effectively a dry-run parse, but the boundaries are clearly articulated.
Naming Consistency5/5
All five tools follow a clean verb_noun snake_case pattern (detect_format, parse_statement, summarize_statement, list_supported_formats, validate_statement) with no stylistic deviations.
Tool Count5/5
Five tools is a tight, well-scoped set for an inline statement parser, with each tool earning its place across detection, discovery, full parsing, summarizing, and validation.
Completeness4/5
The surface covers the full inline workflow: discovering formats, detecting, validating, parsing rows, and summarizing balances. Gaps are minor, such as no file/URL ingestion path, but that appears outside the stated inline-payload scope.
Maintenance
ActivityActive
ResponsivenessNo recent community issues
Related MCP Connectors
Model Context Protocol server for the Apideck Unified API. Connect any MCP-compatible agent framework to 100+ accounting systems, HRIS platforms, file storage providers, and more through one integration. More information https://www.apideck.com/mcp-server
A Model Context Protocol server for Wix AI tools
Model Context Protocol server for Studex tools, notifications, and profile integrations
A comprehensive Model Context Protocol (MCP) server that enables AI assistants to interact with yo…
Related MCP Servers
- AlicenseAqualityDmaintenanceA Model Context Protocol server providing tools for DB queries, API calls, file I/O, and text transformations, enabling AI agents like Claude to perform real-world actions.10MIT
- AlicenseNot gradedqualityDmaintenanceModel Context Protocol server that standardizes tool discovery, execution, and context management for AI applications.MIT
Cerevox MCP Serverofficial
AlicenseNot gradedqualityDmaintenanceModel Context Protocol server for Cerevox AI that exposes document parsing (Lexa), RAG and semantic search (Hippo), and account management APIs, enabling AI agents to parse documents, search and query document collections with RAG, and manage accounts.13 PyPIMIT