Using QR Codes for Payment Card Fraud Detection

Abstract

Debit and credit card payments have become the preferred method of payment for consumers, replacing paper checks and cash. However, this shift has also led to an increase in concerns regarding identity theft and payment security. To address these challenges, it is crucial to develop an effective, secure, and reliable payment system. This research presents a comprehensive study on payment card fraud detection using deep learning techniques. The introduction highlights the significance of a strong financial system supported by a quick and secure payment system. It emphasizes the need for advanced methods to detect fraudulent activities in card transactions. The proposed methodology focuses on the conversion of a comma-separated values (CSV) dataset into quick response (QR) code images, enabling the application of deep neural networks and transfer learning. This representation allows leveraging pre-trained image-based architectures to provide a layer of privacy by encoding numeric transaction attributes into visual patterns. The feature extraction process involves the use of a convolutional neural network, specifically a residual network architecture. The results obtained through the under-sampling dataset balancing method revealed promising performance in terms of precision, accuracy, recall, and F1 score for the traditional models such as K-nearest neighbors (KNN), Decision tree, Random Forest, AdaBoost, Bagging, and Gaussian Naive Bayes. Furthermore, the proposed deep neural network model achieved high precision, indicating its effectiveness in detecting card fraud. The model also achieved high accuracy, recall, and F1 score, showcasing its superior performance compared to traditional machine learning models. In summary, this research contributes to the field of payment card fraud detection by leveraging deep learning techniques. The proposed methodology offers a sophisticated approach to detecting fraudulent activities in card payment systems, addressing the growing concerns of identity theft and payment security. By deploying the trained model in an Android application, real-time fraud detection becomes possible, further enhancing the security of card transactions. The findings of this study provide insights and avenues for future advancements in the field of payment card fraud detection.

1. Introduction

Payment card fraud continues to pose a significant challenge for financial institutions, merchants, and consumers, generating substantial economic losses each year and supporting broader criminal activities such as organized crime and terrorism [1,2,3,4,5,6,7]. As digital transactions expand and cashless systems become more prevalent, the need for accurate, scalable, and adaptive fraud detection systems has become increasingly urgent. Traditional machine-learning techniques have played an important role in this domain, relying on historical transaction patterns and engineered features to distinguish legitimate behavior from fraudulent activity. Although these techniques have achieved notable success, their performance is often constrained by the quality of handcrafted features, the extreme imbalance between fraudulent and non-fraudulent cases, and the continual evolution of fraud strategies [8,9,10,11,12,13,14,15].

Deep learning offers a promising alternative by enabling models to automatically learn discriminative patterns directly from the data, reducing the dependence on manual feature engineering. However, most existing deep-learning approaches for fraud detection still operate on tabular data and are therefore limited in their ability to exploit the representational advantages found in image-based neural architectures. Despite the widespread success of convolutional neural networks and transfer learning in computer vision tasks, their potential application in financial fraud detection remains largely unexplored. This gap suggests an opportunity to investigate whether transforming transaction data into structured visual forms can unlock new representational strengths and improve classification performance.

To address this question, the present study proposes a novel approach in which CSV-based credit card transaction records are converted into QR-code images that serve as inputs to a deep residual network. By representing transactions visually rather than numerically, the model can capitalize on the hierarchical feature-extracting capabilities of convolutional architectures, capturing complex, nonlinear relationships that may not be evident in a traditional tabular format. This work further examines the influence of class-balancing strategies, including SMOTE oversampling and random under-sampling, on the performance of both deep learning and traditional machine-learning models. The proposed framework is additionally validated through deployment in an Android application, demonstrating its potential for real-time fraud detection in mobile environments.

The rest of the manuscript proceeds as follows. Section 2 reviews related work on traditional and deep-learning-based fraud detection methods and situates the present study within that literature. Section 3 describes the dataset, preprocessing procedures, QR transformation process, and model architecture. Section 4 presents the experimental design and results. Section 5 discusses the implications and limitations of the findings, and Section 6 concludes the paper with recommendations for future research.

2. Literature Review

