XMP Metadata Explained -- The Hidden Layer Adobe Created

In 2001, Adobe faced a metadata problem. Photoshop, Illustrator, and InDesign each stored metadata in different proprietary formats. EXIF covered camera data but could not handle creative workflows. IPTC handled news captions but lacked extensibility. Adobe needed a metadata format that could describe anything -- camera settings, copyright, editing history, color profiles, search keywords, and custom application data -- all within a single, extensible framework. Their solution was the Extensible Metadata Platform, or XMP. Twenty-five years later, XMP has become the primary way AI image generators tag their output. Midjourney writes XMP. DALL-E writes XMP. Adobe Firefly writes XMP. If you want to understand how AI images carry identifying information, you need to understand XMP.

What Is XMP and How Does It Work?

XMP is a metadata standard based on the Resource Description Framework (RDF), which is itself a World Wide Web Consortium (W3C) standard for representing relationships between things. RDF uses a subject-predicate-object model (called "triples") to make statements about resources. In XMP's context, the resource is an image file, and the statements are metadata about that image.

XMP serializes RDF data using XML (Extensible Markup Language). An XMP packet is a well-formed XML document embedded within an image file, wrapped in specific processing instructions that allow parsers to locate and extract it. The basic structure looks like this:

<?xpacket begin="..." id="W5M0MpCehiHzreSzNTczkc9d"?>
<x:xmpmeta xmlns:x="adobe:ns:meta/">
  <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
    <rdf:Description rdf:about=""
      xmlns:dc="http://purl.org/dc/elements/1.1/"
      dc:title="My Photo"
      dc:creator="Jane Doe"/>
  </rdf:RDF>
</x:xmpmeta>
<?xpacket end="w"?>

The <?xpacket?> processing instructions mark the boundaries of the XMP packet. The <x:xmpmeta> element wraps the entire packet. Inside, <rdf:RDF> contains one or more <rdf:Description> elements, each containing metadata statements expressed as XML attributes or child elements.

The key innovation of XMP is its use of XML namespaces. Each namespace defines a vocabulary of property names (predicates) for a specific domain. The Dublin Core namespace (dc:) defines general-purpose metadata like title, creator, and description. The EXIF namespace (exif:) mirrors EXIF fields in XMP format. The IPTC namespace (iptc4xmpCore: and iptc4xmpExt:) provides news-industry metadata. And any organization can define its own namespace -- which is exactly what AI tool makers have done.

How XMP Lives Inside Image Files

XMP packets are embedded in image files using format-specific mechanisms:

JPEG: XMP is stored in APP1 marker segments (the same segment type used for EXIF). A JPEG file can contain multiple APP1 segments -- one for EXIF and one for XMP. The XMP packet is identified by the namespace declaration xmlns:x="adobe:ns:meta/". XMP APP1 segments typically begin with the string http://ns.adobe.com/xap/1.0/ as a namespace identifier.

PNG: XMP is stored in iTXt (international text) chunks with the keyword "XML:com.adobe.xmp." PNG's chunk architecture allows unlimited metadata chunks, so XMP fits naturally within the format.

TIFF/HEIF: XMP is stored in a dedicated IFD tag (tag 700, type Byte). The XMP packet occupies the entire tag value.

WebP: XMP is stored in a dedicated XMP chunk within the RIFF container, following the WebP specification for extended format files.

PDF: XMP is embedded as a stream object within the PDF structure, typically attached to the document catalog.

A single image file can contain multiple XMP packets. The XMP specification defines rules for merging packets -- when multiple descriptions exist for the same property, the last one (in file order) takes precedence. This allows editing tools to append new metadata without modifying the original XMP packet, which is important for preserving provenance chains.

The AI Tool XMP Namespaces

This is where XMP becomes directly relevant to AI image detection. Every major AI image generator that writes XMP uses custom namespaces to store identifying information. These namespaces are the digital fingerprints that reveal an image's AI origin.

