Deepfake Detection Guide: How to Spot Synthetic Media Before It Costs You

In February 2024, a finance employee at a multinational company in Hong Kong attended a video conference call. On the call were multiple colleagues — including the company's CFO, a person the employee knew and had worked with. They discussed a confidential financial transaction. The CFO and all other participants on the call were convincing. They sounded right, looked right, and knew the right context.

Every participant other than the finance employee was a deepfake generated in real time. The employee authorized 15 wire transfers totaling HKD 200 million — approximately USD $25.6 million. The fraud was discovered when the employee contacted corporate headquarters directly about the transaction.

This is not a warning about an emerging threat. This happened. The technology was mature enough for deployment against a real target in a real fraud operation, and it worked. The Hong Kong police confirmed the details. The money is gone.

The question for your organization is not whether this technology exists or whether it will be used in fraud — it already is. The question is whether your procedures, your employee training, and your technical controls assume that video calls are reliable authentication mechanisms. Because they are not.

How Deepfake Technology Works

Generative Adversarial Networks: The Origin

The architecture that made synthetic media practical at scale is the Generative Adversarial Network (GAN), proposed by Ian Goodfellow and collaborators in 2014. A GAN consists of two neural networks in competition:

The generator creates synthetic output — a fake face, a fake voice clip, a fake video frame. It starts from random noise and learns to produce increasingly realistic output.

The discriminator evaluates the generator's output and classifies it as real or synthetic, providing a training signal.

These networks train against each other iteratively. The generator gets better at fooling the discriminator; the discriminator gets better at detecting the generator's artifacts. Over millions of training iterations on datasets of real faces, the generator learns to produce faces that humans cannot reliably distinguish from real ones.

Early GAN-based deepfakes (2017-2019) required substantial compute, weeks of training, and consistently produced visible artifacts: unnatural blinking, facial boundary glitches at the edge of the face swap, hair rendering failures, temporal inconsistency in video sequences. By 2021, the artifacts were subtle enough to require forensic tools for reliable detection. By 2023, commercial tools produced output that defeated casual inspection by trained security researchers under normal viewing conditions.

Diffusion Models: The Current State of the Art

Starting in 2022, diffusion-based models began supplementing and replacing GANs for many generation tasks. Diffusion models work through a different mathematical mechanism: they learn to iteratively denoise random Gaussian noise into coherent output, guided by training on large datasets.

For static image generation, diffusion models (Stable Diffusion, DALL-E 3, Midjourney) produce output that is often more photorealistic and artifact-free than comparable GAN outputs. For video, hybrid approaches — GAN-based face swapping combined with diffusion-based refinement and temporal consistency networks — now produce output at quality levels that represent a significant advancement over GAN-only approaches.

The specific tools relevant to fraud contexts:

Face swap models: DeepFaceLab, SimSwap, and their successors can replace the face in a video clip with a target person's face. The quality depends on the amount of training footage available for the target. A CEO who has appeared in earnings calls, conference keynotes, and media interviews has provided substantial training data, all publicly accessible.

Real-time face swap systems: DeepFaceLive and its derivatives apply face swap to live video feeds with latency low enough for use in video calls (typically 50-200ms with adequate GPU hardware). This is what was used in the Hong Kong case — not pre-recorded video, but real-time face swap applied to live video of actors.

Voice cloning: Audio deepfakes are discussed in detail in the companion voice cloning article, but they're inseparable from video deepfake attacks. A convincing real-time face swap with a mismatched voice is immediately detectable. Production deepfake fraud combines face swap with voice cloning for a complete audio-visual synthetic identity.

The Compute Accessibility Shift

In 2020, running a high-quality face swap model required a workstation with a high-end NVIDIA GPU (RTX 3090 or better), several weeks of training time, and specialized technical knowledge. In 2024, the same capability runs on a mid-range gaming laptop, trains in hours using pre-built pipelines, and is accessible to anyone willing to follow YouTube tutorial videos.

Cloud GPU services (Vast.ai, RunPod, Lambda Labs) enable anyone to rent GPU compute for $0.50-$2.00 per hour. Training a face swap model for a specific public figure using publicly available footage costs approximately $10-30 in cloud compute plus the time to collect footage. For a fraud operation targeting a high-value executive with a $25 million potential payoff, this is not a meaningful cost barrier.

Training Data Requirements by Target Type

