How to Build an AI Fake Review Detector

An ai fake review detection tool for your business flags suspicious reviews before they damage your reputation or inflate a competitor's. I build these to analyze writing patterns, reviewer behavior, and timing anomalies that humans miss. A sudden burst of 5-star reviews for a competitor or 1-star reviews on your listing is worth investigating.

The system scores each review for authenticity and flags the ones that look manufactured.

What You Need Before Starting

• A collection of reviews to analyze
• Python 3.8+ with the Anthropic SDK
• Reviewer profile data (when available)
• A database for scoring and flagging

Step 1: Build the Detection Analyzer

import anthropic
import json

client = anthropic.Anthropic()

def analyze_authenticity(review_text, reviewer_data=None):
    context = ""
    if reviewer_data:
        context = f"""
Reviewer profile:
- Review count: {reviewer_data.get('total_reviews', 'unknown')}
- Account age: {reviewer_data.get('account_age', 'unknown')}
- Other reviews: {reviewer_data.get('review_history', 'none')}"""

    response = client.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=200,
        messages=[{
            "role": "user",
            "content": f"""Analyze this review for authenticity. Look for:
1. Generic language with no specific details
2. Excessive superlatives or emotional language
3. Mention of competitor names (shill review)
4. Unnatural phrasing or translated text
5. Reviewer profile anomalies
{context}

Review: {review_text}

Respond with ONLY JSON:
{{"authenticity_score": 0.85, "flags": ["specific concern"], "reasoning": "brief explanation"}}

Score: 0.0 (likely fake) to 1.0 (likely genuine)."""
        }]
    )
    return json.loads(response.content[0].text)

Step 2: Check Timing Patterns

from datetime import datetime, timedelta
from collections import Counter

def detect_timing_anomalies(reviews, window_hours=24):
    """Flag bursts of reviews from similar profiles."""
    reviews_sorted = sorted(reviews, key=lambda r: r["created_at"])
    anomalies = []

    for i, review in enumerate(reviews_sorted):
        window_start = review["created_at"]
        window_end = window_start + timedelta(hours=window_hours)
        window_reviews = [r for r in reviews_sorted if window_start <= r["created_at"] <= window_end]

        if len(window_reviews) >= 5:
            ratings = [r["rating"] for r in window_reviews]
            if ratings.count(5) == len(ratings) or ratings.count(1) == len(ratings):
                anomalies.append({
                    "type": "rating_burst",
                    "count": len(window_reviews),
                    "window_start": window_start.isoformat(),
                    "all_same_rating": ratings[0]
                })

    return anomalies

Step 3: Score the Full Review Set

def score_reviews(reviews):
    results = []
    for review in reviews:
        analysis = analyze_authenticity(review["text"], review.get("reviewer_data"))
        review["authenticity"] = analysis

        save_authenticity_score(review["id"], analysis)

        if analysis["authenticity_score"] < 0.4:
            results.append({
                "review_id": review["id"],
                "score": analysis["authenticity_score"],
                "flags": analysis["flags"],
                "reasoning": analysis["reasoning"]
            })

    return results

Step 4: Cross-Reference Reviewer Patterns

def check_reviewer_patterns(reviewer_id, platform):
    """Check if a reviewer shows suspicious behavior across their history."""
    history = get_reviewer_history(reviewer_id, platform)

    if not history:
        return {"suspicious": False}

    signals = []

    if len(history) > 10 and all(r["rating"] == 5 for r in history):
        signals.append("all_5_star_reviews")

    dates = [r["created_at"] for r in history]
    if len(dates) > 5:
        date_diffs = [(dates[i+1] - dates[i]).days for i in range(len(dates)-1)]
        if max(date_diffs) < 1:
            signals.append("multiple_reviews_same_day")

    categories = [r.get("business_category") for r in history]
    if len(set(categories)) == 1 and len(history) > 3:
        signals.append("all_same_category")

    return {"suspicious": len(signals) > 0, "signals": signals}

Step 5: Generate Reports

def generate_fake_review_report():
    flagged = get_flagged_reviews(min_flags=1)
    timing = detect_timing_anomalies(get_recent_reviews(days=30))

    report = {
        "total_analyzed": get_total_analyzed(),
        "flagged_reviews": len(flagged),
        "timing_anomalies": len(timing),
        "flagged_details": flagged[:20],
        "recommended_actions": []
    }

    for review in flagged:
        if review["authenticity"]["authenticity_score"] < 0.3:
            report["recommended_actions"].append(
                f"Report review {review['id']} to {review['platform']} for removal"
            )

    return report

What to Build Next

Add competitor monitoring. Run the same analysis on your competitors' reviews. If a competitor suddenly gets a flood of suspiciously perfect reviews, that intelligence helps you understand the competitive landscape.

Related Reading

• Competitive Intelligence with AI - fake review detection as competitive intelligence
• The Trust Framework for AI Decisions - building trust through review verification
• Why Monitoring Is Not Optional - monitoring review authenticity as a business practice