How to check whether an image is AI-generated, and what metadata can't tell you

Metadata is the first place to look, because when it's there it's specific: a signed manifest naming the model, a generator tag, a chunk holding the prompt and seed. That's real evidence.

The catch is the shape of the answer. Metadata can confirm an image was generated. It can never confirm one wasn't. Everything below follows from that asymmetry, and most confusion about AI detection comes from ignoring it.

The four signals worth checking

1. C2PA content credentials

A signed provenance manifest, embedded by Adobe Firefly, Photoshop's generative features, ChatGPT, Microsoft Designer and some cameras. It records what made the file, when, and sometimes the chain of edits.

c2patool image.jpg
exiftool -a -G1 -JUMBF:all -APP11 image.jpg

In a browser, the content credentials checker reads it locally.

A valid manifest is strong evidence, because it's cryptographically signed. If it's intact and the signer is one you recognise, it means what it says. Detail in the C2PA explainer.

2. XMP and EXIF generator tags

Less formal, and easier to read:

exiftool -a -G1 -Software -XMP:all -IPTC:all image.jpg

Look for a Software field naming a tool, XMP fields describing a digital source type, or creator fields naming an organisation. These are plain assertions with no signature, so treat them as a strong hint rather than proof.

3. PNG text chunks

The richest source when present. Local Stable Diffusion interfaces write generation data straight into the PNG:

exiftool -a -G1 -PNG:all image.png

Automatic1111 writes a parameters chunk with the prompt, seed, sampler, CFG and model hash. ComfyUI writes the entire node graph. That's not a hint — it's the recipe. More in the Stable Diffusion metadata post.

4. Absence of a camera signature

A photo from a real camera usually carries make, model, lens, exposure settings, and often GPS. A generated image typically has none of that.

This is the weakest signal by far, and worth being careful with. Screenshots have no camera data. Images re-encoded for the web have none. Anything that passed through a platform that strips metadata has none. A bare file is unremarkable, not suspicious.

Why there's no definite "no"

Every signal above lives in the container next to the pixels, so any operation that rebuilds the file from pixels alone removes all of them at once. That includes deliberate cleaning, but also:

• Uploading to most social platforms, which re-encode as a matter of routine.
• Taking a screenshot.
• Opening and re-saving in almost any editor.
• Converting between formats.

So a clean file tells you very little. It might be generated and stripped; it might be a real photo that went through Instagram. Those two are indistinguishable from metadata alone, and no amount of inspection separates them.

The flip side matters too: the presence of a C2PA manifest doesn't mean "AI". Cameras sign authentic photos with C2PA, and editing a real photo with a generative tool for something minor can attach a manifest to an image that's overwhelmingly photographic. This is why people see "Made with AI" on photos they genuinely took — covered in the Made with AI post.

What about detector tools?

Classifiers that judge the pixels are the usual next step, and they're worth treating with caution. They produce confident-looking percentages, they disagree with each other on the same file, and they misfire in both directions — flagging real photos, passing generated ones. Heavy compression, upscaling and screenshots all degrade them further.

Useful as one input. Not something to treat as a verdict, and not something to accuse a person over.

Invisible watermarks are the more durable mechanism. Schemes like Google's SynthID embed a pattern into the pixels themselves, so they survive the re-encoding that destroys metadata. But they only work for images from participating generators, and verifying one generally needs the matching detector. A negative result means "no watermark found", which again is not the same as "not generated".

A practical inspection order

1. Check C2PA. A valid manifest is your most reliable answer.
2. Read XMP, EXIF and PNG chunks. Generator tags and parameter chunks are often decisive.
3. Look at the camera fields. Present and coherent is mild evidence of a photo; absent means nothing much.
4. Note the file's history. Did it come straight from a device, or via a platform that re-encodes? That determines how much step 1–3 could have told you at all.
5. Only then consider a classifier, and weigh it loosely.

The AI info tag checker runs steps 1–3 in one pass, in your browser, so the file you're examining isn't uploaded anywhere — which matters if it isn't yours to share.

Reading the result honestly

Three outcomes, and only one is firm:

• Signals present → generated, or at least touched by a generative tool. Firm, especially with a valid signature.
• No signals, file came straight off a camera → weak evidence of a photo.
• No signals, file came from the web → you've learned nothing. This is most files.

If something real depends on the answer — a purchase, a dispute, a story — the useful question usually isn't the pixels but the provenance: who produced it, when, and can they show you the original file or the frames around it. Metadata supports that conversation. It rarely settles it alone.

The short version

Metadata gives you a definite yes and never a definite no, because every signal sits outside the pixels and ordinary handling strips it. Check C2PA first, then XMP, EXIF and PNG chunks, and treat missing camera data as unremarkable. Classifiers are a hint, not a verdict.