OpenAI / DALL-E namespace: DALL-E 3 embeds XMP data using the openai: namespace prefix (URI: http://ns.openai.com/xmp/1.0/). Key properties include:

• openai:GenerativeTool -- set to "DALL-E 3"
• openai:GenerativeVersion -- the specific model version (e.g., "3.1")
• openai:Prompt -- the generation prompt text
• openai:Revision -- the API revision identifier
• openai:Seed -- the generation seed value

The prompt field is particularly significant. It means that the exact text you typed to generate a DALL-E image is permanently embedded in the image file, readable by anyone with an XMP parser. This has obvious privacy implications -- prompts may contain personal information, proprietary concepts, or sensitive content that the creator did not intend to share.

Midjourney namespace: Midjourney v6 embeds XMP data using an mwg-rs: (Metadata Working Group - Region Schema) namespace alongside custom fields. Key properties include:

• mwg-rs:Regions -- sometimes contains region data related to the generation
• Custom Software field set to "Midjourney"
• xmp:CreatorTool set to "Midjourney Bot"
• xmp:MetadataDate -- the generation timestamp
• dc:description -- may contain the prompt text or a truncated version

Midjourney's XMP implementation is less structured than DALL-E's. It relies more on standard XMP properties (like xmp:CreatorTool) than custom namespaces, which makes detection somewhat easier -- the "Midjourney" string in the CreatorTool field is a straightforward signature to scan for.

Adobe Firefly namespace: Adobe Firefly uses the xmp: and stEvt: (Resource Event) namespaces extensively, along with custom Adobe namespaces:

• xmp:CreatorTool -- set to "Adobe Firefly"
• stEvt:softwareAgent -- the Firefly version and build
• stEvt:action -- set to "generated" with a timestamp
• xmpMM:DocumentID -- a unique UUID for the generated image
• xmpMM:InstanceID -- a unique UUID for this specific file instance
• xmpMM:OriginalDocumentID -- the original document UUID (preserved across edits)

Adobe's XMP implementation is the most comprehensive because Adobe created XMP. Firefly leverages the full XMP Media Management (xmpMM:) schema to create a complete asset tracking system, with UUIDs that persist across edits and format conversions.

Stable Diffusion / ComfyUI namespace: Open-source tools like Stable Diffusion WebUI and ComfyUI write variable XMP data depending on configuration. The most common fields include:

• xmp:CreatorTool -- set to "Stable Diffusion WebUI" or "ComfyUI"
• User-defined parameters in the Parameters text field (which may be stored in EXIF UserComment rather than XMP)
• Workflow JSON data (ComfyUI-specific, sometimes stored as base64-encoded XMP)

The variability of open-source tool metadata is a challenge for detection. Because users can modify the source code, they can change or omit any XMP fields. A default Stable Diffusion WebUI installation writes identifiable metadata, but a modified installation may write nothing at all.

ISO 16684: The Standard Behind XMP

XMP was standardized as ISO 16684 (Graphic technology -- Extensible metadata platform) in 2011, with a major revision (ISO 16684-1:2019) published in 2019. The ISO standard codifies what Adobe had already implemented, ensuring that XMP is not solely dependent on Adobe's continued support.

ISO 16684 defines:

• The XMP data model (based on RDF)
• The XMP serialization format (based on XML)
• The embedding methods for various file formats
• The rules for XMP packet merging and property precedence
• The standard XMP namespaces and their properties

The standardization of XMP was important for its adoption beyond Adobe's ecosystem. Without ISO standardization, other software companies would have been reluctant to implement a format controlled by a single vendor. ISO 16684 gave XMP the institutional legitimacy needed for broad industry adoption.

However, the standard has not been updated since 2019, and it does not address the AI-specific namespaces and use cases that have emerged since 2023. The ISO working group is considering a new revision (ISO 16684-1:2027) that would formalize AI-related XMP namespaces and define standard properties for AI generation metadata. This revision is in early stages and may take several years to complete.

How to Read XMP Metadata

Reading XMP metadata from an image file requires an XMP parser. Here are the most common approaches:

Online tools: Websites like RemoveAI Image, Jeffrey's EXIF Viewer, and the C2PA Content Credentials validator can extract and display XMP data from uploaded images. RemoveAI Image shows all XMP namespaces and properties, making it easy to identify AI-generation markers.

Desktop software: Adobe Bridge provides the most comprehensive XMP viewer, displaying all namespaces in a structured format. ExifTool (command-line) can extract XMP data with the -xmp flag. ExifTool is the gold standard for metadata extraction and supports virtually every XMP namespace in existence.

Programmatic extraction: For developers, several libraries can parse XMP:

• Python: python-xmp-toolkit or libxmp (bindings to Adobe's XMP SDK)
• JavaScript/Node.js: exifr reads XMP from images in the browser
• Java: Adobe's official XMP SDK (Java bindings)
• Go: github.com/andrianbdn/xmp provides basic XMP parsing

When reading XMP from an AI-generated image, look for these telltale properties:

1. xmp:CreatorTool -- if it contains "DALL-E," "Midjourney," "Stable Diffusion," "Firefly," or any AI tool name, the image is AI-generated
2. openai:GenerativeTool -- specific to OpenAI images
3. stEvt:action with value "generated" -- indicates AI generation in Adobe's schema
4. Any custom namespace with "generative" or "ai" in the URI -- likely an AI-specific namespace
5. xmpMM:DocumentID with a UUID that matches known AI generator patterns

How to Remove XMP Metadata

XMP metadata can be removed from image files using several methods:

Canvas redraw (most thorough): Redrawing the image through an HTML5 Canvas strips all metadata, including XMP, EXIF, IPTC, C2PA, and GPS data. This is the method used by RemoveAI Image. The browser loads the pixel data into a Canvas element, then exports it as a new image file. The new file contains only the pixel data -- no metadata from the original file survives. This is the most reliable method because it does not depend on correctly parsing and removing individual metadata blocks; it simply does not carry them forward.

ExifTool removal: The command exiftool -xmp:all= image.jpg removes all XMP properties from the file. ExifTool can also remove specific namespaces (e.g., exiftool -openai:all= image.jpg to remove only OpenAI XMP data while preserving other XMP). This approach is precise but requires ExifTool to be installed and requires knowledge of which namespaces to target.

Image editing software: Most image editors provide metadata management. Photoshop's File Info dialog allows viewing and deleting XMP properties. Lightroom's metadata panel allows editing but does not easily support bulk deletion. GIMP can export images without metadata by checking "Save EXIF data" off, but XMP handling varies by version.

Social media stripping: Most social media platforms strip XMP data during upload. Facebook, Instagram, and Twitter all remove XMP from the publicly visible image. However, they read and process the XMP data before stripping it -- meaning they have already extracted and stored any AI-identifying information before the public ever sees the image.

FAQ

Is XMP the same as EXIF?

No. EXIF and XMP are separate metadata standards that serve different purposes. EXIF is a fixed-vocabulary binary format designed for camera capture data (shutter speed, aperture, GPS coordinates). XMP is an extensible XML-based format designed for creative workflow data (editing history, asset management, custom properties). They often coexist in the same image file -- many cameras and tools write the same data to both EXIF and XMP for compatibility. However, XMP can express far more than EXIF, which is why AI tools prefer XMP for embedding their identifying information.

Can I add custom XMP data to my images?

Yes. XMP's extensibility is its defining feature. Anyone can define a custom XML namespace and embed it in an XMP packet. You could, for example, create a namespace called myapp: with properties like myapp:projectCode or myapp:approvalStatus and embed them in your images. This is both a strength (flexibility) and a weakness (there is no central registry to prevent namespace collisions or enforce consistency). Adobe maintains a registry of well-known namespaces, but it is advisory, not mandatory.

Does stripping XMP affect image quality?

No. XMP metadata is stored separately from the pixel data in all supported image formats. Removing XMP does not alter the visual content of the image in any way. The only change is a reduction in file size (typically 2-30 KB, depending on how much XMP data was embedded). The pixels, colors, resolution, and compression remain identical after XMP removal.

---

XMP is the invisible hand that connects your AI-generated images to the tools that made them. From generation prompts embedded by DALL-E to asset-tracking UUIDs written by Adobe Firefly, XMP metadata carries more identifying information than most creators realize. RemoveAI Image strips XMP data along with EXIF, IPTC, C2PA content credentials, and GPS coordinates -- all processed locally in your browser with zero server uploads. Take control of what your images reveal today.