How to Check If an Image Is AI Generated (2026 Guide)

OpenAI published “Advancing content provenance for a safer, more transparent AI ecosystem”, announcing that it joined the C2PA Steering Committee, started adding Google’s SynthID watermark to generated images, previewed a public tool for checking whether an image came from OpenAI, and opened access to a DALL-E 3 image-detection classifier through its Researcher Access Program. That post marks a shift: “Is this image real?” is now a routine check for journalists, recruiters, dating-app users, insurance adjusters, and everyday users.

Try Apidog today

💡 If you are a developer, the practical version of “checking an image” often means wiring a detection API into your own app and verifying that it behaves correctly. That is the kind of integration you should test before shipping. If you are not a developer, you can still run most of the checks below with free browser tools.

TL;DR

To check whether an image is AI-generated, use a layered workflow:

1. Get the original file.
2. Check C2PA Content Credentials.
3. Scan for invisible watermarks such as SynthID.
4. Run an ML-based detector or detection API.
5. Inspect the image manually.
6. Run reverse image search.
7. Report a confidence level, not a binary verdict.

No single method is conclusive. Provenance metadata is the strongest signal when present, but it can be stripped. Watermarks are strong when detected, but model-specific. Classifiers are useful, but probabilistic. Visual inspection helps only when the image has obvious artifacts.

Why image detection needs a method stack

A few years ago, most AI-generated images had obvious flaws: extra fingers, broken text, warped glasses, or impossible backgrounds. Current image generators are much better. Many generated photos pass casual inspection and may survive expert review.

That means “look closely” is no longer enough.

Modern detection relies on two stronger ideas:

• Provenance: attach a signed record of origin and edit history to the media file.
• Watermarking: embed a hidden statistical signal inside the pixels.

Both are useful. Both require cooperation from the generator or platform. Both can fail when metadata is stripped, pixels are heavily edited, or the image comes from a model that does not support the method.

Use the methods in order. If one gives a strong signal, document it. If none do, the right answer may be “undetermined.”

Method 1: Check C2PA Content Credentials

C2PA stands for the Coalition for Content Provenance and Authenticity. It is an open technical standard backed by organizations including Adobe, Microsoft, Google, OpenAI, the BBC, and major camera makers.

C2PA attaches a tamper-evident, cryptographically signed block of metadata to a media file. That block is called a manifest. The user-facing term is Content Credentials.

A manifest can describe:

• which tool created the image
• when it was created
• whether AI was involved
• which edits were applied
• whether the file has been altered since signing

OpenAI has attached C2PA Content Credentials to DALL-E 3 images since 2024. Its May 2026 announcement also confirmed that it is a C2PA Conforming Generator, which means other platforms can read, preserve, and pass along that provenance data.

How to check C2PA metadata

1. Get the original image file.
2. Open a Content Credentials inspector, such as contentcredentials.org.
3. Upload or drag in the file.
4. Read the result.

You will usually see one of three outcomes:

• a valid manifest with origin details
• no Content Credentials data
• an invalid or tampered manifest

A valid AI-generation manifest is strong evidence that the image came from an AI tool. A valid camera-origin manifest is strong evidence that the file came from a camera and has a traceable edit history.

Caveats

C2PA only helps when the credential is present and intact.

Common ways credentials disappear:

• Screenshots create a new file without the original manifest.
• Re-encoding or format conversion can drop metadata.
• Social platforms may strip or fail to preserve C2PA metadata.
• Deliberate removal can strip the manifest quickly.

Also, C2PA verifies the integrity of the manifest, not the truth of the scene. A staged or misleading real photo can still have valid credentials.

If there are no Content Credentials, do not assume the image is real or fake. Move to the next method.

Method 2: Detect invisible watermarks such as SynthID

An invisible watermark is a hidden signal embedded directly into the pixels. Unlike metadata, it is not stored beside the image. It is part of the image data.

