AI Video Copyright Detection

The Problem

Reviewing a growing rights-controlled catalog for visually similar reuse candidates does not scale with manual checks alone. This guide shows how to screen suspect videos with semantic retrieval and prepare timestamped side-by-side clips for human review. Similarity is a triage signal; it does not establish copying, ownership, licensing status, infringement, or grounds for an automated takedown.

What You’ll Build

Build a review workflow that:

Indexes rights-controlled portfolio videos as searchable visual descriptions
Screens suspect-video scenes for visually similar candidates
Generates separate side-by-side comparison clips for human review
Groups temporally adjacent candidates as review context
Creates reports with retrieval relevance scores

All powered by VideoDB’s Editor SDK and semantic search.

Setup

Install Dependencies

pip install videodb

Connect to VideoDB

import videodb

# Connect to VideoDB
api_key = "your_api_key"
conn = videodb.connect(api_key=api_key)
coll = conn.get_collection()

Implementation

Step 1: Index Your Portfolio Videos

portfolio_videos = [
    coll.upload(url="https://example.com/original-video-1.mp4"),
    coll.upload(url="https://example.com/original-video-2.mp4"),
]
portfolio_indexes = {}
for video in portfolio_videos:
    index_name = f"portfolio_visual_{video.id}"
    index = next((item for item in video.list_indexes() if item.name == index_name), None)
    if index is None:
        understanding = video.understand(
            segmentation={"type": "shot", "threshold": 20},
            analyzers=[{"type": "vlm", "name": "portfolio_scene", "config": {
                "prompt": "Describe the visual content in detail: people, objects, actions, setting, colors, composition, camera angle, lighting, and any visible text or logos.",
                "schema": {"description": "string"}}}],
        )
        understanding.wait_until_complete()
        analyzer = understanding.get_analyzer("portfolio_scene")
        index = video.index(
            name=index_name,
            source=analyzer,
            use_for=["semantic"],
            fields={"semantic": ["description"]},
        )
    index.wait_until_complete()
    portfolio_indexes[video.id] = index.index_id

Step 2: Upload Suspect Video for Analysis

suspect_video = coll.upload(url="https://example.com/suspect-video.mp4")
suspect_understanding = suspect_video.understand(
    segmentation={"type": "shot", "threshold": 20},
    analyzers=[{"type": "vlm", "name": "portfolio_scene", "config": {
        "prompt": "Describe the visual content in detail: people, objects, actions, setting, colors, composition, camera angle, lighting, and any visible text or logos.",
        "schema": {"description": "string"}}}],
)
suspect_understanding.wait_until_complete()
suspect_analyzer = suspect_understanding.get_analyzer("portfolio_scene")

Step 3: Perform Similarity Comparison

import math


def finite_scene_records(analyzer):
    records = []
    for scene in analyzer.get_output().get("scenes", []):
        data = scene.get("data")
        start, end = scene.get("start"), scene.get("end")
        description = data.get("description") if isinstance(data, dict) else None
        if (
            isinstance(start, (int, float)) and not isinstance(start, bool)
            and isinstance(end, (int, float)) and not isinstance(end, bool)
            and math.isfinite(start) and math.isfinite(end) and end > start
            and isinstance(description, str) and description.strip()
        ):
            records.append({"start": start, "end": end, "description": description.strip()})
    return records


def similarity_candidates(suspect_video, suspect_analyzer, portfolio_indexes, relevance_threshold=0.70):
    matches = []
    for scene in finite_scene_records(suspect_analyzer):
        results = coll.semantic_search(
            query=scene["description"],
            index_ids=list(portfolio_indexes.values()),
            top_k=1,
        )
        for shot in results.get_shots():
            score, start, end = shot.search_score, shot.start, shot.end
            if (
                isinstance(score, (int, float)) and not isinstance(score, bool)
                and isinstance(start, (int, float)) and not isinstance(start, bool)
                and isinstance(end, (int, float)) and not isinstance(end, bool)
                and math.isfinite(score) and math.isfinite(start) and math.isfinite(end)
                and end > start and score >= relevance_threshold
            ):
                matches.append({
                    "suspect_video_id": suspect_video.id,
                    "suspect_start": scene["start"],
                    "suspect_end": scene["end"],
                    "portfolio_video_id": shot.video_id,
                    "portfolio_start": start,
                    "portfolio_end": end,
                    "similarity": float(score),
                })
    return sorted(matches, key=lambda item: item["similarity"], reverse=True)


matches = similarity_candidates(
    suspect_video,
    suspect_analyzer,
    portfolio_indexes,
    relevance_threshold=0.70,
)

Step 4: Group Sequential Review Candidates

from collections import defaultdict


def monotonic_candidate_sequences(matches, max_gap=10.0, min_length=3):
    sequences = []
    by_portfolio_video = defaultdict(list)
    for match in matches:
        by_portfolio_video[match["portfolio_video_id"]].append(match)

    for portfolio_video_id, candidates in by_portfolio_video.items():
        ordered = sorted(candidates, key=lambda item: (item["suspect_start"], item["portfolio_start"]))
        sequence = []
        for candidate in ordered:
            if not sequence:
                sequence = [candidate]
                continue
            previous = sequence[-1]
            suspect_gap = candidate["suspect_start"] - previous["suspect_end"]
            portfolio_gap = candidate["portfolio_start"] - previous["portfolio_end"]
            if (
                candidate["suspect_start"] > previous["suspect_start"]
                and candidate["portfolio_start"] > previous["portfolio_start"]
                and 0 <= suspect_gap <= max_gap
                and 0 <= portfolio_gap <= max_gap
            ):
                sequence.append(candidate)
            else:
                if len(sequence) >= min_length:
                    sequences.append({"portfolio_video_id": portfolio_video_id, "matches": sequence})
                sequence = [candidate]
        if len(sequence) >= min_length:
            sequences.append({"portfolio_video_id": portfolio_video_id, "matches": sequence})
    return sequences