The quality of a deepfake face model scales with the amount and diversity of training footage:

| Target Type | Available Footage | Model Quality | Example | |-------------|------------------|---------------|---------| | Major celebrity | Thousands of hours | Near-undetectable | Tom Hanks, Taylor Swift | | Public executive | Dozens of hours (earnings calls, keynotes) | High quality, real-time viable | Publicly traded company CEO | | Mid-level executive | Hours (company videos, conference talks) | Good quality, some artifacts | VP of Finance at major company | | Private individual | Minutes (social media) | Basic quality, detectable under scrutiny | Targeted family member | | Unknown individual | Seconds or none | Poor quality, easily detected | Cold-target fraud attempts |

The practical implication: fraud operations using deepfake technology preferentially target companies whose executives have substantial public media presence. This includes essentially every publicly traded company, most Fortune 1000 companies, and any organization whose leadership regularly participates in media or public events.

The Hong Kong Deepfake Fraud: A Technical Breakdown

The February 2024 Hong Kong case is worth examining in technical detail because it represents the current state of the art in operationally deployed deepfake fraud.

Initial contact: The targeted finance employee received a phishing email purportedly from the company's UK-based CFO about a "secret transaction" requirement. The employee was appropriately suspicious of the email — they didn't act on it immediately.

The deepfake video call as "verification": The attackers anticipated that the employee would want to verify the request. They invited the employee to a video conference call where multiple "colleagues" — the CFO and several other familiar faces — were present. The employee had some suspicion but was reassured by seeing familiar faces, hearing familiar voices, and having the transaction discussed in a contextually appropriate way.

Technical requirements the attackers satisfied:

Face models for multiple individuals (the CFO and several other executives)
Voice clones for each individual
Real-time face swap running simultaneously for multiple actors (each attacker had a model running on their setup)
Sufficient knowledge of each impersonated person's communication style and manner
Scripted content that passed the employee's contextual knowledge checks (they knew enough about company business to be convincing)

The 15 transfers: The employee made transfers to five different bank accounts totaling HKD 200 million. The fraudsters had established multiple receiving accounts (through money mules) in advance to quickly disperse the funds before discovery.

Discovery: The employee contacted corporate headquarters directly about the transaction — likely as a follow-up administrative step. Headquarters had no knowledge of the transaction. The fraud was discovered.

What would have stopped it: A single organizational control would have been sufficient — a policy that wire transfers above a threshold require written authorization through the company's internal systems, verified through a separate established channel, with a 24-48 hour delay. The deepfake was convincing. The missing control was structural, not perceptual.

Warning

Video calls are no longer reliable authentication mechanisms for high-stakes business actions. A convincing real-time deepfake of a known colleague is within reach of sophisticated criminal operations targeting organizations with publicly traded executives. Any procedure that uses "we can verify it on video call" as a control for wire transfer authorization is operating on a false assumption.

Detection Techniques

What Human Visual Inspection Can (and Cannot) Reliably Find

Current deepfake technology, while dramatically improved, still produces artifacts under careful analysis. The challenge: these artifacts require specific knowledge to identify, are often subtle in motion, and are not reliably detectable by untrained viewers under normal viewing conditions.

Facial boundary artifacts: Face swaps produce blending zones at the edges of the swapped region — around the hairline, along the jaw, at the neck. In high-quality current tools these may only be visible when examining individual frames at reduced playback speed (0.25x) or when the face is moving rapidly.

Accessories and hair rendering: Fine hair strands, transparent glasses frames, earrings and other jewelry that cross the face boundary, and facial hair at the face-swap boundary line are notoriously difficult for current systems to render convincingly. These elements show the highest artifact rate in current-generation face swaps.

# Examining video frame-by-frame for artifacts using ffmpeg
# Extract individual frames at high quality for examination
 
ffmpeg -i suspicious_video.mp4 \
  -vf "fps=30,scale=1920:1080" \
  -q:v 1 \
  frames/frame_%04d.png
 
# Examine frames around areas of interest:
# - Hair-forehead boundary
# - Jaw-neck boundary
# - Glasses frames
# - Ear boundaries
# - Rapid motion frames (head turns, speaking gestures)
 
# Look for:
# - Color gradients at face boundaries that don't match lighting direction
# - Temporal inconsistency (artifacts appear/disappear between adjacent frames)
# - Blurring at face boundary that isn't present in background
# - Hair that merges unnaturally with the face boundary