Credit card fraud detection has been extensively explored across multiple strands of research, beginning with traditional machine-learning approaches and gradually extending toward more sophisticated deep-learning techniques. Early studies primarily relied on supervised learning algorithms such as logistic regression, decision trees, random forests, support vector machines, and K-nearest neighbors to classify transactions based on structured tabular features [16,17,18,19,20,21,22,23,24,25]. These models demonstrated competitive baseline performance and, in many cases, were sufficiently efficient for large-scale deployment. Their effectiveness, however, depends heavily on the quality of manually engineered features and the ability of practitioners to craft representations that meaningfully capture behavioral irregularities. As several authors have noted, feature engineering is both labor-intensive and prone to error, and it may fail to generalize as fraud patterns evolve over time [15]. Traditional models also struggle with severe class imbalance, a hallmark of fraud detection datasets where fraudulent cases represent only a small fraction of transactions [8,14]. Although various rule-based and hybrid systems have attempted to mitigate these challenges [20,21], their performance remains constrained by the inherent limitations of tabular feature representations.

With the emergence of deep learning, the field has increasingly explored architectures capable of automatically extracting hierarchical representations from raw or minimally processed data. Deep neural networks, recurrent neural networks, and hybrid deep-learning frameworks have been applied to detect anomalous financial behavior, often showing improvements over traditional machine-learning models by capturing nonlinear interactions and temporal dependencies [26,27,28,29,30,31,32]. Generative models, such as GAN-based approaches, have further extended these capabilities by producing synthetic minority samples to alleviate class imbalance [23]. Despite these advances, the majority of deep-learning studies in fraud detection continue to operate directly on tabular datasets. These models typically employ multilayer perceptrons, recurrent models, or one-dimensional convolutional layers, all optimized to learn from numerical transaction attributes rather than spatial or structural patterns. As a result, they do not leverage the representational richness of two-dimensional convolutional architectures, which have revolutionized fields such as image recognition, object detection, and visual pattern analysis.

A related body of work focuses on addressing the severe imbalance between fraudulent and legitimate transactions through data-level interventions. Techniques such as SMOTE oversampling, random under-sampling, and GAN-based sample generation have been widely adopted to improve classifier robustness and sensitivity to minority classes [8,14,23]. Although these methods can enhance classification accuracy, they may also introduce distortions, reduce data diversity, or fail to capture meaningful structures within highly heterogeneous transactional data. Parallel to this, several studies have experimented with alternative representations of transaction sequences or aggregated features, for example, through probabilistic graphical models or genetic-algorithm-derived attributes [30,31]. While these approaches provide valuable insights, they remain rooted in traditional tabular structures and do not introduce a spatially encoded representation that can be exploited by modern computer-vision models.

Taken together, the existing literature highlights significant progress in modeling financial fraud yet also reveals a notable gap. Despite the success of convolutional neural networks and residual architectures in extracting hierarchical spatial features from images, there has been little exploration of how financial transactions might be transformed into structured visual formats suitable for such models. No prior study has, to our knowledge, converted tabular credit card transaction data into QR-code images as a means of enabling the application of two-dimensional deep-learning architectures and transfer learning within a fraud detection context. The present work addresses this gap by introducing QR-based visual encoding of transaction records and evaluating its effectiveness using a ResNet-based deep neural network. In doing so, it contributes a new direction to the fraud detection literature by examining how unconventional data representations can enhance model performance and generalization.

3. Materials and Methodology

This study proposes a deep-learning framework for payment card fraud detection by transforming tabular transaction records into QR-code images and training a residual neural network on the resulting visual representations. The methodological workflow includes data collection, preprocessing, QR transformation, model development, and performance evaluation. An overview of the approach is presented in Figure 1.

