Bank Transaction Fraud Detection Using Random Forest — Complete Documentation & Simulation

Overview & System Context

Bank Transaction Fraud Detection Using Random Forest: Comprehensive Web-Sourced Technical Investigation Exhaustive Research Dossier · Pure Web-Scraped Content: ~2732 Words · Real Software Screenshots: 3 1. Executive Overview & Technical Background The expansion of digital payment systems has heightened both the scale and intricacy of online financial transactions, thereby increasing vulnerability to fraudulent activities. Detecting fraud effectively is complicated by the changing nature of attack strategies and the significant disparity between genuine and fraudulent transactions. This research introduces a machine learning-based fraud detection framework utilizing the PaySim synthetic financial transaction dataset. Following the CRISP-DM methodology, the study includes hypothesis-driven exploratory analysis, feature refinement, and a comparative assessment of baseline models such as Logistic Regression and tree-based classifiers like Random Forest, XGBoost, and Decision Tree. To tackle class imbalance, SMOTE is employed, and model performance is enhanced through hyperparameter tuning with GridSearchCV. The proposed framework provides a robust and scalable solution to enhance fraud prevention capabilities in FinTech transaction systems.

The rapid proliferation of digital payment systems and e-commerce platforms has significantly transformed the global financial landscape, facilitating millions of transactions daily while concurrently heightening susceptibility to financial fraud. As transaction volumes increase, fraudulent activities have become more prevalent and sophisticated, posing substantial risks to consumers, merchants, and FinTech companies. In 2023, global losses from online payment and e-commerce fraud were estimated at US$48 billion with payment-card fraud alone accounting for about US$33.8 billion. It is further estimated that nearly 3–4% of all digital transactions worldwide may be fraudulent, underscoring the magnitude of the issue. Traditional rule-based fraud detection systems struggle to adapt to evolving fraud strategies and are further constrained by the highly imbalanced nature of financial transaction data, where fraudulent cases are infrequent. This imbalance often results in suboptimal detection performance and elevated false-positive rates.

To address these challenges, this project proposes a machine learning–based fraud detection framework utilizing the PaySim synthetic transaction dataset and adhering to the CRISP-DM (Cross-Industry Standard Process for Data Mining) methodology . Multiple classification models—including Logistic Regression, Decision Tree, Random Forest, and XGBoost—are evaluated, with SMOTE applied to enhance minority-class representation. Model performance is primarily assessed using the F1 score, and the best-performing model is further optimized using GridSearchCV to develop a robust and scalable fraud detection system suitable for FinTech environments.

The detection of financial fraud has evolved from static, rule-based systems to data-driven machine learning methodologies. This shift addresses the increasing complexity, adaptability, and data imbalance characteristic of fraudulent activities, with behavioral modeling playing a pivotal role in contemporary approaches. Kumar et al. (2022) illustrate that integrating behavioral features—such as transaction frequency, timing, and spending deviations—greatly enhances detection accuracy by identifying subtle anomalies in user behavior.

Figure 1: Credit Card Fraud Detection Using Machine Learning Techniques Major challenges in fraud detection, such as class imbalance, feature sparsity, and concept drift, stressing the need for preprocessing strategies like resampling, cost-sensitive learning, and adaptive model updates to ensure robustness in operational settings. A significant body of research identifies ensemble learning as a leading method for fraud detection in imbalanced datasets. Further emphasizing the importance of temporal and relational data, Cochrane et al. (2021) analyze transaction streams to extract structured and hypothesis-driven features. Their research underscores the added value of contextual information—for example, sequences of transactions and relational links between entities—that help anticipate fraudulent actions earlier than conventional methods.

Fan and Boonen (2025) and kumar et al. (2020) demonstrate that tree-based ensemble models, including Random Forests and XGBoost, consistently outperform linear and kernel-based classifiers, especially when used with SMOTE-based oversampling techniques. These findings are supported by Bhattacharyya et al. (2011) , whose comparative study underscores the superior predictive capability of ensemble methods for credit card fraud detection. Makki et al. (2019) and Achary and Shelke (2023) further confirm that imbalance-aware learning strategies improve minority class recognition while reducing false positives. Boosting and cost-sensitive frameworks have gained traction due to their ability to explicitly prioritize fraudulent instances during training. Bala et al. (2024) show the effectiveness of XGBoost for online fraud detection, while Randhawa et al. (2018) propose cost-sensitive boosting algorithms that adaptively reweight misclassification costs to enhance fraud recall. These approaches build on the foundational work of Sun et al. (2007) , who established cost-sensitive boosting as a principled solution for imbalanced classification problems. Varmedja et al. (2019) add to these insights with their comprehensive survey that categorizes ML approaches into supervised, unsupervised, and hybrid methods, emphasizing the ongoing relevance of SMOTE and ensemble classifiers, particularly random forests. Recent research extends fraud detection beyond static tabular modeling by incorporating temporal and relational dependencies.