Eye and gaze behavior: Authentic video contains natural eye micro-movements — saccades, pupil dilation response to light changes, natural variation in blink timing. Deep fakes trained on face swap (rather than full-body generation) inherit the eye behavior of the actor wearing the fake face, but the eyes don't necessarily match the target's characteristic gaze patterns. This is subtle and not reliably detectable by casual observation.

Temporal consistency failures: Video deepfakes must maintain facial coherence across frames. At transition points — rapid head movement, speaking with wide mouth opening, strong expressions — artifacts can appear that are invisible at normal playback speed. Examining video at reduced speed (0.25x) and stepping frame-by-frame is the most effective human inspection technique.

Physiological signal absence: Authentic video of a face contains a subtle remote photoplethysmography (rPPG) signal — the slight color variation in skin caused by blood flow as the heart beats. Human skin gets microscopically redder when the heart pumps blood through capillaries near the surface. This signal is present in authentic video and measurable through careful analysis of color values over time. Current deepfakes do not reproduce this signal convincingly. This is one of the most technically reliable deepfake indicators available.

Metadata and File Forensics

Before examining visual content, examine the file:

# Check media metadata with exiftool
# Install: brew install exiftool (macOS) or apt install exiftool (Debian/Ubuntu)
 
exiftool suspicious_video.mp4
 
# Critical fields to examine:
# Make/Model: Should correspond to a real camera/phone. AI-generated video has no device.
# Software: Lists any encoding software. "DeepFaceLab", "ffmpeg 6.0", "Lavf58.76.100"
#            all suggest post-processing rather than camera recording.
# Create Date: Time zone consistency with claimed origin?
# GPS coordinates: If present, do they match the claimed location?
# Encoding parameters: Unusually high bit rate after compression? Double-compression?
# Encoder: Specific codec strings identify generation software
 
# Compare file hash if you have a reference:
sha256sum suspicious_video.mp4
# If this hash matches a known deepfake sample in VirusTotal's database, it's confirmed
 
# Check for double compression (video processed multiple times shows layered compression artifacts)
# Use MediaInfo for detailed stream analysis:
mediainfo suspicious_video.mp4

Error Level Analysis (ELA) for images: ELA works by re-compressing an image at a specific quality level and examining the difference between the original and re-compressed version. Regions of the image that have been digitally manipulated tend to show different error levels than authentic regions, because manipulated content has been through an additional compression cycle.

# Error Level Analysis for deepfake image detection
# Requires: pip install Pillow numpy
 
from PIL import Image
import numpy as np
import io
 
def error_level_analysis(image_path: str, quality: int = 90) -> np.ndarray:
    """
    Perform Error Level Analysis on an image.
    Regions with different compression history show as brighter areas
    in the ELA output — indicating potential manipulation.
    """
    original = Image.open(image_path).convert("RGB")
 
    # Re-compress at specified quality
    buffer = io.BytesIO()
    original.save(buffer, format="JPEG", quality=quality)
    buffer.seek(0)
    recompressed = Image.open(buffer).convert("RGB")
 
    # Calculate pixel-wise difference
    original_array = np.array(original, dtype=np.float32)
    recompressed_array = np.array(recompressed, dtype=np.float32)
 
    ela_array = np.abs(original_array - recompressed_array)
 
    # Amplify for visibility
    ela_amplified = ela_array * (255 / ela_array.max() if ela_array.max() > 0 else 1)
 
    # Suspicious regions: bright areas in the face region that don't appear in background
    # This indicates different compression history — suggesting manipulation
    return ela_amplified.astype(np.uint8)
 
 
def analyze_face_regions(image_path: str) -> dict:
    """
    Run ELA and report on face vs background compression inconsistency.
    Higher inconsistency suggests deepfake manipulation.
    """
    ela = error_level_analysis(image_path)
 
    # Simplified metric: mean ELA value (higher = more manipulation evidence)
    overall_ela_mean = ela.mean()
 
    # In practice, you'd use a face detector to isolate face region
    # and compare its ELA signature to the background
    return {
        "overall_ela_mean": float(overall_ela_mean),
        "suspicious": overall_ela_mean > 15.0,  # Threshold from empirical testing
        "confidence": "low" if overall_ela_mean < 10 else "medium" if overall_ela_mean < 20 else "high"
    }

