How Image and Video Metadata Works: EXIF, XMP, and C2PA Explained

Q: Which metadata field reveals that an image is AI-generated?

The clearest is an XMP or C2PA DigitalSourceType set to trainedAlgorithmicMedia , an explicit machine-readable declaration of algorithmic origin. Tool/creator tags naming a generator, plus suspiciously empty EXIF, are strong supporting tells.

By Calabi Labs Editorial Team · 2026-07-28

Metadata is the hidden data about a file that rides alongside the pixels — the camera model, the timestamp, the GPS coordinates, the editing software, and increasingly a signed record of AI origin. Three standards dominate: EXIF (technical capture data written by cameras), XMP (flexible descriptive and rights data written by editors), and C2PA (signed provenance). Reading these fields is how a file quietly announces whether it came from a real phone or a generator.

Open any photo you took today and, invisibly attached to it, is a small database describing how it was made. That database is metadata, and it's often more revealing than the image itself. A real camera writes a dense, internally consistent record; an AI generator writes something thin, blank, or self-incriminating. To understand why, you need to know what the three main metadata standards are and what each one carries.

History: where metadata came from

EXIF (Exchangeable Image File Format) is the oldest of the three, standardized by Japan's JEIDA in 1995 (now maintained under the JEITA/CIPA umbrella) so digital cameras could record capture settings inside the image file. Every smartphone and DSLR writes EXIF.

XMP (Extensible Metadata Platform) was introduced by Adobe in 2001 to solve a different problem: EXIF was rigid and camera-focused, but editors and agencies needed flexible, extensible fields for captions, copyright, keywords, and edit history. XMP uses an XML-based structure and can embed or mirror EXIF and IPTC data. The IPTC (International Press Telecommunications Council) photo metadata standard, older still, handles journalistic caption and rights fields and is commonly carried within XMP.

C2PA is the newcomer, published by the Coalition for Content Provenance and Authenticity (founded 2021), adding cryptographically signed provenance to the metadata layer — a tamper-evident record of origin and edits (see c2pa.org). Where EXIF and XMP are plain, unsigned data anyone can write, C2PA is signed.

How it works: the three layers, field by field

Think of a file's metadata as three drawers, each holding a different kind of information.

1. EXIF — the technical capture record. This is where a real camera writes hard evidence of a physical capture: Make (e.g. Apple), Model (e.g. iPhone 15 Pro), Software (the OS version), DateTimeOriginal, exposure time, ISO, f-number, focal length, lens model, and often GPS coordinates. These fields are numerous, specific, and internally consistent on a real device — the focal length matches the lens, the timestamp matches the file, the GPS is plausible. An AI-generated image typically leaves EXIF empty or fills only a few fields, and it never has the coherent physical fingerprint of a real sensor and lens.

2. XMP — the descriptive and rights layer. This drawer holds captions, creator, copyright, keywords, and edit history. Crucially, it's also where AI tools often declare themselves: a generator or editor may write an XMP property such as DigitalSourceType set to trainedAlgorithmicMedia, or leave a tool/creator tag naming the software. XMP is extensible, so it's a common place for the "made by AI" flag to surface even when there's no full C2PA manifest.

3. C2PA — the signed provenance layer. This is the signed manifest, stored in the JUMBF container, that records origin and edit chain with a cryptographic signature. It's the strongest declaration because it's verifiable and tamper-evident. For AI output it can carry explicit assertions that a model produced the file.

Reading them together is the tell. A forensic check doesn't rely on one field; it looks for consistency across all three drawers. A real phone photo has rich EXIF, coherent XMP, and often no C2PA (or a capture credential), all agreeing. An AI file tends to have thin or empty EXIF, an XMP trainedAlgorithmicMedia flag or a tool tag, and possibly a C2PA manifest declaring algorithmic origin — a combination no camera produces. The mismatch is the signal.

What fields reveal AI vs a real camera

To make it concrete, here's what each side typically looks like:

A real phone capture: Make/Model populated, Software = the phone OS, a valid DateTimeOriginal, GPS, exposure and lens data that are physically consistent, and a camera-typical set of tags (a real device can write well over a hundred).
An AI generation: blank or minimal EXIF, no coherent lens/exposure data, an XMP tag pointing to a generator or an explicit trainedAlgorithmicMedia flag, and possibly a signed C2PA manifest. In a forensic view, the difference between a clean, neutral file and a flagged one can be dozens of tags — and whether any AI-origin declarations are present.

What this means for a creator

The practical point is that metadata is a document you're publishing whether you realize it or not, and it can quietly contradict what your file appears to be. If you want a file to read as an authentic phone capture at the file level, the metadata across all three drawers has to be consistent — populated where a camera would populate it, free of leftover generator tags and AI-origin flags, and without an orphaned C2PA manifest. Blanking everything isn't the goal; an empty metadata block is itself unusual. Consistency with a real device is the goal.

Calabi Sanitizer automates exactly this file-level metadata work — stripping AI-origin flags and leftover C2PA manifests, injecting a coherent phone-capture identity (Make, Model, Software, timestamp, GPS), and showing you an ExifTool proof card of the before-and-after tag counts (for example, 144 tags reduced to ~94 neutral tags).

FAQ

What's the difference between EXIF and XMP?

EXIF is the older, rigid standard where cameras write technical capture data (model, exposure, GPS, timestamp). XMP is Adobe's flexible XML-based standard for descriptive and rights data (captions, copyright, edit history) and is where many AI tools write self-identifying tags. A file often carries both.

Which metadata field reveals that an image is AI-generated?

The clearest is an XMP or C2PA DigitalSourceType set to trainedAlgorithmicMedia, an explicit machine-readable declaration of algorithmic origin. Tool/creator tags naming a generator, plus suspiciously empty EXIF, are strong supporting tells.

Does deleting all metadata make a file look like a real photo?

No. A real camera writes rich, consistent metadata, so a completely blank file is itself a red flag. Making a file read as camera-original means having consistent metadata, not none.

Calabi Sanitizer automates the file-level cleanup described here — try it free at calabilabs.com (10 cleans, no card).