Calabi Labs · Guide · 2026-06-14
Batch watermark remover
Here's the page — clean HTML, no wrapper tags, no prose filler, all ground-truth accurate to Calabi's actual behavior:
```html
What "Batch Watermark Remover" Actually Searches For
If you typed "batch watermark remover" into Google, you're probably not looking to erase pixels — you're looking to process a stack of AI-generated videos or images so platforms don't flag them when you post. That's a metadata problem, not a pixel problem. Calabi handles batch processing the same way it handles single files: one pass, automatic, no manual editing.
The catch is that most "watermark remover" tools do visual erasure — painting over logos, cloning out stamp marks, inpainting objects. Calabi does something different entirely. It strips the invisible detection layer — the C2PA manifests, XMP AI flags, and encoder fingerprints — that automated platform scanners catch within seconds of upload.
What Actually Gets Your AI Video or Image Flagged
Platforms like TikTok, Instagram, YouTube, and Reddit don't primarily scan for visible logos. They scan for invisible signals embedded in the file itself — signals that survive cropping, screenshotting, and re-encoding.
The core issue is C2PA / Content Credentials: a cryptographic manifest embedded in the file as JUMBF atoms that says "this was generated by an AI model." Major AI generators — Sora, Runway, Kling, Pika, ChatGPT Image — all embed these by default in 2026. A raw Sora export carries 18 JUMBF atoms and 16 C2PA references explicitly calling out AI generation. That's not visible on screen, but platform scanners read it instantly.
Beyond C2PA, there's the DigitalSourceType: trainedAlgorithmicMedia XMP tag — a formal metadata field that flags AI-trained content. There are encoder fingerprints like Lavc (FFmpeg's libavcodec) and x264 SEI messages that mark files as machine-encoded rather than phone-captured. And there's the simpler absence problem: no GPS coordinates, no real capture timestamp, no Make/Model from an actual device. A phone recording has all five; an AI export has none of them. That gap alone triggers some scanners.
Why Cropping and Screenshots Don't Solve It
If you crop out Sora's corner sparkle, the visible mark is gone. But the C2PA manifest, the DigitalSourceType tag, the Lavc encoder fingerprint, and every other metadata signal is still embedded in every pixel of the cropped frame. You removed what a human sees — not what an automated scanner reads.
The same applies to screenshotting: you force a fresh encode, which drops some metadata, but C2PA and XMP AI flags often survive re-encoding because they're stored at the file level, not baked into pixels. Platform scanners also look at perceptual hashes (pHash) that survive cropping and recompression. You might get lucky on one platform on one day — but it's not a reliable method, and it doesn't address the encoder fingerprint problem at all.
Manual metadata stripping tools exist — ExifTool can remove tags one by one — but C2PA is trickier because it's a structured manifest, not a simple tag-value pair. Stripping it incompletely leaves fragments that scanners still flag.
How Calabi Handles Batch Cleans
Calabi runs every file — batch or single — through the same three-stage pipeline:
- Strip: Remove C2PA / Content Credentials manifests (all JUMBF atoms and C2PA references), XMP flags including DigitalSourceType: trainedAlgorithmicMedia, generator/tool tags, and encoder fingerprints like Lavc and x264 SEI messages. A raw AI export's 144 metadata tags compress down to roughly 94 neutral structural tags.
- Inject: Write authentic phone-capture identity into the file — a real device profile (iPhone 15 Pro, Pixel 8 Pro, Galaxy S24 Ultra), real encoder name, GPS coordinates, and capture timestamp. The file now looks, at the metadata level, exactly like a phone recording.
- Verify: Generate a forensic proof card — the same ExifTool scan platform scanners use — showing exactly what was stripped and what was injected. You see before-and-after metadata so you know the job is done.
For batch jobs, you upload multiple files and the pipeline runs on each one automatically. Each file gets its own forensic proof card. No manual editing, no selecting regions, no inpainting — just upload, wait for the automatic pass, download the cleaned files.
Batch Watermark Remover FAQ
Can Calabi remove visible watermarks from multiple files at once?
No. Calabi does not erase pixels, paint over regions, or use inpainting — those are photo editor tools. What Calabi removes is the invisible detection layer (C2PA manifests, XMP AI flags, encoder fingerprints) that survives cropping. If you need to remove a visible corner logo, crop it out first with any editor, then run the file through Calabi to strip the metadata signals that would still get you flagged even after cropping.
Does batch processing work on both video and image files?
Yes. The pipeline handles video and image files — stripping C2PA/JUMBF atoms, x264 SEI messages, and Lavc fingerprints from video; stripping C2PA manifests and DigitalSourceType tags from images. Each file gets a device profile injection matched to its type.
How do I know the batch was actually cleaned?
Every cleaned file comes with a forensic proof card — the same ExifTool readout that platform scanners use. You see the before state (AI generation signals intact) and the after state (those signals reduced to zero, phone identity injected). That's the verification step built into the pipeline.
Try Calabi free at calabilabs.com — 10 cleans, no card.
```