ProvenanceGuard
← Go back

← All guides

C2PA Manifest vs a Signed Provenance Assertion: What Is the Difference?

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

The short answer

The difference is scope and home. A C2PA manifest is a standards-based credential bundle embedded in the file; a ProvenanceGuard assertion is this service's own signed statement, embedded as XMP, backed by a fingerprint registry entry. The manifest speaks to supporting software; the assertion plus registry keeps a checkable record after embedded data is stripped.

Seal an image free → Recover a reposted image Pricing

Confusing the two is not a pedantic error: claiming C2PA conformance for a file that carries a vendor assertion is exactly the kind of overclaim that collapses under a client's or a regulator's first question.

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.

What is a signed assertion? a statement about an asset, covering its hash, the declared creator and disclosure, and the registration time, signed so any later alteration of the statement is detectable, and embedded in the file as XMP.

What goes wrong without a plan for the two kinds of signed record

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.

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.

What the inspection, seal and registry each contribute

What sealing does not do is just as clearly bounded. It does not certify that a disclosure statement is legally sufficient, it does not turn the assertion into a C2PA manifest, and it does not store the uploaded original: the registry keeps the sealed and labelled copies and the record, so verification and downloads keep working, while the original bytes are not retained. The seal is evidence of a declaration made at a time, about a specific file, and that precision is what makes it useful later.

Sealing is the moment a record is created. ProvenanceGuard takes the creator and disclosure the uploader declares, the SHA-256 of the original bytes, and the registration time, and signs that assertion with HMAC-SHA256 under the product signing key. The signed assertion is embedded into the file as XMP, producing the sealed copy. Because the signature covers the assertion's contents, altering the creator, the disclosure or the hash inside the file afterwards invalidates the signature, and the verification page shows that plainly.

The honest limits

Alongside the sealed copy, sealing produces a visibly labelled copy: the same image with a parchment custody strip in the pixels naming it as AI-generated content whose provenance is registered with ProvenanceGuard. The distinction matters. Embedded assertions are machine-readable and fragile in transport; a visible label is human-readable and survives anything that keeps the strip in frame, including a screenshot. Publishing the labelled copy where the audience actually sees the image, and keeping the sealed copy as the record, uses each layer for what it is good at.

The limits deserve the same prominence as the features. ProvenanceGuard does not detect deepfakes, does not judge whether an image is harmful, and does not verify that a creator's declared disclosure is true; it records declarations, binds them to fingerprints, and makes them checkable. Its signed assertion is its own XMP-embedded, HMAC-signed statement, explicitly not a C2PA manifest and not a certification by any standards body. Survival re-checks are local simulations of documented platform transforms, not actual uploads, and they are labelled that way in every result.

Decisions to make before you publish

Used inside those limits, the record is strong. Used outside them, by claiming a seal proves authorship in law, or that a simulation proves a platform's behaviour, or that a registry match proves ownership, the same record becomes a liability, because the first competent challenge will find the overclaim. The teams that get the most from provenance tooling are the ones whose public language is as precise as the tool's own: sealed, registered, verifiable, with the dates and hashes to show it.

No single layer does this job alone, and honest tooling says so. Embedded metadata can be stripped. A visible label can be cropped. A fingerprint can drift if an image is edited heavily. A registry entry proves registration, not authorship in a legal sense. Used together, though, the layers cover each other's failures: when the metadata is gone the fingerprint can still find the registry record, and when a copy is too altered to match, the labelled version and the evidence pack still tell the story.

Five actions to take

  1. Write down, for your last campaign, which images carried a manifest, an assertion, or only a registry record
  2. Remove any page or deck that calls a ProvenanceGuard assertion a C2PA manifest
  3. File the exhibit's verification URL beside the asset wherever your team keeps campaign or client records
  4. Run check-a-copy on the version you actually published, and note which checks held: hash, signature, fingerprint
  5. Export an evidence pack while the context is fresh if the asset is regulated, client-facing or likely to be questioned

A worked example: A brand manager asked whether the studio's images were 'C2PA compliant'

For 22 campaign images the accurate answer was layered: 9 carried detectable C2PA markers in their original exports, all 22 carried a signed ProvenanceGuard assertion and a registry record, and the reply she sent used exactly those words.

What the case really shows is timing. Every artefact used, the registry entry, the fingerprint match, the pack, existed because someone spent a few minutes at publication. The same team, equally honest, starting from memory a month later would have had a much harder week.

FAQ

Which one should I rely on for published images?

Rely on the combination and describe it accurately: embedded marking for the file at rest, a visible label for the audience, and the registry record for after distribution. Each covers a failure the others have.

What does the free tier actually do?

The complete job on an asset: byte-level inspection, a signed assertion embedded as XMP, a visibly labelled copy, SHA-256 and perceptual fingerprints registered, and a public verification page. Paid plans add survival re-checks, evidence packs and bulk verification.

What do Pro and Team cost?

Pro is $29 a month and Team is $79 a month, as shown on the pricing page. Paid depth means per-platform survival re-checks, evidence pack export with EU, California and New York wording, and the bulk hash-verification API.

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.

Seal an image free →