Deepfake Detection for Video KYC – Detailed
System Design Report
Introduction
This document explains the full technical architecture and implementation plan for a Deepfake
Detection system designed for video-based KYC verification. The purpose of the system is to
detect manipulated or synthetic identity videos generated using deepfake technology. The project
integrates a React frontend interface, a Python Flask backend API, OpenCV-based face detection,
and a pretrained CNN deepfake classification model. The system is designed as a hackathon
prototype but follows realistic industry architecture used in fintech verification systems.
1. Problem Overview
Digital KYC verification is widely used in banking, fintech platforms, and government identity
verification systems. Users typically record a short video showing their face and identity document.
However, attackers can create deepfake videos that imitate real users. Traditional verification
systems struggle to detect such manipulation. Deepfake technology uses generative models such
as GANs or neural networks to synthesize realistic facial movements. These manipulated videos
can bypass standard face recognition systems. Therefore, financial platforms require automated AI
models capable of detecting manipulated video content. This project proposes a deep learning-
based deepfake detection pipeline combined with liveness detection.
2. System Architecture Overview
Layer Technology Role
Frontend React User interface for uploading KYC video and viewing
results
API Layer Flask (Python) Handles requests and communicates with AI model
Video Processing OpenCV Extract frames and detect faces
Deepfake Detection Pretrained CNN Model Classify frames as real or fake
Aggregation Engine Python Logic Combine frame predictions into final score
Deployment Localhost Demo environment during hackathon
Frontend Design (React)
1 Video Upload Interface – Users upload their KYC verification video.
2 Preview System – Uploaded video can be previewed before submission.
3 API Communication – Frontend sends video to backend using HTTP POST request.
4 Progress Indicator – Shows processing progress while backend analyzes the video.
5 Result Dashboard – Displays authenticity score and final decision.
3. Backend API Design (Flask)
The backend server is implemented using Python Flask. Flask is a lightweight web framework
suitable for rapid prototyping during hackathons. The backend exposes REST API endpoints that
receive video files from the frontend and process them through the deepfake detection pipeline.
Key responsibilities of the backend include: • Receiving video uploads from the frontend •
Extracting frames from video files • Running face detection on each frame • Passing face images
into the deepfake detection model • Aggregating frame predictions • Returning final classification
result
4. Frontend–Backend Communication Flow
1 Step 1: User uploads video using React UI.
2 Step 2: React sends POST request to Flask API endpoint (/detect).
3 Step 3: Backend receives video and temporarily stores it.
4 Step 4: OpenCV extracts frames from the video.
5 Step 5: Face detection identifies face regions in frames.
6 Step 6: Frames are passed into CNN deepfake detection model.
7 Step 7: Model predicts probability of deepfake for each frame.
8 Step 8: Backend aggregates predictions into final score.
9 Step 9: Result returned to frontend in JSON format.
10 Step 10: React displays result to user.
5. Video Processing Pipeline
Video processing begins after the backend receives the uploaded file. The video is decoded frame
by frame. OpenCV is used to capture frames at a fixed interval to reduce computation cost. Typical
processing steps include: 1. Video decoding 2. Frame extraction 3. Face detection using Haar
cascades or DNN models 4. Face cropping 5. Image resizing 6. Normalization before feeding to
CNN Only the facial region is analyzed to focus the deepfake detection model on manipulated
facial features.
6. Deepfake Detection Model
The system uses a pretrained Convolutional Neural Network (CNN) trained on deepfake datasets.
CNN models are effective in detecting subtle artifacts generated by deepfake synthesis models.
The model analyzes features such as: • Inconsistent facial textures • Blurring artifacts around
mouth or eyes • Temporal inconsistencies between frames • Abnormal lighting or shadows
Datasets used for training include: • FaceForensics++ • Deepfake Detection Challenge dataset •
Celeb-DF dataset These datasets contain both real and manipulated videos.
7. Model Evaluation
1 Accuracy – Percentage of correct predictions.
2 Precision – Percentage of predicted deepfakes that are actually deepfakes.
3 Recall – Ability of model to detect deepfake videos.
4 F1 Score – Balance between precision and recall.
5 ROC-AUC – Ability of classifier to distinguish between real and fake samples.
8. Deployment Strategy
During the hackathon, the system will be deployed locally. The React frontend runs on a
development server while the Flask backend runs as a Python server. Typical configuration:
Frontend: localhost:3000 Backend: localhost:5000 The frontend sends requests to the backend
using REST API calls. In a production system, the architecture could be deployed using Docker
containers, cloud GPUs, and scalable API servers.
9. Innovation & Hackathon Impact
This project demonstrates a practical AI security solution for digital identity verification systems. By
combining video analysis, deep learning, and web application architecture, the system can help
prevent fraud during online KYC processes. Key innovative aspects include: • Integration of
deepfake detection into KYC workflow • Frame-level analysis for higher detection accuracy • Real-
time video verification capability • Scalable architecture suitable for fintech applications