Watermarking vs AI Detection: SynthID, C2PA and Classifiers Compared

There are two very different ways to answer "was this made by AI?":

1. Mark it at creation time. The AI system adds a watermark or signed metadata when it generates content, and anyone with the right tool can check for it later.
2. Detect it after the fact. A classifier looks at the content itself and estimates whether it was generated.

In 2026 both approaches are moving fast, partly because regulators now expect them. This post compares watermarking (SynthID), provenance (C2PA) and detection classifiers, with code, so you can decide what your product actually needs.

Why this matters now

• EU: Article 50 of the EU AI Act applies from 2 August 2026. Providers of generative AI must support machine-readable marking of AI-generated audio, image, video and text, and deployers have disclosure duties for deepfakes. The Commission has also published a voluntary Code of Practice on transparency of AI-generated content.
• India: amendments to the IT Rules, in force since 20 February 2026, require synthetically generated content to be prominently labelled and to carry permanent metadata or provenance markers, and they cut takedown deadlines for government and court orders to three hours.
• Industry: at Google I/O in May 2026, Google said C2PA verification and SynthID detection are coming to Search and Chrome, and OpenAI announced it would add SynthID watermarks to its images alongside C2PA credentials.

Approach 1: Watermarking (SynthID)

How it works: while generating, the model nudges its choices in a pattern derived from a secret key. For images and audio the signal is embedded in the pixels or waveform. For text, SynthID Text adjusts token sampling so that a detector with the right keys can later measure the pattern statistically.

Google open-sourced SynthID Text in 2024, and it's available in Hugging Face Transformers. Generating watermarked text looks roughly like this:

# pip install transformers torch accelerate
from transformers import AutoModelForCausalLM, AutoTokenizer, SynthIDTextWatermarkingConfig

model_id = "google/gemma-2-2b-it"   # any causal LM you have access to
tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(model_id)

watermarking_config = SynthIDTextWatermarkingConfig(
    keys=[654, 400, 836, 123, 340, 443, 597, 160, 57, 29],  # keep your real keys secret
    ngram_len=5,
)

inputs = tokenizer(["Write a short note about watermarking."], return_tensors="pt")
out = model.generate(
    **inputs,
    watermarking_config=watermarking_config,
    do_sample=True,
    max_new_tokens=120,
)
print(tokenizer.batch_decode(out, skip_special_tokens=True)[0])

Detecting the watermark needs a detector configured with the same keys (the Transformers docs describe training a Bayesian detector for this).

Strengths: strong signal when present, low false-positive rate, survives light edits.

Weaknesses: it only exists if the generator added it. Open-weight models run locally usually don't. Heavy paraphrasing or translation weakens text watermarks, and checking them depends on whoever holds the keys.

Approach 2: Provenance (C2PA Content Credentials)

How it works: the tool that creates or edits a file attaches a cryptographically signed manifest describing its origin and edit history, for example "generated by model X" or "captured on camera Y, then cropped".

You can inspect it with the open-source c2patool:

cargo install c2patool
c2patool image.jpg            # prints the manifest as JSON, if present

Strengths: rich, verifiable information (who, what, when, which edits), and it's an open standard.

Weaknesses: metadata is easily stripped by screenshots, re-encoding and many upload pipelines. A missing manifest proves nothing. It's also mostly used for images, video and audio, not plain text.

Approach 3: Detection classifiers

How it works: a model trained on large sets of human-made and AI-made content estimates the probability that a new piece was generated. Text detectors use signals like perplexity, burstiness and learned style patterns. Image detectors look for pixel, noise and frequency artifacts.

curl -X POST https://ai.proofai.in/api/v1/detect \
  -H "x-api-key: YOUR_API_KEY" \
  -H "Origin: YOUR_DOMAIN" \
  -H "Content-Type: application/x-www-form-urlencoded" \
  -d 'content=Text you want to check, ideally 50+ words...'
# → { "ai_probability": 85, "verdict": "Likely AI", "segments": [...] }

Strengths: works on any content, whatever generated it and whether or not it was watermarked. That includes content from open-source models and content with stripped metadata.

Weaknesses: probabilistic, so false positives and false negatives happen (short texts and non-native English writing are known weak spots). Classifiers also need retraining as new models appear.

Side-by-side

	Watermark (SynthID)	Provenance (C2PA)	Detection classifier
Needs cooperation from the generator	Yes	Yes	No
Works on open-source / local models	Rarely	Rarely	Yes
Survives screenshots	Often (images)	No	Yes
Tells you who / what made it	Model family only	Yes, in detail	No
Output	Present / absent	Signed manifest	Probability score
False positives	Very low	Very low	Real, must be managed
Text support	Yes (SynthID Text)	Limited	Yes

So which one should you use?

All of them, in layers. A practical verification flow:

1. Check provenance. Valid C2PA credentials give the strongest, most detailed evidence.
2. Check watermarks where you have a detector for them.
3. Run a classifier on everything else. In practice, that's most content on the internet.
4. Treat every result as evidence for a human decision, especially for high-stakes cases like exams, hiring, journalism or KYC.

Watermarks and provenance will cover more content over time, but they'll never cover content from models that don't take part. That's why detection classifiers remain necessary, and why they need to be built and presented responsibly.

Wrapping up

Watermarking, provenance and detection answer slightly different questions. Watermarks and C2PA ask "did a participating tool label this?" Detection asks "does this content look generated?" Good products use both, and they're honest about what each signal can and can't prove.

That's the approach we take at ProofAI: multi-format detection for text, documents and images, returning a confidence score rather than a verdict.

This post wraps up our first series on AI content detection for developers. What should we cover next: benchmarks, video and deepfake detection, or a deeper dive into C2PA? Tell us in the comments. 👇

---

Disclosure: we're the team behind ProofAI at 4Born Solutions. This article was drafted with AI assistance and reviewed and edited by our team.