Anwendungsfälle

Bank Statement Parser deckt reale Finanzabläufe ab: PDF-Kontoauszugsverarbeitung, MT940-zu-CAMT-Migration, automatische Abstimmung mit Saldoprüfung, Compliance-Pipelines, Plaintext-Accounting-Export, REST API-Bereitstellungen, Massenverarbeitung und Multi-Bank-Konsolidierung.

PDF-Kontoauszugsverarbeitung

Ergebnis: Digitale und gescannte PDF-Kontoauszüge mit automatischer Saldoprüfung parsen — keine Cloud-APIs, keine Daten verlassen Ihren Rechner.

Die hybride PDF-Pipeline leitet jedes PDF über den optimalen Extraktionspfad und prüft jedes Ergebnis.

from bankstatementparser.hybrid import smart_ingest

result = smart_ingest("statement.pdf")
print(result.source_method)         # "deterministic" | "llm" | "vision"
print(result.verification.status)   # VERIFIED | DISCREPANCY | FAILED

# Review discrepancies interactively
# bankstatementparser --type review --input result.json

Massenverarbeitung von Auszügen

Ergebnis: Ganze Ordnerstrukturen (Hunderte PDFs, XMLs, CSVs) mit automatischer dateiübergreifender Deduplizierung in einem einzigen Aufruf verarbeiten.

from bankstatementparser.hybrid import scan_and_ingest

batch = scan_and_ingest("statements/2026/", pattern="**/*.pdf")
print(f"Files: {len(batch.results)}, Unique txns: {batch.unique_count}")

Treasury: MT940-zu-CAMT.053-Migration

Ergebnis: Ein einziger API-Aufruf verarbeitet sowohl MT940 als auch CAMT.053 während des SWIFT-Migrationszeitraums (November 2025–November 2028). Separate Parsing-Pipelines entfallen.

Treasury-Teams weltweit migrieren von MT940 auf CAMT.053 vor der SWIFT-Frist im November 2027. Bank Statement Parser verarbeitet beide Formate mit einer einzigen API und macht die Umstellung nahtlos.

from bankstatementparser import create_parser, detect_statement_format

# Process both MT940 and CAMT.053 with the same code
for file in daily_statement_files:
    fmt = detect_statement_format(file)
    parser = create_parser(file, fmt)
    df = parser.parse()
    load_to_treasury_system(df)

Automatische Abstimmung mit Saldoprüfung

Ergebnis: Formatunabhängige DataFrames mit Golden-Rule-Prüfung und Deduplizierung erkennen Fehler und Duplikate, bevor sie Ihr Hauptbuch erreichen.

Kontoauszüge parsen, Salden prüfen und automatisch mit internen Datensätzen abgleichen.

from bankstatementparser import CamtParser, Deduplicator
from bankstatementparser.hybrid import verify_balance_multi_currency

parser = CamtParser("bank_statement.xml")
bank_txns = parser.parse()

# Verify balances per currency
verification = verify_balance_multi_currency(bank_txns)
for ccy, result in verification.items():
    assert result.status == "VERIFIED", f"{ccy} balance mismatch!"

# Deduplicate before reconciliation
dedup = Deduplicator()
result = dedup.deduplicate(dedup.from_dataframe(bank_txns))
clean_txns = result.unique_transactions

# Match against internal records
unmatched = reconcile(clean_txns, internal_ledger)

Plaintext Accounting (hledger / beancount)

Ergebnis: PDF-Kontoauszüge automatisch einlesen und kategorisierte Transaktionen in hledger- oder beancount-Journalformat exportieren.

from bankstatementparser.hybrid import smart_ingest
from bankstatementparser.enrichment import Categorizer
from bankstatementparser.export import to_hledger

result = smart_ingest("statement.pdf")
categorizer = Categorizer()
enriched = categorizer.categorize_batch(result.transactions)
journal = to_hledger(enriched, account="Assets:Bank:Checking")

REST API-Bereitstellung

Ergebnis: Bank Statement Parser als Microservice bereitstellen, der Auszugsdateien per HTTP entgegennimmt und strukturiertes JSON zurückgibt.

# Start the API server
bankstatementparser-api --port 8000

# Ingest a statement
curl -X POST http://localhost:8000/ingest \
  -F "file=@statement.pdf"

Compliance- und Audit-Pipelines

Ergebnis: Deterministische Ausgabe, automatische PII-Schwärzung und Golden-Rule-Prüfung erzeugen prüfungssichere Protokolle, die regulatorische Reproduzierbarkeitsanforderungen erfüllen.

from bankstatementparser import CamtParser

parser = CamtParser("statement.xml")

# Stream with PII redacted for audit logs
for txn in parser.parse_streaming(redact_pii=True):
    audit_log.write(txn)

# Export full data for secure internal processing
parser.export_csv("archive/statement.csv")

SFTP-zu-DataFrame-Workflows

Ergebnis: Direkt aus Bytes parsen, ohne Festplatten-I/O — passt nahtlos in SFTP- und API-gesteuerte Bankkonnektivitäts-Workflows.

from bankstatementparser import CamtParser

xml_bytes = sftp_client.read("daily_statement.xml")
parser = CamtParser.from_bytes(xml_bytes, source_name="daily.xml")
df = parser.parse()

Multi-Bank-Konsolidierung

Ergebnis: Paralleles Parsing von HSBC (CAMT), Barclays (MT940), Revolut (CSV), Wise (OFX) und Chase (PDF) erzeugt einen einzigen normalisierten Datensatz.

from bankstatementparser import parse_files_parallel

results = parse_files_parallel([
    "hsbc/camt053.xml",
    "barclays/mt940.sta",
    "revolut/transactions.csv",
    "wise/statement.ofx",
])

all_transactions = pd.concat([r.transactions for r in results if r.status == "success"])

Stapelverarbeitung mit ZIP-Archiven

Ergebnis: Integrierter ZIP-Bomb-Schutz (100:1-Verhältnislimit, 10 MB Eintrags-Obergrenze, Ablehnung verschlüsselter Einträge) ermöglicht die sichere Verarbeitung monatlicher Auszugsarchive.

from bankstatementparser import iter_secure_xml_entries, CamtParser

for entry in iter_secure_xml_entries("monthly_statements.zip"):
    parser = CamtParser.from_bytes(entry.xml_bytes, source_name=entry.source_name)
    df = parser.parse()
    save_to_warehouse(entry.source_name, df)

Mit Alternativen vergleichen ❯ | Ihre ISO 20022-Migration planen ❯ | Erste Schritte ❯