Cas d'utilisation

Bank Statement Parser gère les flux financiers du monde réel : ingestion de relevés bancaires PDF, migration MT940 vers CAMT, rapprochement automatisé avec vérification du solde, pipelines de conformité, export en comptabilité texte, déploiements via API REST, scan en masse et consolidation multi-banques.

Ingestion de relevés bancaires PDF

Résultat : Analysez des relevés bancaires PDF numériques et scannés avec vérification automatique du solde — sans API cloud, aucune donnée ne quitte votre machine.

Le pipeline PDF hybride achemine chaque PDF vers la voie d'extraction optimale et vérifie chaque résultat.

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

Traitement de relevés en masse

Résultat : Scannez des arborescences complètes (des centaines de PDF, XML, CSV) avec déduplication inter-fichiers automatique en un seul appel.

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}")

Trésorerie : migration MT940 vers CAMT.053

Résultat : Un seul appel API gère à la fois MT940 et CAMT.053 pendant la fenêtre de migration SWIFT (novembre 2025 – novembre 2028), supprimant le besoin de pipelines d'analyse séparés.

Les équipes de trésorerie du monde entier migrent de MT940 vers CAMT.053 avant l'échéance SWIFT de novembre 2027. Bank Statement Parser gère les deux formats avec une seule API, rendant la transition transparente.

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)

Rapprochement automatisé avec vérification du solde

Résultat : Des DataFrames indépendants du format avec vérification par la Règle d'or et déduplication détectent les erreurs et doublons avant qu'ils n'atteignent votre grand livre.

Analysez les relevés bancaires, vérifiez les soldes et comparez avec les enregistrements internes automatiquement.

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)

Comptabilité en texte brut (hledger / beancount)

Résultat : Ingérez automatiquement des relevés bancaires PDF et exportez les transactions catégorisées au format journal hledger ou beancount.

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")

Déploiement via API REST

Résultat : Déployez Bank Statement Parser comme microservice qui accepte des fichiers de relevés via HTTP et renvoie du JSON structuré.

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

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

Pipelines de conformité et d'audit

Résultat : Une sortie déterministe, le masquage automatique des données personnelles et la vérification par la Règle d'or produisent des journaux prêts pour l'audit qui répondent aux exigences de reproductibilité réglementaire.

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")

Flux SFTP vers DataFrame

Résultat : Analysez directement depuis des octets sans E/S disque, s'intégrant nativement dans les flux de connectivité bancaire SFTP et API.

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()

Consolidation multi-banques

Résultat : L'analyse parallèle de HSBC (CAMT), Barclays (MT940), Revolut (CSV), Wise (OFX) et Chase (PDF) produit un jeu de données unique et normalisé.

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"])

Traitement par lots avec archives ZIP

Résultat : La protection intégrée contre les ZIP bombs (ratio 100:1, plafond de 10 Mo par entrée, rejet des entrées chiffrées) vous permet de traiter les archives mensuelles de relevés en toute sécurité.

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)

Comparer avec les alternatives ❯ | Planifiez votre migration ISO 20022 ❯ | Commencer ❯