Automated Detection Tools

Several production-ready tools exist for deepfake detection at scale:

Microsoft Azure AI Content Safety — Video Deepfake Detection: Microsoft's enterprise API for detecting AI-generated video content. Integrated into the Azure Cognitive Services platform, accessible via REST API with pay-per-use pricing. Provides a confidence score for manipulation detection.

Intel FakeCatcher: Uses the rPPG biological signal approach — analyzing the photoplethysmography signal in facial video to detect the absence of authentic blood-flow variation that characterizes real video. Intel claims 96% accuracy in controlled testing conditions. Real-world performance against adversarially optimized deepfakes is lower.

Sensity AI (formerly Deeptrace): Enterprise deepfake detection platform with API access. Trained on a large corpus of known deepfakes including current-generation tools. Has processed media for major media organizations, election monitoring bodies, and corporate intelligence teams.

Hive Moderation: Content moderation platform with deepfake detection API covering video, image, and audio. Used by social media platforms for automated content moderation.

# Example: Deepfake detection using Hive Moderation API
import requests
import base64
from pathlib import Path
 
def check_video_for_deepfake_hive(video_path: str, api_key: str) -> dict:
    """
    Submit video to Hive Moderation's deepfake detection endpoint.
    Returns classification result with confidence scores.
    """
    video_data = Path(video_path).read_bytes()
 
    response = requests.post(
        "https://api.thehive.ai/api/v2/task/sync",
        headers={
            "Authorization": f"Token {api_key}",
        },
        files={
            "video": (video_path, video_data, "video/mp4")
        },
        data={
            "model": "deepfake_detection_video_v2"
        },
        timeout=120
    )
 
    response.raise_for_status()
    result = response.json()
 
    # Extract the relevant output
    output = result.get("status", [{}])[0].get("response", {}).get("output", [])
    if output:
        classes = output[0].get("classes", [])
        deepfake_class = next(
            (c for c in classes if "deepfake" in c.get("class", "").lower()),
            None
        )
        return {
            "is_deepfake": deepfake_class["score"] > 0.7 if deepfake_class else None,
            "deepfake_confidence": deepfake_class["score"] if deepfake_class else None,
            "all_classes": classes
        }
 
    return {"error": "No output from API", "raw": result}
 
 
# Usage
api_key = "your_hive_api_key"
result = check_video_for_deepfake_hive("suspicious_video.mp4", api_key)
print(f"Deepfake detected: {result.get('is_deepfake')}")
print(f"Confidence: {result.get('deepfake_confidence', 0):.3f}")

Note

No automated deepfake detector achieves acceptable false-negative rates against all current-generation synthetic media. Detection models trained on one generation of deepfake technology are regularly defeated by the next generation. The adversarial arms race between generation and detection is ongoing, and generation consistently advances faster. Use these tools as a first-pass filter and for forensic analysis — not as the primary authentication control for high-stakes decisions.

The rPPG Biological Signal Approach

Remote photoplethysmography detection deserves additional explanation because it's one of the most technically robust detection approaches currently available and one of the hardest to defeat through adversarial optimization.

The human face doesn't look completely uniform in color. With each heartbeat, blood is pushed through capillaries near the skin surface, creating a slight periodic variation in the red channel of video captured from a face. This variation is typically invisible to the naked eye but measurable through careful analysis of color values over time.

Deepfakes don't reproduce this biological signal correctly. The generator learns to produce realistic-looking facial texture but doesn't explicitly model the cardiac pulse that produces the rPPG signal. Deep learning-based detection models trained to look for the rPPG signal can detect its absence or misrepresentation with high accuracy.

# Simplified rPPG signal extraction for deepfake detection
# Full implementation requires face detection + region tracking
 
import numpy as np
import cv2
from scipy.signal import butter, filtfilt
 