Zhang et al. (2025) introduce graph neural network-based methods that capture complex user interactions and fraud communities, enabling the detection of coordinated and organized fraud schemes. Maniraj et al. (2019) focus on ensemble designs aimed at maximizing fraud recall, while V. and R. (2012) demonstrate that classical classifiers such as SVMs remain effective when enhanced with behavior-driven feature engineering.

Figure 2: UPI Fraud Detection System Python ML Project Source Code From 2024 onward, the literature increasingly emphasizes deep learning and hybrid architectures to address temporal dynamics and concept drift. Feng (2025) proposes a BiLSTM–Transformer framework that significantly improves fraud recall in mobile banking environments. Btoush et al. (2025) show that stacking deep feature extractors with gradient boosting and explainability mechanisms enhances minority class precision on highly imbalanced datasets. Similarly, Tsai (2025) , R and P (2024) , and Khosravi et al. (2023) demonstrate that attention-enhanced and sequence-aware models outperform traditional ML approaches in detecting low-frequency and evolving fraud patterns.

This study employs the CRISP-DM framework to analyze and model fraudulent financial transactions through its six stages: Business Understanding, Data Understanding, Data Preparation, Modeling, Evaluation, and Deployment. This structured methodology ensures alignment with industry best practices. The primary aim is to develop a robust fraud detection system that achieves high recall with acceptable precision, learns behavioral patterns of fraudulent activity, addresses class imbalance and noisy data, and provides interpretable insights to support risk analysis.

We have used the Kaggle dataset “Synthetic Financial Datasets For Fraud Detection” generated by the PaySim mobile money simulator. The dataset includes a wide range of features such as transaction amount, transaction type, time of transaction, sender and receiver’s bank account details, etc. This dataset has 10 parameters and nearly 600,000 transactions. The outcome variable is a binary label indicating whether a transaction is fraudulent (1) or legitimate (0). The primary challenge is the significant class imbalance: only 8,213 fraudulent cases (0.129%) exist among 6,362,620 legitimate transactions.

Figure 3: How to use machine learning for fraud detection | Miquido Blog 2. System Architecture & Core Working Principles H1 - High-Value Transactions: The transaction amount is positively correlated with the likelihood of fraud. Fraudsters exploit high-value transfers to maximize the monetary gain before detection.

H2 - Transaction Type Risk: Fraud is concentrated in TRANSFER and CASHOUT transaction types. These types allow for quick fund movement and conversion to cash, facilitating illegal liquidity extraction. H3 - Mule Account Networks: Recipient accounts that frequently appear in fraudulent transactions suggest “mule” accounts—intermediaries for channeling illicit funds through fraud networks.

Univariate analysis indicated that fraudulent activities were solely found in the TRANSFER 49.86% and CASHOUT (50.14%) categories, with no instances of fraud in other transaction types, thus supporting Hypothesis 2 and suggesting a sequential fraud pattern where funds are transferred and then withdrawn. The analysis of class distribution highlighted a significant imbalance, with fraudulent transactions making up just 0.129% of the total (a ratio of 1:775).

Additionally, correlation analysis revealed a positive link between the amount of the transaction and the likelihood of fraud, which supports Hypothesis 1. After evaluating their empirical variance and predictive value, four features were removed: step, nameOrig, nameDest, and isFlaggedFraud. In the PaySim dataset, the step feature acts as a monotonically increasing temporal index that systematically cycles through all transactions, showing no significant separation between classes. Fraudulent and non-fraudulent transactions are almost evenly distributed across its range, with nearly identical class-wise means and standard deviations.

Similarly, isFlaggedFraud remains nearly constant ( ≈ \approx 0 for most records), leading to almost zero variance and offering no additional information beyond the target label, making it redundant and potentially problematic due to multicollinearity and noise. On the other hand, nameOrig and nameDest are raw account identifiers that would need aggregation or graph-based transformations to be informative, as they do not inherently encode stable behavioral patterns.

