Safety & DetectionDeepfake Detection

Deepfake Detection

Analyze audio, images, and video for synthetic tampering. Submit media for detection and retrieve structured metrics and visualizations.

For a single-file request, you can also opt in to Resemble watermark detection and SynthID by setting detect_watermark: true. Watermark evidence is returned separately and never changes the deepfake verdict.

Choose an Integration

WorkflowUse it forInterface
Single detectionPersisted analysis of one audio, image, or video file, with synchronous waiting, polling, or a callback.Create Detection
Batch detectionPersisted analysis of up to 50 files in one request.Batch Detection
Streaming audioLive, audio-only analysis with per-window results while audio is still arriving. Streaming results are not persisted as Detect jobs.Streaming Audio Detection

Media can be referenced by a public HTTPS url or by a media_token issued from the Secure Upload API. Use a secure upload when you prefer not to host the source file publicly — the API reads it once via the signed token, which expires 1 hour after issuance.

Request Schema

1interface DetectionRequest {
2  url?: string;          // publicly accessible media URL
3  media_token?: string;  // token from POST /secure_uploads (mutually exclusive with url)
4  callback_url?: string;
5  visualize?: boolean;
6  frame_length?: number;
7  start_region?: number;
8  end_region?: number;
9  max_video_secs?: number;
10  modality?: "audio" | "video" | "all"; // video only
11  face_only?: boolean;   // visual video analysis only; default false
12  intelligence?: boolean;
13  detect_watermark?: boolean; // single-file audio/image/video only; default false
14  audio_source_tracing?: boolean;
15  use_reverse_search?: boolean; // image only
16  use_ood_detector?: boolean;
17  zero_retention_mode?: boolean;
18}

Face-only Video Analysis

Set face_only: true to focus visual video detection on faces by masking non-face regions before analysis. Face-only mode is effective only for video inputs that run visual analysis (modality: "all" or modality: "video"). Audio, image, and audio-only video requests are accepted, but their effective value is false.

Face-only mode does not disable audio analysis or select which video components run. Use modality for that. It also does not change billing or the structure of detection verdicts and reports. Detection responses expose the effective setting in face_only for auditing.

Optional Watermark Analysis

Set detect_watermark: true on a single audio, image, or video detection to run the same decode detectors as the standalone Watermark API:

  • Audio checks Resemble Perth v1, Resemble Perth v2, and SynthID.
  • Image and video check the Resemble image/video watermark detector and SynthID.

The option defaults to false. When omitted or false, no Watermark job is created, no extra charge is added, and the watermark response field is omitted. When enabled, the existing Watermark detection charge is added to the request; SynthID does not add a separate charge.

Watermark analysis uses the standalone source limits: 25 MB for audio and image, and 100 MB for video. It is not supported for batch or zip submissions.

Response Shapes

1interface DetectIntelligenceResult {
2  uuid: string;
3  status: "processing" | "completed" | "failed";
4  error_message: string | null;
5  description: string | IntelligenceDetails | null;
6  created_at: string;
7  detect_uuid: string;
8}
9
10interface DetectWatermarkResult {
11  status: "pending" | "processing" | "completed" | "failed";
12  metrics?: object;       // Resemble detector metrics plus optional synthid boolean
13  error_message?: string; // present only when the watermark analysis failed
14}
15
16interface BaseDetectionResult {
17  success: true;
18  item: {
19    uuid: string;
20    created_at: string;
21    updated_at: string;
22    duration: string;
23    media_type: string;
24    status: string; // "processing" | "completed" | "failed"
25    face_only: boolean; // effective value for this detection
26    url?: string;
27    audio_url?: string; // alias of url
28    filename?: string;
29    zero_retention_mode: boolean;
30    file_deleted_at: string | null;
31    visualize?: boolean;
32    audio_source_tracing_enabled?: boolean;
33    use_ood_detector?: boolean;
34    extra_params?: object;
35    error_message?: string;
36    // GET /detect/{uuid}?experts=true returns an array; other responses use one result.
37    intelligence?: DetectIntelligenceResult | DetectIntelligenceResult[] | null;
38    // Present only when detect_watermark=true was requested.
39    watermark?: DetectWatermarkResult;
40    audio_source_tracing?: {
41      label: string;
42      error_message: string | null;
43    } | null;
44  };
45}
46
47interface AudioDetectionResult extends BaseDetectionResult {
48  item: BaseDetectionResult["item"] & {
49    metrics: {
50      label: string;
51      score: string[];
52      consistency: string;
53      aggregated_score: string;
54      image?: string;
55    };
56  };
57}
58
59interface ImageDetectionResult extends BaseDetectionResult {
60  item: BaseDetectionResult["item"] & {
61    image_metrics: {
62      type: string;
63      label: string;
64      image: string;
65      score: number;
66      children: any[];
67      ifl?: {
68        score: number;
69        heatmap: string;  // URL to heatmap visualization
70      };
71      reverse_image_search_sources?: Array<{ // present when use_reverse_search is enabled
72        url: string;
73        title: string;
74        reason: string;
75        verdict: string;  // e.g. "known_fake"
76        similarity: number;
77      }>;
78    };
79  };
80}
81
82interface VideoDetectionResult extends BaseDetectionResult {
83  item: BaseDetectionResult["item"] & {
84    metrics: AudioDetectionResult["item"]["metrics"];
85    video_metrics: {
86      label: string;
87      score: number;
88      certainty: number;
89      treeview?: string;
90      children: Array<{
91        type: string;
92        conclusion: string;
93        score: number;
94        certainty: number;
95        "certainty (%)": string;
96        children: Array<{
97          type: string;
98          conclusion: string;
99          score: number;
100          certainty: number;
101          "certainty (%)": string;
102          timestamp: number;
103          children: Array<{
104            type: string;
105            conclusion: string;
106            score: number;
107            certainty: number;
108            "certainty (%)": string;
109          }>;
110        }>;
111      }>;
112    };
113  };
114}

For an otherwise successful Detect with watermark analysis, item.status remains processing until the nested Watermark job is terminal. A core detection failure still reports failed. A failed Watermark job is reported in item.watermark without failing an otherwise successful deepfake detection. Intelligence remains independently asynchronous unless its own wait behavior is requested.

FieldTypeDescription
pipelinestring | nullDeprecated field that may appear on older image/video detects returned by the API. Ignored for new detections.

Use the endpoints below to submit jobs and retrieve detection results for each modality.