def extract_rppg_signal(video_path: str, fps: int = 30) -> np.ndarray:
    """
    Extract the rPPG signal from facial video.
    Authentic video shows a periodic signal at heart rate frequency (0.75-3 Hz).
    Deepfake video shows a much weaker or absent signal.
    """
    cap = cv2.VideoCapture(video_path)
    face_cascade = cv2.CascadeClassifier(
        cv2.data.haarcascades + 'haarcascade_frontalface_default.xml'
    )
 
    green_channel_means = []
 
    while True:
        ret, frame = cap.read()
        if not ret:
            break
 
        gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
        faces = face_cascade.detectMultiScale(gray, 1.1, 4)
 
        if len(faces) > 0:
            (x, y, w, h) = faces[0]
            # Extract forehead region (best rPPG signal)
            forehead = frame[y:y+h//4, x+w//4:x+3*w//4]
            # Get mean green channel value (most sensitive to blood volume changes)
            mean_green = forehead[:, :, 1].mean()
            green_channel_means.append(mean_green)
 
    cap.release()
 
    if len(green_channel_means) < fps * 5:  # Need at least 5 seconds
        return np.array([])
 
    signal = np.array(green_channel_means)
 
    # Bandpass filter to isolate heart rate frequencies (0.75-3 Hz = 45-180 BPM)
    nyquist = fps / 2
    low = 0.75 / nyquist
    high = 3.0 / nyquist
    b, a = butter(4, [low, high], btype='band')
    filtered_signal = filtfilt(b, a, signal)
 
    return filtered_signal
 
 
def assess_rppg_presence(video_path: str) -> dict:
    """
    Assess whether a facial video contains a realistic rPPG signal.
    Low signal power suggests deepfake generation.
    """
    signal = extract_rppg_signal(video_path)
 
    if len(signal) == 0:
        return {"error": "Insufficient video or no face detected"}
 
    # Calculate signal power in cardiac frequency band
    signal_power = np.var(signal)
 
    return {
        "rppg_signal_power": float(signal_power),
        "likely_deepfake": signal_power < 0.01,  # Threshold from research literature
        "note": "Lower power values suggest absent biological pulse signal"
    }

Verification Procedures for Organizations

Mandatory Out-of-Band Verification

For any high-stakes action — wire transfers, security credential changes, access grants, public statements — establish verification procedures that use communication channels independently established before the suspicious contact.

The key principle: the verification channel must be established before and independently of the suspicious communication. If a video call tells you to verify via a phone number, and you call that number — you're still talking to the attacker.

Verification channel matrix:

Contact method          |  Verification method required
------------------------|----------------------------------
Email request           |  Phone call to known number from contacts
Phone call (voice only) |  Email to verified address OR known-number callback
Video call              |  Phone call to known number from contacts + pre-established code
WhatsApp / Signal       |  Known-number callback only (message apps can be compromised)
Any combination         |  Multiple independent channels, at least one pre-established

Pre-arrange verification codes: Before a call begins, require a code word that was established in-person or through a separately verified secure channel. This is especially important for executive-level business communications involving financial authorization.

Slow Down High-Value Transactions

Deepfake operations are typically designed around urgency — they create scenarios where the target feels that delay will cause immediate harm. Financial controls that impose mandatory delays are structurally effective against deepfake fraud precisely because they eliminate the urgency leverage.

Required controls for wire transfer authorization:

Dual authorization: Transfers above a threshold require sign-off from two independent authorizers via two independent channels
New payee delay: Any transfer to a new bank account requires a 48-72 hour waiting period, during which the bank details are verified through an independent callback
Transaction limit for phone/video authorization: Unilateral authorization via phone or video call limited to amounts below a defined threshold; anything larger requires written authorization through the internal accounting system
Pre-registered payee accounts: Establish a list of pre-verified accounts for common business payments; transfers to non-listed accounts require the full new-payee verification process

These are not bureaucratic friction. They are fraud controls. Frame them explicitly that way internally, especially when executives push back on verification delays for "urgent" transfers — urgency is the attack mechanism.

Hardware-Based Identity Verification

For internal communications involving sensitive decisions, cryptographic identity verification provides proof that a video call cannot. Signal's Safety Numbers feature, PGP-signed emails, and hardware security key-based authentication all provide identity assurance that synthetic media cannot replicate.

A FIDO2 hardware security key (YubiKey, Google Titan Key) generates cryptographic signatures tied to the specific hardware device. Verifying a cryptographic signature generated by a person's YubiKey proves physical possession of that device. A deepfake cannot produce that signature.

For the highest-sensitivity situations, establishing a pre-call cryptographic handshake (a signed message exchange via Signal before the video call begins) provides a strong assurance layer on top of video call identity.

Employee Training: Concrete and Scenario-Based

Standard security awareness training tells employees to "be suspicious of unsolicited requests." Against deepfake threats, this framing is insufficient because the attacks don't look like suspicious requests — they look like normal requests from familiar people.

Training content needs to explicitly cover:

The existence of real-time face swap technology: Show employees actual demonstrations. Make the capability concrete and personal. Employees who have seen a convincing deepfake demonstration approach video authentication very differently.
The Hong Kong case as a specific scenario: Walk through the attack step by step. Make the $25 million loss real and concrete.
The correct response to video verification: Video calls are not verification. Verification requires an independent channel established before this contact.
The urgency pattern: When a "colleague" on a video call emphasizes urgency, that urgency is the attack mechanism, not a legitimate business requirement.

Tip

A practical training drill: with appropriate internal authorization, have your security team attempt to contact employees via video call using a face-swap tool showing a colleague or executive. This makes the threat concrete and personal in a way that a training slide cannot. Employees who have experienced a convincing deepfake attempt firsthand — even a deliberate internal training drill — approach video authentication with fundamentally different skepticism afterward. The visceral experience of being fooled, or nearly fooled, by synthetic video changes behavior more effectively than any awareness content.

The Detection Arms Race

Every improvement in deepfake detection drives corresponding improvement in deepfake generation. GAN training now routinely incorporates adversarial examples specifically designed to fool known detectors. The next generation of deepfake tools is developed with awareness of current detection methods — an explicit adversarial optimization process.

What this means practically:

No single detection technique is permanent: A detector trained on today's deepfakes will be defeated by deepfakes specifically optimized to fool it. Detection must be layered, regularly updated, and treated as a probabilistic filter rather than a definitive verdict.

Detection tools should be used for pre-screening and forensics, not as authentication controls: An automated deepfake detector integrated into video call software can flag high-probability synthetic content. It cannot provide a guarantee. Use it as one signal among many, not as the reason to trust or distrust a call.

The architecture matters more than the detection: The $25 million Hong Kong loss was preventable not by better deepfake detection but by a simple organizational policy. The detection gap matters less when the procedures don't require detecting the deepfake to prevent the fraud.

Deepfake Detection Checklist

For verifying suspicious media:

File-level investigation:

[ ] Check metadata with exiftool — does the device/software match the claimed source?
[ ] Is GPS data present? Does it match the claimed location?
[ ] Are there encoding artifacts suggesting multiple compression cycles?
[ ] Does the file's creation timestamp match the claimed date?

Visual analysis (for video):

[ ] Examine at 0.25x speed, frame-by-frame at boundaries and during fast motion
[ ] Check facial boundary zones: hairline, jaw, neck, ear boundaries
[ ] Check accessories: glasses frames, earrings, fine hair strands crossing face boundary
[ ] Check lighting: does facial lighting match the environment's light direction?
[ ] Check temporal consistency: do artifacts appear/disappear between frames?

Behavioral analysis (for video/audio):

[ ] Does blink timing seem natural? (not too uniform, not absent)
[ ] Does the voice background audio match the video environment?
[ ] Is there unusual response latency in conversational moments?
[ ] Do physiological signals seem present? (Skin color variation with movement)

Automated tool analysis:

[ ] Submit to Hive Moderation, Microsoft Azure Content Safety, or Sensity AI
[ ] Run ELA analysis on extracted keyframes (for images)
[ ] Analyze rPPG signal strength if technical capability is available

Verification procedures (most important):

[ ] Verified via independently established communication channel?
[ ] Pre-established code word or phrase confirmed?
[ ] Financial action delayed for required cooling-off period?
[ ] Written authorization obtained through the internal system?

The Hong Kong case was not detected by deepfake detection technology — it was detected when the victim followed up through the real corporate hierarchy after the fraud was complete. Build the procedures that would have stopped the transfer before it happened, and you've solved the actual problem regardless of how good or bad deepfake detection becomes.

Deepfake Detection Guide: How to Spot Synthetic Media Before It Costs You

Key Takeaways

How Deepfake Technology Works

Generative Adversarial Networks: The Origin

Diffusion Models: The Current State of the Art

The Compute Accessibility Shift

Training Data Requirements by Target Type

The Hong Kong Deepfake Fraud: A Technical Breakdown

Other Documented Cases

Ferrari CEO Impersonation Attempt (2024)

WPP Multi-Channel Deepfake Attack (2024)

Slovak Election Deepfake Audio (2023)

Military Recruiting Deepfakes (2023)