Our fact and url checker

AI-Driven Media Verification Platform

"Your Shield Against Misinformation"

Inspiration

Misinformation and fake news have become significant problems in today's digital world. The rise of social media and AI-generated content has made it difficult to distinguish fact from fiction. We wanted to create a tool that empowers people to identify misinformation quickly and accurately using AI and machine learning.

Recent incidents, including deepfake videos, manipulated images, and misleading articles, have highlighted the need for a reliable media verification platform. Our goal was to create a solution that allows users to:

Fact-check news claims and articles.
Verify the authenticity of images.
Learn about misinformation and how to detect it through an interactive chatbot.

We focused on building a tool that is:

Accessible – Simple for anyone to use.
Accurate – Backed by AI and data-driven models.
Fast – Provides real-time feedback to users.

What It Does

Our platform offers three core functionalities to provide a comprehensive media verification solution:

Fact Checker

Allows users to input a claim or a URL.
Uses the Google Fact Check API and OpenAI to evaluate the truthfulness of the claim and provide explanations.
Stores results in a MySQL database for reference and future analysis.

Image Verification

Allows users to upload an image.
Uses an ELA-CNN (Error Level Analysis Convolutional Neural Network) model to detect signs of manipulation or deepfake content.
Returns a confidence score indicating whether the image is real or fake.

Misinformation-Awareness Chatbot

Uses OpenAI GPT-4o to answer user questions about misinformation.
Provides insights and advice on identifying false information.

How We Built It

1. Backend Setup (Flask + OpenAI + TensorFlow)

We built the backend using Flask, which allowed us to create a fast and lightweight API. Flask made it easy to set up endpoints for each feature and manage data flow between the front end and the back end.

App Structure:

backend/  
├── app.py  
├── fact_check.py  
├── ela_cnn.py  
├── database.py  
├── model/ela_cnn.h5

Backend Code (app.py)

from flask import Flask, render_template, request, jsonify
from flask_cors import CORS
from fact_check import fact_check_website, check_fact
from database import get_db_connection
import openai
from tensorflow.keras.models import load_model
from ela_cnn import convert_to_ela_image
import numpy as np

# Load ELA CNN model
model = load_model('model/ela_cnn.h5')

app = Flask(__name__)
CORS(app, resources={r"/*": {"origins": "*"}}, supports_credentials=True)

openai.api_key = "your-openai-api-key"

Fact Checker

We used the Google Fact Check API to validate claims and URLs. If the API couldn't find enough information, OpenAI was used to generate a detailed explanation.

Code:

import requests
import openai

# Google Fact Check API key
GOOGLE_FACT_CHECK_API_KEY = "your-google-fact-check-api-key"

def check_fact(claim):
    url = f"https://factchecktools.googleapis.com/v1alpha1/claims:search?query={claim}&key={GOOGLE_FACT_CHECK_API_KEY}"
    response = requests.get(url).json()

    if 'claims' in response and len(response['claims']) > 0:
        claim_result = response['claims'][0]['claimReview'][0]
        result = claim_result['textualRating']
        source = claim_result['publisher']['name']

        # Confidence score based on the result
        confidence_score = 0.9 if result.lower() == 'true' else 0.3

        # Generate explanation using OpenAI
        explanation = openai.ChatCompletion.create(
            model="gpt-4o",
            messages=[{"role": "user", "content": f"Explain why this claim is {result}"}]
        ).choices[0].message['content'].strip()

        return {
            'explanation': explanation,
            'confidence_score': confidence_score
        }

What Worked:

Combined structured data from the API with AI-generated explanations. Ensured accuracy by adjusting confidence scores based on the data source and credibility.

Image Verification (ELA-CNN)

We used Error Level Analysis (ELA) to identify manipulated images. ELA works by analyzing compression artifacts, which allows the model to highlight altered areas.

The CNN model was trained using TensorFlow on a dataset of real and manipulated images.

Code:

from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Conv2D, MaxPooling2D, Flatten, Dense, Dropout
from tensorflow.keras.optimizers import Adam

def build_model():
    model = Sequential()
    model.add(Conv2D(32, (3, 3), activation='relu', input_shape=(128, 128, 3)))
    model.add(MaxPooling2D((2, 2)))
    model.add(Conv2D(64, (3, 3), activation='relu'))
    model.add(MaxPooling2D((2, 2)))
    model.add(Flatten())
    model.add(Dense(128, activation='relu'))
    model.add(Dropout(0.5))
    model.add(Dense(2, activation='softmax'))

    model.compile(optimizer=Adam(learning_rate=0.0001), loss='categorical_crossentropy', metrics=['accuracy'])
    return model

What Worked:

Achieved over 92% accuracy on the test set. Optimized model structure for faster prediction without compromising accuracy.

Misinformation Chatbot

We used OpenAI GPT-4o to develop a chatbot that answers user questions about misinformation. The chatbot provides real-time, context-aware responses.

Code:

response = openai.ChatCompletion.create(
    model="gpt-4o",
    messages=[
        {"role": "system", "content": "You are an expert in misinformation awareness."},
        {"role": "user", "content": user_input}
    ]
).choices[0].message['content'].strip()

What Worked:

Ensured the chatbot provided clear and accurate answers.
Focused on educating users rather than just providing answers.

Challenges We Faced

1. API Rate Limits

Fact-checking APIs like Google Fact Check have strict rate limits, which forced us to implement request batching and caching to avoid exceeding limits.

2. Deepfake Detection Complexity

Training the CNN model was difficult due to the limited dataset of manipulated images. We expanded the dataset through augmentation and synthetic data generation.