Deepfake Detection API

api logo{{el | capitalize:true}}
Start free trial   Subscribe  

Combat Identity Frauds with Advanced Deepfake Detection

The Deepfake Detection API employs advanced algorithms and deep learning techniques to distinguish genuine content from manipulated digital media. This ensures the credibility of visual content like images and videos in various applications like Identity verification, and more. Thus safeguarding against the rising threat of deepfake creations and identity fraud. Integrate this API seamlessly for enhanced security while seamlessly detecting potential fraud in your digital environment.

Try it out  
    Cutting-Edge Features    

Why Arya Deepfake Detection?

High Accuracy Synthetic Content Detection

Identifies deepfake media, spanning videos, images, and audio, that can often elude human detection

Scalable Media Processing

Scale efficiently with easy integration to process large volumes of media content across various platforms and systems

Real-Time Deepfake Detection

Can detect deepfakes in real-time, allowing for a swift response to counter disinformation and fake news

92% Accuracy in Deepfake Detection

Achieve near-perfect results with our tool, accurately identifying deepfakes with precision

An AI Platform that you've
always wanted
With more than 80+ APIs, we stand out as the go-to-platform for developers, consistently delivering unparalleled success rates in driving critical decisions.
Get Started
200 M+

Annual API Volume

95 %+

Accuracy Rate

720 K

Daily API Volume

< 5 Mins

Time to launch

    Effortless AI For Everyone    

More Reasons To Love Arya AI

Hassle-Free,

No Code Platform

Easy to adopt

& integrate

99.99%

API Success Rate

Reliable &

Secure

    Helpful Resources    

Learn More From Our Resources

Blog
Card image cap

9 May 2024

Top deepfake detection tools to know in 2024 [Complete Guide]

Deepfake is an astonishing technology that has been blurring the lines between...

Read More
Blog
Card image cap

15 May 2024

Addressing the Implications of Deepfakes in Election Seasons

As 2024 matures, we all witness an astonishing year for democracy and technology...

Read More
Blog
Card image cap

28 May 2024

Introducing Deepfake Audio Detection [Product Update]

In an age where technology continuously blurs the lines between reality and fabrication...

Read More

Please wait...

Samples to try

Check out the API results using samples provided below.

Drag and drop files
or Click to browse file

Supports: JPG, PNG, etc

Supports: WAV, FLAC, etc

Supports: MP4,AVI etc

Drag and drop files
or Click to browse file

Supports: JPG, PNG, etc

Supports: WAV, FLAC, etc

Supports: MP4,AVI etc

{{upload_type != 'audio' ? 'Your document is processed successfully.' : 'Your Audio is processed successfully.'}}

JSON

{{output.body.result |capitalize }}

Real Audio Confidence: {{output.body.confidence.real*100}}% (This part is likely real) of duration {{output.body.real_duration}}

Fake Audio Confidence: {{output.body.confidence.fake*100}}% (This part is likely fake) of duration {{output.body.fake_duration}}

Silence Intervals

 
Copied

Documentation

HTTP Method: Post
Endpoint
{{url}}/api/v1/deepfake-detection/{{upload_type}}
Copied
API Token
Regenerate
{{tokenDisplay}}
Copied
API Token UAT
postman wrapper button
{{tokenUDisplay}}
Copied

Usage and Code Samples

curl --location --request POST '{{url}}/api/v1/deepfake-detection/{{upload_type}}' \
--header 'token: < your private token >' \
--header 'content-type: application/json' \
--data-raw '{
    "doc_base64": '< base64 string of image / video>',
    "req_id": '< req id string>'
    "isIOS": '< boolean>',
    "doc_type": '< string (video/image)>',
    "orientation": '< int>'
	}'
curl --location --request POST '{{url}}/api/v1/deepfake-detection/{{upload_type}}' \
			--header 'token: < your private token >' \
			--header 'content-type: application/json' \
			--data-raw '{
				"doc_base64": '< base64 string of audio>',
				"req_id": '< req id string>'
				}'
OkHttpClient client = new OkHttpClient().newBuilder().build();
MediaType mediaType = MediaType.parse("application/javascript");
RequestBody body = RequestBody.create(mediaType, "{ "doc_base64": '< base64 string of image / video >',"req_id": '< req id string >', "isIOS": '< boolean >', "doc_type": '< string (video/image) >', "orientation":  '< int >'  }");
Request request = new Request.Builder()
	.url("{{url}}/api/v1/deepfake-detection/{{upload_type}}")
	.method("POST", body)
	.addHeader("token", "< your private token >")
	.addHeader("content-type", "application/json")
	.build();
