Detector24
Image Deepfake Detection
ImageAI Generation and Editing

Image Deepfake Detection

Detect face-swapped deepfakes in photos and selfie frames with Bynn's own detector, built for identity verification. Names the face-swapping method behind an attack.

Accuracy
99.8%
Avg. Speed
800ms
Per Request
$0.0060
API Name
bynn-deepfake-image

Bynn Image Deepfake Detection

The Bynn Image Deepfake Detection model identifies face swaps in images: a photo or selfie frame in which the face has been replaced by a face-swapping tool. Built by Bynn for identity verification, it returns a clear decision, a probability and the face-swapping method the content most resembles.

The Challenge

Deepfake technology has democratized face manipulation. What once required Hollywood-level resources now runs on consumer hardware. Free tools replace a face in a photo or a live camera feed in seconds, with lighting, expression and head movement carried over from the real person in front of the camera.

The consequences are severe. Criminals create fake IDs using face-swapped photos. Romance scammers build profile pictures that pass casual inspection. KYC verification systems face manipulated selfies designed to match stolen identity documents. Financial fraud, account takeovers and synthetic identity creation all leverage face manipulation technology.

Detection is an arms race. Yesterday's detection methods fail against today's tools. Platforms need detection that is built for the content they actually receive and refreshed as new tools appear.

Model Overview

The Bynn Deepfake Detection model is Bynn's own face-swap detector, built for identity verification: it is designed for the selfie frames and videos real verification sessions produce, and it is kept current as new face-swapping tools appear. It returns a probability, a clear decision and the face-swapping method the content most resembles.

Achieving 99.8% accuracy, with 99.99% of face-swap attacks detected at a false reject rate of 0.32% on held-out verification sessions, it provides robust protection against face-swap attacks on identity verification and authentication flows.

How It Works

  • Face analysis: the face in each frame is located and analyzed for the traces a face swap leaves behind
  • Decision: the analysis yields a fake probability and a clear real or fake decision for the image
  • Attribution: the response names the face-swapping method the content most resembles, for investigation and reporting

Request

Send one image with image_url or base64_image (JPEG, PNG or WebP, up to 20MB). Send the image as it was captured, without resizing or re-encoding it first. To analyze several frames of the same capture together, use Video Deepfake Detection with the recording.

Response Structure

The API returns a structured JSON response containing:

  • label: String, "fake" or "real", or "unverifiable" when no face could be analyzed
  • is_fake: Boolean, true when a face swap was detected; null when unverifiable
  • is_real: Boolean, the inverse of is_fake; null when unverifiable
  • fake_probability: Float (0.0 to 1.0), probability that the content is a face swap
  • confidence: Float (0.0 to 1.0), the model's confidence in the returned label
  • frames_total and frames_scored: Integer, always 1 for an image, and 1 or 0 depending on whether a face was analyzed
  • swapper: String, the face-swapping method the content most resembles, "real" for real content
  • frame_probabilities: Array with the image's fake probability, or null when no face was found

Example Response:

{
  "label": "fake",
  "is_fake": true,
  "is_real": false,
  "fake_probability": 0.998,
  "confidence": 0.998,
  "frames_total": 1,
  "frames_scored": 1,
  "swapper": "inswapper_128",
  "frame_probabilities": [0.998]
}
Code

Note: an "unverifiable" result means no face could be analyzed. Treat it as content to retry or review, not as evidence of a real person.

Performance Metrics

Metric Value
Detection Accuracy 99.8%
True Positive Rate (burst) 99.99%
True Positive Rate (single frame) 99.90%
False Reject Rate (FRR) 0.32%
AUC 0.999
Average Response Time 800ms
Max File Size 20MB
Supported Formats JPEG, PNG, WebP

Use Cases

  • KYC Verification: check the selfie frames of a verification session for a face swap before matching the face to the document
  • Authentication Security: prevent face-swap attacks on facial recognition authentication
  • Social Media and Dating Platforms: flag profile photos in which a real face was swapped
  • Financial Services: screen customer photos for face swaps before account approval