As a result, the final feature set retained six predictors: type (categorical transaction category), amount (numeric transaction value), oldbalanceOrg and newbalanceOrig (sender’s balances before and after the transaction), and oldbalanceDest and newbalanceDest (recipient’s balances before and after the transaction). Categorical encoding was applied using scikit-learn’s LabelEncoder, converting transaction types into integer values (CASH-IN → \rightarrow 0, CASH-OUT → \rightarrow 1, DEBIT → \rightarrow 2, PAYMENT → \rightarrow 3, TRANSFER → \rightarrow 4).

The dataset was then divided using stratified random sampling with a 90:10 train-test split. This stratification produced an X_train of shape (5,726,358, 6) with Y_train having 5,718,966 non-fraud (0) and 7,392 fraud (1) samples, and an X_test of shape (636,262, 6) with Y_test containing 635,441 non-fraud (0) and 821 fraud (1) samples, preserving the original fraud prevalence rate of 0.12%.

3. Software Implementation, Frameworks & Protocols To establish performance benchmarks and identify the best candidate for hyperparameter tuning, four baseline classification algorithms were assessed on the imbalanced training dataset: Logistic Regression was applied using L-BFGS optimization (max_iter=1000) to create a linear baseline and define interpretable decision boundaries.

Decision Tree Classifier (max_depth=None, random_state=42) was used to capture non-linear feature interactions and establish interpretable decision rules. Random Forest (n_estimators=15, random_state=42) was evaluated to utilize ensemble bagging for variance reduction and better generalization.

XGBoost (max_depth=3, learning_rate=0.1, random_state=42) was configured with native class weighting capability via scale_pos_weight to address the imbalance. In order to tackle the significant class imbalance, SMOTE was applied solely to the training dataset. This technique generated synthetic samples of the minority class through k-nearest neighbors interpolation, effectively altering the original imbalance ratio of about 755:1 to a balanced 1:1. The Random Forest model was then trained on this SMOTE-adjusted data, utilizing 15 estimators, parallel processing, and a fixed random seed to ensure the results could be replicated.

The Random Forest classifier underwent hyperparameter tuning via grid search, employing stratified 3-fold cross-validation on the SMOTE-adjusted training data. The search space encompassed crucial parameters such as : n_estimators (50, 100), max_depth (None, 10), min_samples_split (2), min_samples_leaf (1, 2), max_features (‘sqrt’), and class_weight (‘balanced’), resulting in 16 potential configurations.

Class_weight=’balanced’ specifically modified the penalty for misclassification costs to ensure that errors involving fraud cases are penalized more severely than those involving legitimate cases, even after SMOTE oversampling. The F1-score served as the optimization metric to balance precision and recall in the context of class imbalance. Stratification maintained class distribution across the folds, and the optimal model utilized class-weighted learning to enhance the SMOTE-based resampling before the final evaluation.

Logistic Regression achieved an accuracy of 99.91%; however, the model’s ability to detect fraud was limited, with a recall of just 0.43% and an F1-score of 0.57, indicating a significant bias towards the majority class despite the high overall accuracy. Decision Tree Classifier (max_depth=None, random_state=42) showed a marked improvement with a 97% fraud recall and an F1-score of 0.84, though the unrestricted tree depth raises concerns about overfitting on the large training set.

Random Forest (n_estimators=15, random_state=42) achieved the highest F1-score of 0.87, along with outstanding fraud precision (97%) and a 79% recall, indicating an effective balance between precision and recall for the severe class imbalance issue. 4. Practical Deployment, Analysis & Case Studies XGBoost (max_depth=3, learning_rate=0.1, random_state=42) achieved a competitive ROC-AUC (0.96) and precision (98%); however, XGBoost showed lower recall (70%) and an F1-score of 0.82 compared to Random Forest.

Random Forest was selected as the champion baseline model with the highest F1-score of 0.87. To achieve a roughly equal class distribution in the training data, SMOTE was employed, increasing the dataset from 5.7 million to 11.4 million samples by creating synthetic examples of the minority class. This approach ensured adequate representation of the minority class during model training and mitigated bias towards the majority class.

