A watermark check answers one question very well. Here's the code for the questions it can't answer.

On October 7, 2026, Google opened SynthID Detector to everyone. It's free, it works worldwide in English, and you sign in with a Google, OpenAI or Apple account. Upload an image, a video or an audio file, and it tells you whether the file carries a SynthID watermark.

That's a real step forward. Google says it has watermarked more than 180 billion images and videos and 240,000 years of audio since 2023, and the detector now reads watermarks from OpenAI, NVIDIA and Kakao models as well as Google's own.

But the detector's own homepage says it plainly: "This is not a general AI detector." It finds one specific signal from one group of companies. If you're building a moderation queue, a KYC flow, a newsroom tool or anything else that has to decide whether media is real, a free watermark check is one layer, not the whole stack.

The short version: SynthID Detector is the most reliable way to confirm that a file came from a SynthID-enabled model. It can't tell you anything about media from Midjourney, Stable Diffusion, Flux, open-source voice clones or any model outside the SynthID group, it can be defeated by enough transformations, and a "not detected" result doesn't mean a human made the file. To cover those gaps, add forensic detection, which looks at the pixels or the audio itself. Below is how the pieces fit, with working Python and Node code using the DeepfakeDetector.ai API.

Table of Contents

  1. What Changed With SynthID Detector
  2. How Watermark Detection Actually Works
  3. Five Things a Watermark Check Can't Catch
  4. Watermarks, Provenance and Forensics: Three Different Questions
  5. Adding Forensic Image Detection in Python
  6. Voice: Score Segments, Not Just Files
  7. Putting It Together: A Simple Triage Function
  8. Production Notes
  9. Conclusion
  10. FAQs

1. What Changed With SynthID Detector

SynthID Detector isn't brand new. Google launched an early version in May 2025, but only for journalists, media professionals and researchers on a waitlist. The October 2026 release opened it to the public and expanded what it reads.

Here's what you get today:

  • Media types: images, video and audio. For video and audio, it points to the segments that carry the watermark.
  • Watermarks it reads: SynthID from Google's models (Gemini, Imagen, Veo, Lyria) plus partners that adopted it, currently OpenAI, NVIDIA and Kakao. Google says Apple support is coming.
  • Cost: free, with a sign-in.
  • Where else it shows up: the same checks are built into Google Search, the Gemini app and Chrome, which together handle more than a million verification requests a day, according to Google.

What it doesn't come with is a public API. It's a web portal. Google does have a separate Content Detection API on Google Cloud, announced in preview in May 2026, but it's limited to a group of trusted partners for now and only accepts JPEG, PNG and WebP images.

So for most developers, SynthID Detector is something a person uses by hand, not something you call from a pipeline.

2. How Watermark Detection Actually Works

SynthID embeds an imperceptible signal into content at the moment a participating model generates or edits it. For images and video, the signal lives in the pixels. For audio, it lives in the frequency components. It isn't metadata, so stripping EXIF data or re-saving the file doesn't remove it.

Detection is the other half. The detector looks for that specific signal and reports one of two outcomes:

  • Watermark detected: the file was likely generated or edited by a SynthID-enabled model.
  • Watermark not detected: no confident signal was found.

Because the detector is looking for a signal that was put there on purpose, a positive result is strong evidence. That's the big advantage over forensic detectors, which have to infer AI generation from patterns the model left behind by accident. Google's own FAQ makes the same comparison: watermark checks are more reliable, forensic detectors are broader in scope.

The catch is in that word "broader."

3. Five Things a Watermark Check Can't Catch

1. Anything made by a model outside the SynthID group

This is the big one. Midjourney, Stable Diffusion, Flux and the long list of open-source and locally run image models don't embed SynthID. Neither do many voice cloning tools, especially open-source models people run on their own machines. Content from those models will always come back "not detected," no matter how obviously synthetic it is. The same goes for anything made by a SynthID partner before it adopted the watermark.

2. A watermark that's been worn down on purpose

SynthID is built to survive normal handling: filters, color changes and lossy compression. Google is also honest about the limit. Its FAQ says the watermark "is not infallible and if someone tries many transformations, they may be able to find one that doesn't get detected." Heavy cropping, re-encoding and screenshots can also degrade the signal. A motivated attacker has time to try.