The dataset used in this work was obtained from the publicly available Kaggle repository of simulated credit card transactions generated using the Sparkov Data Creation Tool. It contains more than 1.5 million purchase records from January to December 2019, each described by twenty-two numerical and categorical features. A detailed description of the transaction features used in this study is provided in Appendix A (

Table A1. Features of the CSV dataset.

S/No.	Features	Description
1.	Transaction date and time	This shows the date and time the transaction took place
2.	Ccnum	This represents the credit card number
3.	Merchant	This column represents what transaction was made
4.	Category	Category of the purchased item
5.	Amount	Transaction amount
6.	First name	First name of the account holder
7.	Last name	Last name of the account holder
8.	Gender	The sex of the account holder
9.	Street	The address of the street of the account holder
10.	City	The city of the account holder
11.	State	The state of the account holder
12.	Zip	The zip code of the account holder
13.	Latitude	The latitude position of the fraud
14.	Longitude	The longitude position of the fraud
15.	City PoP	Estimated population of the city of residence
16.	Date of Birth	Card holder date of birth
17.	Job	Card holder occupation
18.	Transaction number	Unique transaction identifier
19.	Unix Time	UNIX timestamp of the transaction
20.	Merchant Latitude	Merchant Latitude
21.	Merchant Longitude	Merchant Longitude
22.	Class	Categories present in the dataset

). Although the dataset reflects real-world transactional patterns, it is synthetic and exhibits an artificially high fraud rate of approximately 11.3%, whereas operational datasets typically contain less than 1% fraudulent cases. The present study therefore serves as a methodological investigation of visual encoding techniques for fraud detection, with future validation on real-world datasets required to assess operational performance.

Prior to modeling, the dataset was examined for missing values and inconsistencies, and irrelevant or redundant attributes were removed. Because the data were highly imbalanced, two parallel balancing strategies were employed to evaluate their effects on model performance. SMOTE oversampling was first applied at the tabular level to synthesize additional minority-class instances. In a second approach, random under-sampling was used to reduce the majority class. These two pathways enable a comparative analysis of how different balancing techniques interact with the QR-based representation and subsequent deep learning.

After preprocessing, each transaction record was encoded as a QR-code image using the Python qrcode library (version 7.4) implemented in Python 3.9. This transformation creates a structured binary pattern that compactly represents all transaction attributes in a two-dimensional visual format. The generated QR codes are used solely as a machine-readable data representation and do not encode URLs or provide access to external resources. Converting tabular data into QR images serves two purposes: it enables the use of convolutional neural networks, which excel at extracting spatial features, and it provides a privacy-preserving abstraction by obscuring exact numerical values. All QR images were generated at a resolution of 32 × 32 pixels for computational efficiency. An example of the QR transformation is shown in Figure 2.

Following image generation, a residual neural network (ResNet) [32] was adopted as the classification model. ResNet architectures incorporate skip connections that alleviate vanishing gradients and improve the trainability of deep networks. A pre-trained ResNet model originally trained on ImageNet was fine-tuned on the QR-image dataset to leverage the benefits of transfer learning. The final fully connected layer was replaced with a binary classification output, and binary cross-entropy was used as the loss function. Model optimization was performed using the Adam algorithm. Hyperparameters, including the learning rate, number of epochs, and batch size, were tuned experimentally; supporting evidence for these selections is presented in Section 4.2.

Model training was carried out using PyTorch (version 1.13.1), OpenCV (version 4.7.0), and Scikit-learn libraries (version 1.2.2) on an HP ZBook workstation equipped with an Intel^® Core™ i7-6820HQ processor, 16 GB of RAM, and an NVIDIA GPU with 8 GB of dedicated memory. GPU acceleration substantially reduced training time, enabling efficient experimentation with multiple balanced datasets and network configurations.

To assess model performance, the processed dataset was divided into training, validation, and test subsets. Accuracy, precision, recall, F1-score, and confusion matrices were computed for both the SMOTE-balanced and under-sampled datasets. These metrics also enabled a direct comparison between the proposed deep-learning model and several traditional machine-learning baselines, including KNN, decision trees, random forests, bagging, AdaBoost, and Gaussian Naïve Bayes. To demonstrate practical applicability, the trained model was subsequently exported in TensorFlow format and deployed in an Android mobile application capable of classifying QR-encoded transactions in real time.

4. Analysis, Implementation and Results

4.1. Implementation

