Every few months a new rule or product announcement promises that AI-generated text, images and video will carry an invisible mark so we can tell them apart from the real thing. It sounds like a tidy engineering fix. In practice, the honest answer is a firm “yes, in part, under conditions” and the conditions matter more than the headline. This guide explains how watermarks for images and text actually work, shows you a working version of each that I built and tested, measures exactly how they break, and then lays out what the technology can and cannot promise.
First, what problem are we trying to solve?
Generative AI can now produce a convincing essay, a photograph of an event that never happened, or a product review from a customer who does not exist, all in seconds and at almost no cost. Most of that content is harmless. Some of it is not: fake news images, spam at industrial scale, students passing off machine-written work, scam messages that read like they came from a real person.
The appeal of a watermark is that it moves the question from “does this look fake?”, which humans and software are increasingly bad at answering, to “was this marked when it was made?”, which is a question you can settle with arithmetic. The idea is old. Banknotes carry hidden marks, and paper mills have used visible watermarks for centuries. The new part is hiding a mark inside something that has no fixed physical form, like a paragraph of words.
The short version. A watermark can be added to AI content at the moment it is generated, and software holding the secret key can detect it later with measurable confidence. That works well when the generator cooperates and the content is left alone. It works poorly when the content is short, heavily edited, rewritten by another AI, or produced by a system that never added a mark. A missing watermark proves nothing.
Four different things people call “watermarking”
The word gets used loosely, and confusion about it causes most of the bad arguments. There are really four separate tools, and they fail in different ways.
- A visible label. A caption such as “AI generated” or a logo in the corner. Honest creators use it, but anyone can crop it out or never add it.
- Provenance metadata. A signed record attached to the file saying who made it and what tools were used. The best-known standard is C2PA, also called Content Credentials. It is strong when the file stays intact, and easy to lose when a platform strips it.
- An invisible watermark. A pattern woven into the pixels, the sound or the word choices themselves, detectable only with a secret key. This is what most people mean by “watermarking AI” and it is the main subject of this article.
- A detector. A separate AI model that looks at content and guesses whether it was machine-made, with no mark involved. It needs no cooperation from the generator, and it is the least reliable of the four.
The first three put information into the content or its wrapper. The last one only guesses. Keep that difference in mind, because it explains why a watermark detector can be nearly certain while a classifier cannot.
Image watermarks: start with the obvious idea, and watch it fail
Images are the easiest place to begin, because a picture is just a grid of numbers. Each pixel has a brightness from 0 to 255, and changing a pixel by one level is invisible to the eye. So the first idea most people come up with is this: hide your message in the last bit of every pixel. Flipping the least significant bit changes the brightness by at most one level, which nobody can see, and it gives you one hidden bit per pixel.
I built a test picture, a smooth synthetic scene with a little noise added to mimic a camera, hid 2,000 random bits in it, and then tried to read them back after some everyday handling. A synthetic picture is smoother than a real photograph, which matters later, and I will say how.
import io
import numpy as np
from PIL import Image
rng = np.random.default_rng(3)
H = W = 256
y, x = np.mgrid[0:H, 0:W]
photo = 120 + 50 * np.sin(x / 23) * np.cos(y / 31) + 40 * (((x - 150) ** 2 + (y - 100) ** 2) < 60 ** 2)
photo += rng.normal(0, 3, (H, W)) # a little sensor-style texture
photo = np.clip(photo, 0, 255).astype(np.uint8)
def jpeg(a, q):
buf = io.BytesIO(); Image.fromarray(a).save(buf, "JPEG", quality=q)
return np.array(Image.open(buf))
# ---- 1. The simple way: hide bits in the least significant bit of each pixel ----
bits = rng.integers(0, 2, 2000)
lsb = photo.copy().ravel()
lsb[:2000] = (lsb[:2000] & 0xFE) | bits
lsb = lsb.reshape(H, W)
print("Hiding 2,000 bits in the last bit of 2,000 pixels")
for name, img in (("untouched copy", lsb),
("saved as JPEG, quality 95", jpeg(lsb, 95)),
("tiny noise, +/-1 level", np.clip(lsb.astype(int) + rng.integers(-1, 2, lsb.shape), 0, 255).astype(np.uint8)),
("brightened by 1 level", np.clip(lsb.astype(int) + 1, 0, 255).astype(np.uint8))):
got = img.ravel()[:2000] & 1
print(f" {name:<28} bits recovered: {100 * (got == bits).mean():5.1f}% (50% is a coin flip)")
# ---- 2. Spread-spectrum: add a faint secret noise pattern, detect by correlation ----
pattern = np.random.default_rng(99).choice([-1.0, 1.0], (H, W))
def mark(a, alpha):
return np.clip(np.rint(a + alpha * pattern), 0, 255).astype(np.uint8)
def residual(a): # remove the smooth picture, keep fine detail
f = a.astype(float)
p = np.pad(f, 1, mode="edge")
blur = sum(p[i:i + H, j:j + W] for i in range(3) for j in range(3)) / 9
return f - blur
def score(a, pat=pattern): # z-score of the correlation with the pattern
r = residual(a)
return float((r * pat).sum() / (r.std() * np.sqrt(r.size)))
def psnr(a, b):
return 10 * np.log10(255 ** 2 / np.mean((a.astype(float) - b.astype(float)) ** 2))
print()
print("Secret-pattern watermark, strength alpha = 3")
wm = mark(photo, 3)
print(f" picture quality (PSNR) : {psnr(photo, wm):.1f} dB (above about 40 dB is hard to see)")
tests = [
("never watermarked", photo),
("watermarked", wm),
("JPEG quality 90", jpeg(wm, 90)),
("JPEG quality 75", jpeg(wm, 75)),
("JPEG quality 50", jpeg(wm, 50)),
("added noise, sigma 4", np.clip(wm + np.random.default_rng(8).normal(0, 4, wm.shape), 0, 255).astype(np.uint8)),
("shrunk to 50% and back", np.array(Image.fromarray(wm).resize((128, 128), Image.BILINEAR).resize((256, 256), Image.BILINEAR))),
("cropped 8 pixels off the edge", np.array(Image.fromarray(wm).crop((8, 8, 256, 256)).resize((256, 256), Image.BILINEAR))),
]
for name, img in tests:
z = score(img)
print(f" {name:<30} z = {z:6.1f} {'DETECTED' if z > 4 else 'not detected'}")
print()
print("Stronger watermark = easier to find, but easier to see")
print(f" {'alpha':>5}{'PSNR':>9}{'z after JPEG 75':>18}")
for a in (1, 2, 3, 5, 8):
w = mark(photo, a)
print(f" {a:>5}{psnr(photo, w):>7.1f} dB{score(jpeg(w, 75)):>14.1f}")
Output:
Hiding 2,000 bits in the last bit of 2,000 pixels
untouched copy bits recovered: 100.0% (50% is a coin flip)
saved as JPEG, quality 95 bits recovered: 49.7% (50% is a coin flip)
tiny noise, +/-1 level bits recovered: 32.1% (50% is a coin flip)
brightened by 1 level bits recovered: 0.0% (50% is a coin flip)
Secret-pattern watermark, strength alpha = 3
picture quality (PSNR) : 38.6 dB (above about 40 dB is hard to see)
never watermarked z = -1.2 not detected
watermarked z = 160.4 DETECTED
JPEG quality 90 z = 109.8 DETECTED
JPEG quality 75 z = 62.9 DETECTED
JPEG quality 50 z = 35.6 DETECTED
added noise, sigma 4 z = 119.4 DETECTED
shrunk to 50% and back z = 46.9 DETECTED
cropped 8 pixels off the edge z = -0.4 not detected
Stronger watermark = easier to find, but easier to see
alpha PSNR z after JPEG 75
1 48.1 dB 20.2
2 42.1 dB 42.0
3 38.6 dB 62.9
5 34.2 dB 95.9
8 30.1 dB 134.0
The hidden bits were recovered perfectly from an untouched copy. But saving the picture as a high-quality JPEG, which most platforms do automatically, wiped the message out: 49.7 percent recovered, which is a coin flip. Adding invisible noise of one brightness level destroyed it too. And brightening the whole image by a single level flipped every last bit, giving 0.0 percent, a perfect inversion. The idea is correct and the implementation is useless, because the last bit is exactly the part of a picture that compression and editing throw away first.
A better idea: spread a faint pattern across the whole image
The robust trick, used in various forms for decades, is to stop hiding bits in individual pixels. Instead, you add a very faint secret noise pattern to the entire picture, the same pattern everywhere, a plus or minus a few brightness levels. To check for it, you measure how strongly the picture’s fine detail correlates with your secret pattern. Someone without the key sees only slight grain. Someone with the key sees a correlation score that is wildly higher than chance.
The strength of the evidence grows with the number of pixels, which is why it survives damage. Each pixel contributes a tiny nudge, and you only need the total to stand out. The z-score reported in the output is how many standard deviations above random chance the match is. Above 4 is already strong, since the chance of reaching it by accident is about 3 in 100,000.
The same program tested this against JPEG compression, noise, resizing and cropping:
The results are in the second half of the output above. At a strength of 3 brightness levels, the picture quality measured 38.6 dB, just under the point where differences become hard to see, and the original unmarked picture scored a harmless −1.2. The watermarked picture scored 160. After JPEG quality 90 it was still 110; at quality 50 it was still 36. Added noise left it at 119, and even shrinking to half size and back left it at 47. All detected.
The one edit that killed it was cropping. Trimming just 8 pixels off the edge and rescaling slid the picture out of alignment with the pattern, and the score fell to −0.4, indistinguishable from nothing. A real system defends against this by searching over small shifts and scales, or by hiding the mark in a form that does not depend on exact position. That is more work for the detector, and clever attackers keep finding combinations of crops, warps and filters that the detector does not search.
The unavoidable trade-off: visibility against robustness
The last table in the output shows the dilemma at the heart of every watermark. A stronger mark survives more abuse and also becomes more visible.
At strength 1 the picture quality was an excellent 48.1 dB but the score after JPEG was only 20. At strength 8 the score reached 134, and the picture quality dropped to 30.1 dB, which is visibly grainy. There is no setting that is both invisible and indestructible, only a compromise, and each designer picks a different one. Real systems blunt this trade-off by shaping the mark to hide where the eye is least sensitive, such as busy textures, but they cannot make it disappear.
One honest caveat about my test: the synthetic picture is smoother than most real photographs, and smooth areas leave the mark standing out more cleanly. A real photograph carries its own fine detail that acts as noise against the detector, so real scores will be lower. The pattern of results, though, matches what published research shows: weak against alignment attacks, strong against ordinary compression and noise.
Text watermarks: the same idea, built from word choices
Text has no pixels to nudge, so how can you hide a mark in a paragraph? The answer is subtle and elegant, and it was set out clearly in a 2023 research paper from the University of Maryland, “A Watermark for Large Language Models”.
A language model writes one word at a time by choosing from a list of probable next words. Before each choice, the watermarking system looks at the previous word and uses a secret key to split the whole vocabulary into two groups: a “green list” and a “red list”. The split looks random, but it is repeatable by anyone holding the key, and it changes with every preceding word. The generator then gives green words a small boost in probability. It does not forbid red words. It just leans toward green.
Over a few sentences, nobody can notice the lean. But statistically, a watermarked passage contains far more green words than chance would give. To detect it, you rebuild the green lists from the key, count how many words in the passage landed on green, and ask how surprising that count is. If a quarter of the vocabulary is green, an ordinary 200-word text should hit about 50 green words. A watermarked one might hit 100. The z-score converts that gap into a confidence level.
Notice what this means. The watermark lives in the choices, not in any individual word. No single word is wrong, and the text reads naturally. And only someone with the key can tell, because without it the green lists look like random noise.
I built one and tested it
To measure how a watermark behaves, I implemented the scheme on a toy language model with a 1,000-word vocabulary, using a green fraction of 25 percent and a boost of 2. A toy model is not a real chatbot, and I will point out where that makes the results friendlier than reality. But it lets me run thousands of texts and measure properly.
import numpy as np
from math import erfc, sqrt
V, GAMMA, KEY = 1000, 0.25, 12345 # toy vocabulary, green fraction, secret key
rng = np.random.default_rng(0)
LM = rng.normal(0, 2.5, (V, V)) # toy language model: logits for every previous word
LM_PEAKED = LM * 3.2 # same model, but very predictable (low entropy)
def hash_green():
"""green[prev, tok] is True for a secret 25% of words, different for every previous word."""
p = np.arange(V, dtype=np.uint64)[:, None]
t = np.arange(V, dtype=np.uint64)[None, :]
x = (p * np.uint64(1000003) + t * np.uint64(7919) + np.uint64(KEY)) * np.uint64(0x9E3779B97F4A7C15)
x ^= x >> np.uint64(29); x *= np.uint64(0xBF58476D1CE4E5B9); x ^= x >> np.uint64(32)
return (x % np.uint64(100)) < np.uint64(int(GAMMA * 100))
GREEN = hash_green()
def generate(n, T, delta, model, seed):
"""n texts of T words. delta = 0 means no watermark."""
r = np.random.default_rng(seed)
out = np.zeros((n, T + 1), dtype=int)
out[:, 0] = r.integers(0, V, n)
for i in range(1, T + 1):
prev = out[:, i - 1]
z = model[prev] + delta * GREEN[prev]
p = np.exp(z - z.max(1, keepdims=True)); p /= p.sum(1, keepdims=True)
out[:, i] = (p.cumsum(1) > r.random((n, 1))).argmax(1)
return out
def zscore(tok):
"""How many standard deviations above chance is the green-word count?"""
hits = GREEN[tok[:, :-1], tok[:, 1:]].sum(1)
T = tok.shape[1] - 1
return (hits - GAMMA * T) / np.sqrt(T * GAMMA * (1 - GAMMA))
def tail(z): # chance of such a score in ordinary text
return 0.5 * erfc(z / sqrt(2))
THRESH = 4.0
print(f"threshold z > {THRESH}: chance of a false alarm per text = {tail(THRESH):.6f}")
print()
plain = generate(2000, 200, 0, LM, 1)
marked = generate(2000, 200, 2.0, LM, 2)
print("200-word texts, 2,000 of each")
print(f" ordinary text : mean z = {zscore(plain).mean():5.2f}, flagged = {(zscore(plain) > THRESH).sum():>4} of 2000")
print(f" watermarked : mean z = {zscore(marked).mean():5.2f}, flagged = {(zscore(marked) > THRESH).sum():>4} of 2000")
print()
print("Detection rate by length (watermarked, delta = 2)")
for T in (20, 50, 100, 200, 400):
z = zscore(generate(1000, T, 2.0, LM, 10 + T))
print(f" {T:>4} words: {100 * (z > THRESH).mean():5.1f}% flagged")
print()
print("Rewriting attack: replace a share of words at random (200-word texts)")
r = np.random.default_rng(5)
for share in (0.0, 0.1, 0.25, 0.4, 0.6):
t = marked.copy()
mask = r.random(t.shape) < share
mask[:, 0] = False
t[mask] = r.integers(0, V, mask.sum())
z = zscore(t)
print(f" {int(share * 100):>3}% replaced: mean z = {z.mean():5.2f}, flagged = {100 * (z > THRESH).mean():5.1f}%")
print()
print("Predictable text carries little watermark (200 words, delta = 2)")
for name, model in (("ordinary entropy", LM), ("very predictable", LM_PEAKED)):
z = zscore(generate(1000, 200, 2.0, model, 77))
print(f" {name:<17}: mean z = {z.mean():5.2f}, flagged = {100 * (z > THRESH).mean():5.1f}%")
print()
print("Dilution: 100 watermarked words inside a longer document")
w = generate(1000, 100, 2.0, LM, 31)
for extra in (0, 100, 300, 900):
h = generate(1000, extra, 0, LM, 32 + extra)[:, 1:] if extra else np.zeros((1000, 0), dtype=int)
z = zscore(np.concatenate([w, h], 1))
print(f" + {extra:>3} human words: mean z = {z.mean():5.2f}, flagged = {100 * (z > THRESH).mean():5.1f}%")
Output:
threshold z > 4.0: chance of a false alarm per text = 0.000032
200-word texts, 2,000 of each
ordinary text : mean z = -0.13, flagged = 0 of 2000
watermarked : mean z = 13.84, flagged = 2000 of 2000
Detection rate by length (watermarked, delta = 2)
20 words: 69.8% flagged
50 words: 99.5% flagged
100 words: 100.0% flagged
200 words: 100.0% flagged
400 words: 100.0% flagged
Rewriting attack: replace a share of words at random (200-word texts)
0% replaced: mean z = 13.84, flagged = 100.0%
10% replaced: mean z = 11.25, flagged = 100.0%
25% replaced: mean z = 7.82, flagged = 100.0%
40% replaced: mean z = 4.97, flagged = 79.5%
60% replaced: mean z = 2.24, flagged = 5.5%
Predictable text carries little watermark (200 words, delta = 2)
ordinary entropy : mean z = 13.81, flagged = 100.0%
very predictable : mean z = 4.20, flagged = 71.2%
Dilution: 100 watermarked words inside a longer document
+ 0 human words: mean z = 9.79, flagged = 100.0%
+ 100 human words: mean z = 6.85, flagged = 99.9%
+ 300 human words: mean z = 4.78, flagged = 78.2%
+ 900 human words: mean z = 2.76, flagged = 10.1%
Start with the first block. Ordinary text scored a mean of −0.13, and none of 2,000 texts crossed the threshold of 4, which matches the predicted false alarm rate of about 0.003 percent per text. The watermarked texts averaged 13.8, and all 2,000 were flagged. That is the strength of the method: a clean separation, with an error rate you can compute in advance.
Length matters enormously
The second block shows detection by length. At 100 words or more, every watermarked text was caught. At 50 words it was 99.5 percent, and at 20 words only 69.8 percent. A watermark is a statistical signal, and statistics need data. A one-line reply, a short caption or a headline simply does not contain enough words to prove anything, which is why short messages are the hardest case for every real system.
Rewriting breaks it, gradually
The third block is the attack. I replaced a share of the words at random, a crude stand-in for someone editing or paraphrasing the text by hand. Replacing 10 or 25 percent of the words left detection at 100 percent. At 40 percent it fell to 79.5 percent, and at 60 percent to 5.5 percent. Each replaced word damages not only itself but also the word after it, because the green list depends on the previous word, so the damage compounds.
A human editing a few phrases will not remove the mark. But someone who runs the text through another AI and asks for a rewrite, or translates it to another language and back, changes nearly every word at once, and the mark is gone. This is the central weakness of text watermarking, and the companies working on it say so. OpenAI, for example, reportedly built an experimental text watermark in 2024 and said it held up against local tampering but was far less robust against translation or rewording with another model, which is one reason it has been cautious about releasing it.
Predictable text hides no watermark
The fourth block tests a different weakness. The mark can only lean when the model has a real choice between several good words. If the next word is nearly forced, there is nothing to nudge. When I made the toy model very predictable, the mean score dropped from 13.8 to 4.2 and only 71.2 percent of texts were flagged. Real language is full of forced words: source code, lists of facts, quotations, boilerplate. A watermark on a code snippet or a short factual answer is weak for the same reason.
My toy model is also friendlier than a real chatbot. Real language models are often more predictable than my random one, so real systems need more words than my numbers suggest to reach the same confidence.
Mixing in human text dilutes it
The final block starts with 100 watermarked words and adds human-written words around them. With 100 extra words, detection stayed at 99.9 percent. At 300 extra it fell to 78.2 percent, and at 900 extra to 10.1 percent. This matters for the real world, where an AI draft is often pasted into a longer document. The mark does not vanish, but it gets diluted, and a detector that reads the whole document may miss a watermarked paragraph that a detector reading paragraph by paragraph would catch.
What the real systems look like
Google DeepMind’s SynthID Text, described in a paper in Nature in October 2024 and later open-sourced, takes a related but more refined approach, adjusting word probabilities using secret keys and offering detection with three outcomes: watermarked, not watermarked, or uncertain. Its documentation stresses that detection is probabilistic and that the keys must be kept private, because a leaked configuration makes the watermark easy for others to copy. It also describes a setting that trades robustness against detectability, which is the same trade-off we saw with images.
Provenance metadata: the signed receipt
The second big approach does not hide anything in the content. Instead, it attaches a signed receipt to the file. C2PA, backed by a large group of camera makers, software companies and AI labs, defines a “manifest” that records who created a file, what tools were used and what edits were made, protected by a cryptographic signature. The manifest includes a hash of the content, called a hard binding, so that any change to the pixels breaks the match and the tampering is visible.
The weakness is the one every receipt has: it can be lost. Ordinary metadata such as EXIF fields can be edited with free tools, and many platforms strip metadata when you upload a file. Reports have found that some major platforms do not preserve credentials on the video they serve. To cope, the C2PA specification adds a “soft binding”, which is either a content fingerprint or an invisible watermark that lets a validator look up the missing manifest in a repository. In other words, the watermark does not replace the signed receipt, it helps you find it again.
Two further limits are worth stating plainly. A valid credential proves who signed what, not that the content is true. And a missing credential proves nothing about the content, because most files today carry none.
Why a detector that guesses is not the same thing
People often lump watermark detection together with AI-text detectors, the tools that claim to tell whether an essay was written by a machine by studying its style. They are different in kind. A watermark detector asks a precise question with a computable error rate: do these words follow a key I know? A style detector has no key and no mark. It estimates whether the writing feels machine-made, which is a guess, and good human writers can look machine-like while polished AI writing can look human.
The trouble with guessing detectors is not only that they make mistakes. It is what the mistakes do to the people accused. Here is the arithmetic for 1,000 essays:
# If a detector flags an essay as AI-written, how likely is it to be right?
def flagged(n, share_ai, hit_rate, false_alarm):
ai = n * share_ai
human = n - ai
right = ai * hit_rate # AI essays correctly flagged
wrong = human * false_alarm # human essays wrongly flagged
return right, wrong, right / (right + wrong)
print(f"{'AI share':>9}{'hit rate':>10}{'false alarm':>13}{'flagged right':>15}{'flagged wrong':>15}{'flag is correct':>17}")
for share, hit, fa in ((0.10, 0.90, 0.01), (0.10, 0.90, 0.05), (0.01, 0.90, 0.01), (0.01, 0.90, 0.05)):
r, w, ppv = flagged(1000, share, hit, fa)
print(f"{share:>9.0%}{hit:>10.0%}{fa:>13.0%}{r:>15.1f}{w:>15.1f}{ppv:>17.0%}")
print()
print("(1,000 essays in each row)")
Output:
AI share hit rate false alarm flagged right flagged wrong flag is correct
10% 90% 1% 90.0 9.0 91%
10% 90% 5% 90.0 45.0 67%
1% 90% 1% 9.0 9.9 48%
1% 90% 5% 9.0 49.5 15%
(1,000 essays in each row)
Look at the last row. If only 1 percent of essays are really AI-written and the detector has a 5 percent false alarm rate, a flagged essay is right only 15 percent of the time. Out of 58.5 flags, 49.5 land on innocent writers. Even the best-looking row, a 1 percent false alarm rate, gives 9 wrong accusations per 1,000 essays. This is the base-rate problem, and it is why careful institutions treat a detector score as a reason to ask questions, never as proof. Compare that with the watermark threshold of z above 4, where the chance of a false alarm is about 3 in 100,000.
The biggest limit: someone has to cooperate
Everything so far assumes the generator adds a mark. That is a big assumption. A watermark is applied by the system that produces the content, so it only covers systems that choose to apply one. Anyone can run an open-weight model on their own computer, and nothing forces it to watermark. A bad actor can also use a service in a country with no marking requirement, or simply remove a mark by regenerating the content through a second model. Published research has argued that invisible image watermarks can be removed by passing the image through a generative model, which re-draws the pixels while keeping the look.
So the logic runs in only one direction. A detected watermark is strong evidence that content came from a marking-enabled system. A missing watermark is no evidence of anything. That asymmetry is why watermarking is useful for companies who want to identify their own outputs, and much weaker as a tool to catch deliberate abuse.
What the law is asking for
Regulators have noticed. The European Union’s AI Act includes transparency rules in Article 50 requiring providers of generative systems to mark synthetic audio, image, video and text in a machine-readable way, and requiring deployers to label deepfakes and certain public-interest text. Published summaries say the transparency obligations start to apply on 2 August 2026, with a later deadline of 2 December 2026 reported for machine-readable marking in systems already on the market, and that the Commission published a voluntary Code of Practice on this in June 2026. Check the current legal status before relying on any date, because timetables have been subject to proposed amendments.
One detail in the way the Code is framed is telling. Commentators note that it does not prescribe a single technique, since no single marking method currently meets all four requirements the Act sets: effectiveness, interoperability, robustness and reliability. The practical answer is layering: signed metadata, an invisible watermark and a fingerprint registry, so that when one layer is stripped another may survive.
So, can it really be done?
| Question | Honest answer |
|---|---|
| Can a mark be added invisibly? | Yes, for images and, with enough words, for text. |
| Can detection have a known error rate? | Yes, for key-based watermarks. In my test, 0 false alarms in 2,000 texts at z above 4. |
| Does it survive ordinary handling? | Often: JPEG, noise and light editing, yes. Heavy rewriting, translation or re-generation, no. |
| Does it work on short text? | Weakly. 20 words gave 69.8 percent detection in my toy model. |
| Can it catch a determined bad actor? | No. Open models need not mark, and marks can be removed. |
| Does a missing mark mean human-made? | No. |
| Is it useful anyway? | Yes, as one layer for cooperating systems, platforms and compliance. |
Where this shows up in real situations
The technology matters because of the people who use the content. Click through five situations and notice how the answer changes with who is watching and what is at stake.
Classroom essay
A teacher suspects a student’s essay came from a chatbot. Can a watermark settle it?
What it means. Only if the chatbot the student used adds a watermark and nobody rewrote the text afterwards. A positive result from a key-based check is strong evidence; a negative result means nothing, since the student may have used a tool that never marks. A style-based detector is weaker still, and my arithmetic showed a flag can be wrong most of the time when AI use is rare. Treat any score as a reason to talk, and ask to see drafts.
Newsroom photo
A photo arrives from a source during a breaking story. How does an editor use provenance tools?
What it means. If it carries valid Content Credentials, the editor can see who signed it and which edits were declared, which is useful. But a credential shows who signed, not that the scene is true, and a missing one is normal because platforms strip metadata. An invisible watermark can help find the original record again. The editor still checks the source, the location and the light, as always.
Social upload
Someone uploads an AI picture to a social site, which shrinks and re-saves it. What survives?
What it means. In my test the secret pattern survived JPEG at quality 50 and shrinking to half size, while the last-bit trick was gone after one save. That is why serious systems rely on robust watermarks rather than fragile ones. A crop that shifts the alignment can still defeat a simple detector, so platforms search over shifts and scales.
Fake reviews
A shop is flooded with short, glowing product reviews. Could watermarks expose the bots?
What it means. Unlikely. Reviews are short, and in my toy model 20 words were caught only 69.8 percent of the time. Spammers also choose tools that do not mark, or rewrite the text. Platforms do better by looking at behaviour: account age, posting bursts, and repeated phrasing across many accounts.
Cloned voice
A caller sounds exactly like a family member and asks for money. Will a watermark protect you?
What it means. Audio can carry inaudible marks too, but they only help if the tool that cloned the voice added one, and playing a clip through a speaker and re-recording it can weaken them. Do not rely on a mark for safety. Hang up and call the person back on a number you already have, and agree a family code word in advance.
Which tool for which job?
When people ask me what they should rely on, I walk them through a short list of questions. The point is to match the tool to the control you actually have.
Practical advice if you publish content
- Disclose AI use plainly. A visible note is the only mark that works against nobody and for everybody. It also keeps you on the right side of rules that require labels.
- Keep content credentials when you export. If your tools add C2PA information, avoid pipelines that strip metadata, and record your editing steps.
- Keep your drafts. Version history, notes and source files are strong evidence of human authorship, and they are not affected by anyone’s detector.
- Never accuse on one score. If you run a detector, treat a flag as a prompt for a conversation, and look at process evidence before drawing a conclusion.
- Do not trust the absence of a mark. Content without a watermark is the normal case, not a sign of authenticity.
- Protect your keys. If you run a watermarking system yourself, a leaked key lets others forge or strip the mark.
Common mistakes and misunderstandings
- Treating a watermark as proof of authenticity. It can show a marking-enabled system made something. It cannot show that unmarked content is real.
- Confusing watermarks with detectors. One has a key and a computable error rate; the other guesses from style.
- Expecting short text to be reliably marked. Twenty words is not enough evidence.
- Assuming metadata survives. Many platforms strip it. Plan for its loss.
- Believing a stronger mark is free. More robustness costs visibility or text quality.
- Forgetting base rates. A detector with a small false alarm rate can still be wrong most of the time when real cases are rare.
- Ignoring open-weight models. A rule that applies to hosted services cannot reach software running on a private computer.
- Using one signal alone. Layers, such as signed metadata plus a watermark plus a fingerprint lookup, give far better coverage.
A mental model that sticks
Think of the seal on a bottle of medicine. The seal tells you that, if it is intact, nobody has opened the bottle since it left the factory. It does not tell you that every other bottle in the world was made in that factory, and a counterfeiter can simply sell bottles with no seal at all. An AI watermark is that seal. It is a good way for an honest manufacturer to show a product is its own and untouched. It was never a way to catch every forger, and it works best when shoppers have learned to be suspicious of a bottle that arrives without one.
Practice problems with answers
Try each one before you tap to check.
1. A watermark detector uses a green fraction of 25 percent. In a 200-word ordinary text, about how many green words do you expect?
About 50, since 25 percent of 200 is 50. A watermarked text lands far above that.
2. Why did hiding bits in the last bit of each pixel fail after one JPEG save?
JPEG compression discards the finest brightness detail, and the last bit is exactly that detail. Only 49.7 percent of bits survived, which is a coin flip.
3. Why does a 20-word message make a poor watermark target?
There are too few word choices to build statistical evidence. In my toy model only 69.8 percent were caught, against 100 percent at 100 words.
4. A detector has a 5 percent false alarm rate and 1 percent of 1,000 essays are AI-written. About how many innocent essays get flagged?
About 49.5 (5 percent of the 990 human essays). With only 9 true flags, a flagged essay is right about 15 percent of the time.
5. If an image has no watermark, is it human-made?
No. Most generators do not mark, and marks can be removed. A missing mark is no evidence either way.
6. Why is a stronger image watermark not free?
It survives more edits but adds more visible grain. In my test strength 8 gave a score of 134 but quality fell to 30.1 dB.
7. Why does a credential not prove a photo is true?
It proves who signed the file and what edits were declared. A signer can still sign a staged or misleading picture.
Test yourself: five quick questions
Tap a question to reveal the answer. The correct option is marked.
What does a key-based text watermark change?
- The font of the text
- The probability of word choices
- The length of the text
- The punctuation only
It leans word choices toward a secret green list, and detection counts how many words landed there.
What happened to last-bit hiding after a JPEG save?
- It was perfect
- It got stronger
- It dropped to about a coin flip
- It was invisible
Only 49.7 percent of bits came back, because compression throws away the last bit first.
What does a missing watermark tell you?
- Nothing
- The content is human-made
- The content is fake
- The content is old
Most content carries no mark, and some generators never add one.
Why do style-based detectors cause false accusations?
- They are too slow
- They use keys
- They only read images
- They guess, and rare AI use means most flags are wrong
With 1 percent AI use and a 5 percent false alarm rate, only about 15 percent of flags were correct.
Which change broke the secret image pattern in my test?
- JPEG quality 50
- Cropping 8 pixels and rescaling
- Adding noise
- Shrinking to half size
The crop moved the picture out of alignment with the pattern and the score fell to −0.4.
Frequently asked questions
Can AI-generated text really be watermarked?
Yes, when the generator cooperates. A key-based scheme leans word choices toward a secret list, and a detector with the key can test for it. It works best on longer, natural text and gets weaker when text is short, predictable or rewritten.
Can a watermark be removed?
Often, with effort. Rewriting text with another AI, translating it back and forth, or re-generating an image through another model can wipe a mark. Robust designs raise the cost but nobody claims they are unremovable.
Are AI text detectors the same as watermark detectors?
No. A watermark detector tests for a pattern made with a secret key and has a computable error rate. A style detector guesses from how the writing feels and has no key, which is why its false alarms are a bigger problem.
What is C2PA or Content Credentials?
A standard for signed provenance records attached to a file, saying who made it and what edits followed. It breaks visibly if the content is altered, but the record can be stripped when platforms re-save files.
Does the EU AI Act require watermarks?
Article 50 requires providers to mark synthetic audio, image, video and text in a machine-readable way, with dates reported for 2026. It does not prescribe one technique, and timetables have been under discussion, so check the current status.
Should I trust an AI detector score on a student essay?
Treat it as a hint only. Rare AI use plus even a small false alarm rate means many flags land on innocent writers. Look at drafts, version history and a conversation with the student.
Key takeaways
- A watermark is added when content is generated and detected later with a secret key. Detection is statistical, with a computable error rate.
- In my tests, hiding bits in the last bit of pixels was destroyed by one JPEG save, while a faint secret pattern survived JPEG at quality 50, added noise and shrinking, but not a small crop.
- A text watermark leans word choices toward a secret green list. On my toy model it flagged every 200-word watermarked text with zero false alarms in 2,000 ordinary ones.
- Text marks are weak when the text is short, predictable, diluted with human writing, or rewritten by another AI: only 69.8 percent at 20 words and 5.5 percent after 60 percent of words were replaced.
- Style-based detectors are different: with 1 percent real AI use and a 5 percent false alarm rate, a flag was right only 15 percent of the time.
- A missing watermark proves nothing, so use layers (visible labels, signed metadata, watermarks) and never accuse anyone on a single score.
Sources and further reading
- Kirchenbauer et al., “A Watermark for Large Language Models” (2023), the green-list method.
- Google AI for Developers: SynthID Text documentation and the Nature paper on SynthID-Text (October 2024).
- C2PA guidance on hard and soft bindings.
- European Commission: Code of Practice on Transparency of AI-generated Content and Article 50 of the EU AI Act.