3. Proof that something is real

A "not detected" result has at least three possible explanations: the file is genuine, it came from a model without SynthID, or the watermark was degraded. The detector can't tell you which. In product terms, a negative watermark check should never be the reason a file gets a "verified human" badge.

4. How much of the file is AI

A real photo touched up with a Google AI editing tool can carry the same watermark as an image generated from scratch. The image result tells you a SynthID-enabled model was involved, not whether the whole thing is fake or which parts changed. For video and audio, segment-level results help, but for images you get a yes or no.

5. Your pipeline

There's no public API, so you can't run SynthID Detector on every upload, every voicemail or every KYC selfie. Someone has to drag files into a web page. That's fine for a fact-checker looking at one viral image. It doesn't work for a platform that sees thousands of files an hour.

4. Watermarks, Provenance and Forensics: Three Different Questions

It helps to stop thinking of "AI detection" as one check. There are three separate signals, and each answers a different question.

Signal Question it answers Strength Main gap
Watermark (SynthID) Did a participating model generate or edit this? Very reliable when present Only covers models that embed it
Provenance (C2PA Content Credentials, generator metadata) What tool created or edited this file, according to the file itself? Names the tool, often cryptographically signed Stripped by screenshots and most social uploads
Forensics (pixel and audio analysis) Does the content itself look synthetic? Works on any file, from any model Probabilistic, so you get a score, not proof

A sensible pipeline checks all three and treats them differently. A watermark or a signed C2PA manifest from a generator is close to conclusive. A forensic score is evidence you weigh, set thresholds on and send to a human when it's borderline.

If you only need provenance for the occasional image, DeepfakeDetector.ai has a free C2PA checker that reads the manifest plus EXIF, XMP and PNG metadata, no signup required. For volume, the same provenance read is built into its image API, which is what the code below uses.

5. Adding Forensic Image Detection in Python

The DeepfakeDetector.ai API is plain REST with a Bearer key. API access starts on the $49 a month Starter plan, which includes 1,000 checks a month shared between the web app and the API.

Every check is three calls:

  1. POST /api/v1/uploads/image with an empty body. You get back an upload_id and a signed upload_url that's valid for two hours.
  2. PUT the raw file bytes to that upload_url.
  3. POST /api/v1/detect/image with {"upload_id": "..."}. The verdict comes back in the same response.

Voice works the same way. You swap image for voice in both paths.

Here's a small client that handles both, including the 429 rate-limit response, which comes with a Retry-After header:

import os import time import mimetypes import requests BASE = os.environ.get("DFD_BASE_URL", "https://app.deepfakedetector.ai") API_KEY = os.environ["DFD_API_KEY"] HEADERS = {"Authorization": f"Bearer {API_KEY}"} class DetectionError(Exception): pass def _post(path, json=None, retries=3): for attempt in range(retries): r = requests.post(f"{BASE}{path}", headers=HEADERS, json=json, timeout=60) if r.status_code == 429: time.sleep(int(r.headers.get("Retry-After", 5))) continue if r.ok: return r.json()["data"] err = r.json().get("error", {}) raise DetectionError(f"{r.status_code} {err.get('code')}: {err.get('message')}") raise DetectionError("rate limited after retries") def detect(path, kind="image"): """kind is 'image' or 'voice'. Returns the 'data' object from the API.""" # 1. get a signed upload URL (empty body) upload = _post(f"/api/v1/uploads/{kind}") # 2. PUT the raw bytes to the signed URL content_type = mimetypes.guess_type(path)[0] or "application/octet-stream" with open(path, "rb") as f: put = requests.put(upload["upload_url"], data=f, headers={"Content-Type": content_type}, timeout=120) put.raise_for_status() # 3. run detection (synchronous) return _post(f"/api/v1/detect/{kind}", json={"upload_id": upload["upload_id"]}) if __name__ == "__main__": import sys result = detect(sys.argv[1], sys.argv[2] if len(sys.argv) > 2 else "image") print(result["verdict_label"], result["ai_score"]) trace = result.get("source_trace") or {} if trace.get("tool"): print("Source trace:", trace["tool"], f"({trace.get('signal_strength')})") 