SynthID, developed by Google DeepMind, embeds an imperceptible signal into media generated by Google models such as Gemini and Imagen. According to Google, SynthID has been applied to billions of pieces of AI content across images, audio, video, and text.

OpenAI’s May 2026 announcement also said it is adding SynthID watermarking to its generated images. That makes SynthID detection relevant across two major providers.

How to check for SynthID

Use Google’s public SynthID Detector portal. Upload the image, and the detector checks whether a SynthID watermark is present.

You can read more about the technology on Google DeepMind’s SynthID page.

Caveats

Watermark detection is strong but narrow.

• It is model-specific. A clean SynthID result does not mean the image is human-made.
• Coverage is partial. Not every generator applies watermarks.
• Open-source models can be run without watermarking.
• Heavy editing can degrade the signal.

Interpret the result asymmetrically:

• Positive SynthID result: strong evidence of AI generation.
• Negative SynthID result: not meaningful by itself.

Method 3: Use an ML detection classifier or API

When an image has no C2PA metadata and no detectable watermark, use a classifier-based detector.

These models are trained on real and synthetic images. They look for statistical fingerprints such as:

• missing or unnatural camera sensor noise
• frequency-domain artifacts
• texture patterns
• generation-specific image structure

The output is usually a probability, for example:

87% likely AI-generated

Several commercial and free tools work this way. Some also try to identify the source model.

OpenAI’s DALL-E 3 detection classifier, opened to researchers in May 2026, is a specialized example of this category.

Developer workflow: call a detection API

If you are building detection into a product, the practical workflow looks like this:

1. Choose a detection API or host your own classifier.
2. Send representative real-world test images.
3. Capture the confidence score and response fields.
4. Decide how your app should handle high, low, and uncertain scores.
5. Log the result with supporting evidence.
6. Avoid automated high-stakes decisions based on one score.

A generic request might look like this:

curl -X POST "https://example-detector.com/v1/analyze" \
  -H "Authorization: Bearer $API_KEY" \
  -F "image=@sample.jpg"

A typical response shape might look like:

{
  "ai_probability": 0.87,
  "label": "likely_ai_generated",
  "model_confidence": "high"
}

Your application should not treat that as a final verdict. Instead, map it into an evidence pipeline:

function classifyImageDetection(score) {
  if (score >= 0.9) return "high_confidence_ai";
  if (score <= 0.2) return "likely_real_or_undetected";
  return "inconclusive";
}

If you are evaluating providers, this roundup of the best AI image detection APIs for developers compares accuracy, pricing, and supported models.

If you want to own the pipeline, this guide on how to build your own AI image detector API covers training and serving a classifier.

You can script and replay detection calls in Apidog with saved environments so your image-check endpoint behaves consistently in development and production. If your detection logic is wired into an AI agent, the Apidog AI agent debugger helps you inspect what the model sent and received.

Caveats

Classifiers are broadly applicable but uncertain.

• False positives happen. Real photos can be flagged as AI, especially edited, compressed, low-light, or low-texture images.
• Detectors lag new models. A classifier trained before a new generator launches may not recognize its artifacts.
• Adversarial edits can defeat them. Noise, recompression, filters, and resizing can change the score.
• Scores are probabilities. “73% AI” means uncertain, not guilty.

For more detail, see why AI image detection fails.

Do not make high-stakes decisions based on one classifier score.

Method 4: Manual visual inspection

Manual inspection is useful, but only as a supporting method.

Look for:

• Hands and fingers: extra fingers, fused digits, strange joints.
• Text: warped signs, fake letters, broken logos.
• Teeth and jewelry: inconsistent teeth, mismatched earrings, broken chains.
• Accessories: glasses, watch straps, belts, or buckles that connect incorrectly.
• Reflections and shadows: mirrors, sunglasses, water, or shadows that do not match the scene.
• Lighting and physics: inconsistent light sources or impossible blur.
• Backgrounds: repeating textures, merged objects, impossible architecture.
• Image dimensions: generator-default dimensions can be a weak hint, never proof.
• Skin texture: overly smooth, plastic-like skin with no pores or natural variation.

