- Cloudmersive Documentation

Node.JS Python C# Java PHP Objective-C Ruby Apex C/C++ cURL Swift JavaScript Go

Power Automate

Run this command to install the SDK:

npm install cloudmersive-video-api-client --save

Or add this snippet to your package.json:

  "dependencies": {
    "cloudmersive-video-api-client": "^2.0.5"
  }

var CloudmersiveVideoApiClient = require('cloudmersive-video-api-client');
var defaultClient = CloudmersiveVideoApiClient.ApiClient.instance;

// Configure API key authorization: Apikey
var Apikey = defaultClient.authentications['Apikey'];
Apikey.apiKey = 'YOUR API KEY';



var apiInstance = new CloudmersiveVideoApiClient.VideoApi();

var opts = { 
  'inputFile': Buffer.from(fs.readFileSync("C:\\temp\\inputfile").buffer), // File | Input file to perform the operation on.
  'fileUrl': "fileUrl_example", // String | Optional; URL of a video file being scanned. Use this option for files larger than 2GB.
  'framesPerSecond': 8.14 // Number | Optional; How many video frames per second to be scanned. Minimum value is 0.05 (1 frame per 20 seconds), maximum is 1. Default is 0.33 frame per second (1 frame scanned every 3 seconds). Maximum of 1000 total frames can be scanned, potentially adjusting the framerate for longer videos.
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
apiInstance.videoScanForNsfw(opts, callback);

Run this command to install the SDK:

pip install cloudmersive-video-api-client

from __future__ import print_function
import time
import cloudmersive_dataintegration_api_client
from cloudmersive_dataintegration_api_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: Apikey
configuration = cloudmersive_dataintegration_api_client.Configuration()
configuration.api_key['Apikey'] = 'YOUR_API_KEY'



# create an instance of the API class
api_instance = cloudmersive_dataintegration_api_client.VideoApi(cloudmersive_dataintegration_api_client.ApiClient(configuration))
input_file = '/path/to/file' # file | Input file to perform the operation on. (optional)
file_url = 'file_url_example' # str | Optional; URL of a video file being scanned. Use this option for files larger than 2GB. (optional)
frames_per_second = NULL # object | Optional; How many video frames per second to be scanned. Minimum value is 0.05 (1 frame per 20 seconds), maximum is 1. Default is 0.33 frame per second (1 frame scanned every 3 seconds). Maximum of 1000 total frames can be scanned, potentially adjusting the framerate for longer videos. (optional)

try:
    # Scan a Video for NSFW content.
    api_response = api_instance.video_scan_for_nsfw(input_file=input_file, file_url=file_url, frames_per_second=frames_per_second)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling VideoApi->video_scan_for_nsfw: %s\n" % e)

.NET Framework | .NET Core

Run this command to install the SDK:

Install-Package Cloudmersive.APIClient.NET.VideoAndMediaServices -Version 3.0.5

using System;
using System.Diagnostics;
using Cloudmersive.APIClient.NET.VideoAndMediaServices.Api;
using Cloudmersive.APIClient.NET.VideoAndMediaServices.Client;
using Cloudmersive.APIClient.NET.VideoAndMediaServices.Model;

namespace Example
{
    public class VideoScanForNsfwExample
    {
        public void main()
        {
            // Configure API key authorization: Apikey
            Configuration.Default.AddApiKey("Apikey", "YOUR_API_KEY");
            
            

            var apiInstance = new VideoApi();
            var inputFile = new System.IO.FileStream("C:\\temp\\inputfile", System.IO.FileMode.Open); // System.IO.Stream | Input file to perform the operation on. (optional) 
            var fileUrl = fileUrl_example;  // string | Optional; URL of a video file being scanned. Use this option for files larger than 2GB. (optional) 
            var framesPerSecond = 8.14;  // decimal? | Optional; How many video frames per second to be scanned. Minimum value is 0.05 (1 frame per 20 seconds), maximum is 1. Default is 0.33 frame per second (1 frame scanned every 3 seconds). Maximum of 1000 total frames can be scanned, potentially adjusting the framerate for longer videos. (optional) 

            try
            {
                // Scan a Video for NSFW content.
                NsfwResult result = apiInstance.VideoScanForNsfw(inputFile, fileUrl, framesPerSecond);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling VideoApi.VideoScanForNsfw: " + e.Message );
            }
        }
    }
}

using System;
using System.Diagnostics;
using Cloudmersive.APIClient.NETCore.VideoAndMediaServices.Api;
using Cloudmersive.APIClient.NETCore.VideoAndMediaServices.Client;
using Cloudmersive.APIClient.NETCore.VideoAndMediaServices.Model;

namespace Example
{
    public class VideoScanForNsfwExample
    {
        public void main()
        {
            // Configure API key authorization: Apikey
            Configuration.Default.AddApiKey("Apikey", "YOUR_API_KEY");
            
            

            var apiInstance = new VideoApi();
            var inputFile = new System.IO.FileStream("C:\\temp\\inputfile", System.IO.FileMode.Open); // System.IO.Stream | Input file to perform the operation on. (optional) 
            var fileUrl = fileUrl_example;  // string | Optional; URL of a video file being scanned. Use this option for files larger than 2GB. (optional) 
            var framesPerSecond = 8.14;  // decimal? | Optional; How many video frames per second to be scanned. Minimum value is 0.05 (1 frame per 20 seconds), maximum is 1. Default is 0.33 frame per second (1 frame scanned every 3 seconds). Maximum of 1000 total frames can be scanned, potentially adjusting the framerate for longer videos. (optional) 

            try
            {
                // Scan a Video for NSFW content.
                NsfwResult result = apiInstance.VideoScanForNsfw(inputFile, fileUrl, framesPerSecond);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling VideoApi.VideoScanForNsfw: " + e.Message );
            }
        }
    }
}

To install with Maven, add a reference to the repository in pom.xml:

<repositories>
    <repository>
        <id>jitpack.io</id>
        <url>https://jitpack.io</url>
    </repository>
</repositories>

And add a reference to the dependency in pom.xml:

<dependencies>
<dependency>
    <groupId>com.github.Cloudmersive</groupId>
    <artifactId>Cloudmersive.APIClient.Java</artifactId>
    <version>v4.25</version>
</dependency>
</dependencies>

To install with Gradle, add it in your root build.gradle at the end of repositories:

allprojects {
	repositories {
		...
		maven { url 'https://jitpack.io' }
	}
}

And add the dependency in build.gradle:

dependencies {
        implementation 'com.github.Cloudmersive:Cloudmersive.APIClient.Java:v4.25'
}

// Import classes:
//import com.cloudmersive.client.invoker.ApiClient;
//import com.cloudmersive.client.invoker.ApiException;
//import com.cloudmersive.client.invoker.Configuration;
//import com.cloudmersive.client.invoker.auth.*;
//import com.cloudmersive.client.VideoApi;

ApiClient defaultClient = Configuration.getDefaultApiClient();

// Configure API key authorization: Apikey
ApiKeyAuth Apikey = (ApiKeyAuth) defaultClient.getAuthentication("Apikey");
Apikey.setApiKey("YOUR API KEY");
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//Apikey.setApiKeyPrefix("Token");

VideoApi apiInstance = new VideoApi();
File inputFile = new File("/path/to/file"); // File | Input file to perform the operation on.
String fileUrl = "fileUrl_example"; // String | Optional; URL of a video file being scanned. Use this option for files larger than 2GB.
BigDecimal framesPerSecond = new BigDecimal(); // BigDecimal | Optional; How many video frames per second to be scanned. Minimum value is 0.05 (1 frame per 20 seconds), maximum is 1. Default is 0.33 frame per second (1 frame scanned every 3 seconds). Maximum of 1000 total frames can be scanned, potentially adjusting the framerate for longer videos.
try {
    NsfwResult result = apiInstance.videoScanForNsfw(inputFile, fileUrl, framesPerSecond);
    System.out.println(result);
} catch (ApiException e) {
    System.err.println("Exception when calling VideoApi#videoScanForNsfw");
    e.printStackTrace();
}

Run this command to install the SDK:

composer require cloudmersive/cloudmersive_video_api_client

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: Apikey
$config = Swagger\Client\Configuration::getDefaultConfiguration()->setApiKey('Apikey', 'YOUR_API_KEY');



$apiInstance = new Swagger\Client\Api\VideoApi(
    
    
    new GuzzleHttp\Client(),
    $config
);
$input_file = "/path/to/file"; // \SplFileObject | Input file to perform the operation on.
$file_url = "file_url_example"; // string | Optional; URL of a video file being scanned. Use this option for files larger than 2GB.
$frames_per_second = 8.14; // float | Optional; How many video frames per second to be scanned. Minimum value is 0.05 (1 frame per 20 seconds), maximum is 1. Default is 0.33 frame per second (1 frame scanned every 3 seconds). Maximum of 1000 total frames can be scanned, potentially adjusting the framerate for longer videos.

try {
    $result = $apiInstance->videoScanForNsfw($input_file, $file_url, $frames_per_second);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling VideoApi->videoScanForNsfw: ', $e->getMessage(), PHP_EOL;
}
?>

Add the Objective-C client to your Podfile:

Add the Ruby client to your Gemfile:

gem 'cloudmersive-video-api-client', '~> 2.0', '>= 2.0.5'

# load the gem
require 'cloudmersive-video-api-client'
# setup authorization
CloudmersiveVideoApiClient.configure do |config|
  # Configure API key authorization: Apikey
  config.api_key['Apikey'] = 'YOUR API KEY'
  # Uncomment the following line to set a prefix for the API key, e.g. 'Bearer' (defaults to nil)
  #config.api_key_prefix['Apikey'] = 'Bearer'
end

api_instance = CloudmersiveVideoApiClient::VideoApi.new

opts = { 
  input_file: File.new('/path/to/inputfile'), # File | Input file to perform the operation on.
  file_url: 'file_url_example', # String | Optional; URL of a video file being scanned. Use this option for files larger than 2GB.
  frames_per_second: 8.14 # Float | Optional; How many video frames per second to be scanned. Minimum value is 0.05 (1 frame per 20 seconds), maximum is 1. Default is 0.33 frame per second (1 frame scanned every 3 seconds). Maximum of 1000 total frames can be scanned, potentially adjusting the framerate for longer videos.
}

begin
  #Scan a Video for NSFW content.
  result = api_instance.video_scan_for_nsfw(opts)
  p result
rescue CloudmersiveVideoApiClient::ApiError => e
  puts "Exception when calling VideoApi->video_scan_for_nsfw: #{e}"
end

Download and copy the /client folder into your Apex project:

Download Apex Client

SwagVideoApi api = new SwagVideoApi();
SwagClient client = api.getClient();

// Configure API key authorization: Apikey
ApiKeyAuth Apikey = (ApiKeyAuth) client.getAuthentication('Apikey');
Apikey.setApiKey('YOUR API KEY');

Map<String, Object> params = new Map<String, Object>{
    'inputFile' => Blob.valueOf('Sample text file\nContents'),
    'fileUrl' => 'fileUrl_example',
    'framesPerSecond' => 8.14
};

try {
    // cross your fingers
    SwagNsfwResult result = api.videoScanForNsfw(params);
    System.debug(result);
} catch (Swagger.ApiException e) {
    // ...handle your exceptions
}

Install libcurl in your C/C++ project:

libcurl/7.75.0

CURL *curl;
CURLcode res;
curl = curl_easy_init();
if(curl) {
     curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "POST");
     curl_easy_setopt(curl, CURLOPT_URL, "https://api.cloudmersive.com/video/scan/nsfw");
     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, "fileUrl: <string>");
     headers = curl_slist_append(headers, "framesPerSecond: <number>");
     headers = curl_slist_append(headers, "Content-Type: multipart/form-data");
     headers = curl_slist_append(headers, "Apikey: YOUR-API-KEY-HERE");
     curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
     curl_mime *mime;
     curl_mimepart *part;
     mime = curl_mime_init(curl);
     part = curl_mime_addpart(mime);
     curl_mime_name(part, "inputFile");
     curl_mime_filedata(part, "/path/to/file");
     curl_easy_setopt(curl, CURLOPT_MIMEPOST, mime);
     res = curl_easy_perform(curl);
     curl_mime_free(mime);
}
curl_easy_cleanup(curl);

