ProvenanceGuard
← Go back

← All guides

How to Check If an Image Has C2PA or Other Provenance Metadata

By the Ingenious AI team · Published: November 14, 2026 · Reviewed: November 14, 2026 · 8 min read

The short answer

Upload the JPEG or PNG to a byte-level inspection and read the result field by field: C2PA markers, XMP, EXIF, PNG text chunks, AI disclosure in metadata, and any prior signed assertion with its signature validity. ProvenanceGuard's free inspection does exactly this on the real bytes, up to 25 MB, and makes no inference from the filename.

Seal an image free → Recover a reposted image Pricing

The file you are about to publish has a history you did not witness: it may have been marked, stripped, re-exported or asserted already, and each of those pasts needs a different next step.

Inspection comes before sealing, because an asset may already carry signals. ProvenanceGuard reads the actual bytes of an uploaded JPEG or PNG and reports what is really there: C2PA and JUMBF markers, an XMP packet, EXIF data, PNG text chunks, any AI disclosure already present in the metadata, and any prior ProvenanceGuard assertion, including whether that assertion's signature still verifies. Nothing is inferred from the filename or the uploader's claims; every field on the inspection result is derived from the file itself.

What is provenance inspection? reading an image file's actual bytes for provenance signals: C2PA and JUMBF markers, XMP packets, EXIF fields, PNG text chunks, embedded disclosures and earlier signed assertions, and reporting each as present, absent or invalid.

Why checking an image for provenance metadata matters

That byte-level honesty changes decisions. A file that arrives with a valid C2PA manifest needs different handling from a file whose metadata was already stripped by an earlier platform hop, and both differ from a file that was never marked at all. Checking first stops a common mistake: sealing and republishing an image while assuming its original manifest is intact, when in fact the copy in hand lost it two uploads ago. The inspection result becomes the baseline the rest of the record is built on.

Inspection also has limits worth stating. A marker being present says the bytes contain it; it does not say the claims inside it are true, and a signature check says whether a ProvenanceGuard assertion was altered, not whether the disclosure text a creator typed was accurate. Provenance records what was declared and when it was registered. Treating it as more than that, in either direction, is how teams end up both over-trusting and under-using the records they have.

How the record is built

Only JPEG and PNG files are supported, up to 25 MB, because those are the formats whose byte structures the inspection, embedding and fingerprinting are built and tested against. A file in another format is refused rather than guessed at. That refusal is a feature: a provenance tool that silently approximated on formats it does not understand would produce records that look solid and are not, which is worse than no record at all.

The weakness is transport, not design. The manifest lives inside the file, and the everyday machinery of the web rewrites files. Platforms resize and re-encode uploads, messaging apps compress them, and screenshots discard the file entirely. When the bytes are rewritten, an embedded manifest is commonly dropped, and the image that arrives at the next viewer carries no credentials even though it was properly marked at creation. Compliant at creation and non-compliant at distribution is the normal outcome, not an edge case.

Where it meets the real world

That is why a registry layer exists alongside embedded marking rather than instead of it. ProvenanceGuard detects C2PA markers during inspection and reports them truthfully, and its survival simulations show whether a C2PA manifest present in a sealed file survives a platform-style transform; in the simulated transforms it does not, while the registry fingerprint match does. The lesson is not that C2PA is useless, but that an embedded manifest alone cannot be the whole compliance plan for content that will be distributed.

C2PA is a technical specification for attaching a manifest to media: a structured, signed bundle of assertions about how the content was created and edited, typically carried in a JUMBF box inside the file. When a camera, generator or editor that implements the specification writes a manifest, and the file reaches a viewer unaltered, supporting software can read the manifest and show the content's credentials. The idea is sound and increasingly widely implemented across cameras, tools and platforms.

Putting it into practice

Checking a copy is the mirror image of sealing one. On an asset's verification page, uploading a candidate copy runs the same byte inspection on it and compares it against the record: its SHA-256 against the original and sealed hashes, whether a ProvenanceGuard assertion is present and its signature valid, and the perceptual distance between the copy and the registered fingerprint, with a match at a Hamming distance of ten or under on the average hash, or an exact hash match. The result states which of those held and which did not, separately, instead of collapsing them into one vague verdict.

For libraries rather than single files, bulk verification is a paid API feature: submit up to a hundred SHA-256 hashes in one call and get back, per hash, whether it is registered, its exhibit ID, its public verification URL and its registration time. That shape suits the questions teams actually ask at scale: whether everything in a delivered campaign folder was sealed, whether a partner's asset library overlaps the registry, or whether a month of published images all carry records. Single lookups stay free and public through the verification page and the single-hash API.

Five actions to take

  1. Inspect the file you actually hold, not the original you assume it matches
  2. Record which of the six inspection fields are present before you decide anything
  3. Export an evidence pack while the context is fresh if the asset is regulated, client-facing or likely to be questioned
  4. Re-check one published asset through the Recovery lookup so you know the stripped-copy path works before you need it
  5. Seal the final export of the asset, with the creator and disclosure declared in your own accurate words

A worked example: A newsletter editor sent a contributed AI image

Inspection showed XMP present, no C2PA markers, and an AI disclosure sitting in the metadata from the contributor's tool; she sealed that exact file, kept the disclosure wording, and linked the verification page from the issue's credits for its 4,800 readers.

Notice what made the difference: not a better argument, but a record created before it was needed, carrying dates and hashes a stranger could check. That is the whole pattern this guide recommends, applied at the scale of one team and one deadline.

FAQ

Can I check by looking at the file properties on my computer?

Operating-system property panels show fragments, usually EXIF, and miss JUMBF structure and signature validity. A byte-level inspection checks all the territories at once and reports an assertion's signature as valid or not, which a properties panel cannot do.

Are my uploaded originals stored?

No. The registry keeps the sealed and labelled copies derived at sealing time and the registry record, so downloads and verification keep working, while the uploaded original bytes are not retained.

Can anyone verify a record, or only the owner?

Anyone. Verification pages are public by design, the single-hash lookup is a public API, and an exhibit ID or a file hash is enough. A record only its owner could check would not settle a dispute with a stranger.

Is ProvenanceGuard's assertion a C2PA manifest?

No. It is ProvenanceGuard's own signed assertion, embedded as XMP and HMAC-signed, and labelled that way everywhere. The inspection detects genuine C2PA markers when a file carries them, but the two records are never conflated.

Seal an image free →