DisclosureGuardRegulatory dossier

Blog · ← All posts

Why AI Disclosure Labels Disappear After Upload

Last updated: October 13, 2026 · 8 min read

By the Ingenious AI team

You did everything right. The image left your editor with a C2PA manifest attached, the caption said "Created with AI," the platform's disclosure toggle was set. Then the file went through the upload pipeline, and the version your audience sees carries no trace of any of it.

This is label drift: the gap between the disclosure you applied and the disclosure that survives. We built an entire product feature around it (our drift lab simulates exactly what platforms do to your files) because it turned out to be the most common disclosure failure we could find. Not malice. Not negligence. Just physics: platforms recompress everything, and recompression eats metadata.

The two kinds of disclosure, and which one dies first

Disclosure lives in two places, and they have completely different survival rates.

Visible disclosure is baked into what the viewer sees: the caption text, the on-screen badge, the "How this ad was made" line in the ad copy, the YouTube label on the player. This survives unless someone edits the post or the caption. It's fragile to human handling but immune to compression.

Embedded disclosure lives inside the file: C2PA manifests, XMP fields, EXIF data, IPTC tags. This is invisible to the viewer, machine-readable, and exactly what upload pipelines destroy. The file looks identical. The pixels are fine. The metadata is gone.

The trap is that most teams think of these as one thing, "we labeled it", when they're really two independent systems with different failure modes. You can have perfect embedded provenance and zero visible disclosure (fails the EU's Art. 50 viewer-facing requirement), or a perfect visible label with no embedded proof (fails the moment anyone asks "prove it"). You need both, and you need to know which one your pipeline kills.

What survives where: the platform-by-platform reality

Here's what actually happens to embedded metadata when you upload, based on documented platform behavior:

Platform behavior changes without notice, so treat any list like this as a snapshot, not a contract. The durable lesson isn't "Instagram strips EXIF", it's that you can't control what the platform does to your file, so your disclosure strategy can't depend on the file arriving unchanged.

The three ways drift actually happens

In our drift testing, disclosure dies in three distinct places. Knowing which one got you matters, because the fixes are different.

1. The export preset. This one happens before the platform ever sees the file. A designer exports with "Save for Web" or an equivalent preset optimized for small file size, and the preset discards metadata to save bytes. The C2PA manifest that was attached in the working file never makes it into the delivered file. Fix: check your export settings, most Adobe and Figma export flows have a metadata/metadata-inclusion option, and verify the exported file, not the working file.

2. The platform transcode. The file arrives with its manifest intact, and the platform's re-encode strips it. This is the Instagram/Facebook/YouTube case above. There's no setting that prevents it. Fix: don't fight the transcode, put the disclosure where transcodes can't reach it (visible labels, platform upload controls).

3. The human handoff. The file is fine, the metadata is fine, and then the client's social manager rewrites the caption without the AI label, or the VA uploading to YouTube skips the "AI use" toggle because nobody told her. This is the most common one and the least technical. Fix: the delivery package. Send the file with a one-line disclosure instruction per destination, and check the published post.

Notice that only one of the three is a technology problem. The other two are process problems. That's why our drift check simulates the pipeline end-to-end rather than just inspecting the file: the file can be perfect and the disclosure can still be gone by the time it reaches the audience.

A walkthrough: the 30-image campaign that lost its labels

Here's a hypothetical scenario that mirrors what we see in testing. A brand's agency produces 30 AI-generated product lifestyle images. The retoucher exports them all from Photoshop with C2PA content credentials attached. The files are perfect: manifests valid, generator fields correct, actions listing the AI steps.

The images go to three destinations. Destination one: the brand's own website. The CMS serves the originals, manifests intact, verifiable, done. Destination two: Instagram. The upload transcodes everything; every manifest is gone within seconds. The captions say "Created with AI," so the visible disclosure holds, but the embedded proof is gone. Destination three: a Google Ads display campaign. The images are fine, but nobody fills in the synthetic-content disclosure copy, and nobody writes the "How this ad was made" line.

Same 30 files, three completely different disclosure outcomes. The team that checked only the files would report "fully disclosed." The team that checked the published outputs would find two of three destinations with gaps. This is why the audit unit is the published asset, not the file on your hard drive.

How to make disclosure survive: the layered approach

Since no single layer survives everything, stack them:

The common mistake is investing everything in layer 3 because it feels the most technical and therefore the most serious. In practice, layer 3 is the one that dies first on social platforms. The serious money goes into layers 1, 2, and 4, the ones that survive contact with the real pipeline.

Test before you trust

Don't take any of this on faith, including this post. The test is cheap:

  1. Take a file with embedded disclosure (C2PA manifest, XMP fields, whatever your tools produce).
  2. Upload it to each destination the way you actually publish, same app, same settings, same account type.
  3. Download the published version and check what's left. Our free drift check automates exactly this: upload or paste a URL and see whether the disclosure metadata survives a simulated Instagram-style recompress.
  4. Write down the results per destination. That's your real disclosure policy, not what the file contains, but what the audience receives.

Run this test once per quarter, because platforms change their transcode behavior without announcing it. The test that passed in January can fail in June, and nobody will tell you.

The bottom line

Label drift isn't a bug in your process. It's the default behavior of the internet's plumbing: files get recompressed, metadata gets stripped, captions get rewritten, toggles get skipped. A disclosure strategy that assumes the file arrives unchanged is a strategy built for a pipeline that doesn't exist.

Build for the pipeline that does exist. Visible labels for the viewer. Platform controls for the platform. Embedded provenance for the record. And a log outside the file for when everything else fails. Check the published asset, not the working file, because the published asset is the only one anyone else will ever see.

Run the free drift check on your next upload →

Related reading