Calabi Labs · Guide · 2026-06-15
Openai adopts google synthid watermarks for ai image detection winbu
Here's the complete HTML page:
```html
What Actually Gets Your AI Image Flagged: It's Not Just the Visible Watermark
Most creators focus on visible overlays — a corner logo, a DALL-E sparkle icon — and assume removing those solves the problem. But platform detectors are reading an invisible layer underneath, and that's where the real exposure lives.
Beyond the C2PA manifest, there are supporting signals that compound the detection surface:
- XMP AI flags — fields like
DigitalSourceType: trainedAlgorithmicMediain the image's XMP metadata, explicitly tagging the file as AI-generated. - Encoder fingerprints — AI image pipelines almost universally use libavcodec/Lavc for encoding. That tool tag appears in the bitstream metadata. Video exports carry x264/x265 SEI (Supplemental Enhancement Information) NAL units that fingerprint the encoder chain.
- Missing capture context — real phone photos carry GPS coordinates, camera Make/Model fields, software version strings, and capture timestamps. AI exports have none of these by default. That absence itself is a detectable signal.
In sum: a raw AI export carries a full paper trail of its synthetic origin across multiple independent metadata systems. Platforms don't need to rely on any single one — they cross-check several simultaneously.
Why the Obvious Fixes Don't Work
If you're thinking I'll just crop out the watermark, screenshot it, or re-upload it, here's the honest breakdown of what actually happens at the platform level.
Cropping or screenshotting removes the visible artifact but leaves the metadata layer intact. C2PA JUMBF atoms, XMP AI flags, and encoder fingerprints are embedded in the file structure, not painted into the pixels. A platform scanner reading the file header after upload still sees them. You cannot crop away a metadata tag the same way you crop away a corner logo.
Re-encoding or re-exporting in Photoshop, Preview, or FFmpeg does strip some metadata, but it often fails to remove the C2PA manifest completely — especially if the manifest is cryptographically signed. What's more, re-encoding introduces its own fingerprints. If the new encoder isn't a recognized phone camera app (Adobe tools, generic libavcodec exports), the platform flags the new encoder string as suspicious. You may lose the AI metadata only to gain a "suspicious export tool" flag instead.
How to Actually Clean an AI Image Before Posting
Calabi takes a three-stage pass through your file — not pixel editing, not inpainting, not object removal. It works entirely on the invisible metadata and encoding layer.
- Strip the AI detection signals. Calabi removes every C2PA Content Credential manifest — the JUMBF atoms and C2PA references that say "this was made by an AI." It strips XMP fields including
DigitalSourceType: trainedAlgorithmicMedia, removes generator and tool tags, and clears encoder fingerprints like Lavc and x264 SEI entries from the bitstream. - Inject authentic phone-capture identity. Calabi writes Make, Model, Software version, GPS coordinates, and a capture timestamp from real device profiles — iPhone 15 Pro, Pixel 8 Pro, Galaxy S24 Ultra, and others. It replaces the AI encoder fingerprint with a real phone encoder identifier. The result is a file that looks, to platform scanners, like it came from a physical device.
- Verify with a forensic proof card. Before download, Calabi generates a side-by-side ExifTool report showing exactly what was stripped and what was injected. You see the same scan the platforms use — 18 JUMBF atoms reduced to 0, 16 C2PA references cleared, 144 AI metadata tags reduced to roughly 94 neutral structural tags. No guesswork.
The visible content of your image — the actual pixels, the composition, the details — is untouched. Calabi does not paint over, reconstruct, or fill any region of your image.
Frequently Asked Questions
Cropping removes the visible corner logo or sparkle overlay. It does not remove C2PA Content Credentials, XMP AI flags, or encoder fingerprints embedded in the file header. Those survive cropping because they live in the metadata structure, not the pixel grid. Calabi removes the metadata layer that actually survives cropping and gets scanned at upload.
Can I just re-export my AI image from Photoshop to strip the metadata?
Re-exporting strips some basic metadata, but C2PA manifests are often cryptographically bound to the file and resist casual removal. More importantly, a re-export through desktop software introduces its own encoder fingerprints — tools like Adobe Photoshop or generic FFmpeg exports are recognizable as non-phone pipelines. Platforms may flag the new encoder string as suspicious. Calabi replaces the entire detection surface with a verified phone-capture identity rather than just stripping and hoping for the best.
Try Calabi free at calabilabs.com — 10 cleans, no card.
```