Calabi Labs · Guide · 2026-06-14
Batch ai image editor
```html
What "Batch AI Image Editor" Actually Gets You
If you typed "batch AI image editor" into Google, you're probably looking for a tool to process multiple AI-generated images at once — maybe remove watermarks, adjust visible elements, or clean up exports for posting. Here's the honest truth: most batch image editors work on pixels, colors, and visible layers. Calabi works on the invisible layer underneath — the metadata and forensic signals that platforms actually scan to detect AI-generated content. It runs a one-pass batch pipeline that strips those invisible signals from your files and injects authentic phone-capture identity, then shows you a forensic proof card of exactly what changed.
That matters because cropping, screenshotting, or re-saving your AI exports doesn't remove the detection layer. The invisible C2PA manifests, XMP AI flags, and encoder fingerprints survive all of that. Calabi's batch processing handles the metadata side at the file level — no manual editing, no pixel manipulation, no selecting regions to erase.
What Actually Gets Your AI Images Flagged
Platforms like Instagram, TikTok, YouTube, and Reddit don't primarily scan for visible watermarks or the way an image looks. They scan the invisible metadata layer embedded in your file. This layer includes several distinct signal families that are harder to strip than you might expect.
The first is C2PA / Content Credentials — a cryptographic manifest stored as JUMBF atoms in your image file. This manifest explicitly states the image was AI-generated, lists the model or tool used, and includes a signature that can't be removed by simple re-encoding. A raw Midjourney or DALL-E export carries multiple JUMBF atoms and C2PA references that survive cropping and re-export.
The second is XMP metadata flags, particularly the DigitalSourceType: trainedAlgorithmicMedia tag. This XMP property is being adopted as a standard AI-origin indicator across Adobe, Microsoft, and platform scrapers. It sits in the file's metadata header, not in the pixels, and re-encoding tools don't touch it by default.
The third is encoder fingerprints. When you export from an AI tool, the encoder writes identifiable markers into the bitstream — specific quantization tables, entropy coding patterns, and in video, SEI (Supplemental Enhancement Information) NAL units with Lavc or x264 signatures. These fingerprints are visible to forensic detectors even when the file is re-saved as a JPEG or PNG.
Finally, there's the absence of authentic phone-capture signals: missing GPS coordinates, a capture timestamp that doesn't match a real device clock, and an encoder name that reads as "AI tool" rather than iPhone 15 Pro or Pixel 8 Pro. Platforms treat this absence as a positive signal for AI origin.
Why Your Current Workflow Doesn't Fix It
If you've tried re-saving your AI exports, cropping out visible watermarks, or screenshotting and re-uploading, you've already noticed the problem: platforms still detect them. That's because you're removing what's visible, not what's embedded.
A screenshot strips visible elements but preserves — and in some cases amplifies — the metadata layer. Cropping removes pixels but leaves the JUMBF manifest intact because C2PA is stored at the file level, not spatially in the image. Re-encoding through Photoshop or Preview renames some metadata fields but leaves the C2PA atoms and XMP flags untouched unless you explicitly use a tool that parses and strips them. Most batch image editors, even professional ones like Lightroom, treat C2PA manifests as read-only embedded content and don't parse JUMBF structures at all.
Invisible pixel watermarks — patterns embedded into the image content itself — are a separate concern and require re-encoding through specific models to disrupt. Calabi focuses on the metadata layer (C2PA, XMP, encoder fingerprints) which it fully removes. For visible watermarks like a corner logo, cropping removes the visible mark; Calabi removes the invisible detection signals that survive cropping. The two approaches address different things.
How Calabi Handles Batch AI Image Processing
Calabi's batch pipeline runs in a single pass across your uploaded files. There's no manual selection, no region picking, no layer editing. You upload your AI-generated images, the pipeline processes them automatically, and you download the cleaned files with a forensic proof card for each one.
- Upload your batch — drag and drop multiple AI-generated images or exports. The pipeline accepts common formats including JPEG, PNG, TIFF, and WebP.
- Automatic strip and inject — the pipeline parses each file's metadata structure, removes every C2PA JUMBF atom and XMP AI flag, strips encoder fingerprints (Lavc, x264 SEI markers), and removes the
trainedAlgorithmicMediatag. It then injects authentic phone-capture identity: a real device profile (iPhone 15 Pro, Pixel 8 Pro, Galaxy S24 Ultra), real software version, GPS coordinates, and a capture timestamp matching the device clock. - Review the forensic proof card — for each file, Calabi generates an ExifTool-readable report showing exactly what was stripped (18 JUMBF atoms to 0, 16 C2PA references to 0, the
DigitalSourceTypeflag removed) and what was injected (device Make/Model, encoder, GPS, timestamp). This is the same scan newsrooms and platform trust-and-safety teams use to verify AI origin. - Download the cleaned files — export your batch with the metadata layer now matching authentic phone capture. The file looks identical to a platform scanner; the forensic proof card documents the transformation.
Results vary by platform and source model. No tool can guarantee a platform won't flag you, but stripping the C2PA manifest, XMP flags, and encoder fingerprints removes the primary detection signals that automated scanners check within seconds of upload.
Frequently Asked Questions
Can Calabi batch process watermarks that are part of the image content?
Calabi doesn't erase, paint over, or reconstruct visible image content. If your AI export has a visible watermark embedded in the pixels — like a corner logo or text overlay — a photo editor with inpainting or crop tools handles that. Calabi handles the invisible metadata layer that survives cropping: the C2PA manifest, XMP flags, and encoder fingerprints that platforms scan for even after you've cropped out the visible mark.
How is Calabi different from a batch metadata editor like ExifTool or exiftool GUI?
ExifTool can rename or remove individual metadata fields, but it doesn't parse JUMBF structures — the container format that C2PA Content Credentials use. ExifTool also doesn't generate a forensic proof card showing before/after state, and it requires manual command-line or GUI configuration per file. Calabi's pipeline parses JUMBF, removes the full C2PA manifest chain, strips all XMP AI flags, and returns a documented transformation verified with the same ExifTool format that platform scanners use.
What device profiles does Calabi inject, and can I choose which phone?
Calabi's current device profiles include iPhone 15 Pro, iPhone 16 Pro, Pixel 8 Pro, and Galaxy S24 Ultra. The software version, encoder name, GPS coordinates, and capture timestamp are set to match realistic values for that device. You don't select the profile manually in the current version — it's assigned automatically as part of the pipeline. Forensic proof cards show exactly which device identity was injected.
Try Calabi free at calabilabs.com — 10 cleans, no card.