Cazuri de utilizare

Bank Statement Parser gestionează fluxuri de lucru financiare reale: ingestie de extrase bancare PDF, migrare MT940-la-CAMT, reconciliere automată cu verificarea soldului, pipeline-uri de conformitate, export pentru contabilitate în text simplu, implementări REST API, scanare în masă și consolidare multi-bancă.

Ingestie extrase bancare PDF

Rezultat: Parsați extrase bancare PDF digitale și scanate cu verificare automată a soldului — fără API-uri cloud, nicio dată nu părăsește mașina.

Pipeline-ul hibrid PDF rutează fiecare PDF prin calea optimă de extracție și verifică fiecare rezultat.

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

Procesare extrase în masă

Rezultat: Scanați arbori întregi de foldere (sute de PDF-uri, XML-uri, CSV-uri) cu deduplicare automată între fișiere, într-un singur apel.

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

Trezorerie: migrare MT940 la CAMT.053

Rezultat: Un singur apel API gestionează atât MT940, cât și CAMT.053 în timpul ferestrei de migrare SWIFT (noiembrie 2025–noiembrie 2028), eliminând nevoia de pipeline-uri de parsare separate.

Echipele de trezorerie din întreaga lume migrează de la MT940 la CAMT.053 înainte de termenul SWIFT din noiembrie 2027. Bank Statement Parser gestionează ambele formate cu un singur API, făcând tranziția simplă.

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)

Reconciliere automată cu verificarea soldului

Rezultat: DataFrames independente de format cu verificare prin Regula de Aur și deduplicare detectează erorile și duplicatele înainte de a ajunge în registru.

Parsați extrase bancare, verificați soldurile și potriviți automat cu înregistrările interne.

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)

Contabilitate în text simplu (hledger / beancount)

Rezultat: Ingestie automată a extraselor bancare PDF și export al tranzacțiilor categorizate în format jurnal hledger sau 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")

Implementare REST API

Rezultat: Implementați Bank Statement Parser ca microserviciu care acceptă fișiere de extrase prin HTTP și returnează JSON structurat.

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

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

Pipeline-uri de conformitate și audit

Rezultat: Ieșirea deterministă, redactarea automată a PII și verificarea prin Regula de Aur produc jurnale pregătite pentru audit care îndeplinesc cerințele de reproductibilitate reglementară.

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

Fluxuri SFTP-to-DataFrame

Rezultat: Parsați direct din octeți cu zero I/O pe disc, integrându-se nativ în fluxurile de conectivitate bancară bazate pe SFTP și 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()

Consolidare multi-bancă

Rezultat: Parsarea paralelă a extraselor de la HSBC (CAMT), Barclays (MT940), Revolut (CSV), Wise (OFX) și Chase (PDF) produce un singur set de date normalizat.

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

Procesare în loturi cu arhive ZIP

Rezultat: Protecția încorporată împotriva ZIP bomb (limită de raport 100:1, limită de 10 MB pe intrare, respingere a intrărilor criptate) permite procesarea în siguranță a arhivelor lunare de extrase.

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)

Comparați cu alternative ❯ | Planificați migrarea ISO 20022 ❯ | Începeți ❯