Skip to main content
AI Watermark Removal

Comparison

C2PA vs SynthID

C2PA and SynthID solve different failure modes rather than competing head to head. C2PA Content Credentials are a signed metadata manifest bound to a file's exact bytes, which is rich in detail but breaks the moment those bytes change: a screenshot, a re-encode, or an ordinary social upload can strip it. SynthID-style watermarks live in the pixels, audio, or token distribution instead, so they survive far more everyday handling, but they're checked with a probabilistic detector rather than a manifest lookup. OpenAI now runs both on the same images for exactly that reason.

Published 2026-08-11Updated 2026-08-11Confirmed

Key takeaways

  • C2PA Content Credentials are signed metadata bound to a file's exact bytes. A screenshot, re-encode, or ordinary social-media upload can strip them, per both C2PA's own verification tool and OpenAI's documentation.
  • SynthID (Google DeepMind) and Meta's Stable Signature embed the signal directly in pixels, audio, or token probabilities, so they survive cropping, recompression, and screenshots far better. Not perfectly, and not against determined adversarial editing.
  • Verification is a different kind of operation for each. C2PA is a manifest lookup that returns a present/absent, cryptographically-backed answer; SynthID is a statistical detector that returns a confidence score or an explicit "uncertain."
  • OpenAI ships both C2PA and SynthID on ChatGPT, Codex, and API images specifically because each covers the other's failure mode, the same two-layer pattern Anthropic uses for Claude's outputs.

SynthID Text mechanism

How a statistical text watermark enters output

GeminiGeminiSynthID Text

Prompt context

The model builds next-token probabilities from the text so far.

Sampling pool

Top-K and Top-P narrow the candidate tokens.

Logits processor

SynthID Text adjusts generation-time scores using a keyed signal.

Watermarked text

The chosen tokens still read naturally, but carry a statistical pattern.

Detector score

A detector scores whether enough text matches the configured signal.

Why paraphrasing matters

The watermark is distributed across token choices. Light edits may leave enough signal, while heavy rewriting or translation can reduce detector confidence because many original token choices disappear.

Two different bets on where the truth lives

Confirmed

You'll get the one mechanical difference that explains every other difference below.

C2PA (Coalition for Content Provenance and Authenticity) Content Credentials are a signed metadata record, a "manifest," attached to a file. It documents what produced the file, which tool was used, and what edits happened afterward.

The manifest is cryptographically bound to the file's exact bytes through hard binding: a hash of the asset is embedded in the signed manifest, so any alteration to asset or provenance breaks the match. Nothing in that mechanism touches the pixels or audio a viewer actually perceives.

It's a wrapper around the file, the same category of thing as EXIF or IPTC metadata, just signed and extensible.

SynthID, developed by Google DeepMind, works the opposite way and never touches file metadata at all.

  • Images, video, and audio: the watermark is embedded directly into the generated content during creation, applied so it doesn't change perceived quality.
  • Text: SynthID runs as a logits processor during generation, nudging the model's token-probability distribution using a pseudorandom function.

The text version leaves a statistical fingerprint across word choices, not a file-level marker. Because the signal lives in the content rather than a wrapper, it travels through format conversion, cropping, or a screenshot in a way a metadata field structurally cannot.

What survives a screenshot, and what doesn't

Confirmed

Here's the practical crux: which everyday actions quietly destroy which signal.

A screenshot regenerates an entirely new file from re-rendered pixels, so it breaks C2PA's hash match outright. So does re-saving in a different format, resizing, or most re-encoding.

The Coalition's own verification tool states the limitation plainly: if metadata has been removed, the image was captured as a screenshot, or the file was re-encoded, the C2PA manifest data may no longer be accessible or readable.

None of that requires an attacker. Many platforms strip embedded metadata on upload as routine processing, so credentials vanish with zero adversarial intent.

Embedded watermarks are built for exactly this scenario, and the vendors are specific about what they claim:

  • Google says SynthID for images and video is designed to stand up to cropping, filters, changed frame rates, and lossy compression.
  • The audio version is meant to resist added noise, MP3 compression, and changes to the speed of the track.
  • Meta's Stable Signature, trained jointly with Inria directly into the decoder of its generative models rather than applied afterward, says the original watermark will likely remain in the digital data however a person transforms an image, through cropping, compression, and color adjustment.

Not one of those claims is unconditional. Google is explicit that SynthID Text's detector confidence can be greatly reduced when text is thoroughly rewritten or translated, and defeating a pixel-level watermark under determined adversarial editing remains an open research problem for every vendor.

Verification is not the same kind of operation

You'll see why one check returns a yes or no and the other returns a probability, plus the buried number that makes the difference concrete.

Checking a C2PA credential means reading a manifest, not detecting a signal. The Coalition runs Content Credentials Verify for this: upload or paste a file and it shows the issuer, editing history, generating application, and thumbnail trail, if an intact manifest is present.

OpenAI runs an equivalent tool for its own outputs at openai.com/verify. Either way the result works like checking a digital signature: present and cryptographically valid, or not. No confidence score when it works, no partial credit when it's been stripped.

Verifying SynthID means running a statistical detector against the content itself. For SynthID Text, Google has open-sourced a Bayesian detector, distributed through Hugging Face Transformers and GitHub.

It doesn't return a simple yes or no. It reports one of three states (watermarked, not watermarked, or uncertain) against a threshold the operator sets to trade off false positives against false negatives.

Who can actually run the detector

Reported

