Calabi Labs · Guide · 2026-06-14
Batch watermark removal guide
Batch Watermark Removal: What Actually Works in 2026
There's no tool that erases visible logos from hundreds of images in one click — anyone telling you otherwise is selling photo-editing vaporware. What does work at scale is stripping the invisible detection layer that gets your AI content flagged on Instagram, TikTok, YouTube, and Reddit before a human ever sees it. That layer — C2PA manifests, XMP AI tags, and encoder fingerprints — is what batch processing actually removes, cleanly and verifiably, across an entire folder of files.
What Actually Gets Your Files Flagged
When a platform "detects AI content," it's not looking at whether your image looks generated. It's scanning the invisible metadata and digital signatures baked into your file. The specific signals that trigger automated flags in 2026 include:
- C2PA / Content Credentials manifests — JUMBF atoms embedded in the file that cryptographically declare "this was made by AI." Platforms like Adobe and Microsoft already honor these manifests, and Instagram's backend scans for them.
- XMP AI flags — Fields like
DigitalSourceType: trainedAlgorithmicMedia,Generator: Adobe Firefly, andCreatorTooltags that sit in the XMP metadata layer readable by any ExifTool-compatible scanner. - Encoder fingerprints — Specific codec signatures in video files, like
Lavc(FFmpeg) orx264 SEINAL units, that identify the encoding software as AI-generated rather than a phone capture. - Missing provenance signals — A real phone photo has GPS coordinates, a capture timestamp, and a real device Make/Model. AI exports have none of these. Platforms flag the absence as much as the presence.
A raw AI export from Midjourney, Sora, DALL-E, or Runway can carry 140+ metadata tags that scream "artificial." That metadata survives cropping, screenshotting, and re-saving — because it's not in the visible pixels.
Why the Obvious Fixes Fail at Scale
If you're processing 50 or 500 files, you already know these approaches don't cut it:
- Batch cropping — Removes the visible corner logo or watermark, yes. But C2PA atoms, XMP AI tags, and encoder fingerprints sit in the file's metadata layer, not the pixel grid. Cropping touches none of them. You remove the visible mark; the invisible "made by AI" signal stays intact.
- Batch screenshotting / re-saving — Re-encoding through a screen capture strips some metadata but rarely all of it.
x264 SEIencoder fingerprints persist through re-encoding, and most tools don't touch C2PA manifests at all. You lose quality from re-encoding and still don't get a clean forensic bill of health. - Python / ExifTool scripts — You can write a script to strip EXIF and XMP tags from a folder. But C2PA manifests use a specific JUMBF binary structure that basic EXIFTool commands miss. You'd need deep knowledge of the C2PA spec to catch all 18+ JUMBF atom types, and encoder-specific fingerprints require parsing video bitstream headers.
- Standalone batch metadata strippers — Some tools strip metadata but leave you with no proof of what was removed or what was injected. You can't verify what a platform will actually scan. That's a trust gap, not a solution.
How to Batch-Remove the Detection Layer with Calabi
Calabi processes files through a three-stage pipeline that strips the detection signals, injects authentic phone-capture identity, and gives you a forensic proof card for every file. Here's how to run it on a batch:
- Upload your files — Drag and drop a folder of AI-generated videos or images. Calabi processes them one at a time through its automatic pipeline — no manual settings per file.
- Automatic strip + inject — For each file, Calabi strips all C2PA manifests (reducing JUMBF atoms from 18 to 0, C2PA references to 0), removes
DigitalSourceType: trainedAlgorithmicMediaand all generator/tool XMP tags, and removes encoder fingerprints like Lavc and x264 SEI. It then injects a real phone device profile — iPhone 15 Pro, Pixel 8 Pro, or Galaxy S24 Ultra — with GPS, capture timestamp, and a genuine phone encoder name. - Review the forensic proof card — Every file comes back with an ExifTool-readable report showing exactly what was stripped and what was injected. You see the before-and-after count: 144 tags down to ~94 neutral structural tags, 18 JUMBF atoms to 0. That's the same scan platforms use, so you know exactly what they'll see.
- Download the cleaned files — Export the batch with their new phone-capture identity intact. Ready to upload to any platform.
No pixel editing. No inpainting. No clone-stamp. The visible watermark — if present — is a cropping job. Calabi handles the invisible detection layer that cropping leaves behind.
FAQ
Can Calabi remove visible watermarks from a batch of 100 images?
No. Calabi doesn't edit pixels, doesn't use inpainting, and doesn't reconstruct any region of an image. If your files have a visible corner logo or Sora-style sparkle mark, crop it out first — that's a standard editing step. Calabi then strips the invisible metadata layer that survives cropping and would get you flagged anyway.
Does batch processing degrade video quality?
Calabi re-encodes through its pipeline but preserves structural quality. The forensic proof card shows the exact metadata changes — the tag count before and after — so you can verify the output meets your standards before downloading.
How does Calabi compare to running ExifTool or a Python script on a folder?
Scripts can strip basic EXIF and XMP tags. They almost never catch the full C2PA JUMBF manifest structure, video-specific encoder fingerprints like x264 SEI NAL units, or the trainedAlgorithmicMedia flag. Calabi's pipeline targets all of them and returns a verifiable proof card showing exactly what was removed — something a script can't give you.
Try Calabi free at calabilabs.com — 10 cleans, no card.