Known Limitations

  • Face swaps only: the model detects a real face that was replaced. Fully AI-generated faces are covered by AI-Generated Image Detection, and printed photos, masks and screen replays by Face Liveness Detection. Use them together for full coverage.
  • One face per frame: the most prominent face is analyzed. Crop first if a specific face in a group matters.
  • Image quality: very small, blurred or partially visible faces reduce reliability.
  • Generator evolution: new face-swapping tools appear constantly; the model is updated as they do, and detection effectiveness should be monitored.

Disclaimers

This model provides a probability and a decision, not definitive proof of manipulation.

  • Screening Tool: use it as part of a multi-layered verification strategy together with liveness, document checks and face matching, not as the sole decision factor
  • Human Review: route flagged high-stakes decisions to a reviewer
  • Not Legal Evidence: a probability is not a finding of fraud

API Reference

Version
2609
Sep 16, 2026
Avg. Processing
800ms
Per Request
$0.006
Required Plan
trial

Input Parameters

Live face-swap detection on a burst of selfie frames: detects real-time face swaps and names the swapper family they resemble

framesarray

The stills of one verification burst, 1 to 32 JPEG or PNG frames as URLs. Frames are scored individually and pooled; a frame without a face is reported and left out of the decision

Example:
["https://example.com/burst/frame1.jpg","https://example.com/burst/frame2.jpg"]
base64_framesarray

The same burst as base64-encoded frames (bare or data URI)

Example:
["/9j/4AAQSkZJRgABAQAA..."]
image_urlstring

A single frame, scored as a one-frame burst

Example:
https://example.com/selfie.jpg
video_urlstring

A video (MP4, MOV, AVI, WebM, MKV, up to 100MB): 32 evenly spaced frames per minute are cut from it and scored as one burst

Example:
https://example.com/selfie.mp4
base64_videostring

The same video, base64-encoded

Example:
AAAAIGZ0eXBpc29t...

Response Fields

Face-swap verdict for the burst with the per-frame evidence behind it

labelstring

"fake" or "real" at the calibrated burst threshold; "unverifiable" when no frame had a face

Example:
fake
is_fakeboolean

True if the burst is a face swap; null when unverifiable

Example:
true
is_realboolean

Inverse of is_fake; null when unverifiable

Example:
false
fake_probabilityfloat

Probability that the content is a face swap: the strongest evidence found, the pooled score or the highest frame; null when unverifiable

Example:
0.998
confidencefloat

Probability of the returned label: fake_probability for "fake", its complement for "real"

Example:
0.998
frames_totalinteger

Frames received

Example:
5
frames_scoredinteger

Frames in which a face was found and scored

Example:
5
fake_framesinteger

Frames whose face the model flagged as swapped

Example:
5
swapperstring

The swapper family the artefacts most resemble, "real" for real content; explanatory only

Example:
inswapper_128
frame_probabilitiesarray

The fake probability of each frame in order, null where no face was found

Example:
[ 0.998, 0.997, null ]

Complete Example

Request

{
  "model": "bynn-deepfake-image",
  "frames": [
    "https://example.com/burst/frame1.jpg",
    "https://example.com/burst/frame2.jpg",
    "https://example.com/burst/frame3.jpg"
  ]
}

Response

{
  "success": true,
  "data": {
    "label": "fake",
    "is_fake": true,
    "is_real": false,
    "fake_probability": 0.998,
    "confidence": 0.998,
    "frames_total": 3,
    "frames_scored": 2,
    "fake_frames": 2,
    "swapper": "inswapper_128",
    "frame_probabilities": [
      0.998,
      0.997,
      null
    ]
  }
}

Additional Information

Rate Limiting
If we throttle your request, you will receive a 429 HTTP error code along with an error message. You should then retry with an exponential back-off strategy, meaning that you should retry after 4 seconds, then 8 seconds, then 16 seconds, etc.
Supported Formats
jpeg, jpg, png, webp
Maximum File Size
20MB
Tags:deepfakemanipulationaiface-swap

Ready to get started?

Integrate Image Deepfake Detection into your application today with our easy-to-use API.