All prerequisite libraries were imported at the start of the modeling process. Most libraries were from the PyTorch framework for model construction and hyperparameter configuration. Additional libraries such as Scikit-Image, OS, and OpenCV (cv2) were used for data import, splitting, and visualization of the QR-code dataset for credit card fraud detection. The dataset, stored as a comma-separated values (CSV) file, was separated based on the classification labels (Real/Fake). Each sample was then converted into a QR code according to its class. The training set contained 1,296,675 instances, and the test set contained 555,719 instances. Various analyses, including univariate and bivariate analyses, were conducted to explore dataset characteristics.

The dataset exhibited a class imbalance, with fraudulent transactions accounting for 11.3% and legitimate transactions accounting for 88.7%. To address this imbalance, two approaches were employed: SMOTE (Synthetic Minority Over-sampling Technique) and random under-sampling. Since the dataset was in CSV format, each row was converted into a QR code image to enable the application of deep neural networks. Due to computational limitations, only a subset of the dataset was used for model training, validation, and testing.

The architecture employed Residual Blocks to mitigate the issue of exploding gradients. Skip connections linked activations from earlier layers directly to subsequent layers, bypassing intermediate layers. Training parameters were carefully configured to ensure optimal model performance. The stochastic gradient descent optimizer was employed to iteratively update model weights and minimize loss. The binary cross-entropy loss function was selected to measure the deviation of model predictions from the true labels in this binary classification task.

4.2. Results

4.2.1. Deployment to Mobile Application

The trained ResNet model was integrated into an Android mobile application. After training, the model was saved in TensorFlow format and imported into Android Studio 8.0.1, the official integrated development environment for Android development. The application was implemented using Java (JDK 11) and XML 1.0for the user interface, leveraging TensorFlow APIs (version 2.11) to enable on-device QR code classification. This integration allows the model to process credit card transaction data and classify each transaction as real or fraudulent directly on the mobile device, demonstrating the practical applicability of the proposed approach.

4.2.2. Model Performance

The performance of the model was evaluated using the training and test datasets. Key metrics, including loss and accuracy, were recorded throughout the training process to monitor model convergence and generalization. Both over-sampling and under-sampling approaches demonstrated stable convergence during training, with loss decreasing consistently and accuracy improving across epochs. During hyperparameter tuning, a batch size of 128 was selected as it provided a good balance between training stability and computational efficiency given the available hardware resources.

4.2.3. Model Comparison

This study employed two data balancing techniques: SMOTE (over-sampling) and random under-sampling. The following sections present performance comparisons between traditional machine learning models (KNN, Decision Tree, Random Forest, AdaBoost, Bagging, and Gaussian Naive Bayes) and the proposed deep learning model.

Application of Over-Sampling Data Balancing Technique (SMOTE)

Performance results for the over-sampling approach are presented in

Table 1. Confusion Matrix—Proposed Model (Over-sampling with SMOTE).

	Predicted Legitimate (0)	Predicted Fraudulent (1)
True Legitimate (0)	4333	166
True Fraudulent (1)	374	4127

(confusion matrix for the proposed model) and

Table 2. Classification Reports for Over-sampling data balancing technique SMOTE.

Model	Accuracy %	Precision %	Recall %	F1 Score %
KNN	0.99	0.99	1.00	0.99
Decision Tree	0.98	0.98	0.99	0.98
Random Forest	0.99	0.99	1.00	0.99
AdaBoost	0.92	0.95	0.88	0.92
Bagging	0.99	0.99	0.99	0.99
GaussianNB	0.85	0.96	0.74	0.83
Proposed Model	0.94	0.96	0.92	0.94

(classification metrics for all models).

The proposed model correctly identified 4333 legitimate transactions (true negatives) and 4127 fraudulent transactions (true positives), with 166 false positives and 374 false negatives.

Application of Random Under-Sampling Data Balancing Technique

Performance results for the under-sampling approach are presented in

Table 3. Confusion Matrix—Proposed Model (Under-sampling).

	Predicted Legitimate (0)	Predicted Fraudulent (1)
True Legitimate (0)	1195	19
True Fraudulent (1)	118	1068

