What each tool writes

• AUTOMATIC1111's web UI writes a PNG text chunk named parameters. It holds your prompt, negative prompt, steps, sampler, CFG scale, seed, size, model name and model hash, plus anything an extension adds.
• ComfyUI stores the API graph in a text chunk called prompt, and the UI graph in another called workflow, unless metadata is disabled on the server. A workflow can be big and may include checkpoint and LoRA file names from your machine.
• None of this is signed. It is ordinary metadata, not a C2PA manifest, so anybody can read it and anybody can remove it.

List the chunks yourself

This short Python script has no dependencies. It lists text chunks (tEXt, iTXt, zTXt), any C2PA container (caBX) and an EXIF block in a PNG.

import struct, sys

for path in sys.argv[1:]:
    b = open(path, "rb").read()
    if b[:8] != b"\x89PNG\r\n\x1a\n":
        print(path, "is not a PNG"); continue
    i = 8
    while i + 8 <= len(b):
        size, kind = struct.unpack(">I4s", b[i:i + 8])
        body = b[i + 8:i + 8 + size]
        if kind == b"tEXt":
            key, _, val = body.partition(b"\0")
            print(f"tEXt  {key.decode('latin-1'):<12} {len(val)} bytes: {val[:70].decode('latin-1')!r}")
        elif kind in (b"iTXt", b"zTXt"):
            key = body.split(b"\0", 1)[0]
            print(f"{kind.decode()}  {key.decode('utf-8', 'replace'):<12} {size} bytes")
        elif kind == b"caBX":
            print(f"caBX  (C2PA/JUMBF container) {size} bytes")
        elif kind == b"eXIf":
            print(f"eXIf  EXIF block {size} bytes")
        i += 12 + size

Run it as python3 pngtext.py image.png. If you see parameters, prompt or workflow, the generation recipe will travel with the file.

Should you remove it?

That depends. Many people leave the prompt in on purpose, since sharing a recipe is part of the community. Remove it when the prompt is client work, contains a name or private detail, or when the workflow chunk reveals folder paths you'd rather not publish.

Note that stripping the text chunks does not make an image "undetectable". Some generators also add invisible watermarks in the pixels, and platforms may label content on other signals. This is only about what's written in the file.

Doing it without a script

If you'd rather not use a command line, Remove AI Meta has a page for this exact case. It's a browser tool that shows the chunks before and after cleaning, and runs locally. Its AI-provenance mode removes the usual keys (parameters, prompt), and its strip-all mode also removes the ComfyUI workflow chunk. One clean is free; more are paid.

Script tested on a sample PNG with parameters and prompt chunks.

What's in a ChatGPT image download

OpenAI's help describes two separate marks on supported images:

1. C2PA Content Credentials: a signed manifest stored inside the file, saying the image was made with OpenAI tools.
2. A SynthID-style watermark: a signal embedded in the pixels that is meant to survive some edits.

They live in different places. The first is metadata. The second is in the image content.

What a screenshot does

A screenshot is a brand new file made by your operating system. It contains pixels, not the original file's container, so the C2PA manifest isn't copied across. The same is true if you re-save the picture in an editor that doesn't preserve metadata, or if a platform re-encodes it on upload (many do).

What a screenshot does not do: remove anything in the pixels. A watermark that is built into the image content may or may not survive, and no one outside the vendor can guarantee either way. Nor does it control what a platform does with other signals; platforms can label content based on declarations in your post, on detectors, or on user reports.

A screenshot isn't a good workflow anyway

• You lose resolution and often colour accuracy.
• You get UI chrome or scaling blur.
• You can't verify afterwards what the new file contains.

If your actual goal is "send this image without the provenance record attached", cleaning the original file is better: it keeps the full-resolution pixels and you can check the result.

How to check any file in 30 seconds

Content Credentials has a free verifier at contentcredentials.org/verify. For a quick local check you can also use a tool that reads the container and lists what it finds.

I work on Remove AI Meta, which has a page for ChatGPT downloads: it inspects the file, strips the C2PA manifest and other metadata in the browser, and re-scans the output. It is explicit that SynthID-type watermarks stay, and that it can't force a platform to remove a label. One clean is free; more are paid.

If you need to disclose AI use for school, work or a platform rule, do that regardless. Metadata presence or absence doesn't change your obligation.

Not affiliated with OpenAI. Based on OpenAI's published help on image provenance as of October 2026.

If you have downloaded an image from a news site, a stock library, or an AI generator lately, there is a decent chance it carries provenance data you never asked for. The Content Credentials system, built on the C2PA specification, attaches a signed manifest to the file describing who created it, what tools were used, and whether generative AI was involved. Adobe, Microsoft, Google, and most camera manufacturers now write these manifests by default. Separately, IPTC fields and EXIF blocks have been embedding author names, GPS coordinates, and software fingerprints for decades.