Caveat

Manual inspection fails on current top-tier models.

The absence of visible flaws does not mean an image is real. It may mean the generator is good, the user selected the best output, or the image has been edited.

Use manual inspection for two things:

1. Confirm obvious AI errors when you see them.
2. Add context to other evidence.

Do not use it as your only test.

Method 5: Reverse image search

Reverse image search does not detect AI artifacts. It checks image history.

Use tools such as Google Images, TinEye, or similar services. Look for:

• A clear origin: stock library, photographer portfolio, or old news article.
• An AI origin: AI-art community, prompt gallery, or “made with Midjourney” page.
• Suspicious identity reuse: the same face appearing across unrelated accounts.
• Context mismatch: an image presented as current news but originally posted years ago or in another location.

Reverse image search is especially useful for detecting misrepresentation. An image can be real and still be used dishonestly.

It will not help much with a freshly generated image that has never been posted before.

Comparison: five image-checking methods

Method	Reliability	What it catches	What it misses	Effort / cost
C2PA Content Credentials	Highest, when present	Origin, edit history, AI involvement, signed provenance	Screenshots, re-encoded files, stripped metadata	Low; free browser tools
Invisible watermark, such as SynthID	High, when present	AI images from watermarking models	Non-watermarking models, open-source generators, degraded files	Low; free portal
ML classifier or API	Moderate; probabilistic	Statistical AI fingerprints on many images	New models, adversarial edits, false positives	Low to medium; free tools or paid API
Manual inspection	Low on top models	Obvious artifacts from weaker or non-curated outputs	High-quality generated images	Low; requires judgment
Reverse image search	Moderate; indirect	Image history, original source, reused images	Freshly generated images with no online history	Low; free

Methods 1 and 2 give strong evidence when they work, but often return nothing. Methods 3 through 5 usually provide some signal, but not certainty.

Recommended decision flow

Use this flow when reviewing an image:

1. Do you have the original file?
   
   If yes, check C2PA Content Credentials.

2. Is there a valid AI provenance manifest?
   
   Treat that as strong evidence of AI generation.

3. Is there a valid camera-origin manifest with no AI assertion?
   
   Treat that as strong evidence of a real captured photo, while still considering context.

4. No useful C2PA data?
   
   Scan for SynthID.

5. SynthID positive?
   
   Treat that as strong evidence of AI generation.

6. SynthID negative?
   
   Continue. A negative result does not rule out AI.

7. Run a classifier.
   
   Use high scores as supporting evidence, low scores as weak evidence, and middle scores as inconclusive.

8. Inspect visually.
   
   Clear anatomical or text errors strengthen the AI case. No errors do not prove authenticity.

9. Run reverse image search.
   
   Check origin, reuse, and context.

10. Report confidence, not certainty.

A good final statement looks like:

High confidence AI-generated: positive SynthID result and 94% classifier score.

Or:

Undetermined: no C2PA data, no watermark detected, classifier score inconclusive, and no reverse-search history.

Avoid unsupported binary claims such as:

This is definitely fake.

Conclusion

Checking whether an image is AI-generated is an evidence-gathering workflow.

Use this order:

1. C2PA Content Credentials
2. Invisible watermarks such as SynthID
3. ML classifiers or detection APIs
4. Manual visual inspection
5. Reverse image search

Key rules:

• Provenance and watermarks are strongest when present.
• Missing metadata does not prove anything.
• Classifier scores are probabilities, not verdicts.
• Manual inspection cannot reliably validate modern AI images.
• Reverse image search adds historical context.
• Always report confidence and say “undetermined” when evidence is weak or conflicting.

If you are a developer building this into a product, wire up a detection API and test it against real inputs before shipping. Download Apidog to design, debug, and test that integration in one workspace with saved requests and environments.