sequences = monotonic_candidate_sequences(matches)

Step 5: Generate Side-by-Side Review Clips

from videodb.editor import Timeline, Track, Clip, VideoAsset, Position, Fit

review_clips = []
for match in matches[:5]:
    # Each candidate receives a separate side-by-side review timeline.
    timeline = Timeline(conn)
    track = Track()
    duration = min(
        match["portfolio_end"] - match["portfolio_start"],
        match["suspect_end"] - match["suspect_start"],
    )

    # Portfolio video (left side)
    portfolio_asset = VideoAsset(
        id=match["portfolio_video_id"],
        start=match["portfolio_start"]
    )
    portfolio_clip = Clip(
        asset=portfolio_asset,
        duration=duration,
        position=Position.left,
        fit=Fit.crop,
        scale=0.5
    )
    track.add_clip(0, portfolio_clip)

    # Suspect video (right side)
    suspect_asset = VideoAsset(
        id=suspect_video.id,
        start=match["suspect_start"]
    )
    suspect_clip = Clip(
        asset=suspect_asset,
        duration=duration,
        position=Position.right,
        fit=Fit.crop,
        scale=0.5
    )
    track.add_clip(0, suspect_clip)

    timeline.add_track(track)
    review_clips.append(
        {
            "portfolio_video_id": match["portfolio_video_id"],
            "similarity": match["similarity"],
            "stream_url": timeline.generate_stream(),
        }
    )

Step 6: Generate a Review Report

# Create a review report. Similarity scores are not legal conclusions.
report = {
    "suspect_video_id": suspect_video.id,
    "relevance_threshold": 0.70,
    "candidate_count": len(matches),
    "monotonic_candidate_groups": len(sequences),
    "review_clips": review_clips,
    "review_note": "AI-assisted screening only; human rights and legal review are required.",
}

What You Get

A review workflow with:

Scene-by-scene visual descriptions for rights-controlled reference videos
Semantic similarity candidates for human review
Monotonic, bounded-gap candidate groups for temporal context
Separate side-by-side comparison clips
Retrieval relevance scores and an explicit human-review note

Here is an example side-by-side review clip:

How It Works

Portfolio Indexing - Convert rights-controlled reference videos into searchable scene descriptions
Suspect Upload - Upload a video for screening
Similarity Scan - Retrieve visually similar candidates for review
Sequential Detection - Group monotonic candidates with bounded timestamp gaps
Review Clip Generation - Create side-by-side comparison clips
Human Review - Assess ownership, licensing, and legal questions outside this workflow

Similarity Thresholds

0.70+ = Candidate included for review
Below 0.70 = Excluded by this example’s relevance cutoff

Tune the cutoff for review workload and false positives; semantic relevance does not determine copying or infringement.

The Result

With this system, you can:

Screen candidate videos against a rights-controlled portfolio
Review timestamped, visually similar moments
Generate side-by-side review clips for investigators
Prioritize human review with transparent relevance scores

Use the results as AI-assisted screening, not as a legal conclusion or automated enforcement decision.

Explore the Full Notebook

Open the complete AI-assisted review workflow with batch processing and portfolio management.

Profanity Beeper

Auto-detect and beep curse words in audio

Content Removal

Skip inappropriate visual content in streams

Overview

Agentic Workflows

Video Search and Understanding

Live Intelligence

Content Factory

Programmatic Editing

Safety & Compliance

The Problem

What You’ll Build

Setup

Install Dependencies

Connect to VideoDB

Implementation

Step 1: Index Your Portfolio Videos

Step 2: Upload Suspect Video for Analysis

Step 3: Perform Similarity Comparison

Step 4: Group Sequential Review Candidates

Step 5: Generate Side-by-Side Review Clips

Step 6: Generate a Review Report

What You Get

How It Works

Similarity Thresholds

The Result

Explore the Full Notebook

Profanity Beeper

Content Removal

​The Problem

​What You’ll Build

​Setup

​Install Dependencies

​Connect to VideoDB

​Implementation

​Step 1: Index Your Portfolio Videos

​Step 2: Upload Suspect Video for Analysis

​Step 3: Perform Similarity Comparison

​Step 4: Group Sequential Review Candidates

​Step 5: Generate Side-by-Side Review Clips

​Step 6: Generate a Review Report

​What You Get

​How It Works

​Similarity Thresholds

​The Result

Explore the Full Notebook

​Related Tutorials

Profanity Beeper

Content Removal

The Problem

What You’ll Build

Setup

Install Dependencies

Connect to VideoDB

Implementation

Step 1: Index Your Portfolio Videos

Step 2: Upload Suspect Video for Analysis

Step 3: Perform Similarity Comparison

Step 4: Group Sequential Review Candidates

Step 5: Generate Side-by-Side Review Clips

Step 6: Generate a Review Report

What You Get

How It Works

Similarity Thresholds

The Result

Related Tutorials