Response response = client.newCall(request).execute();
OkHttpClient client = new OkHttpClient().newBuilder().build();
	MediaType mediaType = MediaType.parse("application/javascript");
	RequestBody body = RequestBody.create(mediaType, "{ "doc_base64": '< base64 string of audio >',"req_id": '< req id string >'  }");
	Request request = new Request.Builder()
		.url("{{url}}/api/v1/deepfake-detection/{{upload_type}}")
		.method("POST", body)
		.addHeader("token", "< your private token >")
		.addHeader("content-type", "application/json")
		.build();
	Response response = client.newCall(request).execute();
require "uri"
require "net/http"
url = URI("{{url}}/api/v1/deepfake-detection/{{upload_type}}")
https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true
request = Net::HTTP::Post.new(url)
request["token"] = "< your private token >"
request["content-type"] = "application/json"
request.body = "{"doc_base64": '< base64 string of image / video >',"req_id": < req id string >, "isIOS": '< boolean >', "doc_type": '< string (video/image) >', "orientation":  '< int >',  }"
response = https.request(request)
puts response.read_body
require "uri"
	require "net/http"
	url = URI("{{url}}/api/v1/deepfake-detection/{{upload_type}}")
	https = Net::HTTP.new(url.host, url.port)
	https.use_ssl = true
	request = Net::HTTP::Post.new(url)
	request["token"] = "< your private token >"
	request["content-type"] = "application/json"
	request.body = "{"doc_base64": "< base64 string of audio >","req_id": < req id string >  }"
	response = https.request(request)
	puts response.read_body
CURL *curl;
CURLcode res;
curl = curl_easy_init();
if(curl) {
  curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "POST");
  curl_easy_setopt(curl, CURLOPT_URL, "{{url}}/api/v1/deepfake-detection/{{upload_type}}");
  curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1L);
  curl_easy_setopt(curl, CURLOPT_DEFAULT_PROTOCOL, "https");
  struct curl_slist *headers = NULL;
  headers = curl_slist_append(headers, "token: < your private token >");
  headers = curl_slist_append(headers, "content-type: application/json");
  curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
  const char *data =  "{"doc_base64": '< base64 string of image / video >',"req_id": < req id string >, "isIOS": '< boolean >', "doc_type": '< string (video/image) >', "orientation":  '< int >',  }";
  curl_easy_setopt(curl, CURLOPT_POSTFIELDS, data);
  res = curl_easy_perform(curl);
}
curl_easy_cleanup(curl);
CURL *curl;
	CURLcode res;
	curl = curl_easy_init();
	if(curl) {
	  curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "POST");
	  curl_easy_setopt(curl, CURLOPT_URL, "{{url}}/api/v1/deepfake-detection/{{upload_type}}");
	  curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1L);
	  curl_easy_setopt(curl, CURLOPT_DEFAULT_PROTOCOL, "https");
	  struct curl_slist *headers = NULL;
	  headers = curl_slist_append(headers, "token: < your private token >");
	  headers = curl_slist_append(headers, "content-type: application/json");
	  curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
	  const char *data =  "{"doc_base64": "< base64 string of audio >","req_id": < req id string > }";
	  curl_easy_setopt(curl, CURLOPT_POSTFIELDS, data);
	  res = curl_easy_perform(curl);
	}
	curl_easy_cleanup(curl);
var request = require('request');
var options = {
  'method': 'POST',
  'url': '{{url}}/api/v1/deepfake-detection/{{upload_type}}',
  'headers': {
  'token': '< your private token >',
  'content-type':'application/json'
},
body: '{"doc_base64": "< base64 string of image / video >","req_id": < req id string >, "isIOS": '< boolean >', "doc_type": '< string (video/image) >', "orientation":  '< int >' }'
};
request(options, function (error, response) {
if (error) throw new Error(error);
  console.log(response.body);
});
var request = require('request');
	var options = {
	  'method': 'POST',
	  'url': '{{url}}/api/v1/deepfake-detection/{{upload_type}}',
	  'headers': {
	  'token': '< your private token >',
	  'content-type':'application/json'
	},
	body: '{"doc_base64": "< base64 string of audio >","req_id": < req id string > }'
	};
	request(options, function (error, response) {
	if (error) throw new Error(error);
	  console.log(response.body);
	});