(confusion matrix for the proposed model) and

Table 4. Classification Reports for Under-sampling data balancing technique.

Model	Accuracy %	Precision %	Recall %	F1 Score %
KNN	0.85	0.85	0.85	0.85
Decision Tree	0.86	0.86	0.86	0.86
Random Forest	0.91	0.91	0.91	0.91
AdaBoost	0.92	0.95	0.88	0.92
Bagging	0.85	0.85	0.85	0.85
GaussianNB	0.83	0.96	0.74	0.83
Proposed Model	0.94	0.95	0.94	0.94

(classification metrics for all models).

The proposed model correctly identified 1195 legitimate transactions (true negatives) and 1068 fraudulent transactions (true positives), with only 19 false positives and 118 false negatives.

5. Discussion

The experimental results demonstrate that the proposed QR code-based deep learning approach achieves competitive performance in payment card fraud detection. Two key findings emerge from this study: the effectiveness of combining visual data representation with convolutional architectures, and the impact of different data balancing strategies on model performance.

5.1. Performance Comparison and Methodological Advantages

Both data balancing approaches demonstrated strong performance, though with different characteristics. The SMOTE over-sampling approach (Table 2) achieved 94% accuracy, 96% precision, 92% recall, and 94% F1 score. The under-sampling approach (Table 4) achieved 94% accuracy, 95% precision, 94% recall, and 94% F1 score. While both achieved identical accuracy, the under-sampling approach demonstrated more balanced performance with improved recall (94% vs. 92%), indicating better detection of actual fraud cases. The SMOTE approach achieved slightly higher precision (96% vs. 95%), meaning fewer false alarms when fraud is predicted.

Both approaches outperformed traditional machine learning models. Under the under-sampling regime, the proposed model matched or exceeded Random Forest (91% across all metrics) and AdaBoost (92% accuracy, 95% precision, 88% recall). Similarly, under SMOTE over-sampling, traditional models achieved strong results (KNN: 99% accuracy, Decision Tree: 98%, Random Forest: 99%), but these high accuracies may reflect overfitting to the synthetic samples rather than genuine generalization capability. The combination of deep learning with either balancing strategy enabled effective feature extraction from QR-encoded transaction data, demonstrating that visual representation can capture complex patterns in financial transactions [26].

While data balancing techniques have been successfully applied in fraud detection research [24], our results reveal important trade-offs when combined with image-based representations. SMOTE generates synthetic minority class samples through feature interpolation, which may produce semantically inconsistent transactions when subsequently encoded as QR images. The resulting pixel patterns may not fully reflect genuine transaction behaviors. Although SMOTE achieved marginally higher precision (96% vs. 95%), the under-sampling approach demonstrated superior recall (94% vs. 92%), meaning it successfully identified a higher proportion of actual fraudulent transactions. This 2% improvement in recall translates to detecting approximately 2% more fraudulent transactions, a meaningful difference in high-volume transaction environments.

5.2. Practical Implications of Error Types

In fraud detection systems, the two types of errors carry substantially different real-world consequences. False positives (legitimate transactions incorrectly flagged as fraudulent) result in declined transactions, customer inconvenience, and potential loss of business. False negatives (fraudulent transactions incorrectly classified as legitimate) result in direct financial losses and potential facilitation of criminal activity [1,7].

5.3. Comparison with Prior Research

Our results compare favorably with findings from previous studies on fraud detection using neural networks. Fiore et al. [24] achieved 91.6% precision and 94.2% accuracy using resampling approaches with neural networks, while our under-sampling approach achieved 95% precision and 94% accuracy, and our SMOTE approach achieved 96% precision with 94% accuracy. The improvements in precision are particularly significant given the high cost of false positives in production environments. Chang et al. [30] demonstrated that feature engineering combined with machine learning could effectively detect fraud, which supports our approach of transforming tabular data into visual representations to leverage pre-trained convolutional architectures.