For developers, this matters in both directions. You might want to read that metadata to verify an image's origin, or you might need to strip it before shipping assets to production. This guide covers both, with commands you can run today.

What C2PA actually stores

A C2PA manifest is a CBOR-encoded structure embedded in a JUMBF box inside the file. It contains assertions (the claim), a signature from the signing certificate, and a chain of ingredients pointing to source assets. In a JPEG, it lives in an APP11 segment. In PNG, it's a caBX chunk. In MP4, a uuid box.

You can inspect a manifest with the official c2patool from the Content Authenticity Initiative:

c2patool image.jpg

That prints the full claim, the signer, and any AI-generated assertions. If you want machine-readable output for a pipeline:

c2patool image.jpg --output json | jq '.manifests[].assertions'

The c2pa.ai_generative_training and c2pa.actions assertions are the ones most people care about, since they flag whether an asset was used for or produced by generative models.

Reading IPTC and EXIF without extra tooling

For classic metadata, ImageMagick and ExifTool are still the fastest path. ExifTool is more thorough:

exiftool -a -G1 -s image.jpg

The -G1 flag groups output by metadata family (EXIF, IPTC, XMP, ICC_Profile, JUMBF), which makes it obvious where each field comes from. To see only IPTC:

exiftool -iptc:all image.jpg

To see only C2PA-related JUMBF data that ExifTool can parse:

exiftool -jumbf:all image.jpg

ExifTool's JUMBF support is partial, so treat c2patool as the source of truth for C2PA specifically.

Removing the metadata

This is where people get tripped up. Stripping EXIF does not strip C2PA, and stripping C2PA does not necessarily strip IPTC. They are different containers, and a naive convert call may drop some and preserve others.

Strip everything with ImageMagick

magick input.jpg -strip output.jpg

-strip removes EXIF, IPTC, XMP, and most ancillary chunks. It does not reliably remove C2PA manifests in every build, because the JUMBF box can survive depending on the coder. Verify afterward:

c2patool output.jpg

If it still reports a manifest, you need a second pass.

Strip C2PA specifically

The c2patool CLI does not have a removal flag as of the current release. The reliable approach is to re-encode the pixel data through a library that does not preserve the manifest, then confirm the JUMBF box is gone. In Python:

from PIL import Image

img = Image.open("input.jpg")
img.save("output.jpg", quality=95)

Pillow writes a fresh file with no C2PA box and no inherited IPTC. It does preserve some EXIF by default, so pass exif=b"" if you want a clean slate:

img.save("output.jpg", quality=95, exif=b"")

Strip IPTC and EXIF with ExifTool

exiftool -all= -overwrite_original image.jpg

That removes every writable tag. Add -icc_profile preservation if color accuracy matters for your use case:

exiftool -all= -tagsfromfile @ -icc_profile -overwrite_original image.jpg

A verification loop worth automating

Metadata removal is easy to get wrong silently. Build a check into your asset pipeline:

#!/usr/bin/env bash
set -e
FILE="$1"

if c2patool "$FILE" 2>/dev/null | grep -q "manifest"; then
  echo "C2PA manifest still present in $FILE"
  exit 1
fi

COUNT=$(exiftool -a -G1 -s "$FILE" | grep -cE "^(EXIF|IPTC|XMP)")
if [ "$COUNT" -gt 0 ]; then
  echo "$COUNT metadata fields remain in $FILE"
  exit 1
fi

echo "$FILE is clean"

Run this in CI on any user-uploaded image before it hits your CDN. It catches the common case where a library re-embeds metadata you thought you removed.

When to keep metadata instead

Not every workflow should strip everything. If you are building a verification feature, you want the manifest intact. If you are archiving photojournalism, destroying provenance is actively harmful. The rule of thumb: strip for outbound assets where metadata is noise or a privacy risk, preserve for inbound assets where provenance is the point.

For quick one-off jobs where you would rather not chain three CLI tools, Remove AI Meta handles C2PA cleanup, IPTC, and EXIF in a single pass and shows a before-and-after diff so you can confirm what was actually removed. It is useful when you need to check a file on a machine without your usual toolchain installed.

Practical notes

• PNG caBX chunks and JPEG APP11 segments are the two you will encounter most. WebP stores C2PA in a C2PA RIFF chunk.

• Re-encoding at quality 95 is visually lossless for most photographic content but does change the file hash. If you need byte-identical pixels, you cannot remove embedded metadata without rewriting the container.

• Signed manifests are cryptographically bound to the asset. Any pixel change invalidates the signature, which is why re-encoding is a valid removal strategy: the manifest becomes unverifiable even if the box lingers.

Metadata is not decoration. It is data your users did not consent to ship, and it is worth knowing exactly how to read it and how to remove it.