Run it with DFD_API_KEY=sk_live_... python detect.py photo.jpg. Accepted image formats are JPG, PNG, WebP, BMP, TIFF and HEIC.

The response for an image looks like this (trimmed):

{ "data": { "verdict": "likely_ai", "verdict_label": "Likely AI", "ai_score": 0.71, "source_trace": { "status": "source_signal_found", "tool": "Midjourney", "signal_strength": "moderate" } }, "meta": { "request_id": "req_...", "api_version": "v1" } } 

Two fields matter most:

  • ai_score runs from 0 to 1, and the verdict follows fixed bands: AI Generated at 0.86 and up, Likely AI from 0.50 to 0.85, Likely Human from 0.16 to 0.49, and Human below 0.16. You can also set your own threshold on the raw score.
  • source_trace is the provenance layer. When the file still carries C2PA Content Credentials or generator metadata, it names the tool and gives an evidence level. Notice the example names Midjourney, a generator SynthID can't see at all.

One detail I like for moderation: editing tools such as Photoshop, Lightroom, GIMP and Canva are classified as editors, not generators, so a retouched photo isn't reported as AI just because it was edited.

6. Voice: Score Segments, Not Just Files

Voice is where the watermark gap hurts most, because many of the tools behind voice-clone scams, especially open-source models that run locally, don't embed SynthID. It's also where a single file-level score can mislead you. A scammer can take a real voicemail and splice in one cloned sentence, and averaged over a minute of audio, that sentence barely moves the score.

The voice endpoint handles this by scoring every 6-second segment of recordings longer than 6 seconds. The response adds duration, segment_count, average_ai_score, max_ai_score and a segments array. Accepted formats are MP3, WAV, OGG, M4A, FLAC and AAC.

Here's the same flow in Node 18+ (no dependencies), returning only the segments worth a human listen:

