Calabi Labs · Guide · 2026-06-15
Exif editor
```html
What Is an EXIF Editor and Why Creators Need One in 2026
An EXIF editor is a tool that lets you view, modify, or strip the metadata embedded in an image or video file — things like camera make and model, GPS coordinates, capture timestamp, software used, and dozens of other technical tags. Traditional EXIF editors like ExifTool, Adobe Bridge, or built-in OS inspectors handle the standard camera and location fields. But if you're working with AI-generated content, those tools miss an entire hidden layer of signals that platforms like Instagram, TikTok, and YouTube now scan automatically. Calabi is built specifically for that layer.
What Actually Gets Your File Flagged
When you upload an image or video, platforms don't just look at the pixels. They scan invisible metadata that travels with your file. The most consequential signals for AI content are:
- C2PA / Content Credentials — stored as JUMBF atoms in the file. This is a cryptographic manifest that says, cryptographically, "this was made by an AI model." It embeds provenance data that survives cropping and re-encoding. A raw export from Midjourney, Sora, or Runway typically contains 18+ of these atoms.
- XMP AI flags — specifically the
DigitalSourceType: trainedAlgorithmicMediatag. This single field is a red flag to automated detection systems and sits in the XMP metadata namespace, separate from classic EXIF. - Encoder fingerprints — video files exported from AI tools carry recognizable encoder tags in their bitstream. Fields like
Lavc(FFmpeg's libavcodec) orx264 SEI(Supplemental Enhancement Information) in the video stream identify the encoding software. AI video exports from Sora, Runway, or Kling consistently show these fingerprints. - Missing capture identity — a file with no GPS, no real camera model, no capture timestamp, and no real device encoder looks suspicious to platforms running provenance checks. Real phone captures have a consistent metadata profile; AI exports lack it entirely.
Standard EXIF editors work on the visible EXIF tags — the ones you see in Photo properties. They don't touch JUMBF/C2PA atoms, XMP AI namespace fields, or video bitstream encoder signatures. That's why editing a few EXIF fields in Photoshop doesn't solve the detection problem.
Why the Obvious Fixes Fail
If you've tried to post AI content and gotten flagged, suppressed, or labeled, you may have attempted one of these approaches:
- Removing EXIF data entirely — stripping all metadata makes a file look like a screenshot or a fresh export from an unknown tool. Platforms flag blank-metadata uploads from accounts that normally post phone captures.
- Cropping the image — cropping removes the visible content that might contain a watermark, but C2PA/JUMBF metadata lives in the file structure itself, not the pixels. It survives cropping completely.
- Screenshotting and re-uploading — this removes some metadata but not C2PA or XMP AI flags. The encoder fingerprint also still appears if the screenshot preserves the original file's embedded stream data.
- Editing EXIF in Photoshop or an online EXIF editor — these tools edit standard EXIF tags (Make, Model, DateTime). They don't strip C2PA atoms, the
trainedAlgorithmicMediaXMP flag, or encoder fingerprints in video files.
The detection layer lives beneath what traditional EXIF tools touch. A full clean requires removing cryptographic manifests, XMP namespace flags, and encoder stream data, then replacing all of it with a coherent, real-device identity profile.
How Calabi Actually Cleans AI Content
Calabi runs a one-pass pipeline that handles the three layers platforms scan:
- Strip the AI signals. Calabi removes all C2PA/JUMBF atoms (verified reduced from 18 to 0 in test runs), the
DigitalSourceType: trainedAlgorithmicMediaXMP flag, generator and tool tags, and encoder fingerprints like Lavc and x264 SEI from video bitstreams. A raw AI export carries roughly 144 metadata tags; Calabi strips the detection-relevant ones, leaving a neutral structural set of about 94 tags. - Inject authentic phone-capture identity. Instead of leaving metadata blank, Calabi writes a real device profile — iPhone 15 Pro, Pixel 8 Pro, or Galaxy S24 Ultra — with Make, Model, Software version, GPS coordinates, and a capture timestamp. It also injects a genuine phone encoder name rather than Lavc or FFmpeg.
- Return a forensic proof card. Before you download, Calabi shows you the ExifTool scan — the same forensic output newsrooms and platforms use — so you can verify exactly what was stripped and what was injected. No guessing.
The result is a file that reads to automated systems as a normal phone recording, with a consistent, believable metadata profile. You upload, the pipeline runs automatically, you review the proof card, and you download the cleaned file.
Frequently Asked Questions
Can't I just use ExifTool to remove AI metadata?
ExifTool is powerful for standard EXIF tags, but it doesn't fully strip C2PA/JUMBF atoms or the XMP AI namespace flags by default. It also doesn't inject a coherent device identity profile. Calabi handles the complete pipeline — strip, inject, verify — in one pass, and shows you the before/after proof.
What about visible watermarks, like Sora's sparkle icon?
Calabi removes the invisible metadata layer that survives cropping. For visible watermarks, cropping or a photo editor handles the visual mark. The problem most creators run into isn't the visible icon — it's the invisible detection signal that persists even after you crop. That's what Calabi targets.
Does this work for video files too?
Yes. Calabi handles video files and strips encoder fingerprints like Lavc and x264 SEI from the video bitstream, not just the container metadata. The pipeline strips the AI signals, injects a phone device profile, and returns a proof card showing the bitstream changes.
Try Calabi free at calabilabs.com — 10 cleans, no card.
```