- Cloudmersive Documentation

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

Run this command to install the SDK:

npm install cloudmersive-phishingapi-client --save

Or add this snippet to your package.json:

  "dependencies": {
    "cloudmersive-phishingapi-client": "^2.0.0"
  }

var CloudmersivePhishingapiClient = require('cloudmersive-phishingapi-client');
var defaultClient = CloudmersivePhishingapiClient.ApiClient.instance;

// Configure API key authorization: Apikey
var Apikey = defaultClient.authentications['Apikey'];
Apikey.apiKey = 'YOUR API KEY';



var apiInstance = new CloudmersivePhishingapiClient.PhishingDetectionApi();

var opts = { 
  'model': "Advanced", // String | 
  'customPolicyId': "customPolicyId_example", // String | 
  'inputFile': Buffer.from(fs.readFileSync("C:\\temp\\inputfile").buffer) // File | 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
apiInstance.phishingDetectFileAdvancedPost(opts, callback);

Run this command to install the SDK:

pip install cloudmersive-phishing-api-client

from __future__ import print_function
import time
import cloudmersive_phishing_api_client
from cloudmersive_phishing_api_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: Apikey
configuration = cloudmersive_phishing_api_client.Configuration()
configuration.api_key['Apikey'] = 'YOUR_API_KEY'



# create an instance of the API class
api_instance = cloudmersive_phishing_api_client.PhishingDetectionApi(cloudmersive_phishing_api_client.ApiClient(configuration))
model = 'Advanced' # str |  (optional) (default to Advanced)
custom_policy_id = 'custom_policy_id_example' # str |  (optional)
input_file = '/path/to/file' # file |  (optional)

try:
    # Perform advanced AI phishing detection and classification against input text string.  Analyzes input content as well as embedded URLs with AI deep learning to detect phishing, phishing and other unsafe content.  Uses 25-100 API calls depending on model selected.
    api_response = api_instance.phishing_detect_file_advanced_post(model=model, custom_policy_id=custom_policy_id, input_file=input_file)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PhishingDetectionApi->phishing_detect_file_advanced_post: %s\n" % e)

.NET Framework | .NET Core

Run this command to install the SDK:

NuGet\Install-Package Cloudmersive.APIClient.NET.Phishing -Version 4.0.3

using System.Collections.Generic;
using System.Diagnostics;
using Cloudmersive.APIClient.NET.Phishing.Api;
using Cloudmersive.APIClient.NET.Phishing.Client;
using Cloudmersive.APIClient.NET.Phishing.Model;

namespace Example
{
    public class PhishingDetectFileAdvancedPostExample
    {
        public static void Main()
        {
            Configuration config = new Configuration();
            config.BasePath = "http://localhost";
            // Configure API key authorization: Apikey
            config.AddApiKey("Apikey", "YOUR_API_KEY");
            
            // config.AddApiKeyPrefix("Apikey", "Bearer");

            var apiInstance = new PhishingDetectionApi(config);
            var model = "\"Advanced\"";  // string |  (optional)  (default to "Advanced")
            var customPolicyId = "customPolicyId_example";  // string |  (optional) 
            var inputFile = new System.IO.MemoryStream(System.IO.File.ReadAllBytes("/path/to/inputfile"));  // System.IO.Stream |  (optional) 

            try
            {
                // Perform advanced AI phishing detection and classification against input text string.  Analyzes input content as well as embedded URLs with AI deep learning to detect phishing, phishing and other unsafe content.  Uses 25-100 API calls depending on model selected.
                PhishingDetectionAdvancedResponse result = apiInstance.PhishingDetectFileAdvancedPost(model, customPolicyId, inputFile);
                Debug.WriteLine(result);
            }
            catch (ApiException  e)
            {
                Debug.Print("Exception when calling PhishingDetectionApi.PhishingDetectFileAdvancedPost: " + e.Message);
                Debug.Print("Status Code: " + e.ErrorCode);
                Debug.Print(e.StackTrace);
            }
        }
    }
}

using System;
using System.Diagnostics;
using Cloudmersive.APIClient.NETCore.Phishing.Api;
using Cloudmersive.APIClient.NETCore.Phishing.Client;
using Cloudmersive.APIClient.NETCore.Phishing.Model;

namespace Example
{
    public class PhishingDetectFileAdvancedPostExample
    {
        public void main()
        {
            // Configure API key authorization: Apikey
            Configuration.Default.AddApiKey("Apikey", "YOUR_API_KEY");
            
            

            var apiInstance = new PhishingDetectionApi();
            var model = model_example;  // string |  (optional)  (default to Advanced)
            var customPolicyId = customPolicyId_example;  // string |  (optional) 
            var inputFile = new System.IO.FileStream("C:\\temp\\inputfile", System.IO.FileMode.Open); // System.IO.Stream |  (optional) 

            try
            {
                // Perform advanced AI phishing detection and classification against input text string.  Analyzes input content as well as embedded URLs with AI deep learning to detect phishing, phishing and other unsafe content.  Uses 25-100 API calls depending on model selected.
                PhishingDetectionAdvancedResponse result = apiInstance.PhishingDetectFileAdvancedPost(model, customPolicyId, inputFile);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PhishingDetectionApi.PhishingDetectFileAdvancedPost: " + e.Message );
            }
        }
    }
}

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

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

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

And add the dependency in build.gradle:

Run this command to install the SDK:

composer require cloudmersive/cloudmersive_phishing_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\PhishingDetectionApi(
    
    
    new GuzzleHttp\Client(),
    $config
);
$model = "Advanced"; // string | 
$custom_policy_id = "custom_policy_id_example"; // string | 
$input_file = "/path/to/file"; // \SplFileObject | 

try {
    $result = $apiInstance->phishingDetectFileAdvancedPost($model, $custom_policy_id, $input_file);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling PhishingDetectionApi->phishingDetectFileAdvancedPost: ', $e->getMessage(), PHP_EOL;
}
?>

Add the Objective-C client to your Podfile:

CMDefaultConfiguration *apiConfig = [CMDefaultConfiguration sharedConfig];

// Configure API key authorization: (authentication scheme: Apikey)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Apikey"];




NSString* model = @"Advanced"; //  (optional) (default to Advanced)
NSURL* inputFile = [NSURL fileURLWithPath:@"/path/to/file"]; //  (optional)

CMPhishingDetectionApi*apiInstance = [[CMPhishingDetectionApi alloc] init];

// Perform advanced AI phishing detection and classification against input text string.  Analyzes input content as well as embedded URLs with AI deep learning to detect phishing, phishing and other unsafe content.  Uses 25-100 API calls depending on model selected.
[apiInstance phishingDetectFileAdvancedPostWithModel:model
              inputFile:inputFile
          completionHandler: ^(CMPhishingDetectionAdvancedResponse* output, NSError* error) {
                        if (output) {
                            NSLog(@"%@", output);
                        }
                        if (error) {
                            NSLog(@"Error calling CMPhishingDetectionApi->phishingDetectFileAdvancedPost: %@", error);
                        }
                    }];

Add the Ruby client to your Gemfile:

gem 'cloudmersive-phishing-detection-api-client', '~> 2.2', '>= 2.2.2'

# load the gem
require 'cloudmersive-phishing-detection-api-client'
# setup authorization
CloudmersivePhishingDetectionApiClient.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 = CloudmersivePhishingDetectionApiClient::PhishingDetectionApi.new

opts = { 
  model: 'Advanced', # String | 
  custom_policy_id: 'custom_policy_id_example', # String | 
  input_file: File.new('/path/to/inputfile') # File | 
}

begin
  #Perform advanced AI phishing detection and classification against input text string.  Analyzes input content as well as embedded URLs with AI deep learning to detect phishing, phishing and other unsafe content.  Uses 25-100 API calls depending on model selected.
  result = api_instance.phishing_detect_file_advanced_post(opts)
  p result
rescue CloudmersivePhishingDetectionApiClient::ApiError => e
  puts "Exception when calling PhishingDetectionApi->phishing_detect_file_advanced_post: #{e}"
end

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

Download Apex Client

SwagPhishingDetectionApi api = new SwagPhishingDetectionApi();
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>{
    'model' => 'model_example',
    'customPolicyId' => 'customPolicyId_example',
    'inputFile' => Blob.valueOf('Sample text file\nContents')
};

try {
    // cross your fingers
    SwagPhishingDetectionAdvancedRespons result = api.phishingDetectFileAdvancedPost(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, "//phishing/detect/file/advanced");
     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, "model: Advanced");
     headers = curl_slist_append(headers, "customPolicyId: <string>");
     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 '//phishing/detect/file/advanced' \
--header 'model: Advanced' \
--header 'customPolicyId: <string>' \
--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: "//phishing/detect/file/advanced")!,timeoutInterval: Double.infinity)
request.addValue("Advanced", forHTTPHeaderField: "model")
request.addValue("<string>", forHTTPHeaderField: "customPolicyId")
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", "//phishing/detect/file/advanced");
xhr.setRequestHeader("model", "Advanced");
xhr.setRequestHeader("customPolicyId", "<string>");

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

xhr.send(data);

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

var settings = {
     "url": "//phishing/detect/file/advanced",
     "method": "POST",
     "timeout": 0,
     "headers": {
          "model": "Advanced",
          "customPolicyId": "<string>",
          "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 := "//phishing/detect/file/advanced"
     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("model", "Advanced")
     req.Header.Add("customPolicyId", "<string>")
     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