The findings revealed that the enhanced Random Forest model achieved an accuracy of 99.97%, a fraud precision of 92%, a fraud recall of 90%, and an F1-score of 0.91, significantly surpassing the baseline imbalanced model, demonstrating that the dual combination of SMOTE oversampling and hyperparameter optimization substantially enhanced fraud detection performance by addressing both data-level imbalance and algorithm-level bias.

This study illustrates that combining Random Forest with SMOTE and hyperparameter optimization is highly effective in identifying fraud within significantly imbalanced financial datasets, achieving an impressive 99.97% accuracy and an F1-score of 0.91, which greatly exceeds the performance of baseline models. In operational FinTech settings, it is crucial that the model provides risk scores quickly to prevent delays in real-time transaction approvals. The Random Forest can be implemented as a scalable API microservice, capable of evaluating precomputed features such as type, amount, and balances in milliseconds, while managing peak demands through horizontal scaling.

In adversarial situations such as fraud injection, where attackers test decision boundaries or alter patterns (such as dividing high-value transfers), the system needs ongoing drift monitoring, regular retraining, and hybrid protections that integrate machine learning with rule-based overrides to ensure robustness. Future research should explore temporal modeling (using LSTM/Transformers), multimodal features (like device and geolocation data), and causal inference to improve real-world performance. Additionally, hybrid ensembles that combine machine learning, rules, and domain expertise should be developed to balance fraud prevention with customer experience.

Tools for explainability, such as SHAP or LIME, can further guarantee transparency, regulatory compliance, and expert validation of significant feature contributions. I am deeply grateful to Indira Gandhi Delhi Technical University for Women for offering a supportive and encouraging atmosphere. I also wish to extend my thanks to Dr. Ritesh Yaduwanshi, whose guidance, expertise, and unwavering support were instrumental in the success of this research.

An end-to-end data science and machine learning pipeline designed to detect fraudulent financial transactions. This repository demonstrates how advanced analytics, feature engineering, and class-imbalance techniques can be leveraged to mitigate monetary risk and secure banking ecosystems. Financial fraud costs institutions billions of dollars annually. This project implements a robust binary classification framework to identify suspicious transactions out of highly imbalanced banking data.

By analyzing transactional behaviors, account balances, and historical flags, the machine learning models built here optimize the trade-off between capturing maximum fraud (Recall) and minimizing disruptions to legitimate customers (Precision). 5. Performance Evaluation & Extended Technical Observations Compared three distinct algorithmic approaches to discover the optimal decision boundary: Standard accuracy is highly misleading in fraud analytics. Instead, this system evaluates performance using: I End-to-end Machine Learning pipeline to detect fraudulent banking transactions in real-time. Built using Python, Random Forest, and XGBoost to handle extreme data imbalance. I ML-powered fraud detection on 28K+ banking transactions | Python · SQL · Power BI · Random Forest · XGBoost End-to-end machine learning pipeline for detecting fraudulent banking transactions and payment anomalies — built with real-world banking domain expertise.

This project analyses 28,000+ banking transaction records to detect fraud patterns, payment anomalies, and reconciliation gaps. Built from the perspective of a banking operations professional, it mirrors the data quality and fraud management challenges faced by real financial institutions. Business Problem: Financial institutions lose billions annually to payment fraud. Manual detection is slow, inconsistent, and misses complex patterns. This project builds an automated ML detection pipeline that identifies fraudulent transactions with 92% accuracy.

4+ years of banking operations experience (SBI Cards, Federal Bank) now channelled into data analytics and IT delivery. ML-powered fraud detection on 28K+ banking transactions | Python · SQL · Power BI · Random Forest · XGBoost A comprehensive fraud detection system for bank transactions using Random Forest classification. Achieves 99.87% accuracy and 89.66% precision on highly imbalanced data (210:1 ratio) through advanced preprocessing techniques including SMOTE and feature engineering.

This project tackles the critical challenge of detecting fraudulent transactions in Paris bank accounts using machine learning. With fraud representing only 0.47% of transactions, the system employs sophisticated techniques to identify fraudulent patterns while minimizing false alarms. Financial fraud is a critical global issue affecting millions of transactions daily. This project addresses: Harvested Online Documentation & Reference Sources • https://arxiv.org/html/2604.07952v1 • https://github.com/Tejaschalamp/Bank-Fraud-Detection-Model • https://github.com/Miranwara99/banking-fraud-detection • https://github.com/stupidtallguy/bank-fraud-detection-ml