AI Deepfake & Image Detector API - Detect AI-Generated Images

Instantly analyze any image to determine if it was created by an AI generator like DALL-E, Midjourney, or Stable Diffusion. This API combines 12 independent detection signals -- including EXIF analysis, AI dimension matching, C2PA metadata verification, statistical pixel analysis, and software fingerprinting -- to produce a confidence score and identify the likely generator.

Perfect for content moderation pipelines, journalism verification workflows, social media platforms, and any application where distinguishing real photos from AI-generated images matters.

Key Features

• 12 Detection Signals analyzed in parallel for comprehensive coverage
• Generator Identification -- identifies DALL-E, Midjourney, Stable Diffusion, ComfyUI, Leonardo.ai, NovelAI, Adobe Firefly, and more
• Confidence Scoring -- 0 to 1 score with clear isLikelyAI boolean (threshold: 0.45)
• C2PA / Content Credentials detection for authenticated media verification
• Stable Diffusion parameter extraction -- detects Steps:, Sampler:, CFG scale: metadata
• ComfyUI workflow detection -- identifies embedded workflow JSON
• EXIF & XMP deep parsing -- lightweight binary parser, no heavy dependencies
• Real camera validation -- recognizes 18 major camera/phone manufacturers
• Statistical pixel analysis -- color uniformity, variance consistency, sharpness profiling
• Base64 & URL input -- send images as URLs or inline base64 data
• Sub-second response -- typical analysis completes in under 200ms
• 20MB max file size with streaming download and size enforcement

How It Works

flowchart LR
    A["Image Input<br/>(URL or Base64)"] --> B["Download &<br/>Validate"]
    B --> C{"12 Parallel<br/>Signal Analyzers"}
    C --> D["EXIF Missing"]
    C --> E["Real Camera"]
    C --> F["AI Software<br/>Metadata"]
    C --> G["SD Generation<br/>Params"]
    C --> H["C2PA Metadata"]
    C --> I["AI Dimensions"]
    C --> J["No GPS"]
    C --> K["Color<br/>Distribution"]
    C --> L["Variance<br/>Consistency"]
    C --> M["Sharpness<br/>Pattern"]
    C --> N["PNG No Alpha"]
    C --> O["Default Density"]
    D & E & F & G & H & I & J & K & L & M & N & O --> P["Confidence<br/>Scoring Engine"]
    P --> Q["JSON Result<br/>isLikelyAI + score<br/>+ generator guess"]

Detection Signals

#	Signal	Description	Weight
1	exif_missing	No meaningful EXIF or camera metadata found	+0.20
2	real_camera	Known camera manufacturer detected (Canon, Nikon, Apple, etc.)	-0.30
3	ai_software_metadata	AI generator software signature found in metadata	+0.45
4	sd_generation_params	Stable Diffusion parameters (Steps, Sampler, CFG scale) or ComfyUI workflow detected	+0.50
5	c2pa_metadata	C2PA / Content Credentials manifest found	+0.15
6	ai_dimensions	Image dimensions match known AI generator outputs (e.g., 1024x1024, 1024x1792)	+0.20
7	no_gps	No GPS data and no real camera detected	+0.05
8	color_distribution	Unusual color uniformity coefficient (too low or too high)	+0.08
9	variance_consistency	Corner-to-center variance ratio suspiciously close to 1.0	+0.07
10	sharpness_pattern	Unnaturally low or consistent Laplacian sharpness score	+0.06
11	png_no_alpha	Large PNG without alpha channel (common AI output pattern)	+0.05
12	default_density	Default or missing DPI (72 or none) with no real camera	+0.03

Scoring logic: With strong metadata evidence (signals 3 or 4), confidence can reach up to 0.98. With only statistical/heuristic evidence, confidence is capped at 0.65. A negative weight (signal 2) actively reduces the score when a real camera is identified.

API Endpoints

Method	Endpoint	Description
GET	/detect?url=IMAGE_URL	Analyze an image by URL
POST	/detect	Analyze an image by URL or base64 (JSON body)
GET	/health	Health check and service info
GET	/	Same as /health

How to Use

Analyze by URL (GET)

$curl "https://YOUR_STANDBY_URL/detect?url=https://example.com/photo.jpg"

Analyze by URL (POST)

curl -X POST "https://YOUR_STANDBY_URL/detect" \
  -H "Content-Type: application/json" \
  -d '{"url": "https://example.com/photo.jpg"}'

Analyze by Base64 (POST)

curl -X POST "https://YOUR_STANDBY_URL/detect" \
  -H "Content-Type: application/json" \
  -d '{"base64": "data:image/png;base64,iVBORw0KGgo..."}'

Health Check

$curl "https://YOUR_STANDBY_URL/health"

Output Example

{
  "isLikelyAI": true,
  "confidence": 0.82,
  "signals": [
    {
      "name": "exif_missing",
      "detected": true,
      "weight": 0.2,
      "detail": "No meaningful EXIF/camera metadata found"
    },
    {
      "name": "ai_software_metadata",
      "detected": true,
      "weight": 0.45,
      "detail": "AI software detected: stable diffusion"
    },
    {
      "name": "sd_generation_params",
      "detected": true,
      "weight": 0.5,
      "detail": "Stable Diffusion generation parameters found in metadata"
    },
    {
      "name": "ai_dimensions",
      "detected": true,
      "weight": 0.2,
      "detail": "Dimensions 1024x1024 match known AI generator output"
    },
    {
      "name": "color_distribution",
      "detected": true,
      "weight": 0.08,
      "detail": "Color uniformity coefficient: 0.1234"
    },
    {
      "name": "variance_consistency",
      "detected": true,
      "weight": 0.07,
      "detail": "Corner/center variance ratio: 1.0312 (AI-like if ~1.0)"
    }
  ],
  "metadata": {
    "hasStableDiffusionParams": true,
    "aiSoftwareMatch": "stable diffusion",
    "format": "png",
    "width": 1024,
    "height": 1024
  },
  "generatorGuess": "likely_stable_diffusion",
  "analysisTime": 147
}