var client = new RestClient("{{url}}/api/v1/deepfake-detection/{{upload_type}}");
ṣclient.Timeout = -1;
var request = new RestRequest(Method.POST);
request.AddHeader("token", "< your private token >");
request.AddHeader("content-type", "application/json");
var body = @"{" + "" +
@"    "doc_base64": '< base64 string of image / video >'," + "" +
@"    "req_id": < req id string >" + "" +
@"    "isIOS": < boolean >" + "" +
@"    "orientation": < int >" + "" +
@"    "doc_type": < string (video/image)  >" + "" +
@"  }";
request.AddParameter("application/json", body,  ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
Console.WriteLine(response.Content);
var client = new RestClient("{{url}}/api/v1/deepfake-detection/{{upload_type}}");
	ṣclient.Timeout = -1;
	var request = new RestRequest(Method.POST);
	request.AddHeader("token", "< your private token >");
	request.AddHeader("content-type", "application/json");
	var body = @"{" + "" +
    @"    "doc_base64": '< base64 string of audio >'," + "" +
    @"    "req_id": < req id string >" + "" +
	@"  }";
	request.AddParameter("application/json", body,  ParameterType.RequestBody);
	IRestResponse response = client.Execute(request);
	Console.WriteLine(response.Content);
php
require_once 'HTTP/Request2.php';
$request = new HTTP_Request2();
$request->setUrl('{{url}}/api/v1/deepfake-detection/{{upload_type}}');
$request->setMethod(HTTP_Request2::METHOD_POST);
$request->setConfig(array(
'follow_redirects' => TRUE
));
$request->setHeader(array(
  'token' => '< your private token >',
  'content-type' => 'application/json'
));
$request->setBody('{"doc_base64": "< base64 string of image / video >","req_id": < req id string >,  "isIOS": '< boolean >', "doc_type": '< string (video/image) >', "orientation":  '< int >'  }');
try {
  $response = $request->send();
  if ($response->getStatus() == 200) {
  echo $response->getBody();
  }
  else {
  echo 'Unexpected HTTP status: ' . $response->getStatus() . ' ' .
  $response->getReasonPhrase();
  }
}
catch(HTTP_Request2_Exception $e) {
  echo 'Error: ' . $e->getMessage();
}
?>
php
	require_once 'HTTP/Request2.php';
	$request = new HTTP_Request2();
	$request->setUrl('{{url}}/api/v1/deepfake-detection/{{upload_type}}');
	$request->setMethod(HTTP_Request2::METHOD_POST);
	$request->setConfig(array(
	'follow_redirects' => TRUE
	));
	$request->setHeader(array(
	  'token' => '< your private token >',
	  'content-type' => 'application/json'
	));
	$request->setBody('{"doc_base64": '< base64 string of audio >',"req_id": '< req id string >'  }');
	try {
	  $response = $request->send();
	  if ($response->getStatus() == 200) {
	  echo $response->getBody();
	  }
	  else {
	  echo 'Unexpected HTTP status: ' . $response->getStatus() . ' ' .
	  $response->getReasonPhrase();
	  }
	}
	catch(HTTP_Request2_Exception $e) {
	  echo 'Error: ' . $e->getMessage();
	}
	?>
import requests
url = "{{url}}/api/v1/deepfake-detection/{{upload_type}}"
payload = {"doc_base64": "< base64 string of image / video >", "req_id": < req id string >, "isIOS": '< boolean >', "doc_type": '< string (video/image) >', "orientation":  '< int >',  }
headers = {
  'token': '< your private token >',
  'content-type':'application/json'
}
response = requests.request("POST", url, json=payload, headers=headers)
print(response.text)
import requests
	url = "{{url}}/api/v1/deepfake-detection/{{upload_type}}"
	payload = {"doc_base64": '< base64 string of audio >',"req_id": '< req id string >'  }
	headers = {
	  'token': '< your private token >',
	  'content-type':'application/json'
	}
	response = requests.request("POST", url, json=payload, headers=headers)
	print(response.text)

Request Parameters

Header parameters
Name Description
token String
Body parameters
Name Description
body {
  "req_id" : < string>,
  "doc_base64": < base64 encoded string>
  "doc_type": < string>
  "isIOS": < boolean >
  "orientation": < int >
} 		{
  "req_id" : < string>,
  "doc_base64": < base64 encoded string>
}

Response Parameters

Status: 200 - API Request Successful
Body parameters
Name Description
body {
  "req_id" : < string>,
  "success" : < boolean>,
  "error_message" : < string> ,
  "doc_type" : < string> ,
  "result" : < string > ,
} 		{
  "success" : < boolean>,
  "confidence" : < dict>,
  "error_message" : < string>,
  "details" : < dict>,
  "total_duration" : < string>,
  "real_duration" : < string>,
  "fake_duration" : < string>,
  "silence_intervals" : < array>,
  "non_silence_intervals" : < array>
}

Field Details

Request Field Details
Fields Values/Description
req_id Unique request ID used for processing requests
doc_base64 Base64 encoded string of the document
doc_type Type of document uploaded (image or video)
isIOS boolean value if iOS
orientation integer
Response Field Details
Fields Values/Description
req_id Corresponding request id
success Flag if the request is processed successfully
doc_type Type of document uploaded
confidence Dictionary which give info of amount of real and fake part in audio
details Provides detailed audio analysis for specific part of audio data
error_message If success is False then: Error message
total_duration The total time duration of the analyzed content.
real_duration The duration of content identified as real.
fake_duration The duration of content identified as fake.
silence_intervals Time intervals where silence was detected.
non_silence_intervals Time intervals where non-silent (active) content was detected
result Result String