Here's the access gap nobody mentions: the more durable signal is the harder one to check.

For images, video, and audio, Google's checker is the SynthID Detector. You reach it either by asking the Gemini app about an uploaded file or through a standalone portal launched at I/O on May 20, 2025.

That portal is waitlist-gated for journalists, media professionals, and researchers, with no public API. At launch only image detection was live, with video and text detection promised in the coming weeks.

The most recent independent check found (journalist Henk van Ess, November 20, 2025) reported it still waitlist-only, with in-app verification hit-or-miss for audio and video and reliable for images. No later source confirms general availability.

Asking Gemini in chat had a bigger problem for part of 2026. Upload two images in one session, ask about the second, and it returned the verdict for the first. The fact-checking outlet Lead Stories caught it across four tested sessions, producing both false positives and false negatives, and after its July 13, 2026 coverage Google fixed it globally by July 16.

The in-chat route has published limits of its own. Google states Gemini "can currently only recognize content created by Google AI tools," with caps of 100MB per file, video under 90 seconds, audio under an hour, and roughly 10 checks per media type per 24 hours.

In production, nobody picks one

Confirmed

You'll see the exact reasons three major labs ship both layers instead of choosing between them.

OpenAI's clearest public statement says it is incorporating watermarking through Google DeepMind's SynthID, starting with images generated through ChatGPT, Codex, or the OpenAI API. Its stated reason: SynthID embeds an invisible watermarking layer that complements C2PA metadata-based approaches.

In OpenAI's own words, C2PA helps content carry detailed context while SynthID helps preserve a signal when metadata doesn't survive. Supported images now carry both, checkable together at openai.com/verify.

The same pattern shows up across the field:

  • Anthropic pairs an imperceptible watermark embedded directly in generated text with signed C2PA metadata attached to supported Claude-generated image files.
  • Meta uses Stable Signature as its embedded-watermark layer for its own generative image models.
  • C2PA's own specification writes the fallback into the standard: "soft binding," an invisible watermark or a cloud-hosted fingerprint lookup, is the defined recovery path when hard binding breaks.

That last one is the tell. The standard itself concedes that metadata alone doesn't survive real-world handling, which is the same admission every one of these companies has made in practice.

What neither one proves

Confirmed

Here's what to keep in mind before telling anyone what a verification result actually means.

A present C2PA manifest or a positive SynthID detection is evidence about a generation or editing process, not proof of truth, intent, or ownership. Neither company claims otherwise.

A cryptographically valid manifest shows that whoever signed it made a set of declarations. It does not verify those declarations, since the signing tool can't know what happened upstream.

SynthID detectors carry the opposite kind of uncertainty by design. They output likelihoods rather than certainties, and Google's text detector treats "uncertain" as a first-class result rather than forcing a binary answer.

Absence proves least of all. OpenAI is explicit that its verification tool won't reach a definitive conclusion when no signal is found, because provenance signals can sometimes be stripped, so a blank result means only that nothing readable survived to that point.

FAQ

Which is harder to remove: C2PA or SynthID?

In practice a SynthID-style embedded watermark is harder to remove than C2PA's default metadata binding, and that's not speculation: it's the reasoning OpenAI gives for shipping both on the same images. OpenAI's documentation says C2PA metadata can be stripped, lost through uploads and downloads, or broken by transformations like resizing or screenshots, while watermarking tends to survive those better. "Harder to remove" still isn't "impossible": Google says SynthID Text's detector confidence can be greatly reduced by heavy rewriting or translation, and defeating an image or audio watermark under determined adversarial editing is an open research problem.

How do I check whether a specific file has a C2PA credential or a SynthID watermark?

Different tools for different signals. For C2PA, use a manifest reader: the Coalition's Content Credentials Verify tool, or openai.com/verify for OpenAI-generated files, which show the issuer, edit history, and generating tool if a manifest is intact. For SynthID you need the matching detector: Google's open-sourced Bayesian detector for text via Hugging Face Transformers and GitHub, or the SynthID Detector for images, video, and audio through the Gemini app or a dedicated portal that remains limited to approved testers. There is no single tool that checks both.

If a screenshot strips the C2PA metadata, is there any way to tell an image came from an AI tool?

Only if a separate embedded watermark was applied too, and you have access to its detector. That's the gap OpenAI's dual system is built to close: the screenshot destroys the manifest, but a SynthID mark lives in the pixels and can still be detected. If no watermark was applied in the first place, or you can't reach that vendor's detector, there's currently no reliable way to establish origin after a screenshot.

Are C2PA and SynthID competitors, or are they used together?

Used together, not chosen between, by every major vendor covered here. OpenAI pairs C2PA metadata with Google DeepMind's SynthID on the same ChatGPT, Codex, and API images; Anthropic pairs an imperceptible text watermark with C2PA metadata on supported Claude-generated image files; Meta runs Stable Signature alongside separate AI-content metadata labeling. The "vs" framing is useful for understanding where each one fails, but in production none of these companies treats it as an either/or.

Next steps

  • Run one of your own AI-generated images through the Coalition's browser-based checker and see whether the manifest survived. Content Credentials Verify
  • Go deeper on what's inside the manifest itself, down to the created_assertions and gathered_assertions split. C2PA Content Credentials
  • Read what independent red teams actually found when they attacked SynthID across text, images, audio, and video. SynthID watermark
  • If you care about text specifically, look at how much rewriting it takes before a statistical watermark stops registering. Text watermark robustness

Sources and citation status