Batch Remove NotebookLM Watermarks: Process Multiple Files at Once (2026)

One File Is Easy — What About Twenty?

Removing a NotebookLM watermark from a single file takes seconds. But if you've exported an entire course worth of slide decks, a week's worth of video overviews, or a batch of Gemini images for a project, doing them one at a time gets tedious fast.

This guide covers three approaches to batch watermark removal, from the simplest (our browser tool) to fully automated pipelines. Pick the one that matches your volume and technical comfort level.

Approach 1: Our Browser Tool (1–10 Files)

The simplest option. NotebookLM Remover processes files entirely in your browser — no upload, no server. For small batches, the workflow is straightforward:

1. Go to the tool page for your format (video, slides, PPTX, infographic, or Gemini image)
2. Drop your first file into the dropzone
3. Wait for processing (typically 2–10 seconds depending on format and file size)
4. Download the cleaned file
5. Repeat for the next file

Pros:

• Zero setup — works in any modern browser
• 100% local processing — files never leave your device
• Handles all formats: video, PDF, PPTX, infographics, Gemini images, audio
• Free, no account required

Cons:

• One file at a time (sequential processing)
• Manual download for each result
• Not practical for 50+ files

Best for: Teachers cleaning a handful of lecture slides, students preparing a few presentations, anyone with fewer than 10 files.

Approach 2: Python Scripts (10–100+ Files)

If you're comfortable with Python, scripting gives you true batch processing with a single command. The same libraries that power professional tools can process entire directories of files automatically.

Batch PPTX Watermark Removal

The python-pptx library can open, modify, and save PowerPoint files. The watermark in NotebookLM PPTX exports is a shape element carrying a hyperlink to gamma.app or containing "NotebookLM" branding — it sits in slide layouts and masters, so removing it there clears every slide.

from pptx import Presentation
import glob, os

input_dir = "exports/"
output_dir = "cleaned/"
os.makedirs(output_dir, exist_ok=True)

for filepath in glob.glob(f"{input_dir}*.pptx"):
    prs = Presentation(filepath)
    removed = 0

    for master in prs.slide_masters:
        for layout in master.slide_layouts:
            for shape in list(layout.shapes):
                try:
                    addr = (shape.click_action.hyperlink.address or "").lower()
                except Exception:
                    addr = ""
                if "notebooklm" in addr or "google" in addr:
                    shape._element.getparent().remove(shape._element)
                    removed += 1

    out = os.path.join(output_dir, os.path.basename(filepath))
    prs.save(out)
    print(f"{os.path.basename(filepath)}: removed {removed} watermark(s)")

Run it: pip install python-pptx && python batch_pptx.py

Batch PDF Watermark Removal

For PDF slides, PyMuPDF (imported as fitz) can remove watermark annotations and images from each page:

import fitz  # pip install PyMuPDF
import glob, os

input_dir = "exports/"
output_dir = "cleaned/"
os.makedirs(output_dir, exist_ok=True)

for filepath in glob.glob(f"{input_dir}*.pdf"):
    doc = fitz.open(filepath)
    removed = 0

    for page in doc:
        # Remove link annotations pointing to NotebookLM/Google
        for link in page.get_links():
            uri = (link.get("uri") or "").lower()
            if "notebooklm" in uri or "google.com" in uri:
                page.delete_link(link)
                removed += 1

    out = os.path.join(output_dir, os.path.basename(filepath))
    doc.save(out, deflate=True, garbage=4)
    doc.close()
    print(f"{os.path.basename(filepath)}: removed {removed} watermark(s)")

Batch Video Watermark Removal

For video overviews, ffmpeg-python wraps FFmpeg's delogo filter. The watermark coordinates are fixed per resolution:

import ffmpeg
import glob, os

input_dir = "exports/"
output_dir = "cleaned/"
os.makedirs(output_dir, exist_ok=True)

# NotebookLM 1080p watermark coordinates
DELOGO = {"x": 1104, "y": 656, "w": 770, "h": 62}
TAIL_TRIM = 2.5  # seconds to trim from end