The QR code transformation approach offers several advantages over traditional tabular methods. First, it enables transfer learning from large-scale image datasets, allowing the model to leverage knowledge from domains with abundant labeled data [26]. Second, the visual encoding provides an implicit privacy layer by obscuring direct numerical attributes [31]. Third, convolutional architectures can capture spatial relationships and hierarchical patterns that may be less accessible to traditional machine learning models operating on raw features [33].

5.4. Limitations and Scope of Inference

Several limitations should be considered when interpreting these results. First, the synthetic dataset exhibits a fraud rate of approximately 11.3%, which is considerably higher than real-world payment card fraud rates. This higher prevalence simplifies the classification problem and may overestimate model performance in actual deployment scenarios. Future validation using real transaction data with naturally occurring fraud rates is essential to establish the model’s robustness under realistic class imbalance conditions.

Second, the computational requirements of converting tabular data to images and training convolutional networks may limit scalability for real-time fraud detection systems processing millions of transactions daily. The trade-off between detection accuracy and inference latency requires careful evaluation in production environments. Third, while the QR encoding provides privacy benefits, the 32 × 32 pixel resolution may result in information loss for datasets with high-dimensional feature spaces. Further investigation is needed to determine optimal encoding parameters for different transaction data structures.

Fourth, the study focused on a specific set of transaction features available in the dataset. Real-world fraud detection systems often incorporate additional behavioral signals, temporal patterns, and merchant-specific information that may improve detection accuracy. The generalizability of the QR-based approach to datasets with different feature compositions remains an open question.

5.5. Future Research Directions

Several avenues exist for extending this work. First, testing the framework on real-world transaction datasets with naturally occurring fraud rates would provide more realistic performance estimates. Second, exploring alternative image encoding schemes or hybrid approaches that combine visual and tabular representations may improve both performance and computational efficiency. Third, incorporating sequential modeling techniques [32] to capture temporal dependencies in transaction sequences could enhance detection of sophisticated fraud patterns. Finally, investigating ensemble methods that combine multiple balancing strategies and architectures may yield more robust fraud detection systems suitable for diverse deployment scenarios.

6. Conclusions

This study proposed a novel approach to payment card fraud detection by converting tabular transaction data from CSV format into QR code images and applying deep neural network architectures for classification. The research addressed limitations in existing approaches by eliminating manual feature engineering through automatic feature learning in convolutional neural networks.

We compared the performance of our proposed ResNet-based model against traditional machine learning approaches including K-nearest neighbors, Random Forest, Decision Tree, Bagging, AdaBoost, and Gaussian Naive Bayes. Two data balancing strategies were evaluated: SMOTE over-sampling and random under-sampling. The under-sampling approach combined with the proposed deep learning model achieved 94% accuracy, 95% precision, 94% recall, and 94% F1 score, demonstrating more balanced performance across metrics. The SMOTE approach achieved identical 94% accuracy with 96% precision, 92% recall, and 94% F1 score, showing a trade-off between precision and recall. These results demonstrate that the QR code transformation enables effective application of transfer learning and convolutional architectures to fraud detection tasks.

The under-sampling technique proved more effective than over-sampling in this context. Under-sampling minimizes the risk of data duplication and overfitting, providing a cleaner and more balanced dataset for training. In contrast, SMOTE-generated synthetic samples, when encoded as QR images, may introduce representational artifacts that do not fully reflect genuine transaction patterns. Critically, the under-sampling approach produced substantially fewer false positives (19 versus 166), which has significant practical implications for customer experience and operational costs in deployed fraud detection systems.

The practical deployment of the trained model in an Android application demonstrates the feasibility of real-time fraud detection using this approach. However, several limitations should be noted. The synthetic dataset’s elevated fraud rate (11.3%) does not reflect real-world conditions where fraud typically represents less than 1% of transactions. Additionally, the computational requirements of image-based deep learning may present challenges for high-throughput production environments. Future research should validate this framework using real transaction data, explore hybrid representations that balance performance and efficiency, incorporate temporal sequence modeling, and investigate methods to optimize the approach for datasets with naturally occurring, highly imbalanced class distributions. Despite these limitations, this work contributes a promising methodology that combines visual data transformation with deep learning for enhanced payment card fraud detection.