In this guide
Best 10 AI Projects That Catch Fakes: Deepfakes, Fake News, Phishing & Spam
Quick answer: Ten AI builds that catch fakes, from quick wins to publishable work. Start with the SMS spam filter (TF-IDF plus Naive Bayes on 5,574 real messages) or the UCI phishing detector for a fast working demo. The XceptionNet deepfake detector on FaceForensics++ and the BERT fake-news classifier on the LIAR benchmark carry the strongest novelty story for paper-style reports and viva discussions.
These ten were picked from the themes clients enquire about most: students who want an AI project with a real public dataset, a model they can explain, metrics they can defend, and a live demo — not a toy classifier trained on a CSV nobody has heard of. Every project below is a real, published projectech.in listing; each entry links to its live page with the full build detail. Two entries cover deepfake media, three cover fake-news text, four cover phishing, and one covers SMS spam — the four sub-problems map to different datasets, models and demo styles, so pick the one that matches your timeline and your appetite for deep learning.
1. Deepfake Detection using XceptionNet
Synthetic face videos keep getting harder to spot by eye, and that is exactly why this project works as a student build: the problem is real, the benchmark is public, and the evaluation story writes itself. The project fine-tunes XceptionNet — pretrained on ImageNet — for binary face-forgery classification on FaceForensics++ (Rossler et al., 2019): 1,000 original YouTube videos, each manipulated by four methods (Deepfakes, FaceSwap, Face2Face, NeuralTextures), giving 4,000 forged videos at raw, high-quality (c23) and low-quality (c40) compression. Faces are cropped and aligned to 299x299 inputs, frame-level scores are aggregated into per-video verdicts, and performance is reported with AUC — the metric the benchmark community actually uses. Students pick it because the dataset does the credibility heavy lifting: a viva examiner recognises FaceForensics++, the c40 split gives you an honest robustness discussion (heavy compression hides forgery traces), and the listing ships with report and PPT. Train on a free Colab GPU; the methodology, not the hardware, is the point.
2. Deepfake Detection using Deep Learning (Python)
If video pipelines feel heavy, this is the image-level counterpart: a CNN pipeline that flags manipulated face images and shows its working. The interesting technical angle here is frequency analysis — GAN-generated faces leave subtle frequency-domain artifacts that are invisible in pixel space but visible after a Fourier transform — combined with explainable heatmaps that highlight which regions of the face drove the model's decision. That explainability is the viva asset: instead of "the model said fake," you walk the examiner through the heatmap on eyes, teeth and hairlines where synthesis artifacts cluster. It is a lighter build than the XceptionNet video pipeline above (single images, smaller models), which makes it a sensible pick when your timeline is tight but you still want the deepfake theme. The listing includes code and viva preparation, so the effort goes into understanding the frequency features rather than scaffolding.
3. Fake News Detection using BERT (LIAR)
Fake-news detection is one of the most requested NLP project themes, and the LIAR benchmark (Wang, 2017) is what separates a serious build from a toy: 12,836 short statements from PolitiFact, labeled on a six-point truthfulness scale (pants-fire, false, barely-true, half-true, mostly-true, true), with speaker, subject and context metadata attached. This project fine-tunes BERT-base for six-way claim classification and wraps it in a live claim-analyzer demo — paste a statement, get a truthfulness verdict. Students pick it for two reasons: the six-way label is genuinely harder and more honest than a crude fake/real binary, which gives you a real discussion section, and the metadata (who said it, in what context) lets you experiment with feature combinations beyond raw text. The listing ships a full report, so the writing burden is handled and your time goes into the fine-tuning and the demo.
4. Fake News Detection using NLP & Machine Learning
This is the comparison-study build: TF-IDF plus Logistic Regression as the classical baseline, set against LSTM and BERT variants, with a paste-and-check web app for the demo. The project here is the comparison itself — the ablation story of what each model family gains over the last one is exactly what examiners probe in a viva, and running all three gives you answers instead of guesses. It is also the most hardware-friendly of the fake-news entries: the TF-IDF baseline trains on a laptop CPU in minutes, so you can have a working end-to-end pipeline on day one and treat the deep models as upgrades. Students who are nervous about committing to a single big model pick this one because every experiment produces a reportable result, including the failures. Source code, report and viva kit are included in the listing.
5. Fake News Detection using BERT on the LIAR Dataset
A second BERT-on-LIAR build with a different center of gravity: explainability. Where the entry above leads with the claim-analyzer demo, this one leads with token-influence explanations — which words in a statement pushed the model toward "false" or "true." That is a strong choice if your guide or examiner cares about trustworthy AI: you can demonstrate, live, that the model attends to verifiable claim words rather than stylistic tics. Under the hood it is the same serious setup — BERT fine-tuned on the LIAR benchmark's 12,836 labeled PolitiFact statements — but the evaluation narrative is about interpretability rather than raw accuracy. Pick this over the other BERT entry if you want your viva conversation to be about why the model decides, not just what it decides. Code, notebook, report and PPT come with the listing.
6. Phishing URL Detection using ML
Phishing is the attack most students have personally encountered, which makes this an easy project to motivate: the build is an XGBoost classifier over 30 engineered URL features — lexical signals (length, hyphens, subdomains, IP-in-host) plus host signals (domain age, DNS records) — trained on phishing URLs from the PhishTank community feed and legitimate URLs from the Tranco top-1M list, at a build target of roughly 110,000 labeled URLs. The methodology detail that matters most is the time-split evaluation: URLs are split by first-seen date, not randomly, so the model is tested on future phishing campaigns it has never seen — the honest way to evaluate a security classifier, and a point examiners respect. Output is a 0-100 risk score behind a live URL-scanner demo. Students pick it because the feature engineering is tangible (you can explain every one of the 30 features) and the demo is instantly convincing: paste any suspicious link, watch the score.
7. Phishing URL Detection using Random Forest
The classical-ML counterpart to the XGBoost build above, and the better pick if you want the feature-engineering story to be the heart of the project. It uses the UCI Phishing Websites dataset (UCI ML Repository, dataset 327): 11,055 URLs described by 30 ternary features in four groups — address-bar signals, SSL and domain signals, page-content signals, and reputation signals like traffic and PageRank. The modeling work is a grid-searched Random Forest (tree count and max depth tuned on a validation split), which is exactly the kind of systematic experiment a report needs. Because the dataset is fixed and well-documented, your effort goes into understanding why features work rather than into data collection. The listing includes a checker demo, report, PPT and viva kit — a complete package for students who want a rigorous but CPU-friendly build with no GPU dependency at all.
8. Phishing Website Detection using ML
Also built on the UCI Phishing Websites data (6,157 legitimate vs 4,898 phishing sites, 30 URL and page signals), but with a different emphasis: a 200-tree Random Forest tuned on F1 score, fronted by an explainable URL-scanner demo that shows which signals fired for a given verdict. The explainability angle is what distinguishes it from the entry above — instead of a bare legitimate/phishing label, the demo surfaces the contributing features, which turns a black-box classifier into something you can walk an examiner through feature by feature. F1 tuning (rather than raw accuracy) is the right call on imbalanced security data and gives you a clean precision-recall discussion for the report. Pick this if you want the demo to teach as well as classify; pick the previous entry if you want the deepest feature-engineering write-up.
9. AI Based Phishing Website Detection
This is the deployment-story pick: the same phishing-detection problem, but delivered as a Flask REST API plus a Chrome extension (Manifest V3) that warns you in the browser in real time. The technical content covers feature engineering over URL, WHOIS and DNS signals (domain age is a classic phishing tell — freshly registered domains deserve suspicion), and the listing reports accuracy above 95% on its benchmark split. The honest engineering lesson here, and a good viva talking point, is model decay: phishing tactics evolve, so the project ships a retrain script and documents that the model should be refreshed periodically rather than treated as finished. Students pick it when the demo matters most — nothing convinces an examiner like a live browser warning firing on a test phishing page — and when they want API-plus-extension architecture on their resume.
10. SMS Spam Detection using NLP
The fastest working demo in this list and the classic first NLP project done properly. The dataset is the UCI SMS Spam Collection (Almeida and Hidalgo, 2011): 5,574 real English SMS messages, hand-labeled — 4,827 ham (86.6%) and 747 spam (13.4%) — drawn from forums, the NUS SMS corpus and the SMS Spam Corpus v.0.1. The pipeline is TF-IDF (word unigrams and bigrams) plus Naive Bayes, which trains in seconds on any laptop and still separates ham from spam surprisingly well. The class imbalance is the real lesson: with only 13.4% spam, accuracy lies and precision/recall tells the truth — that single insight, demonstrated live, is worth more in a viva than a bigger model trained carelessly. The listing includes a training notebook and a live demo, so this is the pick when your deadline is measured in weeks, not months.
The ten, compared
| Project | Core tech | Dataset | Build difficulty | Who it's for |
|---|---|---|---|---|
| Deepfake Detection (XceptionNet) | XceptionNet fine-tune, face crops | FaceForensics++ (4,000 forged videos) | Medium–Hard | Students chasing publishable novelty; needs a GPU |
| Deepfake Detection (Python) | CNN + frequency analysis, heatmaps | Face image data | Medium | Tight timeline, wants the deepfake theme + explainability |
| Fake News Detection (BERT, LIAR) | BERT-base fine-tune, 6-way | LIAR (12,836 PolitiFact statements) | Medium–Hard | NLP students; strongest claim-verification story |
| Fake News Detection (NLP & ML) | TF-IDF+LR vs LSTM vs BERT | News text corpora | Easy–Medium | Wants a comparison study; CPU-friendly start |
| Fake News Detection (BERT, LIAR) | BERT + token-influence explanations | LIAR | Medium–Hard | Wants the viva to be about interpretability |
| Phishing URL Detection (ML) | XGBoost, 30 engineered features | PhishTank + Tranco (~110k URLs) | Medium | Likes feature engineering + honest time-split evaluation |
| Phishing URL Detection (RF) | Random Forest, grid search | UCI Phishing Websites (11,055 URLs) | Easy–Medium | Rigorous CPU-only build, no GPU needed |
| Phishing Website Detection (ML) | Random Forest (200 trees), F1-tuned | UCI Phishing Websites | Easy–Medium | Wants an explainable demo that teaches |
| AI Phishing Website Detection | Flask API + Chrome extension | Benchmark phishing/legit sets | Medium | Wants a live in-browser demo + deployment story |
| SMS Spam Detection (NLP) | TF-IDF + Naive Bayes | UCI SMS Spam Collection (5,574 msgs) | Easy | Shortest path to a working demo; deadline in weeks |
How to pick yours
Be honest about three things: deadline, hardware, and what you want the viva conversation to be about. Three to four weeks and no GPU? The SMS spam filter or the UCI Random Forest phishing detector will be demo-ready fastest, and both teach real evaluation discipline (class imbalance, F1 over accuracy). Two months and Colab access? The XceptionNet deepfake detector or either BERT-on-LIAR build gives you a named public benchmark and a novelty story strong enough for a paper-style report. Want the demo to carry the viva? The Chrome-extension phishing detector and the claim-analyzer are the most visual. One caution that applies to the whole list: fakes evolve — deepfake generators improve and phishing kits change monthly — so treat evaluation as a snapshot and say so in your report; examiners respect that honesty more than a suspiciously perfect accuracy number. If you want any of these built to order with code, report, PPT and viva preparation, request a quotation and mention your branch, deadline and whether you have GPU access — the build is scoped around your answers.
FAQ
Which of these can I finish in 3–4 weeks?
The SMS spam detector (TF-IDF + Naive Bayes trains in seconds) or the Random Forest phishing detector on the fixed UCI dataset. Both run on a laptop CPU, both have a clear evaluation story, and both leave you time to polish the demo and the report instead of fighting data pipelines.
Can I publish a paper from one of these projects?
The XceptionNet deepfake detector and the BERT-on-LIAR fake-news builds are the strongest candidates: public benchmarks, reproducible setups, and open questions (robustness under compression, explainability, cross-dataset generalization) that map naturally to a results-and-discussion section. A paper still needs your own experiments and analysis on top of the build — the project gives you the platform, not the publication.
Do I need a GPU?
Only for the deep-learning entries: fine-tuning XceptionNet or BERT realistically wants a GPU, and the free Colab tier is enough for these dataset sizes. The TF-IDF, Random Forest and XGBoost builds train comfortably on a CPU. If you have no GPU access at all, pick from the classical-ML half of the list.
How should I evaluate a phishing or fake-news model honestly?
Split by time, not randomly, wherever the data has timestamps — a random split lets the model memorize campaigns it would never have seen yet, which inflates scores. Report precision, recall and F1 alongside accuracy, especially on imbalanced data like the SMS spam set (13.4% spam). And test on the harder slice: FaceForensics++ c40 compression for deepfakes, the full six LIAR labels for fake news.
How do I demo these in a viva?
Bring the live tool, not just slides: the URL scanner with a test phishing link, the claim analyzer with a fresh statement, the spam filter with real-looking messages, the deepfake heatmap on a sample face. Examiners remember interactive demos, and each of these listings ships the demo as part of the build.
Are these projects or just model-training exercises?
Each listing is a complete build: data pipeline, model, evaluation, demo interface (web app, scanner, or browser extension), report, PPT and viva preparation. The model is the core, but the demo and the documentation are what make it submittable as a project.
A closing note, honestly
Every project above is built to order and quotation-based — the listing pages describe exactly what is included (code, report, PPT, demo, viva kit) so you know what you are paying for. Two honest caveats before you pick: first, detection is an arms race — today's generator beats yesterday's detector, so no accuracy number on this page should be read as permanent; second, a detector is only as honest as its evaluation, so prefer the entries with public benchmarks and time-split testing, and say what your model cannot do in your report. Pick the sub-problem you find genuinely interesting — deepfake media, fake news, phishing, or spam — because you will spend weeks with it, and curiosity survives deadlines better than hype.