import { readFile } from "node:fs/promises"; const BASE = process.env.DFD_BASE_URL ?? "https://app.deepfakedetector.ai"; const auth = { Authorization: `Bearer ${process.env.DFD_API_KEY}` }; async function call(path, body) { const res = await fetch(`${BASE}${path}`, { method: "POST", headers: { ...auth, "Content-Type": "application/json" }, body: body ? JSON.stringify(body) : undefined, }); const json = await res.json(); if (!res.ok) throw new Error(`${res.status} ${json.error?.code}: ${json.error?.message}`); return json.data; } export async function checkRecording(path, contentType = "audio/mpeg") { const { upload_id, upload_url } = await call("/api/v1/uploads/voice"); const put = await fetch(upload_url, { method: "PUT", headers: { "Content-Type": contentType }, body: await readFile(path), }); if (!put.ok) throw new Error(`upload failed: ${put.status}`); const result = await call("/api/v1/detect/voice", { upload_id }); // Segments are 6 seconds long. Pull out the ones worth a human listen. const flagged = (result.segments ?? []).filter((s) => s.ai_score >= 0.5); return { verdict: result.verdict_label, score: result.ai_score, maxSegment: result.max_ai_score, flagged: flagged.map((s) => `${s.start}s to ${s.end}s (${s.verdict_label})`), }; } const file = process.argv[2]; if (file) console.log(await checkRecording(file)); 

The output gives a reviewer something they can act on:

{ verdict: 'Likely AI', score: 0.73, maxSegment: 0.92, flagged: [ '6s to 12s (AI Generated)' ] } 

Instead of "this file is 73% AI," the reviewer hears "listen to seconds 6 to 12." That's the difference between a score and a workflow.

The voice API checks recordings, not live calls. For a live call, the defense is still procedural: hang up and call back on a known number.

7. Putting It Together: A Simple Triage Function

Once you have the signals, the logic that combines them is short. The important part is the order: conclusive signals first, scores second, and an honest label when nothing turns up.

def triage(watermark_found, forensic): """Combine a SynthID result (True, False or None if unchecked) with a forensic result from detect().""" score = forensic["ai_score"] trace = (forensic.get("source_trace") or {}).get("tool") max_segment = forensic.get("max_ai_score", score) if watermark_found: return "ai_confirmed", "SynthID watermark present" if trace: return "ai_confirmed", f"provenance names {trace}" if score >= 0.86 or max_segment >= 0.86: return "likely_ai", "strong forensic signal" if score >= 0.50 or max_segment >= 0.50: return "review", "send to a human with the flagged segments" return "no_signal", "nothing found; this is not proof it is real" 

A few choices in there are deliberate:

  • watermark_found can be None. Since SynthID Detector has no public API, most pipelines won't have that signal for every file. When a person checks a file by hand, store the result; otherwise the function falls through to provenance and forensics.
  • max_segment counts as much as the average. For voice, one strongly flagged segment is enough to send a file to review.
  • The last label is "no_signal," not "human." Nothing in this stack can prove a file is authentic, so don't let your UI claim it.

Tune the thresholds to the cost of a mistake. A marketplace flagging AI product photos can be relaxed. A finance team approving a payment on the strength of a voicemail should send anything above 0.5 to a person.

8. Production Notes

Errors. Every error returns error.code, error.message and a request_id. The ones to branch on are invalid_api_key (401), quota_exceeded (402) and rate_limit_exceeded (429, with Retry-After). Log the request_id with every result so you can trace a disputed verdict later.

Keys. Keys are shown once when you create them and hashed at rest, so put the key in a secret manager straight away. Never ship it in client-side code, since anyone could read it and spend your quota.

Send originals. Screenshots and social media re-uploads strip C2PA credentials and degrade watermarks, and heavy compression makes forensic detection harder too. Wherever possible, check the file as it was uploaded to you, before your own pipeline resizes or re-encodes it.

Volume. The Starter plan's 1,000 checks a month is enough for a review queue. Business ($199 a month) raises it to 5,000 checks and Enterprise ($599 a month) to 20,000. Video detection runs in the web app today, and video through the API is available to volume customers through sales.

Keep a human in the loop. Every forensic detector, this one included, returns a probability. Use the score to decide what a person looks at first, not to make final decisions that affect real people on its own.

Conclusion

Google making SynthID Detector free is good news. For anything made by Gemini, Imagen, Veo, Lyria or a partner model, it's the most reliable check you can run, and anyone can use it.

It just answers a narrower question than the one most products need answered. It can't see Midjourney, Flux, Stable Diffusion or many voice clones, it can be worn down by enough edits, it can't prove anything is real, and it has no public API.

The fix is layering. Use watermarks where they exist, read provenance when the file still has it, and add forensic detection for everything else, with segment-level scores for audio and a human reviewing anything borderline. The code above is about 100 lines, and it covers the files a watermark check never will.

FAQs

Is SynthID Detector free?

Yes. Since October 7, 2026, SynthID Detector at synthid.com is free for anyone, worldwide, in English. You need to sign in with a Google, OpenAI or Apple account. It checks images, video and audio.

What does SynthID Detector detect?

It detects the SynthID watermark that Google DeepMind's technology embeds in content from Google's AI models and from partners that adopted it, currently OpenAI, NVIDIA and Kakao. It is not a general AI detector, so it can't identify AI content from models that don't use SynthID.

Does "watermark not detected" mean the image is real?

No. It can mean the file is genuine, that it was made by a model without SynthID, or that the watermark was degraded by heavy editing. Google's own FAQ says a negative result does not rule out AI generation.

Can a SynthID watermark be removed?

It's designed to survive common edits like filters, color changes and compression. Google says it isn't infallible, though, and that someone who tries many transformations may find one that defeats detection. Heavy cropping, re-encoding and screenshots can also weaken it.

Is there a SynthID Detector API?

Not for the free portal. Google has a separate Content Detection API on Google Cloud, in preview since May 2026, but access is limited to selected partners and it only accepts JPEG, PNG and WebP images. Unless you're in that preview, checking media from your own code means using a third-party detection API.

What's the difference between watermark detection and forensic detection?

Watermark detection looks for a signal deliberately embedded when the content was generated, so it's very reliable but only works for models that add one. Forensic detection analyzes the pixels or audio for patterns synthetic media tends to leave, so it works on content from any model but returns a probability rather than proof.

How do I detect AI-generated images and voices in my own app?

Use a detection API that returns a score you can act on. The DeepfakeDetector.ai API, for example, takes an image or a recording through a signed upload, then returns a verdict, an AI score from 0 to 1, a source trace for images and 6-second segment scores for voice. API access starts at $49 a month.