for filepath in glob.glob(f"{input_dir}*.mp4"):
    probe = ffmpeg.probe(filepath)
    duration = float(probe["format"]["duration"])

    out = os.path.join(output_dir, os.path.basename(filepath))
    (
        ffmpeg
        .input(filepath, t=duration - TAIL_TRIM)
        .video.filter("delogo", **DELOGO)
        .output(out, acodec="copy", vcodec="libx264", crf=18)
        .overwrite_output()
        .run(quiet=True)
    )
    print(f"Cleaned: {os.path.basename(filepath)}")

Pros of the Python approach:

• True batch processing — hundreds of files in one command
• Fully customizable — adjust detection logic, output quality, naming conventions
• Scriptable and repeatable — add to CI/CD pipelines or scheduled tasks
• Process files locally — same privacy as the browser tool

Cons:

• Requires Python installation and library setup
• Need to know correct watermark coordinates per resolution (for video)
• Debugging requires technical knowledge
• Detection logic is your responsibility — our browser tool handles edge cases automatically

Approach 3: Shell Script + FFmpeg (Video Only)

If you only need to batch-process video files and have FFmpeg installed, a simple shell loop does the job without Python:

#!/bin/bash
mkdir -p cleaned

for f in exports/*.mp4; do
  name=$(basename "$f")
  duration=$(ffprobe -v error -show_entries format=duration \
    -of default=noprint_wrappers=1:nokey=1 "$f")
  trimmed=$(echo "$duration - 2.5" | bc)

  ffmpeg -i "$f" -t "$trimmed" \
    -vf "delogo=x=1104:y=656:w=770:h=62" \
    -c:a copy -crf 18 "cleaned/$name" -y

  echo "Done: $name"
done

Save as batch_clean.sh, make it executable (chmod +x batch_clean.sh), and run. Adjust the delogo coordinates if your videos are 720p (x=736:y=437:w=513:h=41).

Which Approach Should You Use?

Scenario	Best Approach	Why
1–10 files, any format	Browser tool	Zero setup, handles everything
10–50 mixed files	Python script	One command, all formats
50+ video files only	Shell + FFmpeg	Fastest for video-only batches
Recurring daily/weekly exports	Python + cron/scheduler	Automate entirely, fire and forget
Non-technical user, any volume	Browser tool	No install, no command line

Tips for Efficient Batch Processing

• Organize first — sort files by format (PDF, PPTX, video) into separate folders before running batch scripts. Each format needs a different processing approach.
• Check resolution — video watermark coordinates differ between 1080p and 720p. Process each resolution separately or add resolution detection to your script.
• Verify a sample — run your script on 2–3 files first and manually check the results before processing the entire batch.
• Keep originals — always output to a separate directory. Never overwrite the source files.
• Monitor disk space — video processing can consume significant space. A batch of 50 HD videos needs ~25 GB of working space for the cleaned copies.

Privacy Across All Approaches

Every method described here processes files locally on your device:

• Browser tool — runs entirely in your browser via WebAssembly. Files never leave the tab.
• Python scripts — run on your machine. Nothing is uploaded anywhere.
• Shell scripts — FFmpeg runs locally. No network calls involved.

No approach in this guide sends your files to a remote server. If privacy matters (and for business or academic documents, it should), all three options are equally safe.

Frequently Asked Questions

Can your browser tool process multiple files at once?

Currently it processes one file at a time. You can drop the next file as soon as the previous one finishes — there's no enforced delay. For true parallel batch processing across dozens of files, use the Python scripting approach described above.

Will batch processing affect the quality?

No. Each file is processed identically whether it's the first or the hundredth. For images and documents, removal is lossless (we delete the watermark element, not redraw the image). For video, the quality depends on your encoding settings — the scripts above use CRF 18, which is visually lossless.

Can I automate this to run whenever I export from NotebookLM?

Yes, with a folder-watching script. Set up a Python script that monitors your downloads folder for new NotebookLM exports (using watchdog or a simple polling loop), processes them automatically, and saves the cleaned versions to a separate folder. Combine with the batch scripts above for a fully hands-free pipeline.