curl --location --request POST 'https://api.cloudmersive.com/video/scan/nsfw' \
--header 'fileUrl: <string>' \
--header 'framesPerSecond: <number>' \
--header 'Content-Type: multipart/form-data' \
--header 'Apikey: YOUR-API-KEY-HERE' \
--form 'inputFile=@"/path/to/file"'

import Foundation
#if canImport(FoundationNetworking)
import FoundationNetworking
#endif

var semaphore = DispatchSemaphore (value: 0)

let parameters = [
     [
          "key": "inputFile",
          "src": "/path/to/file",
          "type": "file"
     ]] as [[String : Any]]

let boundary = "Boundary-\(UUID().uuidString)"
var body = ""
var error: Error? = nil
for param in parameters {
     if param["disabled"] == nil {
          let paramName = param["key"]!
          body += "--\(boundary)\r\n"
          body += "Content-Disposition:form-data; name=\"\(paramName)\""
          if param["contentType"] != nil {
               body += "\r\nContent-Type: \(param["contentType"] as! String)"
          }
          let paramType = param["type"] as! String
          if paramType == "text" {
               let paramValue = param["value"] as! String
               body += "\r\n\r\n\(paramValue)\r\n"
          } else {
               let paramSrc = param["src"] as! String
               let fileData = try NSData(contentsOfFile:paramSrc, options:[]) as Data
               let fileContent = String(data: fileData, encoding: .utf8)!
               body += "; filename=\"\(paramSrc)\"\r\n"
                 + "Content-Type: \"content-type header\"\r\n\r\n\(fileContent)\r\n"
          }
     }
}
body += "--\(boundary)--\r\n";
let postData = body.data(using: .utf8)

