ProvenanceGuard
← Go back

← All guides

How a Provenance Registry Works: Fingerprints, Exhibits and Public Lookup

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

The short answer

At sealing the registry stores the exhibit ID, the original and sealed SHA-256 hashes, the perceptual fingerprints, the declared creator and disclosure, and the registration time, and it keeps the sealed and labelled copies so verification and downloads work. Uploaded originals are not stored. Lookups resolve by exhibit ID on the public page, by SHA-256 through the API, or by perceptual match through recovery.

Seal an image free → Recover a reposted image Pricing

The registry is deliberately boring: a small set of facts per asset, publicly resolvable, kept accurately. Its power is that 'boring and checkable' beats 'rich and arguable' in every dispute.

Two kinds of fingerprint do two kinds of work. The SHA-256 is exact: change one byte and it changes completely, which makes it perfect for proving a copy is bit-for-bit the registered file and useless for recognising a resized repost. The perceptual fingerprints, computed from the pixels rather than the bytes, are approximate on purpose: they stay close when a copy is resized, re-encoded or lightly edited, and drift as edits accumulate. A good registry stores both and is honest about which kind of match it is reporting.

What is a provenance registry? a database that stores, per asset, an exhibit ID, exact and perceptual fingerprints, declarations and registration time, and resolves public lookups by ID or hash, so records can be checked without possessing the original file.

What goes wrong without a plan for how the registry works

The registry model also disciplines what a match means. A fingerprint match says this image is the registered image or a close descendant of it; it does not say the person showing it to you owns it, and it does not say the disclosure attached to it was correct. Those judgements stay human. What the registry removes is the argument about identity and timing: which file, registered when, carrying which declaration. Most real disputes shrink considerably once those three facts stop being contestable.

The registry is the part that survives distribution. At sealing, the asset's SHA-256, its sealed copy's SHA-256, and its perceptual fingerprints are stored against a public exhibit ID. Anyone with that ID, or with the file's hash, can open the public verification page or query the verification API and confirm that this exact file, or a near copy of it, was registered, when, and with what declared creator and disclosure. Verification pages are public by design: a record only a vendor can check would not settle disputes.

What the inspection, seal and registry each contribute

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.

The honest limits

Recovery exists for the copy that comes back to you with nothing attached: no metadata, a new filename, dimensions changed by two platform hops. The Recovery Registry lookup fingerprints the uploaded copy perceptually, using aHash, dHash and pHash together, and searches the registry for a record within the stated threshold: a combined distance of at most 36 differing bits out of 192 compared, or 12 out of 64 for older records that carry only the legacy average hash. A match returns the original exhibit, its creator and disclosure declarations, and its registration time.

The honesty of the method is in its stated limits. This is fingerprint-only soft binding: ProvenanceGuard embeds no invisible watermark, so recovery can only find images that were registered before they travelled, and only while their pixels stay within threshold of the original. Heavy cropping, collage, or aggressive filtering can push a copy beyond matching, and the lookup then says so rather than forcing a nearest guess. A tool that always found something would be manufacturing provenance, which is the opposite of the point.

Decisions to make before you publish

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.

ProvenanceGuard is built around those layers, and its wording is deliberately narrow. The free job inspects one JPEG or PNG, embeds a signed ProvenanceGuard assertion in XMP, produces a visibly labelled copy, registers the SHA-256 and perceptual fingerprints, and gives the asset a public verification page. The assertion is HMAC-signed and labelled accurately everywhere as ProvenanceGuard's own assertion; it is not a C2PA manifest and is never described as one.

Five actions to take

  1. Store exhibit IDs in your own systems at sealing time
  2. Resolve lookups through the public routes a stranger would use
  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 platform team integrating verification into an asset dashboard

Using the single-hash API, the dashboard resolved 98 percent of its AI catalogue to exhibit pages automatically; the unresolved remainder were pre-registry assets, which the team sealed in a single backlog session.

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

What happens to the record if I stop paying?

Sealing, verification and recovery are the free, complete job; paid plans add depth such as survival re-checks, evidence packs and bulk verification. A record's public verifiability is not a subscription feature.

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 →