Supported Generators

The API can identify images from these AI generators via metadata fingerprinting:

Generator	Detection Method
Stable Diffusion (Automatic1111, ComfyUI, InvokeAI)	Software field, SD parameters (Steps:, Sampler:, CFG scale:), ComfyUI workflow JSON
DALL-E (OpenAI)	Software/creator field matching dall-e or openai
Midjourney	Software/creator field matching midjourney or niji
NovelAI	Software field matching novelai
Leonardo.ai	Software field matching leonardo.ai
DreamStudio	Software field matching dreamstudio
Playground AI	Software field matching playground ai
Adobe Firefly	Software field matching firefly or adobe firefly
Google Imagen	Software field matching imagen

When no metadata fingerprint is found, the API still analyzes dimensions, pixel statistics, and format patterns to estimate AI likelihood.

Use Cases

• Content Moderation -- Automatically flag AI-generated images uploaded to your platform before they reach users
• Journalism & Fact-Checking -- Verify whether news images are authentic photographs or AI-generated fakes
• Social Media Platforms -- Label or filter AI-generated profile pictures, posts, and ads at scale
• Legal & Forensics -- Screen evidence images for AI manipulation indicators in investigations
• Academic Integrity -- Detect AI-generated images in research papers and student submissions
• Dating & Identity Verification -- Flag synthetic profile photos on dating apps and identity platforms
• Insurance Claims -- Screen submitted damage photos for AI generation or manipulation signals
• Art & NFT Marketplaces -- Verify authenticity claims by detecting AI generation signatures

Pricing

$0.005 per image analyzed (Pay-Per-Event)

Each call to /detect that successfully returns a result charges one image-analyzed event. Health check calls are free.

Volume	Cost
100 images	$0.50
1,000 images	$5.00
10,000 images	$50.00
100,000 images	$500.00

Input Specification

Parameter	Type	Required	Description
url	string	Yes*	Direct URL to a publicly accessible image
base64	string	Yes*	Base64-encoded image data (with or without data:image/...;base64, prefix)

*One of url or base64 is required.

Supported formats: JPEG, PNG, WebP

Size limit: 20MB maximum (enforced during download and after base64 decoding)

Timeout: 30-second limit for fetching remote images

Limitations

• Heuristic-based detection -- This API uses metadata analysis, dimension matching, and statistical pixel analysis. It does not use a neural network classifier. Results are probabilistic, not definitive.
• Not 100% accurate -- Images that have been re-saved, compressed, cropped, screenshotted, or stripped of metadata will lose many detection signals. Statistical-only detection is capped at 0.65 confidence.
• 20MB file size limit -- Images larger than 20MB are rejected to maintain fast response times.
• Metadata dependency -- The strongest signals (AI software, SD parameters, C2PA) rely on metadata that can be stripped. When metadata is absent, only weaker statistical signals remain.
• Photo editing software -- Images processed in Photoshop, Lightroom, GIMP, or Capture One are automatically capped at 0.35 confidence even if other signals fire, to reduce false positives.
• New generators -- Newly released AI generators may not be in the fingerprint database until the pattern list is updated.
• Screenshots and re-uploads -- Taking a screenshot of an AI image removes all metadata, making detection significantly harder.

FAQ

How accurate is this API?

When AI generation metadata is present (Stable Diffusion parameters, AI software signatures), confidence scores reach 0.82--0.98 and accuracy is very high. When metadata has been stripped, the API falls back to statistical analysis with confidence capped at 0.65. Think of it as a strong first-pass filter, not a forensic certainty tool.

Does it use AI/ML models for detection?

No. This API uses deterministic signal analysis -- binary metadata parsing, dimension matching, statistical pixel analysis, and pattern matching. This makes it fast (sub-200ms), predictable, and cheap to run without GPU requirements.

Can it detect images from ChatGPT or Grok?

If the image retains its original metadata (e.g., DALL-E software signature from ChatGPT, or xAI signatures from Grok), yes. If the platform strips metadata before serving the image, detection relies on statistical signals only.

What happens if I send a real photo?

Real photos from cameras typically trigger the real_camera signal (weight -0.30), which actively pushes the confidence score down. A photo with full EXIF, GPS, and a recognized camera maker will typically score below 0.10.

Can it detect deepfake videos?

No. This API analyzes still images only. For video deepfake detection, you would need to extract individual frames and analyze them separately.

What is C2PA?

C2PA (Coalition for Content Provenance and Authenticity) is an open standard for content credentials. Some AI generators and cameras embed C2PA manifests to declare how content was created. This API detects the presence of C2PA metadata as one of its 12 signals.

Is the API CORS-enabled?

Yes. The API returns Access-Control-Allow-Origin: * headers, so it can be called directly from browser-based applications.

What if the image URL requires authentication?

The API fetches images with a generic User-Agent header and follows redirects. If your image URL requires cookies, authentication headers, or is behind a login wall, use the base64 input method instead -- download the image yourself and send it as base64.

---

Keywords: ai image detector, deepfake detector api, detect ai generated images, ai content detection, fake image detector, midjourney detector, dall-e detector, c2pa verification, stable diffusion detector, ai photo checker, content authenticity, image forensics api