var request = URLRequest(url: URL(string: "https://api.cloudmersive.com/video/scan/nsfw")!,timeoutInterval: Double.infinity)
request.addValue("<string>", forHTTPHeaderField: "fileUrl")
request.addValue("<number>", forHTTPHeaderField: "framesPerSecond")
request.addValue("multipart/form-data", forHTTPHeaderField: "Content-Type")
request.addValue("YOUR-API-KEY-HERE", forHTTPHeaderField: "Apikey")
request.addValue("multipart/form-data; boundary=\(boundary)", forHTTPHeaderField: "Content-Type")

request.httpMethod = "POST"
request.httpBody = postData

let task = URLSession.shared.dataTask(with: request) { data, response, error in 
     guard let data = data else {
          print(String(describing: error))
          semaphore.signal()
          return
     }
     print(String(data: data, encoding: .utf8)!)
     semaphore.signal()
}

task.resume()
semaphore.wait()

XHR | jQuery

This code snippet uses the built-in JavaScript XHR request capability

var data = new FormData();
data.append("inputFile", fileInput.files[0], "file");
 
var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function() {
     if(this.readyState === 4) {
          console.log(this.responseText);
     }
});

xhr.open("POST", "https://api.cloudmersive.com/video/scan/nsfw");
xhr.setRequestHeader("fileUrl", "<string>");
xhr.setRequestHeader("framesPerSecond", "<number>");

