Banks open APIs under PSD2, but raw transactions are noise. Without a model, they are just a CSV dump, not a tool for lending or personal finance. We turn Open Banking data into ready-to-use ML models and product features: from categorization to scoring. Our transaction analysis goes beyond MCC categorization, enabling personalized financial recommendations based on spending patterns. A typical project costs $80,000 and yields annual savings of $100,000. Clients report operational savings of 25% or more.
Problems we solve
Raw transactions contain garbage: duplicates, incorrect merchant names, gaps. Standard MCC codes don't differentiate between "coffee" and "lunch" — both fall under Dining. AI categorization using NLP distinguishes 50+ categories with 92% accuracy, twice as good as MCC. The second layer is scoring: without Open Banking, a thin-file borrower gets no credit despite stable cash flow. We verify income from inflows, calculate affordability based on real expenses.
How the AI model processes transactions in real time?
The categorization model runs as a microservice: transactions arrive via Kafka in batches of 1000. We use ONNX Runtime for inference — p99 latency <30ms. Fine-tuning on all-MiniLM-L6-v2 yields 768-dim embeddings; training takes 2 hours on a single A100. The model is trained on 50,000 labeled transactions per language. Multi-label allows classifying "taxi" as both Transport and Business if the trip occurs during work hours. This accuracy is critical for predictive cash flow and scoring.
How do Open Banking data improve scoring accuracy?
Traditional scoring only sees credit history. Open Banking reveals actual cash flow: salary, rent, subscriptions, savings. The ML model analyzes volatility — income stability, seasonality. For SMEs, cash flow lending without accounting reports: credit based on account turnover. Scoring accuracy with Open Banking is 30% higher than with credit bureaus alone. This also enhances transaction analysis and affordability assessment.
Why is AI categorization better than standard MCC?
MCC is a coarse directory assigned by the acquirer's bank. A single transaction may be "Restaurant" but is it a coffee shop or business lunch? An NLP categorizer based on merchant name + amount + time of day achieves 92% accuracy. Multi-label: "taxi" can be both Transport and Business if during work hours. Such data feeds PFM recommendations and scoring models. This advanced transaction categorization is key to our AI system.
| Approach | Accuracy | Number of categories | Data source |
|---|---|---|---|
| MCC | 45% | ~30 | Acquiring bank |
| NLP (TF-IDF) | 70% | ~50 | Merchant name |
| NLP (Transformer) | 92% | 50+ | Merchant name + amount + time |
How we do it: stack and configs
The core is an Open Banking aggregator. We don't write parsers for each bank — we use a ready-made layer:
| Aggregator | Geography | Strengths |
|---|---|---|
| Plaid | US, Europe | Developer-friendly, rich data set |
| Salt Edge | Global | 5000+ banks, single API |
| TrueLayer | UK/EU | Optimized for PSD2, Fast |
| Tink | Europe | BankID integration, consent management |
Security — FAPI (Financial-grade API): OAuth 2.0 + PKCE, JWT signed/encrypted, mutual TLS. Consent management — strict PSD2 compliance: client revokes access in one click, data immediately deleted. We also enforce idempotency keys for safe retries and use AES-256 encryption at rest. Deployment is containerized via Docker and orchestrated with Kubernetes on AWS/GCP/Azure.
Example integration with Salt Edge:
from openbanking import OpenBankingClient
# Initialize via aggregator
client = OpenBankingClient(
client_id="your_app_id",
client_secret="your_secret",
redirect_uri="https://your-app.com/callback"
)
# User authorization
auth_url = client.get_authorization_url(scope=['accounts', 'transactions'])
# Redirect user → bank → callback with code
# Get transactions
transactions = client.get_transactions(
account_id="acc_123",
from_date="2024-01-01",
to_date="2024-12-31"
)
# ML processing
from your_ml import categorize, compute_score
categorized = categorize(transactions)
credit_score = compute_score(categorized)
Our Work Process
- Analysis: We study your business goals, select an aggregator, design the consent flow.
- Integration: Connect the Open Banking API, set up ETL for transactions using tools like Airbyte or custom pipelines.
- ML: Train categorization and scoring models on your data (few-shot), with anomaly detection via isolation forests.
- Testing: Load testing — 10k transactions/s, p99 latency <50ms, including failover scenarios.
- Deployment: Deploy in your environment, train your team on model monitoring and retraining.
What's Included in the Result
- Consent management dashboard for customers.
- ETL pipeline for transaction normalization.
- ML modules: categorization (50+ labels) and scoring (cash flow, affordability).
- API documentation and operations manual.
- Team training (2 days).
- 3 months of support.
Timeline and How to Start
Turnkey development takes from 3 to 5 months. Exact timeline depends on aggregator choice and ML model complexity. Get a consultation from an engineer — we will assess your project and show a demo on real data. Order a pilot on your data: test scoring accuracy in 2 weeks. We guarantee FAPI compliance and integration experience with 10+ platforms.
According to the Revised Payment Services Directive (PSD2), access to bank data is mandatory for payment service providers.