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.
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.
Figure 1
What survives what: four signals against eight ordinary things people do to content
The single most useful comparison in provenance, because it explains why a file that was genuinely AI-generated so often arrives with nothing left to find.
| What happens to the content | C2PA metadata | Embedded media watermark | Statistical text watermark | Visible label |
|---|---|---|---|---|
| Screenshot | Destroyed | Usually survives | Not applicable | Survives |
| Re-encode or compress | Usually destroyed | Degrades | Not applicable | Survives |
| Crop | May survive | Degrades | Not applicable | Often removed |
| Upload to a social platform | Commonly stripped | Usually survives | Not applicable | Survives |
| Strip metadata deliberately | Destroyed | Untouched | Not applicable | Untouched |
| Paraphrase the text | Not applicable | Not applicable | Degrades with edit strength | Removed |
| Translate the text | Not applicable | Not applicable | Usually lost | Removed |
| No detector available | Public verifiers exist | Provider-gated | Gated preview only | Human-readable |
Method C2PA behaviour follows from the specification's binding of a manifest to file bytes. Media and text watermark rows follow provider documentation and the published robustness literature. Cells describe expected behaviour, not a bench test by this site.
Checked 2026-08-13
Full comparisonWhat is the mechanical difference between C2PA and SynthID?
ConfirmedOne mechanical difference sits under every other difference in this comparison: a wrapper around the file, or a signal inside it.
C2PA wraps a signed metadata manifest around a file, while SynthID embeds a signal inside the content itself. 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.
Does a C2PA credential survive a screenshot?
ConfirmedHere'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.
Is verifying C2PA the same as verifying SynthID?
One check reads a manifest and answers yes or no. The other runs a detector that put 80% of pristine watermarked text in its own uncertain band.
No, they are different operations: verifying C2PA is a manifest lookup, while verifying SynthID means running a statistical detector against the content. 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/research/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 SynthID detector?
ReportedThe signal that survives more handling is also the one almost nobody can run. SynthID's image detector has stayed waitlist-gated since May 2025.
It depends on the modality: Google's standalone detector for images, video and audio is open only to approved journalists, media professionals and researchers, while the text detector is open sourced for anyone to run. 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.
Do real products choose between C2PA and SynthID?
ConfirmedOpenAI, Anthropic, and Meta all ship both layers, and the C2PA spec itself writes the watermark fallback in as the defined recovery path.
No, they ship both: OpenAI and Anthropic each pair C2PA metadata with an embedded watermark, and C2PA's own specification writes that fallback into the standard. 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/research/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. On August 14, 2026, Anthropic named the text mechanism directly: a version of Google DeepMind's SynthID-Text approach, keyed word selection rather than a file-level signal, published in a technical explainer that goes well beyond what this comparison could say about Claude's text watermark before that date.
- 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 do C2PA and SynthID fail to prove?
ConfirmedA valid manifest proves who signed it, not that the signer was right. Absence proves less than either result does.
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/research/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
- Anthropic named its own text mechanism on August 14, 2026: a version of SynthID-Text, explained in full including what survives editing and what the announced detection API will and won't prove. Claude's text watermark, explained
- 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
- OfficialC2PA Content Credentials explainer
- OfficialGoogle AI Developers: SynthID
- OfficialOpenAI: content provenance
- OfficialOpenAI Help: provenance signals in OpenAI-generated content
- OfficialContent Credentials Verify tool
- OfficialGoogle DeepMind: SynthID technology overview
- OfficialMeta AI: Stable Signature watermarking for generative AI
- OfficialClaude Support: how Claude marks AI-generated content
- OfficialGoogle: SynthID Detector portal launch
- OfficialGoogle Support: check if content was made with Google AI (Gemini limits)
- ReportingDigital Digging (Henk van Ess): Google's SynthID, three tools, three results (2025-11-20)
- ReportingLead Stories via Yahoo Tech: Gemini's SynthID checker returned verdicts for the wrong upload (2026-07-13, updated 2026-07-16)
- ResearchAIES 2026 preprint: forensic readiness of LLM text watermarks (2026-07-17)
- ResearchGoogle DeepMind: SynthID-Image (scale figure, self-reported)