xhr.setRequestHeader("Apikey", "YOUR-API-KEY-HERE");

xhr.send(data);

var form = new FormData();
form.append("inputFile", fileInput.files[0], "file");

var settings = {
     "url": "https://api.cloudmersive.com/video/scan/nsfw",
     "method": "POST",
     "timeout": 0,
     "headers": {
          "fileUrl": "<string>",
          "framesPerSecond": "<number>",
          "Content-Type": "multipart/form-data",
          "Apikey": "YOUR-API-KEY-HERE"
     },
     "processData": false,
     "mimeType": "multipart/form-data",
     "contentType": false,
     "data": form
};

$.ajax(settings).done(function (response) {
     console.log(response);
});

package main

import (
     "fmt"
     "bytes"
     "mime/multipart"
     "os"
     "path/filepath"
     "io"
     "net/http"
     "io/ioutil"
)

func main() {

     url := "https://api.cloudmersive.com/video/scan/nsfw"
     method := "POST"

     payload := &bytes.Buffer{}
     writer := multipart.NewWriter(payload)
     file, errFile1 := os.Open("/path/to/file")
     defer file.Close()
     part1,
         errFile1 := writer.CreateFormFile("inputFile",filepath.Base("/path/to/file"))
     _, errFile1 = io.Copy(part1, file)
     if errFile1 != nil {
          fmt.Println(errFile1)
          return
     }
     err := writer.Close()
     if err != nil {
          fmt.Println(err)
          return
     }


     client := &http.Client {
     }
     req, err := http.NewRequest(method, url, payload)

     if err != nil {
          fmt.Println(err)
          return
     }
     req.Header.Add("fileUrl", "<string>")
     req.Header.Add("framesPerSecond", "<number>")
     req.Header.Add("Content-Type", "multipart/form-data")
     req.Header.Add("Apikey", "YOUR-API-KEY-HERE")

     req.Header.Set("Content-Type", writer.FormDataContentType())
     res, err := client.Do(req)
     if err != nil {
          fmt.Println(err)
          return
     }
     defer res.Body.Close()

     body, err := ioutil.ReadAll(res.Body)
     if err != nil {
          fmt.Println(err)
          return
     }
     fmt.Println(string(body))
}

Walkthrough Video