VisageCloud

POST Change password for an account using old password

{{baseUrl}}/rest/v1.1/account/changePassword

QUERY PARAMS

oldPassword

newPassword

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/rest/v1.1/account/changePassword?email=&oldPassword=&newPassword=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/rest/v1.1/account/changePassword" {:query-params {:email ""
                                                                                            :oldPassword ""
                                                                                            :newPassword ""}})

require "http/client"

url = "{{baseUrl}}/rest/v1.1/account/changePassword?email=&oldPassword=&newPassword="

response = HTTP::Client.post url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/rest/v1.1/account/changePassword?email=&oldPassword=&newPassword="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/rest/v1.1/account/changePassword?email=&oldPassword=&newPassword=");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/rest/v1.1/account/changePassword?email=&oldPassword=&newPassword="

	req, _ := http.NewRequest("POST", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/rest/v1.1/account/changePassword?email=&oldPassword=&newPassword= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/rest/v1.1/account/changePassword?email=&oldPassword=&newPassword=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/rest/v1.1/account/changePassword?email=&oldPassword=&newPassword="))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/rest/v1.1/account/changePassword?email=&oldPassword=&newPassword=")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/rest/v1.1/account/changePassword?email=&oldPassword=&newPassword=")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

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

xhr.open('POST', '{{baseUrl}}/rest/v1.1/account/changePassword?email=&oldPassword=&newPassword=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/rest/v1.1/account/changePassword',
  params: {email: '', oldPassword: '', newPassword: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/rest/v1.1/account/changePassword?email=&oldPassword=&newPassword=';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/rest/v1.1/account/changePassword?email=&oldPassword=&newPassword=',
  method: 'POST',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/rest/v1.1/account/changePassword?email=&oldPassword=&newPassword=")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/rest/v1.1/account/changePassword?email=&oldPassword=&newPassword=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/rest/v1.1/account/changePassword',
  qs: {email: '', oldPassword: '', newPassword: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/rest/v1.1/account/changePassword');

req.query({
  email: '',
  oldPassword: '',
  newPassword: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/rest/v1.1/account/changePassword',
  params: {email: '', oldPassword: '', newPassword: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/rest/v1.1/account/changePassword?email=&oldPassword=&newPassword=';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/rest/v1.1/account/changePassword?email=&oldPassword=&newPassword="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/rest/v1.1/account/changePassword?email=&oldPassword=&newPassword=" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/rest/v1.1/account/changePassword?email=&oldPassword=&newPassword=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/rest/v1.1/account/changePassword?email=&oldPassword=&newPassword=');

echo $response->getBody();

setUrl('{{baseUrl}}/rest/v1.1/account/changePassword');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'email' => '',
  'oldPassword' => '',
  'newPassword' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/rest/v1.1/account/changePassword');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'email' => '',
  'oldPassword' => '',
  'newPassword' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/rest/v1.1/account/changePassword?email=&oldPassword=&newPassword=' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/rest/v1.1/account/changePassword?email=&oldPassword=&newPassword=' -Method POST

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/rest/v1.1/account/changePassword?email=&oldPassword=&newPassword=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/rest/v1.1/account/changePassword"

querystring = {"email":"","oldPassword":"","newPassword":""}

response = requests.post(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/rest/v1.1/account/changePassword"

queryString <- list(
  email = "",
  oldPassword = "",
  newPassword = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/rest/v1.1/account/changePassword?email=&oldPassword=&newPassword=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/rest/v1.1/account/changePassword') do |req|
  req.params['email'] = ''
  req.params['oldPassword'] = ''
  req.params['newPassword'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/rest/v1.1/account/changePassword";

    let querystring = [
        ("email", ""),
        ("oldPassword", ""),
        ("newPassword", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.post(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/rest/v1.1/account/changePassword?email=&oldPassword=&newPassword='

http POST '{{baseUrl}}/rest/v1.1/account/changePassword?email=&oldPassword=&newPassword='

wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/rest/v1.1/account/changePassword?email=&oldPassword=&newPassword='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/rest/v1.1/account/changePassword?email=&oldPassword=&newPassword=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Get account information by accessKey and secretKey

{{baseUrl}}/rest/v1.1/account/account

QUERY PARAMS

accessKey

secretKey

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/rest/v1.1/account/account?accessKey=&secretKey=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/rest/v1.1/account/account" {:query-params {:accessKey ""
                                                                                    :secretKey ""}})

require "http/client"

url = "{{baseUrl}}/rest/v1.1/account/account?accessKey=&secretKey="

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/rest/v1.1/account/account?accessKey=&secretKey="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/rest/v1.1/account/account?accessKey=&secretKey=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/rest/v1.1/account/account?accessKey=&secretKey="

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/rest/v1.1/account/account?accessKey=&secretKey= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/rest/v1.1/account/account?accessKey=&secretKey=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/rest/v1.1/account/account?accessKey=&secretKey="))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/rest/v1.1/account/account?accessKey=&secretKey=")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/rest/v1.1/account/account?accessKey=&secretKey=")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

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

xhr.open('GET', '{{baseUrl}}/rest/v1.1/account/account?accessKey=&secretKey=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/rest/v1.1/account/account',
  params: {accessKey: '', secretKey: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/rest/v1.1/account/account?accessKey=&secretKey=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/rest/v1.1/account/account?accessKey=&secretKey=',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/rest/v1.1/account/account?accessKey=&secretKey=")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/rest/v1.1/account/account?accessKey=&secretKey=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/rest/v1.1/account/account',
  qs: {accessKey: '', secretKey: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/rest/v1.1/account/account');

req.query({
  accessKey: '',
  secretKey: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/rest/v1.1/account/account',
  params: {accessKey: '', secretKey: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/rest/v1.1/account/account?accessKey=&secretKey=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/rest/v1.1/account/account?accessKey=&secretKey="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/rest/v1.1/account/account?accessKey=&secretKey=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/rest/v1.1/account/account?accessKey=&secretKey=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/rest/v1.1/account/account?accessKey=&secretKey=');

echo $response->getBody();

setUrl('{{baseUrl}}/rest/v1.1/account/account');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'accessKey' => '',
  'secretKey' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/rest/v1.1/account/account');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'accessKey' => '',
  'secretKey' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/rest/v1.1/account/account?accessKey=&secretKey=' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/rest/v1.1/account/account?accessKey=&secretKey=' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/rest/v1.1/account/account?accessKey=&secretKey=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/rest/v1.1/account/account"

querystring = {"accessKey":"","secretKey":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/rest/v1.1/account/account"

queryString <- list(
  accessKey = "",
  secretKey = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/rest/v1.1/account/account?accessKey=&secretKey=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/rest/v1.1/account/account') do |req|
  req.params['accessKey'] = ''
  req.params['secretKey'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/rest/v1.1/account/account";

    let querystring = [
        ("accessKey", ""),
        ("secretKey", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/rest/v1.1/account/account?accessKey=&secretKey='

http GET '{{baseUrl}}/rest/v1.1/account/account?accessKey=&secretKey='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/rest/v1.1/account/account?accessKey=&secretKey='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/rest/v1.1/account/account?accessKey=&secretKey=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST Get account information including accessKey and secretKey by email and password

{{baseUrl}}/rest/v1.1/account/login

QUERY PARAMS

password

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/rest/v1.1/account/login?email=&password=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/rest/v1.1/account/login" {:query-params {:email ""
                                                                                   :password ""}})

require "http/client"

url = "{{baseUrl}}/rest/v1.1/account/login?email=&password="

response = HTTP::Client.post url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/rest/v1.1/account/login?email=&password="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/rest/v1.1/account/login?email=&password=");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/rest/v1.1/account/login?email=&password="

	req, _ := http.NewRequest("POST", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/rest/v1.1/account/login?email=&password= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/rest/v1.1/account/login?email=&password=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/rest/v1.1/account/login?email=&password="))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/rest/v1.1/account/login?email=&password=")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/rest/v1.1/account/login?email=&password=")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

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

xhr.open('POST', '{{baseUrl}}/rest/v1.1/account/login?email=&password=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/rest/v1.1/account/login',
  params: {email: '', password: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/rest/v1.1/account/login?email=&password=';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/rest/v1.1/account/login?email=&password=',
  method: 'POST',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/rest/v1.1/account/login?email=&password=")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/rest/v1.1/account/login?email=&password=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/rest/v1.1/account/login',
  qs: {email: '', password: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/rest/v1.1/account/login');

req.query({
  email: '',
  password: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/rest/v1.1/account/login',
  params: {email: '', password: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/rest/v1.1/account/login?email=&password=';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/rest/v1.1/account/login?email=&password="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/rest/v1.1/account/login?email=&password=" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/rest/v1.1/account/login?email=&password=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/rest/v1.1/account/login?email=&password=');

echo $response->getBody();

setUrl('{{baseUrl}}/rest/v1.1/account/login');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'email' => '',
  'password' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/rest/v1.1/account/login');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'email' => '',
  'password' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/rest/v1.1/account/login?email=&password=' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/rest/v1.1/account/login?email=&password=' -Method POST

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/rest/v1.1/account/login?email=&password=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/rest/v1.1/account/login"

querystring = {"email":"","password":""}

response = requests.post(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/rest/v1.1/account/login"

queryString <- list(
  email = "",
  password = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/rest/v1.1/account/login?email=&password=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/rest/v1.1/account/login') do |req|
  req.params['email'] = ''
  req.params['password'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/rest/v1.1/account/login";

    let querystring = [
        ("email", ""),
        ("password", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.post(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/rest/v1.1/account/login?email=&password='

http POST '{{baseUrl}}/rest/v1.1/account/login?email=&password='

wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/rest/v1.1/account/login?email=&password='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/rest/v1.1/account/login?email=&password=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Get billing information by accessKey and secretKey

{{baseUrl}}/rest/v1.1/account/billing

QUERY PARAMS

accessKey

secretKey

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/rest/v1.1/account/billing?accessKey=&secretKey=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/rest/v1.1/account/billing" {:query-params {:accessKey ""
                                                                                    :secretKey ""}})

require "http/client"

url = "{{baseUrl}}/rest/v1.1/account/billing?accessKey=&secretKey="

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/rest/v1.1/account/billing?accessKey=&secretKey="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/rest/v1.1/account/billing?accessKey=&secretKey=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/rest/v1.1/account/billing?accessKey=&secretKey="

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/rest/v1.1/account/billing?accessKey=&secretKey= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/rest/v1.1/account/billing?accessKey=&secretKey=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/rest/v1.1/account/billing?accessKey=&secretKey="))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/rest/v1.1/account/billing?accessKey=&secretKey=")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/rest/v1.1/account/billing?accessKey=&secretKey=")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

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

xhr.open('GET', '{{baseUrl}}/rest/v1.1/account/billing?accessKey=&secretKey=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/rest/v1.1/account/billing',
  params: {accessKey: '', secretKey: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/rest/v1.1/account/billing?accessKey=&secretKey=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/rest/v1.1/account/billing?accessKey=&secretKey=',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/rest/v1.1/account/billing?accessKey=&secretKey=")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/rest/v1.1/account/billing?accessKey=&secretKey=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/rest/v1.1/account/billing',
  qs: {accessKey: '', secretKey: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/rest/v1.1/account/billing');

req.query({
  accessKey: '',
  secretKey: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/rest/v1.1/account/billing',
  params: {accessKey: '', secretKey: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/rest/v1.1/account/billing?accessKey=&secretKey=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/rest/v1.1/account/billing?accessKey=&secretKey="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/rest/v1.1/account/billing?accessKey=&secretKey=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/rest/v1.1/account/billing?accessKey=&secretKey=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/rest/v1.1/account/billing?accessKey=&secretKey=');

echo $response->getBody();

setUrl('{{baseUrl}}/rest/v1.1/account/billing');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'accessKey' => '',
  'secretKey' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/rest/v1.1/account/billing');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'accessKey' => '',
  'secretKey' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/rest/v1.1/account/billing?accessKey=&secretKey=' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/rest/v1.1/account/billing?accessKey=&secretKey=' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/rest/v1.1/account/billing?accessKey=&secretKey=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/rest/v1.1/account/billing"

querystring = {"accessKey":"","secretKey":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/rest/v1.1/account/billing"

queryString <- list(
  accessKey = "",
  secretKey = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/rest/v1.1/account/billing?accessKey=&secretKey=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/rest/v1.1/account/billing') do |req|
  req.params['accessKey'] = ''
  req.params['secretKey'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/rest/v1.1/account/billing";

    let querystring = [
        ("accessKey", ""),
        ("secretKey", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/rest/v1.1/account/billing?accessKey=&secretKey='

http GET '{{baseUrl}}/rest/v1.1/account/billing?accessKey=&secretKey='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/rest/v1.1/account/billing?accessKey=&secretKey='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/rest/v1.1/account/billing?accessKey=&secretKey=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Compare several faces identified by faceHash, without depending on mapping faces to profiles

{{baseUrl}}/rest/v1.1/analysis/compare

QUERY PARAMS

accessKey

secretKey

faceHashes

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/rest/v1.1/analysis/compare?accessKey=&secretKey=&faceHashes=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/rest/v1.1/analysis/compare" {:query-params {:accessKey ""
                                                                                     :secretKey ""
                                                                                     :faceHashes ""}})

require "http/client"

url = "{{baseUrl}}/rest/v1.1/analysis/compare?accessKey=&secretKey=&faceHashes="

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/rest/v1.1/analysis/compare?accessKey=&secretKey=&faceHashes="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/rest/v1.1/analysis/compare?accessKey=&secretKey=&faceHashes=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/rest/v1.1/analysis/compare?accessKey=&secretKey=&faceHashes="

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/rest/v1.1/analysis/compare?accessKey=&secretKey=&faceHashes= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/rest/v1.1/analysis/compare?accessKey=&secretKey=&faceHashes=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/rest/v1.1/analysis/compare?accessKey=&secretKey=&faceHashes="))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/rest/v1.1/analysis/compare?accessKey=&secretKey=&faceHashes=")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/rest/v1.1/analysis/compare?accessKey=&secretKey=&faceHashes=")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

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

xhr.open('GET', '{{baseUrl}}/rest/v1.1/analysis/compare?accessKey=&secretKey=&faceHashes=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/rest/v1.1/analysis/compare',
  params: {accessKey: '', secretKey: '', faceHashes: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/rest/v1.1/analysis/compare?accessKey=&secretKey=&faceHashes=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/rest/v1.1/analysis/compare?accessKey=&secretKey=&faceHashes=',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/rest/v1.1/analysis/compare?accessKey=&secretKey=&faceHashes=")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/rest/v1.1/analysis/compare?accessKey=&secretKey=&faceHashes=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/rest/v1.1/analysis/compare',
  qs: {accessKey: '', secretKey: '', faceHashes: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/rest/v1.1/analysis/compare');

req.query({
  accessKey: '',
  secretKey: '',
  faceHashes: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/rest/v1.1/analysis/compare',
  params: {accessKey: '', secretKey: '', faceHashes: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/rest/v1.1/analysis/compare?accessKey=&secretKey=&faceHashes=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/rest/v1.1/analysis/compare?accessKey=&secretKey=&faceHashes="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/rest/v1.1/analysis/compare?accessKey=&secretKey=&faceHashes=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/rest/v1.1/analysis/compare?accessKey=&secretKey=&faceHashes=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/rest/v1.1/analysis/compare?accessKey=&secretKey=&faceHashes=');

echo $response->getBody();

setUrl('{{baseUrl}}/rest/v1.1/analysis/compare');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'accessKey' => '',
  'secretKey' => '',
  'faceHashes' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/rest/v1.1/analysis/compare');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'accessKey' => '',
  'secretKey' => '',
  'faceHashes' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/rest/v1.1/analysis/compare?accessKey=&secretKey=&faceHashes=' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/rest/v1.1/analysis/compare?accessKey=&secretKey=&faceHashes=' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/rest/v1.1/analysis/compare?accessKey=&secretKey=&faceHashes=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/rest/v1.1/analysis/compare"

querystring = {"accessKey":"","secretKey":"","faceHashes":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/rest/v1.1/analysis/compare"

queryString <- list(
  accessKey = "",
  secretKey = "",
  faceHashes = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/rest/v1.1/analysis/compare?accessKey=&secretKey=&faceHashes=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/rest/v1.1/analysis/compare') do |req|
  req.params['accessKey'] = ''
  req.params['secretKey'] = ''
  req.params['faceHashes'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/rest/v1.1/analysis/compare";

    let querystring = [
        ("accessKey", ""),
        ("secretKey", ""),
        ("faceHashes", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/rest/v1.1/analysis/compare?accessKey=&secretKey=&faceHashes='

http GET '{{baseUrl}}/rest/v1.1/analysis/compare?accessKey=&secretKey=&faceHashes='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/rest/v1.1/analysis/compare?accessKey=&secretKey=&faceHashes='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/rest/v1.1/analysis/compare?accessKey=&secretKey=&faceHashes=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST Perform detection on a given picture or picture URL

{{baseUrl}}/rest/v1.1/analysis/detection

QUERY PARAMS

accessKey

secretKey

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/rest/v1.1/analysis/detection?accessKey=&secretKey=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/rest/v1.1/analysis/detection" {:query-params {:accessKey ""
                                                                                        :secretKey ""}})

require "http/client"

url = "{{baseUrl}}/rest/v1.1/analysis/detection?accessKey=&secretKey="

response = HTTP::Client.post url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/rest/v1.1/analysis/detection?accessKey=&secretKey="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/rest/v1.1/analysis/detection?accessKey=&secretKey=");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/rest/v1.1/analysis/detection?accessKey=&secretKey="

	req, _ := http.NewRequest("POST", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/rest/v1.1/analysis/detection?accessKey=&secretKey= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/rest/v1.1/analysis/detection?accessKey=&secretKey=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/rest/v1.1/analysis/detection?accessKey=&secretKey="))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/rest/v1.1/analysis/detection?accessKey=&secretKey=")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/rest/v1.1/analysis/detection?accessKey=&secretKey=")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

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

xhr.open('POST', '{{baseUrl}}/rest/v1.1/analysis/detection?accessKey=&secretKey=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/rest/v1.1/analysis/detection',
  params: {accessKey: '', secretKey: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/rest/v1.1/analysis/detection?accessKey=&secretKey=';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/rest/v1.1/analysis/detection?accessKey=&secretKey=',
  method: 'POST',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/rest/v1.1/analysis/detection?accessKey=&secretKey=")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/rest/v1.1/analysis/detection?accessKey=&secretKey=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/rest/v1.1/analysis/detection',
  qs: {accessKey: '', secretKey: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/rest/v1.1/analysis/detection');

req.query({
  accessKey: '',
  secretKey: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/rest/v1.1/analysis/detection',
  params: {accessKey: '', secretKey: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/rest/v1.1/analysis/detection?accessKey=&secretKey=';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/rest/v1.1/analysis/detection?accessKey=&secretKey="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/rest/v1.1/analysis/detection?accessKey=&secretKey=" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/rest/v1.1/analysis/detection?accessKey=&secretKey=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/rest/v1.1/analysis/detection?accessKey=&secretKey=');

echo $response->getBody();

setUrl('{{baseUrl}}/rest/v1.1/analysis/detection');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'accessKey' => '',
  'secretKey' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/rest/v1.1/analysis/detection');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'accessKey' => '',
  'secretKey' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/rest/v1.1/analysis/detection?accessKey=&secretKey=' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/rest/v1.1/analysis/detection?accessKey=&secretKey=' -Method POST

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/rest/v1.1/analysis/detection?accessKey=&secretKey=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/rest/v1.1/analysis/detection"

querystring = {"accessKey":"","secretKey":""}

response = requests.post(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/rest/v1.1/analysis/detection"

queryString <- list(
  accessKey = "",
  secretKey = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/rest/v1.1/analysis/detection?accessKey=&secretKey=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/rest/v1.1/analysis/detection') do |req|
  req.params['accessKey'] = ''
  req.params['secretKey'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/rest/v1.1/analysis/detection";

    let querystring = [
        ("accessKey", ""),
        ("secretKey", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.post(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/rest/v1.1/analysis/detection?accessKey=&secretKey='

http POST '{{baseUrl}}/rest/v1.1/analysis/detection?accessKey=&secretKey='

wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/rest/v1.1/analysis/detection?accessKey=&secretKey='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/rest/v1.1/analysis/detection?accessKey=&secretKey=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST Perform labeled recognition on a given picture or picture URL

{{baseUrl}}/rest/v1.1/analysis/recognition

QUERY PARAMS

accessKey

secretKey

collectionId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/rest/v1.1/analysis/recognition?accessKey=&secretKey=&collectionId=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/rest/v1.1/analysis/recognition" {:query-params {:accessKey ""
                                                                                          :secretKey ""
                                                                                          :collectionId ""}})

require "http/client"

url = "{{baseUrl}}/rest/v1.1/analysis/recognition?accessKey=&secretKey=&collectionId="

response = HTTP::Client.post url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/rest/v1.1/analysis/recognition?accessKey=&secretKey=&collectionId="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/rest/v1.1/analysis/recognition?accessKey=&secretKey=&collectionId=");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/rest/v1.1/analysis/recognition?accessKey=&secretKey=&collectionId="

	req, _ := http.NewRequest("POST", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/rest/v1.1/analysis/recognition?accessKey=&secretKey=&collectionId= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/rest/v1.1/analysis/recognition?accessKey=&secretKey=&collectionId=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/rest/v1.1/analysis/recognition?accessKey=&secretKey=&collectionId="))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/rest/v1.1/analysis/recognition?accessKey=&secretKey=&collectionId=")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/rest/v1.1/analysis/recognition?accessKey=&secretKey=&collectionId=")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

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

xhr.open('POST', '{{baseUrl}}/rest/v1.1/analysis/recognition?accessKey=&secretKey=&collectionId=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/rest/v1.1/analysis/recognition',
  params: {accessKey: '', secretKey: '', collectionId: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/rest/v1.1/analysis/recognition?accessKey=&secretKey=&collectionId=';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/rest/v1.1/analysis/recognition?accessKey=&secretKey=&collectionId=',
  method: 'POST',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/rest/v1.1/analysis/recognition?accessKey=&secretKey=&collectionId=")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/rest/v1.1/analysis/recognition?accessKey=&secretKey=&collectionId=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/rest/v1.1/analysis/recognition',
  qs: {accessKey: '', secretKey: '', collectionId: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/rest/v1.1/analysis/recognition');

req.query({
  accessKey: '',
  secretKey: '',
  collectionId: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/rest/v1.1/analysis/recognition',
  params: {accessKey: '', secretKey: '', collectionId: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/rest/v1.1/analysis/recognition?accessKey=&secretKey=&collectionId=';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/rest/v1.1/analysis/recognition?accessKey=&secretKey=&collectionId="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/rest/v1.1/analysis/recognition?accessKey=&secretKey=&collectionId=" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/rest/v1.1/analysis/recognition?accessKey=&secretKey=&collectionId=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/rest/v1.1/analysis/recognition?accessKey=&secretKey=&collectionId=');

echo $response->getBody();

setUrl('{{baseUrl}}/rest/v1.1/analysis/recognition');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'accessKey' => '',
  'secretKey' => '',
  'collectionId' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/rest/v1.1/analysis/recognition');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'accessKey' => '',
  'secretKey' => '',
  'collectionId' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/rest/v1.1/analysis/recognition?accessKey=&secretKey=&collectionId=' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/rest/v1.1/analysis/recognition?accessKey=&secretKey=&collectionId=' -Method POST

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/rest/v1.1/analysis/recognition?accessKey=&secretKey=&collectionId=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/rest/v1.1/analysis/recognition"

querystring = {"accessKey":"","secretKey":"","collectionId":""}

response = requests.post(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/rest/v1.1/analysis/recognition"

queryString <- list(
  accessKey = "",
  secretKey = "",
  collectionId = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/rest/v1.1/analysis/recognition?accessKey=&secretKey=&collectionId=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/rest/v1.1/analysis/recognition') do |req|
  req.params['accessKey'] = ''
  req.params['secretKey'] = ''
  req.params['collectionId'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/rest/v1.1/analysis/recognition";

    let querystring = [
        ("accessKey", ""),
        ("secretKey", ""),
        ("collectionId", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.post(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/rest/v1.1/analysis/recognition?accessKey=&secretKey=&collectionId='

http POST '{{baseUrl}}/rest/v1.1/analysis/recognition?accessKey=&secretKey=&collectionId='

wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/rest/v1.1/analysis/recognition?accessKey=&secretKey=&collectionId='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/rest/v1.1/analysis/recognition?accessKey=&secretKey=&collectionId=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Retrieve a complete analysis object including both detection and recognition information

{{baseUrl}}/rest/v1.1/analysis/retrieve

QUERY PARAMS

accessKey

secretKey

analysisId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/rest/v1.1/analysis/retrieve?accessKey=&secretKey=&analysisId=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/rest/v1.1/analysis/retrieve" {:query-params {:accessKey ""
                                                                                      :secretKey ""
                                                                                      :analysisId ""}})

require "http/client"

url = "{{baseUrl}}/rest/v1.1/analysis/retrieve?accessKey=&secretKey=&analysisId="

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/rest/v1.1/analysis/retrieve?accessKey=&secretKey=&analysisId="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/rest/v1.1/analysis/retrieve?accessKey=&secretKey=&analysisId=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/rest/v1.1/analysis/retrieve?accessKey=&secretKey=&analysisId="

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/rest/v1.1/analysis/retrieve?accessKey=&secretKey=&analysisId= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/rest/v1.1/analysis/retrieve?accessKey=&secretKey=&analysisId=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/rest/v1.1/analysis/retrieve?accessKey=&secretKey=&analysisId="))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/rest/v1.1/analysis/retrieve?accessKey=&secretKey=&analysisId=")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/rest/v1.1/analysis/retrieve?accessKey=&secretKey=&analysisId=")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

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

xhr.open('GET', '{{baseUrl}}/rest/v1.1/analysis/retrieve?accessKey=&secretKey=&analysisId=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/rest/v1.1/analysis/retrieve',
  params: {accessKey: '', secretKey: '', analysisId: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/rest/v1.1/analysis/retrieve?accessKey=&secretKey=&analysisId=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/rest/v1.1/analysis/retrieve?accessKey=&secretKey=&analysisId=',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/rest/v1.1/analysis/retrieve?accessKey=&secretKey=&analysisId=")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/rest/v1.1/analysis/retrieve?accessKey=&secretKey=&analysisId=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/rest/v1.1/analysis/retrieve',
  qs: {accessKey: '', secretKey: '', analysisId: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/rest/v1.1/analysis/retrieve');

req.query({
  accessKey: '',
  secretKey: '',
  analysisId: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/rest/v1.1/analysis/retrieve',
  params: {accessKey: '', secretKey: '', analysisId: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/rest/v1.1/analysis/retrieve?accessKey=&secretKey=&analysisId=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/rest/v1.1/analysis/retrieve?accessKey=&secretKey=&analysisId="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/rest/v1.1/analysis/retrieve?accessKey=&secretKey=&analysisId=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/rest/v1.1/analysis/retrieve?accessKey=&secretKey=&analysisId=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/rest/v1.1/analysis/retrieve?accessKey=&secretKey=&analysisId=');

echo $response->getBody();

setUrl('{{baseUrl}}/rest/v1.1/analysis/retrieve');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'accessKey' => '',
  'secretKey' => '',
  'analysisId' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/rest/v1.1/analysis/retrieve');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'accessKey' => '',
  'secretKey' => '',
  'analysisId' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/rest/v1.1/analysis/retrieve?accessKey=&secretKey=&analysisId=' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/rest/v1.1/analysis/retrieve?accessKey=&secretKey=&analysisId=' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/rest/v1.1/analysis/retrieve?accessKey=&secretKey=&analysisId=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/rest/v1.1/analysis/retrieve"

querystring = {"accessKey":"","secretKey":"","analysisId":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/rest/v1.1/analysis/retrieve"

queryString <- list(
  accessKey = "",
  secretKey = "",
  analysisId = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/rest/v1.1/analysis/retrieve?accessKey=&secretKey=&analysisId=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/rest/v1.1/analysis/retrieve') do |req|
  req.params['accessKey'] = ''
  req.params['secretKey'] = ''
  req.params['analysisId'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/rest/v1.1/analysis/retrieve";

    let querystring = [
        ("accessKey", ""),
        ("secretKey", ""),
        ("analysisId", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/rest/v1.1/analysis/retrieve?accessKey=&secretKey=&analysisId='

http GET '{{baseUrl}}/rest/v1.1/analysis/retrieve?accessKey=&secretKey=&analysisId='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/rest/v1.1/analysis/retrieve?accessKey=&secretKey=&analysisId='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/rest/v1.1/analysis/retrieve?accessKey=&secretKey=&analysisId=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Retrieve the last -count- operations per current account

{{baseUrl}}/rest/v1.1/analysis/listLatest

QUERY PARAMS

accessKey

secretKey

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/rest/v1.1/analysis/listLatest?accessKey=&secretKey=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/rest/v1.1/analysis/listLatest" {:query-params {:accessKey ""
                                                                                        :secretKey ""}})

require "http/client"

url = "{{baseUrl}}/rest/v1.1/analysis/listLatest?accessKey=&secretKey="

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/rest/v1.1/analysis/listLatest?accessKey=&secretKey="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/rest/v1.1/analysis/listLatest?accessKey=&secretKey=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/rest/v1.1/analysis/listLatest?accessKey=&secretKey="

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/rest/v1.1/analysis/listLatest?accessKey=&secretKey= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/rest/v1.1/analysis/listLatest?accessKey=&secretKey=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/rest/v1.1/analysis/listLatest?accessKey=&secretKey="))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/rest/v1.1/analysis/listLatest?accessKey=&secretKey=")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/rest/v1.1/analysis/listLatest?accessKey=&secretKey=")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

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

xhr.open('GET', '{{baseUrl}}/rest/v1.1/analysis/listLatest?accessKey=&secretKey=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/rest/v1.1/analysis/listLatest',
  params: {accessKey: '', secretKey: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/rest/v1.1/analysis/listLatest?accessKey=&secretKey=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/rest/v1.1/analysis/listLatest?accessKey=&secretKey=',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/rest/v1.1/analysis/listLatest?accessKey=&secretKey=")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/rest/v1.1/analysis/listLatest?accessKey=&secretKey=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/rest/v1.1/analysis/listLatest',
  qs: {accessKey: '', secretKey: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/rest/v1.1/analysis/listLatest');

req.query({
  accessKey: '',
  secretKey: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/rest/v1.1/analysis/listLatest',
  params: {accessKey: '', secretKey: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/rest/v1.1/analysis/listLatest?accessKey=&secretKey=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/rest/v1.1/analysis/listLatest?accessKey=&secretKey="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/rest/v1.1/analysis/listLatest?accessKey=&secretKey=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/rest/v1.1/analysis/listLatest?accessKey=&secretKey=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/rest/v1.1/analysis/listLatest?accessKey=&secretKey=');

echo $response->getBody();

setUrl('{{baseUrl}}/rest/v1.1/analysis/listLatest');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'accessKey' => '',
  'secretKey' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/rest/v1.1/analysis/listLatest');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'accessKey' => '',
  'secretKey' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/rest/v1.1/analysis/listLatest?accessKey=&secretKey=' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/rest/v1.1/analysis/listLatest?accessKey=&secretKey=' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/rest/v1.1/analysis/listLatest?accessKey=&secretKey=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/rest/v1.1/analysis/listLatest"

querystring = {"accessKey":"","secretKey":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/rest/v1.1/analysis/listLatest"

queryString <- list(
  accessKey = "",
  secretKey = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/rest/v1.1/analysis/listLatest?accessKey=&secretKey=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/rest/v1.1/analysis/listLatest') do |req|
  req.params['accessKey'] = ''
  req.params['secretKey'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/rest/v1.1/analysis/listLatest";

    let querystring = [
        ("accessKey", ""),
        ("secretKey", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/rest/v1.1/analysis/listLatest?accessKey=&secretKey='

http GET '{{baseUrl}}/rest/v1.1/analysis/listLatest?accessKey=&secretKey='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/rest/v1.1/analysis/listLatest?accessKey=&secretKey='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/rest/v1.1/analysis/listLatest?accessKey=&secretKey=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST Count individuals in streams or collections

{{baseUrl}}/rest/v1.1/analytics/counting

QUERY PARAMS

accessKey

secretKey

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/rest/v1.1/analytics/counting?accessKey=&secretKey=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/rest/v1.1/analytics/counting" {:query-params {:accessKey ""
                                                                                        :secretKey ""}})

require "http/client"

url = "{{baseUrl}}/rest/v1.1/analytics/counting?accessKey=&secretKey="

response = HTTP::Client.post url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/rest/v1.1/analytics/counting?accessKey=&secretKey="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/rest/v1.1/analytics/counting?accessKey=&secretKey=");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/rest/v1.1/analytics/counting?accessKey=&secretKey="

	req, _ := http.NewRequest("POST", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/rest/v1.1/analytics/counting?accessKey=&secretKey= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/rest/v1.1/analytics/counting?accessKey=&secretKey=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/rest/v1.1/analytics/counting?accessKey=&secretKey="))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/rest/v1.1/analytics/counting?accessKey=&secretKey=")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/rest/v1.1/analytics/counting?accessKey=&secretKey=")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

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

xhr.open('POST', '{{baseUrl}}/rest/v1.1/analytics/counting?accessKey=&secretKey=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/rest/v1.1/analytics/counting',
  params: {accessKey: '', secretKey: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/rest/v1.1/analytics/counting?accessKey=&secretKey=';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/rest/v1.1/analytics/counting?accessKey=&secretKey=',
  method: 'POST',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/rest/v1.1/analytics/counting?accessKey=&secretKey=")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/rest/v1.1/analytics/counting?accessKey=&secretKey=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/rest/v1.1/analytics/counting',
  qs: {accessKey: '', secretKey: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/rest/v1.1/analytics/counting');

req.query({
  accessKey: '',
  secretKey: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/rest/v1.1/analytics/counting',
  params: {accessKey: '', secretKey: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/rest/v1.1/analytics/counting?accessKey=&secretKey=';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/rest/v1.1/analytics/counting?accessKey=&secretKey="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/rest/v1.1/analytics/counting?accessKey=&secretKey=" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/rest/v1.1/analytics/counting?accessKey=&secretKey=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/rest/v1.1/analytics/counting?accessKey=&secretKey=');

echo $response->getBody();

setUrl('{{baseUrl}}/rest/v1.1/analytics/counting');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'accessKey' => '',
  'secretKey' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/rest/v1.1/analytics/counting');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'accessKey' => '',
  'secretKey' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/rest/v1.1/analytics/counting?accessKey=&secretKey=' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/rest/v1.1/analytics/counting?accessKey=&secretKey=' -Method POST

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/rest/v1.1/analytics/counting?accessKey=&secretKey=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/rest/v1.1/analytics/counting"

querystring = {"accessKey":"","secretKey":""}

response = requests.post(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/rest/v1.1/analytics/counting"

queryString <- list(
  accessKey = "",
  secretKey = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/rest/v1.1/analytics/counting?accessKey=&secretKey=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/rest/v1.1/analytics/counting') do |req|
  req.params['accessKey'] = ''
  req.params['secretKey'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/rest/v1.1/analytics/counting";

    let querystring = [
        ("accessKey", ""),
        ("secretKey", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.post(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/rest/v1.1/analytics/counting?accessKey=&secretKey='

http POST '{{baseUrl}}/rest/v1.1/analytics/counting?accessKey=&secretKey='

wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/rest/v1.1/analytics/counting?accessKey=&secretKey='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/rest/v1.1/analytics/counting?accessKey=&secretKey=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST Show audience (based on number of occurrences of each person) breakdown per declared attribute (age, gender).

{{baseUrl}}/rest/v1.1/analytics/presence/timeseries

QUERY PARAMS

accessKey

secretKey

attributes

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/rest/v1.1/analytics/presence/timeseries?accessKey=&secretKey=&attributes=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/rest/v1.1/analytics/presence/timeseries" {:query-params {:accessKey ""
                                                                                                   :secretKey ""
                                                                                                   :attributes ""}})

require "http/client"

url = "{{baseUrl}}/rest/v1.1/analytics/presence/timeseries?accessKey=&secretKey=&attributes="

response = HTTP::Client.post url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/rest/v1.1/analytics/presence/timeseries?accessKey=&secretKey=&attributes="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/rest/v1.1/analytics/presence/timeseries?accessKey=&secretKey=&attributes=");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/rest/v1.1/analytics/presence/timeseries?accessKey=&secretKey=&attributes="

	req, _ := http.NewRequest("POST", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/rest/v1.1/analytics/presence/timeseries?accessKey=&secretKey=&attributes= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/rest/v1.1/analytics/presence/timeseries?accessKey=&secretKey=&attributes=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/rest/v1.1/analytics/presence/timeseries?accessKey=&secretKey=&attributes="))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/rest/v1.1/analytics/presence/timeseries?accessKey=&secretKey=&attributes=")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/rest/v1.1/analytics/presence/timeseries?accessKey=&secretKey=&attributes=")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

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

xhr.open('POST', '{{baseUrl}}/rest/v1.1/analytics/presence/timeseries?accessKey=&secretKey=&attributes=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/rest/v1.1/analytics/presence/timeseries',
  params: {accessKey: '', secretKey: '', attributes: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/rest/v1.1/analytics/presence/timeseries?accessKey=&secretKey=&attributes=';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/rest/v1.1/analytics/presence/timeseries?accessKey=&secretKey=&attributes=',
  method: 'POST',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/rest/v1.1/analytics/presence/timeseries?accessKey=&secretKey=&attributes=")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/rest/v1.1/analytics/presence/timeseries?accessKey=&secretKey=&attributes=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/rest/v1.1/analytics/presence/timeseries',
  qs: {accessKey: '', secretKey: '', attributes: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/rest/v1.1/analytics/presence/timeseries');

req.query({
  accessKey: '',
  secretKey: '',
  attributes: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/rest/v1.1/analytics/presence/timeseries',
  params: {accessKey: '', secretKey: '', attributes: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/rest/v1.1/analytics/presence/timeseries?accessKey=&secretKey=&attributes=';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/rest/v1.1/analytics/presence/timeseries?accessKey=&secretKey=&attributes="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/rest/v1.1/analytics/presence/timeseries?accessKey=&secretKey=&attributes=" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/rest/v1.1/analytics/presence/timeseries?accessKey=&secretKey=&attributes=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/rest/v1.1/analytics/presence/timeseries?accessKey=&secretKey=&attributes=');

echo $response->getBody();

setUrl('{{baseUrl}}/rest/v1.1/analytics/presence/timeseries');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'accessKey' => '',
  'secretKey' => '',
  'attributes' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/rest/v1.1/analytics/presence/timeseries');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'accessKey' => '',
  'secretKey' => '',
  'attributes' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/rest/v1.1/analytics/presence/timeseries?accessKey=&secretKey=&attributes=' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/rest/v1.1/analytics/presence/timeseries?accessKey=&secretKey=&attributes=' -Method POST

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/rest/v1.1/analytics/presence/timeseries?accessKey=&secretKey=&attributes=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/rest/v1.1/analytics/presence/timeseries"

querystring = {"accessKey":"","secretKey":"","attributes":""}

response = requests.post(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/rest/v1.1/analytics/presence/timeseries"

queryString <- list(
  accessKey = "",
  secretKey = "",
  attributes = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/rest/v1.1/analytics/presence/timeseries?accessKey=&secretKey=&attributes=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/rest/v1.1/analytics/presence/timeseries') do |req|
  req.params['accessKey'] = ''
  req.params['secretKey'] = ''
  req.params['attributes'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/rest/v1.1/analytics/presence/timeseries";

    let querystring = [
        ("accessKey", ""),
        ("secretKey", ""),
        ("attributes", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.post(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/rest/v1.1/analytics/presence/timeseries?accessKey=&secretKey=&attributes='

http POST '{{baseUrl}}/rest/v1.1/analytics/presence/timeseries?accessKey=&secretKey=&attributes='

wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/rest/v1.1/analytics/presence/timeseries?accessKey=&secretKey=&attributes='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/rest/v1.1/analytics/presence/timeseries?accessKey=&secretKey=&attributes=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST Show presence (based on number of occurences of each face) breakdown per declared attribute (age, gender)

{{baseUrl}}/rest/v1.1/analytics/presence/total

QUERY PARAMS

accessKey

secretKey

streamIds

attributes

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/rest/v1.1/analytics/presence/total?accessKey=&secretKey=&streamIds=&attributes=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/rest/v1.1/analytics/presence/total" {:query-params {:accessKey ""
                                                                                              :secretKey ""
                                                                                              :streamIds ""
                                                                                              :attributes ""}})

require "http/client"

url = "{{baseUrl}}/rest/v1.1/analytics/presence/total?accessKey=&secretKey=&streamIds=&attributes="

response = HTTP::Client.post url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/rest/v1.1/analytics/presence/total?accessKey=&secretKey=&streamIds=&attributes="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/rest/v1.1/analytics/presence/total?accessKey=&secretKey=&streamIds=&attributes=");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/rest/v1.1/analytics/presence/total?accessKey=&secretKey=&streamIds=&attributes="

	req, _ := http.NewRequest("POST", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/rest/v1.1/analytics/presence/total?accessKey=&secretKey=&streamIds=&attributes= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/rest/v1.1/analytics/presence/total?accessKey=&secretKey=&streamIds=&attributes=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/rest/v1.1/analytics/presence/total?accessKey=&secretKey=&streamIds=&attributes="))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/rest/v1.1/analytics/presence/total?accessKey=&secretKey=&streamIds=&attributes=")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/rest/v1.1/analytics/presence/total?accessKey=&secretKey=&streamIds=&attributes=")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

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

xhr.open('POST', '{{baseUrl}}/rest/v1.1/analytics/presence/total?accessKey=&secretKey=&streamIds=&attributes=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/rest/v1.1/analytics/presence/total',
  params: {accessKey: '', secretKey: '', streamIds: '', attributes: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/rest/v1.1/analytics/presence/total?accessKey=&secretKey=&streamIds=&attributes=';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/rest/v1.1/analytics/presence/total?accessKey=&secretKey=&streamIds=&attributes=',
  method: 'POST',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/rest/v1.1/analytics/presence/total?accessKey=&secretKey=&streamIds=&attributes=")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/rest/v1.1/analytics/presence/total?accessKey=&secretKey=&streamIds=&attributes=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/rest/v1.1/analytics/presence/total',
  qs: {accessKey: '', secretKey: '', streamIds: '', attributes: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/rest/v1.1/analytics/presence/total');

req.query({
  accessKey: '',
  secretKey: '',
  streamIds: '',
  attributes: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/rest/v1.1/analytics/presence/total',
  params: {accessKey: '', secretKey: '', streamIds: '', attributes: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/rest/v1.1/analytics/presence/total?accessKey=&secretKey=&streamIds=&attributes=';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/rest/v1.1/analytics/presence/total?accessKey=&secretKey=&streamIds=&attributes="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/rest/v1.1/analytics/presence/total?accessKey=&secretKey=&streamIds=&attributes=" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/rest/v1.1/analytics/presence/total?accessKey=&secretKey=&streamIds=&attributes=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/rest/v1.1/analytics/presence/total?accessKey=&secretKey=&streamIds=&attributes=');

echo $response->getBody();

setUrl('{{baseUrl}}/rest/v1.1/analytics/presence/total');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'accessKey' => '',
  'secretKey' => '',
  'streamIds' => '',
  'attributes' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/rest/v1.1/analytics/presence/total');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'accessKey' => '',
  'secretKey' => '',
  'streamIds' => '',
  'attributes' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/rest/v1.1/analytics/presence/total?accessKey=&secretKey=&streamIds=&attributes=' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/rest/v1.1/analytics/presence/total?accessKey=&secretKey=&streamIds=&attributes=' -Method POST

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/rest/v1.1/analytics/presence/total?accessKey=&secretKey=&streamIds=&attributes=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/rest/v1.1/analytics/presence/total"

querystring = {"accessKey":"","secretKey":"","streamIds":"","attributes":""}

response = requests.post(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/rest/v1.1/analytics/presence/total"

queryString <- list(
  accessKey = "",
  secretKey = "",
  streamIds = "",
  attributes = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/rest/v1.1/analytics/presence/total?accessKey=&secretKey=&streamIds=&attributes=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/rest/v1.1/analytics/presence/total') do |req|
  req.params['accessKey'] = ''
  req.params['secretKey'] = ''
  req.params['streamIds'] = ''
  req.params['attributes'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/rest/v1.1/analytics/presence/total";

    let querystring = [
        ("accessKey", ""),
        ("secretKey", ""),
        ("streamIds", ""),
        ("attributes", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.post(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/rest/v1.1/analytics/presence/total?accessKey=&secretKey=&streamIds=&attributes='

http POST '{{baseUrl}}/rest/v1.1/analytics/presence/total?accessKey=&secretKey=&streamIds=&attributes='

wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/rest/v1.1/analytics/presence/total?accessKey=&secretKey=&streamIds=&attributes='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/rest/v1.1/analytics/presence/total?accessKey=&secretKey=&streamIds=&attributes=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST Create new SVM classifier with given name

{{baseUrl}}/rest/v1.1/classifier/svm

QUERY PARAMS

accessKey

secretKey

name

collectionIds

classificationAttributeName

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/rest/v1.1/classifier/svm?accessKey=&secretKey=&name=&collectionIds=&classificationAttributeName=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/rest/v1.1/classifier/svm" {:query-params {:accessKey ""
                                                                                    :secretKey ""
                                                                                    :name ""
                                                                                    :collectionIds ""
                                                                                    :classificationAttributeName ""}})

require "http/client"

url = "{{baseUrl}}/rest/v1.1/classifier/svm?accessKey=&secretKey=&name=&collectionIds=&classificationAttributeName="

response = HTTP::Client.post url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/rest/v1.1/classifier/svm?accessKey=&secretKey=&name=&collectionIds=&classificationAttributeName="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/rest/v1.1/classifier/svm?accessKey=&secretKey=&name=&collectionIds=&classificationAttributeName=");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/rest/v1.1/classifier/svm?accessKey=&secretKey=&name=&collectionIds=&classificationAttributeName="

	req, _ := http.NewRequest("POST", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/rest/v1.1/classifier/svm?accessKey=&secretKey=&name=&collectionIds=&classificationAttributeName= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/rest/v1.1/classifier/svm?accessKey=&secretKey=&name=&collectionIds=&classificationAttributeName=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/rest/v1.1/classifier/svm?accessKey=&secretKey=&name=&collectionIds=&classificationAttributeName="))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/rest/v1.1/classifier/svm?accessKey=&secretKey=&name=&collectionIds=&classificationAttributeName=")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/rest/v1.1/classifier/svm?accessKey=&secretKey=&name=&collectionIds=&classificationAttributeName=")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

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

xhr.open('POST', '{{baseUrl}}/rest/v1.1/classifier/svm?accessKey=&secretKey=&name=&collectionIds=&classificationAttributeName=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/rest/v1.1/classifier/svm',
  params: {
    accessKey: '',
    secretKey: '',
    name: '',
    collectionIds: '',
    classificationAttributeName: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/rest/v1.1/classifier/svm?accessKey=&secretKey=&name=&collectionIds=&classificationAttributeName=';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/rest/v1.1/classifier/svm?accessKey=&secretKey=&name=&collectionIds=&classificationAttributeName=',
  method: 'POST',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/rest/v1.1/classifier/svm?accessKey=&secretKey=&name=&collectionIds=&classificationAttributeName=")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/rest/v1.1/classifier/svm?accessKey=&secretKey=&name=&collectionIds=&classificationAttributeName=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/rest/v1.1/classifier/svm',
  qs: {
    accessKey: '',
    secretKey: '',
    name: '',
    collectionIds: '',
    classificationAttributeName: ''
  }
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/rest/v1.1/classifier/svm');

req.query({
  accessKey: '',
  secretKey: '',
  name: '',
  collectionIds: '',
  classificationAttributeName: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/rest/v1.1/classifier/svm',
  params: {
    accessKey: '',
    secretKey: '',
    name: '',
    collectionIds: '',
    classificationAttributeName: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/rest/v1.1/classifier/svm?accessKey=&secretKey=&name=&collectionIds=&classificationAttributeName=';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/rest/v1.1/classifier/svm?accessKey=&secretKey=&name=&collectionIds=&classificationAttributeName="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/rest/v1.1/classifier/svm?accessKey=&secretKey=&name=&collectionIds=&classificationAttributeName=" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/rest/v1.1/classifier/svm?accessKey=&secretKey=&name=&collectionIds=&classificationAttributeName=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/rest/v1.1/classifier/svm?accessKey=&secretKey=&name=&collectionIds=&classificationAttributeName=');

echo $response->getBody();

setUrl('{{baseUrl}}/rest/v1.1/classifier/svm');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'accessKey' => '',
  'secretKey' => '',
  'name' => '',
  'collectionIds' => '',
  'classificationAttributeName' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/rest/v1.1/classifier/svm');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'accessKey' => '',
  'secretKey' => '',
  'name' => '',
  'collectionIds' => '',
  'classificationAttributeName' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/rest/v1.1/classifier/svm?accessKey=&secretKey=&name=&collectionIds=&classificationAttributeName=' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/rest/v1.1/classifier/svm?accessKey=&secretKey=&name=&collectionIds=&classificationAttributeName=' -Method POST

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/rest/v1.1/classifier/svm?accessKey=&secretKey=&name=&collectionIds=&classificationAttributeName=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/rest/v1.1/classifier/svm"

querystring = {"accessKey":"","secretKey":"","name":"","collectionIds":"","classificationAttributeName":""}

response = requests.post(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/rest/v1.1/classifier/svm"

queryString <- list(
  accessKey = "",
  secretKey = "",
  name = "",
  collectionIds = "",
  classificationAttributeName = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/rest/v1.1/classifier/svm?accessKey=&secretKey=&name=&collectionIds=&classificationAttributeName=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/rest/v1.1/classifier/svm') do |req|
  req.params['accessKey'] = ''
  req.params['secretKey'] = ''
  req.params['name'] = ''
  req.params['collectionIds'] = ''
  req.params['classificationAttributeName'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/rest/v1.1/classifier/svm";

    let querystring = [
        ("accessKey", ""),
        ("secretKey", ""),
        ("name", ""),
        ("collectionIds", ""),
        ("classificationAttributeName", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.post(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/rest/v1.1/classifier/svm?accessKey=&secretKey=&name=&collectionIds=&classificationAttributeName='

http POST '{{baseUrl}}/rest/v1.1/classifier/svm?accessKey=&secretKey=&name=&collectionIds=&classificationAttributeName='

wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/rest/v1.1/classifier/svm?accessKey=&secretKey=&name=&collectionIds=&classificationAttributeName='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/rest/v1.1/classifier/svm?accessKey=&secretKey=&name=&collectionIds=&classificationAttributeName=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

DELETE Delete existing classifier

{{baseUrl}}/rest/v1.1/classifier/svm

QUERY PARAMS

accessKey

secretKey

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/rest/v1.1/classifier/svm?accessKey=&secretKey=&id=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/rest/v1.1/classifier/svm" {:query-params {:accessKey ""
                                                                                      :secretKey ""
                                                                                      :id ""}})

require "http/client"

url = "{{baseUrl}}/rest/v1.1/classifier/svm?accessKey=&secretKey=&id="

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/rest/v1.1/classifier/svm?accessKey=&secretKey=&id="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/rest/v1.1/classifier/svm?accessKey=&secretKey=&id=");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/rest/v1.1/classifier/svm?accessKey=&secretKey=&id="

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/rest/v1.1/classifier/svm?accessKey=&secretKey=&id= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/rest/v1.1/classifier/svm?accessKey=&secretKey=&id=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/rest/v1.1/classifier/svm?accessKey=&secretKey=&id="))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/rest/v1.1/classifier/svm?accessKey=&secretKey=&id=")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/rest/v1.1/classifier/svm?accessKey=&secretKey=&id=")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

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

xhr.open('DELETE', '{{baseUrl}}/rest/v1.1/classifier/svm?accessKey=&secretKey=&id=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/rest/v1.1/classifier/svm',
  params: {accessKey: '', secretKey: '', id: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/rest/v1.1/classifier/svm?accessKey=&secretKey=&id=';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/rest/v1.1/classifier/svm?accessKey=&secretKey=&id=',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/rest/v1.1/classifier/svm?accessKey=&secretKey=&id=")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/rest/v1.1/classifier/svm?accessKey=&secretKey=&id=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/rest/v1.1/classifier/svm',
  qs: {accessKey: '', secretKey: '', id: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/rest/v1.1/classifier/svm');

req.query({
  accessKey: '',
  secretKey: '',
  id: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/rest/v1.1/classifier/svm',
  params: {accessKey: '', secretKey: '', id: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/rest/v1.1/classifier/svm?accessKey=&secretKey=&id=';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/rest/v1.1/classifier/svm?accessKey=&secretKey=&id="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/rest/v1.1/classifier/svm?accessKey=&secretKey=&id=" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/rest/v1.1/classifier/svm?accessKey=&secretKey=&id=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/rest/v1.1/classifier/svm?accessKey=&secretKey=&id=');

echo $response->getBody();

setUrl('{{baseUrl}}/rest/v1.1/classifier/svm');
$request->setMethod(HTTP_METH_DELETE);

$request->setQueryData([
  'accessKey' => '',
  'secretKey' => '',
  'id' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/rest/v1.1/classifier/svm');
$request->setRequestMethod('DELETE');
$request->setQuery(new http\QueryString([
  'accessKey' => '',
  'secretKey' => '',
  'id' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/rest/v1.1/classifier/svm?accessKey=&secretKey=&id=' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/rest/v1.1/classifier/svm?accessKey=&secretKey=&id=' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/rest/v1.1/classifier/svm?accessKey=&secretKey=&id=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/rest/v1.1/classifier/svm"

querystring = {"accessKey":"","secretKey":"","id":""}

response = requests.delete(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/rest/v1.1/classifier/svm"

queryString <- list(
  accessKey = "",
  secretKey = "",
  id = ""
)

response <- VERB("DELETE", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/rest/v1.1/classifier/svm?accessKey=&secretKey=&id=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/rest/v1.1/classifier/svm') do |req|
  req.params['accessKey'] = ''
  req.params['secretKey'] = ''
  req.params['id'] = ''
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/rest/v1.1/classifier/svm";

    let querystring = [
        ("accessKey", ""),
        ("secretKey", ""),
        ("id", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url '{{baseUrl}}/rest/v1.1/classifier/svm?accessKey=&secretKey=&id='

http DELETE '{{baseUrl}}/rest/v1.1/classifier/svm?accessKey=&secretKey=&id='

wget --quiet \
  --method DELETE \
  --output-document \
  - '{{baseUrl}}/rest/v1.1/classifier/svm?accessKey=&secretKey=&id='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/rest/v1.1/classifier/svm?accessKey=&secretKey=&id=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Get classifer status

{{baseUrl}}/rest/v1.1/classifier/svm/status

QUERY PARAMS

accessKey

secretKey

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/rest/v1.1/classifier/svm/status?accessKey=&secretKey=&id=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/rest/v1.1/classifier/svm/status" {:query-params {:accessKey ""
                                                                                          :secretKey ""
                                                                                          :id ""}})

require "http/client"

url = "{{baseUrl}}/rest/v1.1/classifier/svm/status?accessKey=&secretKey=&id="

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/rest/v1.1/classifier/svm/status?accessKey=&secretKey=&id="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/rest/v1.1/classifier/svm/status?accessKey=&secretKey=&id=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/rest/v1.1/classifier/svm/status?accessKey=&secretKey=&id="

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/rest/v1.1/classifier/svm/status?accessKey=&secretKey=&id= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/rest/v1.1/classifier/svm/status?accessKey=&secretKey=&id=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/rest/v1.1/classifier/svm/status?accessKey=&secretKey=&id="))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/rest/v1.1/classifier/svm/status?accessKey=&secretKey=&id=")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/rest/v1.1/classifier/svm/status?accessKey=&secretKey=&id=")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

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

xhr.open('GET', '{{baseUrl}}/rest/v1.1/classifier/svm/status?accessKey=&secretKey=&id=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/rest/v1.1/classifier/svm/status',
  params: {accessKey: '', secretKey: '', id: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/rest/v1.1/classifier/svm/status?accessKey=&secretKey=&id=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/rest/v1.1/classifier/svm/status?accessKey=&secretKey=&id=',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/rest/v1.1/classifier/svm/status?accessKey=&secretKey=&id=")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/rest/v1.1/classifier/svm/status?accessKey=&secretKey=&id=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/rest/v1.1/classifier/svm/status',
  qs: {accessKey: '', secretKey: '', id: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/rest/v1.1/classifier/svm/status');

req.query({
  accessKey: '',
  secretKey: '',
  id: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/rest/v1.1/classifier/svm/status',
  params: {accessKey: '', secretKey: '', id: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/rest/v1.1/classifier/svm/status?accessKey=&secretKey=&id=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/rest/v1.1/classifier/svm/status?accessKey=&secretKey=&id="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/rest/v1.1/classifier/svm/status?accessKey=&secretKey=&id=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/rest/v1.1/classifier/svm/status?accessKey=&secretKey=&id=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/rest/v1.1/classifier/svm/status?accessKey=&secretKey=&id=');

echo $response->getBody();

setUrl('{{baseUrl}}/rest/v1.1/classifier/svm/status');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'accessKey' => '',
  'secretKey' => '',
  'id' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/rest/v1.1/classifier/svm/status');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'accessKey' => '',
  'secretKey' => '',
  'id' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/rest/v1.1/classifier/svm/status?accessKey=&secretKey=&id=' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/rest/v1.1/classifier/svm/status?accessKey=&secretKey=&id=' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/rest/v1.1/classifier/svm/status?accessKey=&secretKey=&id=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/rest/v1.1/classifier/svm/status"

querystring = {"accessKey":"","secretKey":"","id":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/rest/v1.1/classifier/svm/status"

queryString <- list(
  accessKey = "",
  secretKey = "",
  id = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/rest/v1.1/classifier/svm/status?accessKey=&secretKey=&id=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/rest/v1.1/classifier/svm/status') do |req|
  req.params['accessKey'] = ''
  req.params['secretKey'] = ''
  req.params['id'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/rest/v1.1/classifier/svm/status";

    let querystring = [
        ("accessKey", ""),
        ("secretKey", ""),
        ("id", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/rest/v1.1/classifier/svm/status?accessKey=&secretKey=&id='

http GET '{{baseUrl}}/rest/v1.1/classifier/svm/status?accessKey=&secretKey=&id='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/rest/v1.1/classifier/svm/status?accessKey=&secretKey=&id='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/rest/v1.1/classifier/svm/status?accessKey=&secretKey=&id=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Get classifier full

{{baseUrl}}/rest/v1.1/classifier/svm

QUERY PARAMS

accessKey

secretKey

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/rest/v1.1/classifier/svm?accessKey=&secretKey=&id=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/rest/v1.1/classifier/svm" {:query-params {:accessKey ""
                                                                                   :secretKey ""
                                                                                   :id ""}})

require "http/client"

url = "{{baseUrl}}/rest/v1.1/classifier/svm?accessKey=&secretKey=&id="

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/rest/v1.1/classifier/svm?accessKey=&secretKey=&id="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/rest/v1.1/classifier/svm?accessKey=&secretKey=&id=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/rest/v1.1/classifier/svm?accessKey=&secretKey=&id="

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/rest/v1.1/classifier/svm?accessKey=&secretKey=&id= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/rest/v1.1/classifier/svm?accessKey=&secretKey=&id=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/rest/v1.1/classifier/svm?accessKey=&secretKey=&id="))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/rest/v1.1/classifier/svm?accessKey=&secretKey=&id=")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/rest/v1.1/classifier/svm?accessKey=&secretKey=&id=")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

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

xhr.open('GET', '{{baseUrl}}/rest/v1.1/classifier/svm?accessKey=&secretKey=&id=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/rest/v1.1/classifier/svm',
  params: {accessKey: '', secretKey: '', id: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/rest/v1.1/classifier/svm?accessKey=&secretKey=&id=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/rest/v1.1/classifier/svm?accessKey=&secretKey=&id=',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/rest/v1.1/classifier/svm?accessKey=&secretKey=&id=")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/rest/v1.1/classifier/svm?accessKey=&secretKey=&id=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/rest/v1.1/classifier/svm',
  qs: {accessKey: '', secretKey: '', id: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/rest/v1.1/classifier/svm');

req.query({
  accessKey: '',
  secretKey: '',
  id: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/rest/v1.1/classifier/svm',
  params: {accessKey: '', secretKey: '', id: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/rest/v1.1/classifier/svm?accessKey=&secretKey=&id=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/rest/v1.1/classifier/svm?accessKey=&secretKey=&id="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/rest/v1.1/classifier/svm?accessKey=&secretKey=&id=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/rest/v1.1/classifier/svm?accessKey=&secretKey=&id=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/rest/v1.1/classifier/svm?accessKey=&secretKey=&id=');

echo $response->getBody();

setUrl('{{baseUrl}}/rest/v1.1/classifier/svm');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'accessKey' => '',
  'secretKey' => '',
  'id' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/rest/v1.1/classifier/svm');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'accessKey' => '',
  'secretKey' => '',
  'id' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/rest/v1.1/classifier/svm?accessKey=&secretKey=&id=' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/rest/v1.1/classifier/svm?accessKey=&secretKey=&id=' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/rest/v1.1/classifier/svm?accessKey=&secretKey=&id=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/rest/v1.1/classifier/svm"

querystring = {"accessKey":"","secretKey":"","id":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/rest/v1.1/classifier/svm"

queryString <- list(
  accessKey = "",
  secretKey = "",
  id = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/rest/v1.1/classifier/svm?accessKey=&secretKey=&id=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/rest/v1.1/classifier/svm') do |req|
  req.params['accessKey'] = ''
  req.params['secretKey'] = ''
  req.params['id'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/rest/v1.1/classifier/svm";

    let querystring = [
        ("accessKey", ""),
        ("secretKey", ""),
        ("id", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/rest/v1.1/classifier/svm?accessKey=&secretKey=&id='

http GET '{{baseUrl}}/rest/v1.1/classifier/svm?accessKey=&secretKey=&id='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/rest/v1.1/classifier/svm?accessKey=&secretKey=&id='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/rest/v1.1/classifier/svm?accessKey=&secretKey=&id=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

PUT Change purpose of existing collection

{{baseUrl}}/rest/v1.1/collection/purpose

QUERY PARAMS

accessKey

secretKey

collectionId

purposes

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/rest/v1.1/collection/purpose?accessKey=&secretKey=&collectionId=&purposes=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/rest/v1.1/collection/purpose" {:query-params {:accessKey ""
                                                                                       :secretKey ""
                                                                                       :collectionId ""
                                                                                       :purposes ""}})

require "http/client"

url = "{{baseUrl}}/rest/v1.1/collection/purpose?accessKey=&secretKey=&collectionId=&purposes="

response = HTTP::Client.put url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/rest/v1.1/collection/purpose?accessKey=&secretKey=&collectionId=&purposes="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/rest/v1.1/collection/purpose?accessKey=&secretKey=&collectionId=&purposes=");
var request = new RestRequest("", Method.Put);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/rest/v1.1/collection/purpose?accessKey=&secretKey=&collectionId=&purposes="

	req, _ := http.NewRequest("PUT", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

PUT /baseUrl/rest/v1.1/collection/purpose?accessKey=&secretKey=&collectionId=&purposes= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/rest/v1.1/collection/purpose?accessKey=&secretKey=&collectionId=&purposes=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/rest/v1.1/collection/purpose?accessKey=&secretKey=&collectionId=&purposes="))
    .method("PUT", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/rest/v1.1/collection/purpose?accessKey=&secretKey=&collectionId=&purposes=")
  .put(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/rest/v1.1/collection/purpose?accessKey=&secretKey=&collectionId=&purposes=")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

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

xhr.open('PUT', '{{baseUrl}}/rest/v1.1/collection/purpose?accessKey=&secretKey=&collectionId=&purposes=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/rest/v1.1/collection/purpose',
  params: {accessKey: '', secretKey: '', collectionId: '', purposes: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/rest/v1.1/collection/purpose?accessKey=&secretKey=&collectionId=&purposes=';
const options = {method: 'PUT'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/rest/v1.1/collection/purpose?accessKey=&secretKey=&collectionId=&purposes=',
  method: 'PUT',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/rest/v1.1/collection/purpose?accessKey=&secretKey=&collectionId=&purposes=")
  .put(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/rest/v1.1/collection/purpose?accessKey=&secretKey=&collectionId=&purposes=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/rest/v1.1/collection/purpose',
  qs: {accessKey: '', secretKey: '', collectionId: '', purposes: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/rest/v1.1/collection/purpose');

req.query({
  accessKey: '',
  secretKey: '',
  collectionId: '',
  purposes: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/rest/v1.1/collection/purpose',
  params: {accessKey: '', secretKey: '', collectionId: '', purposes: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/rest/v1.1/collection/purpose?accessKey=&secretKey=&collectionId=&purposes=';
const options = {method: 'PUT'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/rest/v1.1/collection/purpose?accessKey=&secretKey=&collectionId=&purposes="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/rest/v1.1/collection/purpose?accessKey=&secretKey=&collectionId=&purposes=" in

Client.call `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/rest/v1.1/collection/purpose?accessKey=&secretKey=&collectionId=&purposes=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/rest/v1.1/collection/purpose?accessKey=&secretKey=&collectionId=&purposes=');

echo $response->getBody();

setUrl('{{baseUrl}}/rest/v1.1/collection/purpose');
$request->setMethod(HTTP_METH_PUT);

$request->setQueryData([
  'accessKey' => '',
  'secretKey' => '',
  'collectionId' => '',
  'purposes' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/rest/v1.1/collection/purpose');
$request->setRequestMethod('PUT');
$request->setQuery(new http\QueryString([
  'accessKey' => '',
  'secretKey' => '',
  'collectionId' => '',
  'purposes' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/rest/v1.1/collection/purpose?accessKey=&secretKey=&collectionId=&purposes=' -Method PUT

$response = Invoke-RestMethod -Uri '{{baseUrl}}/rest/v1.1/collection/purpose?accessKey=&secretKey=&collectionId=&purposes=' -Method PUT

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("PUT", "/baseUrl/rest/v1.1/collection/purpose?accessKey=&secretKey=&collectionId=&purposes=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/rest/v1.1/collection/purpose"

querystring = {"accessKey":"","secretKey":"","collectionId":"","purposes":""}

response = requests.put(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/rest/v1.1/collection/purpose"

queryString <- list(
  accessKey = "",
  secretKey = "",
  collectionId = "",
  purposes = ""
)

response <- VERB("PUT", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/rest/v1.1/collection/purpose?accessKey=&secretKey=&collectionId=&purposes=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.put('/baseUrl/rest/v1.1/collection/purpose') do |req|
  req.params['accessKey'] = ''
  req.params['secretKey'] = ''
  req.params['collectionId'] = ''
  req.params['purposes'] = ''
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/rest/v1.1/collection/purpose";

    let querystring = [
        ("accessKey", ""),
        ("secretKey", ""),
        ("collectionId", ""),
        ("purposes", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PUT \
  --url '{{baseUrl}}/rest/v1.1/collection/purpose?accessKey=&secretKey=&collectionId=&purposes='

http PUT '{{baseUrl}}/rest/v1.1/collection/purpose?accessKey=&secretKey=&collectionId=&purposes='

wget --quiet \
  --method PUT \
  --output-document \
  - '{{baseUrl}}/rest/v1.1/collection/purpose?accessKey=&secretKey=&collectionId=&purposes='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/rest/v1.1/collection/purpose?accessKey=&secretKey=&collectionId=&purposes=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST Create new empty collection with given name (POST)

{{baseUrl}}/rest/v1.1/collection/collection

QUERY PARAMS

accessKey

secretKey

collectionName

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/rest/v1.1/collection/collection?accessKey=&secretKey=&collectionName=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/rest/v1.1/collection/collection" {:query-params {:accessKey ""
                                                                                           :secretKey ""
                                                                                           :collectionName ""}})

require "http/client"

url = "{{baseUrl}}/rest/v1.1/collection/collection?accessKey=&secretKey=&collectionName="

response = HTTP::Client.post url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/rest/v1.1/collection/collection?accessKey=&secretKey=&collectionName="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/rest/v1.1/collection/collection?accessKey=&secretKey=&collectionName=");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/rest/v1.1/collection/collection?accessKey=&secretKey=&collectionName="

	req, _ := http.NewRequest("POST", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/rest/v1.1/collection/collection?accessKey=&secretKey=&collectionName= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/rest/v1.1/collection/collection?accessKey=&secretKey=&collectionName=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/rest/v1.1/collection/collection?accessKey=&secretKey=&collectionName="))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/rest/v1.1/collection/collection?accessKey=&secretKey=&collectionName=")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/rest/v1.1/collection/collection?accessKey=&secretKey=&collectionName=")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

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

xhr.open('POST', '{{baseUrl}}/rest/v1.1/collection/collection?accessKey=&secretKey=&collectionName=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/rest/v1.1/collection/collection',
  params: {accessKey: '', secretKey: '', collectionName: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/rest/v1.1/collection/collection?accessKey=&secretKey=&collectionName=';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/rest/v1.1/collection/collection?accessKey=&secretKey=&collectionName=',
  method: 'POST',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/rest/v1.1/collection/collection?accessKey=&secretKey=&collectionName=")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/rest/v1.1/collection/collection?accessKey=&secretKey=&collectionName=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/rest/v1.1/collection/collection',
  qs: {accessKey: '', secretKey: '', collectionName: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/rest/v1.1/collection/collection');

req.query({
  accessKey: '',
  secretKey: '',
  collectionName: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/rest/v1.1/collection/collection',
  params: {accessKey: '', secretKey: '', collectionName: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/rest/v1.1/collection/collection?accessKey=&secretKey=&collectionName=';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/rest/v1.1/collection/collection?accessKey=&secretKey=&collectionName="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/rest/v1.1/collection/collection?accessKey=&secretKey=&collectionName=" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/rest/v1.1/collection/collection?accessKey=&secretKey=&collectionName=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/rest/v1.1/collection/collection?accessKey=&secretKey=&collectionName=');

echo $response->getBody();

setUrl('{{baseUrl}}/rest/v1.1/collection/collection');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'accessKey' => '',
  'secretKey' => '',
  'collectionName' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/rest/v1.1/collection/collection');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'accessKey' => '',
  'secretKey' => '',
  'collectionName' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/rest/v1.1/collection/collection?accessKey=&secretKey=&collectionName=' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/rest/v1.1/collection/collection?accessKey=&secretKey=&collectionName=' -Method POST

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/rest/v1.1/collection/collection?accessKey=&secretKey=&collectionName=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/rest/v1.1/collection/collection"

querystring = {"accessKey":"","secretKey":"","collectionName":""}

response = requests.post(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/rest/v1.1/collection/collection"

queryString <- list(
  accessKey = "",
  secretKey = "",
  collectionName = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/rest/v1.1/collection/collection?accessKey=&secretKey=&collectionName=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/rest/v1.1/collection/collection') do |req|
  req.params['accessKey'] = ''
  req.params['secretKey'] = ''
  req.params['collectionName'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/rest/v1.1/collection/collection";

    let querystring = [
        ("accessKey", ""),
        ("secretKey", ""),
        ("collectionName", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.post(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/rest/v1.1/collection/collection?accessKey=&secretKey=&collectionName='

http POST '{{baseUrl}}/rest/v1.1/collection/collection?accessKey=&secretKey=&collectionName='

wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/rest/v1.1/collection/collection?accessKey=&secretKey=&collectionName='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/rest/v1.1/collection/collection?accessKey=&secretKey=&collectionName=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST Create new empty collection with given name

{{baseUrl}}/rest/v1.1/collection/

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/rest/v1.1/collection/");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/rest/v1.1/collection/")

require "http/client"

url = "{{baseUrl}}/rest/v1.1/collection/"

response = HTTP::Client.post url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/rest/v1.1/collection/"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/rest/v1.1/collection/");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/rest/v1.1/collection/"

	req, _ := http.NewRequest("POST", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/rest/v1.1/collection/ HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/rest/v1.1/collection/")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/rest/v1.1/collection/"))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/rest/v1.1/collection/")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/rest/v1.1/collection/")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

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

xhr.open('POST', '{{baseUrl}}/rest/v1.1/collection/');

xhr.send(data);

import axios from 'axios';

const options = {method: 'POST', url: '{{baseUrl}}/rest/v1.1/collection/'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/rest/v1.1/collection/';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/rest/v1.1/collection/',
  method: 'POST',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/rest/v1.1/collection/")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/rest/v1.1/collection/',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'POST', url: '{{baseUrl}}/rest/v1.1/collection/'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/rest/v1.1/collection/');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'POST', url: '{{baseUrl}}/rest/v1.1/collection/'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/rest/v1.1/collection/';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/rest/v1.1/collection/"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/rest/v1.1/collection/" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/rest/v1.1/collection/",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/rest/v1.1/collection/');

echo $response->getBody();

setUrl('{{baseUrl}}/rest/v1.1/collection/');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/rest/v1.1/collection/');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/rest/v1.1/collection/' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/rest/v1.1/collection/' -Method POST

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/rest/v1.1/collection/")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/rest/v1.1/collection/"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/rest/v1.1/collection/"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/rest/v1.1/collection/")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/rest/v1.1/collection/') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/rest/v1.1/collection/";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/rest/v1.1/collection/

http POST {{baseUrl}}/rest/v1.1/collection/

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/rest/v1.1/collection/

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/rest/v1.1/collection/")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

DELETE Delete existing collection with associated profiles and faces. (DELETE)

{{baseUrl}}/rest/v1.1/collection/:id

QUERY PARAMS

accessKey

secretKey

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/rest/v1.1/collection/:id?accessKey=&secretKey=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/rest/v1.1/collection/:id" {:query-params {:accessKey ""
                                                                                      :secretKey ""}})

require "http/client"

url = "{{baseUrl}}/rest/v1.1/collection/:id?accessKey=&secretKey="

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/rest/v1.1/collection/:id?accessKey=&secretKey="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/rest/v1.1/collection/:id?accessKey=&secretKey=");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/rest/v1.1/collection/:id?accessKey=&secretKey="

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/rest/v1.1/collection/:id?accessKey=&secretKey= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/rest/v1.1/collection/:id?accessKey=&secretKey=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/rest/v1.1/collection/:id?accessKey=&secretKey="))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/rest/v1.1/collection/:id?accessKey=&secretKey=")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/rest/v1.1/collection/:id?accessKey=&secretKey=")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

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

xhr.open('DELETE', '{{baseUrl}}/rest/v1.1/collection/:id?accessKey=&secretKey=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/rest/v1.1/collection/:id',
  params: {accessKey: '', secretKey: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/rest/v1.1/collection/:id?accessKey=&secretKey=';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/rest/v1.1/collection/:id?accessKey=&secretKey=',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/rest/v1.1/collection/:id?accessKey=&secretKey=")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/rest/v1.1/collection/:id?accessKey=&secretKey=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/rest/v1.1/collection/:id',
  qs: {accessKey: '', secretKey: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/rest/v1.1/collection/:id');

req.query({
  accessKey: '',
  secretKey: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/rest/v1.1/collection/:id',
  params: {accessKey: '', secretKey: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/rest/v1.1/collection/:id?accessKey=&secretKey=';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/rest/v1.1/collection/:id?accessKey=&secretKey="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/rest/v1.1/collection/:id?accessKey=&secretKey=" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/rest/v1.1/collection/:id?accessKey=&secretKey=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/rest/v1.1/collection/:id?accessKey=&secretKey=');

echo $response->getBody();

setUrl('{{baseUrl}}/rest/v1.1/collection/:id');
$request->setMethod(HTTP_METH_DELETE);

$request->setQueryData([
  'accessKey' => '',
  'secretKey' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/rest/v1.1/collection/:id');
$request->setRequestMethod('DELETE');
$request->setQuery(new http\QueryString([
  'accessKey' => '',
  'secretKey' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/rest/v1.1/collection/:id?accessKey=&secretKey=' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/rest/v1.1/collection/:id?accessKey=&secretKey=' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/rest/v1.1/collection/:id?accessKey=&secretKey=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/rest/v1.1/collection/:id"

querystring = {"accessKey":"","secretKey":""}

response = requests.delete(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/rest/v1.1/collection/:id"

queryString <- list(
  accessKey = "",
  secretKey = ""
)

response <- VERB("DELETE", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/rest/v1.1/collection/:id?accessKey=&secretKey=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/rest/v1.1/collection/:id') do |req|
  req.params['accessKey'] = ''
  req.params['secretKey'] = ''
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/rest/v1.1/collection/:id";

    let querystring = [
        ("accessKey", ""),
        ("secretKey", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url '{{baseUrl}}/rest/v1.1/collection/:id?accessKey=&secretKey='

http DELETE '{{baseUrl}}/rest/v1.1/collection/:id?accessKey=&secretKey='

wget --quiet \
  --method DELETE \
  --output-document \
  - '{{baseUrl}}/rest/v1.1/collection/:id?accessKey=&secretKey='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/rest/v1.1/collection/:id?accessKey=&secretKey=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

DELETE Delete existing collection with associated profiles and faces.

{{baseUrl}}/rest/v1.1/collection/collection

QUERY PARAMS

accessKey

secretKey

collectionId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/rest/v1.1/collection/collection?accessKey=&secretKey=&collectionId=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/rest/v1.1/collection/collection" {:query-params {:accessKey ""
                                                                                             :secretKey ""
                                                                                             :collectionId ""}})

require "http/client"

url = "{{baseUrl}}/rest/v1.1/collection/collection?accessKey=&secretKey=&collectionId="

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/rest/v1.1/collection/collection?accessKey=&secretKey=&collectionId="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/rest/v1.1/collection/collection?accessKey=&secretKey=&collectionId=");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/rest/v1.1/collection/collection?accessKey=&secretKey=&collectionId="

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/rest/v1.1/collection/collection?accessKey=&secretKey=&collectionId= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/rest/v1.1/collection/collection?accessKey=&secretKey=&collectionId=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/rest/v1.1/collection/collection?accessKey=&secretKey=&collectionId="))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/rest/v1.1/collection/collection?accessKey=&secretKey=&collectionId=")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/rest/v1.1/collection/collection?accessKey=&secretKey=&collectionId=")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

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

xhr.open('DELETE', '{{baseUrl}}/rest/v1.1/collection/collection?accessKey=&secretKey=&collectionId=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/rest/v1.1/collection/collection',
  params: {accessKey: '', secretKey: '', collectionId: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/rest/v1.1/collection/collection?accessKey=&secretKey=&collectionId=';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/rest/v1.1/collection/collection?accessKey=&secretKey=&collectionId=',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/rest/v1.1/collection/collection?accessKey=&secretKey=&collectionId=")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/rest/v1.1/collection/collection?accessKey=&secretKey=&collectionId=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/rest/v1.1/collection/collection',
  qs: {accessKey: '', secretKey: '', collectionId: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/rest/v1.1/collection/collection');

req.query({
  accessKey: '',
  secretKey: '',
  collectionId: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/rest/v1.1/collection/collection',
  params: {accessKey: '', secretKey: '', collectionId: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/rest/v1.1/collection/collection?accessKey=&secretKey=&collectionId=';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/rest/v1.1/collection/collection?accessKey=&secretKey=&collectionId="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/rest/v1.1/collection/collection?accessKey=&secretKey=&collectionId=" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/rest/v1.1/collection/collection?accessKey=&secretKey=&collectionId=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/rest/v1.1/collection/collection?accessKey=&secretKey=&collectionId=');

echo $response->getBody();

setUrl('{{baseUrl}}/rest/v1.1/collection/collection');
$request->setMethod(HTTP_METH_DELETE);

$request->setQueryData([
  'accessKey' => '',
  'secretKey' => '',
  'collectionId' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/rest/v1.1/collection/collection');
$request->setRequestMethod('DELETE');
$request->setQuery(new http\QueryString([
  'accessKey' => '',
  'secretKey' => '',
  'collectionId' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/rest/v1.1/collection/collection?accessKey=&secretKey=&collectionId=' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/rest/v1.1/collection/collection?accessKey=&secretKey=&collectionId=' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/rest/v1.1/collection/collection?accessKey=&secretKey=&collectionId=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/rest/v1.1/collection/collection"

querystring = {"accessKey":"","secretKey":"","collectionId":""}

response = requests.delete(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/rest/v1.1/collection/collection"

queryString <- list(
  accessKey = "",
  secretKey = "",
  collectionId = ""
)

response <- VERB("DELETE", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/rest/v1.1/collection/collection?accessKey=&secretKey=&collectionId=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/rest/v1.1/collection/collection') do |req|
  req.params['accessKey'] = ''
  req.params['secretKey'] = ''
  req.params['collectionId'] = ''
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/rest/v1.1/collection/collection";

    let querystring = [
        ("accessKey", ""),
        ("secretKey", ""),
        ("collectionId", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url '{{baseUrl}}/rest/v1.1/collection/collection?accessKey=&secretKey=&collectionId='

http DELETE '{{baseUrl}}/rest/v1.1/collection/collection?accessKey=&secretKey=&collectionId='

wget --quiet \
  --method DELETE \
  --output-document \
  - '{{baseUrl}}/rest/v1.1/collection/collection?accessKey=&secretKey=&collectionId='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/rest/v1.1/collection/collection?accessKey=&secretKey=&collectionId=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Gets all the profiles associated to a collection

{{baseUrl}}/rest/v1.1/collection/:id/profile

QUERY PARAMS

accessKey

secretKey

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/rest/v1.1/collection/:id/profile?accessKey=&secretKey=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/rest/v1.1/collection/:id/profile" {:query-params {:accessKey ""
                                                                                           :secretKey ""}})

require "http/client"

url = "{{baseUrl}}/rest/v1.1/collection/:id/profile?accessKey=&secretKey="

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/rest/v1.1/collection/:id/profile?accessKey=&secretKey="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/rest/v1.1/collection/:id/profile?accessKey=&secretKey=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/rest/v1.1/collection/:id/profile?accessKey=&secretKey="

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/rest/v1.1/collection/:id/profile?accessKey=&secretKey= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/rest/v1.1/collection/:id/profile?accessKey=&secretKey=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/rest/v1.1/collection/:id/profile?accessKey=&secretKey="))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/rest/v1.1/collection/:id/profile?accessKey=&secretKey=")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/rest/v1.1/collection/:id/profile?accessKey=&secretKey=")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

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

xhr.open('GET', '{{baseUrl}}/rest/v1.1/collection/:id/profile?accessKey=&secretKey=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/rest/v1.1/collection/:id/profile',
  params: {accessKey: '', secretKey: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/rest/v1.1/collection/:id/profile?accessKey=&secretKey=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/rest/v1.1/collection/:id/profile?accessKey=&secretKey=',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/rest/v1.1/collection/:id/profile?accessKey=&secretKey=")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/rest/v1.1/collection/:id/profile?accessKey=&secretKey=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/rest/v1.1/collection/:id/profile',
  qs: {accessKey: '', secretKey: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/rest/v1.1/collection/:id/profile');

req.query({
  accessKey: '',
  secretKey: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/rest/v1.1/collection/:id/profile',
  params: {accessKey: '', secretKey: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/rest/v1.1/collection/:id/profile?accessKey=&secretKey=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/rest/v1.1/collection/:id/profile?accessKey=&secretKey="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/rest/v1.1/collection/:id/profile?accessKey=&secretKey=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/rest/v1.1/collection/:id/profile?accessKey=&secretKey=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/rest/v1.1/collection/:id/profile?accessKey=&secretKey=');

echo $response->getBody();

setUrl('{{baseUrl}}/rest/v1.1/collection/:id/profile');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'accessKey' => '',
  'secretKey' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/rest/v1.1/collection/:id/profile');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'accessKey' => '',
  'secretKey' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/rest/v1.1/collection/:id/profile?accessKey=&secretKey=' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/rest/v1.1/collection/:id/profile?accessKey=&secretKey=' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/rest/v1.1/collection/:id/profile?accessKey=&secretKey=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/rest/v1.1/collection/:id/profile"

querystring = {"accessKey":"","secretKey":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/rest/v1.1/collection/:id/profile"

queryString <- list(
  accessKey = "",
  secretKey = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/rest/v1.1/collection/:id/profile?accessKey=&secretKey=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/rest/v1.1/collection/:id/profile') do |req|
  req.params['accessKey'] = ''
  req.params['secretKey'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/rest/v1.1/collection/:id/profile";

    let querystring = [
        ("accessKey", ""),
        ("secretKey", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/rest/v1.1/collection/:id/profile?accessKey=&secretKey='

http GET '{{baseUrl}}/rest/v1.1/collection/:id/profile?accessKey=&secretKey='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/rest/v1.1/collection/:id/profile?accessKey=&secretKey='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/rest/v1.1/collection/:id/profile?accessKey=&secretKey=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Retrieve all collections (GET)

{{baseUrl}}/rest/v1.1/collection/all

QUERY PARAMS

accessKey

secretKey

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/rest/v1.1/collection/all?accessKey=&secretKey=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/rest/v1.1/collection/all" {:query-params {:accessKey ""
                                                                                   :secretKey ""}})

require "http/client"

url = "{{baseUrl}}/rest/v1.1/collection/all?accessKey=&secretKey="

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/rest/v1.1/collection/all?accessKey=&secretKey="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/rest/v1.1/collection/all?accessKey=&secretKey=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/rest/v1.1/collection/all?accessKey=&secretKey="

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/rest/v1.1/collection/all?accessKey=&secretKey= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/rest/v1.1/collection/all?accessKey=&secretKey=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/rest/v1.1/collection/all?accessKey=&secretKey="))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/rest/v1.1/collection/all?accessKey=&secretKey=")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/rest/v1.1/collection/all?accessKey=&secretKey=")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

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

xhr.open('GET', '{{baseUrl}}/rest/v1.1/collection/all?accessKey=&secretKey=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/rest/v1.1/collection/all',
  params: {accessKey: '', secretKey: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/rest/v1.1/collection/all?accessKey=&secretKey=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/rest/v1.1/collection/all?accessKey=&secretKey=',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/rest/v1.1/collection/all?accessKey=&secretKey=")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/rest/v1.1/collection/all?accessKey=&secretKey=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/rest/v1.1/collection/all',
  qs: {accessKey: '', secretKey: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/rest/v1.1/collection/all');

req.query({
  accessKey: '',
  secretKey: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/rest/v1.1/collection/all',
  params: {accessKey: '', secretKey: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/rest/v1.1/collection/all?accessKey=&secretKey=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/rest/v1.1/collection/all?accessKey=&secretKey="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/rest/v1.1/collection/all?accessKey=&secretKey=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/rest/v1.1/collection/all?accessKey=&secretKey=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/rest/v1.1/collection/all?accessKey=&secretKey=');

echo $response->getBody();

setUrl('{{baseUrl}}/rest/v1.1/collection/all');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'accessKey' => '',
  'secretKey' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/rest/v1.1/collection/all');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'accessKey' => '',
  'secretKey' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/rest/v1.1/collection/all?accessKey=&secretKey=' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/rest/v1.1/collection/all?accessKey=&secretKey=' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/rest/v1.1/collection/all?accessKey=&secretKey=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/rest/v1.1/collection/all"

querystring = {"accessKey":"","secretKey":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/rest/v1.1/collection/all"

queryString <- list(
  accessKey = "",
  secretKey = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/rest/v1.1/collection/all?accessKey=&secretKey=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/rest/v1.1/collection/all') do |req|
  req.params['accessKey'] = ''
  req.params['secretKey'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/rest/v1.1/collection/all";

    let querystring = [
        ("accessKey", ""),
        ("secretKey", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/rest/v1.1/collection/all?accessKey=&secretKey='

http GET '{{baseUrl}}/rest/v1.1/collection/all?accessKey=&secretKey='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/rest/v1.1/collection/all?accessKey=&secretKey='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/rest/v1.1/collection/all?accessKey=&secretKey=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Retrieve all collections

{{baseUrl}}/rest/v1.1/collection/

QUERY PARAMS

accessKey

secretKey

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/rest/v1.1/collection/?accessKey=&secretKey=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/rest/v1.1/collection/" {:query-params {:accessKey ""
                                                                                :secretKey ""}})

require "http/client"

url = "{{baseUrl}}/rest/v1.1/collection/?accessKey=&secretKey="

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/rest/v1.1/collection/?accessKey=&secretKey="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/rest/v1.1/collection/?accessKey=&secretKey=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/rest/v1.1/collection/?accessKey=&secretKey="

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/rest/v1.1/collection/?accessKey=&secretKey= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/rest/v1.1/collection/?accessKey=&secretKey=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/rest/v1.1/collection/?accessKey=&secretKey="))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/rest/v1.1/collection/?accessKey=&secretKey=")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/rest/v1.1/collection/?accessKey=&secretKey=")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

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

xhr.open('GET', '{{baseUrl}}/rest/v1.1/collection/?accessKey=&secretKey=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/rest/v1.1/collection/',
  params: {accessKey: '', secretKey: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/rest/v1.1/collection/?accessKey=&secretKey=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/rest/v1.1/collection/?accessKey=&secretKey=',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/rest/v1.1/collection/?accessKey=&secretKey=")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/rest/v1.1/collection/?accessKey=&secretKey=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/rest/v1.1/collection/',
  qs: {accessKey: '', secretKey: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/rest/v1.1/collection/');

req.query({
  accessKey: '',
  secretKey: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/rest/v1.1/collection/',
  params: {accessKey: '', secretKey: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/rest/v1.1/collection/?accessKey=&secretKey=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/rest/v1.1/collection/?accessKey=&secretKey="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/rest/v1.1/collection/?accessKey=&secretKey=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/rest/v1.1/collection/?accessKey=&secretKey=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/rest/v1.1/collection/?accessKey=&secretKey=');

echo $response->getBody();

setUrl('{{baseUrl}}/rest/v1.1/collection/');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'accessKey' => '',
  'secretKey' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/rest/v1.1/collection/');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'accessKey' => '',
  'secretKey' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/rest/v1.1/collection/?accessKey=&secretKey=' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/rest/v1.1/collection/?accessKey=&secretKey=' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/rest/v1.1/collection/?accessKey=&secretKey=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/rest/v1.1/collection/"

querystring = {"accessKey":"","secretKey":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/rest/v1.1/collection/"

queryString <- list(
  accessKey = "",
  secretKey = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/rest/v1.1/collection/?accessKey=&secretKey=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/rest/v1.1/collection/') do |req|
  req.params['accessKey'] = ''
  req.params['secretKey'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/rest/v1.1/collection/";

    let querystring = [
        ("accessKey", ""),
        ("secretKey", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/rest/v1.1/collection/?accessKey=&secretKey='

http GET '{{baseUrl}}/rest/v1.1/collection/?accessKey=&secretKey='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/rest/v1.1/collection/?accessKey=&secretKey='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/rest/v1.1/collection/?accessKey=&secretKey=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Retrieve collection content for data analysis.

{{baseUrl}}/rest/v1.1/collection/export/csv

QUERY PARAMS

accessKey

secretKey

collectionId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/rest/v1.1/collection/export/csv?accessKey=&secretKey=&collectionId=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/rest/v1.1/collection/export/csv" {:query-params {:accessKey ""
                                                                                          :secretKey ""
                                                                                          :collectionId ""}})

require "http/client"

url = "{{baseUrl}}/rest/v1.1/collection/export/csv?accessKey=&secretKey=&collectionId="

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/rest/v1.1/collection/export/csv?accessKey=&secretKey=&collectionId="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/rest/v1.1/collection/export/csv?accessKey=&secretKey=&collectionId=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/rest/v1.1/collection/export/csv?accessKey=&secretKey=&collectionId="

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/rest/v1.1/collection/export/csv?accessKey=&secretKey=&collectionId= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/rest/v1.1/collection/export/csv?accessKey=&secretKey=&collectionId=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/rest/v1.1/collection/export/csv?accessKey=&secretKey=&collectionId="))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/rest/v1.1/collection/export/csv?accessKey=&secretKey=&collectionId=")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/rest/v1.1/collection/export/csv?accessKey=&secretKey=&collectionId=")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

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

xhr.open('GET', '{{baseUrl}}/rest/v1.1/collection/export/csv?accessKey=&secretKey=&collectionId=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/rest/v1.1/collection/export/csv',
  params: {accessKey: '', secretKey: '', collectionId: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/rest/v1.1/collection/export/csv?accessKey=&secretKey=&collectionId=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/rest/v1.1/collection/export/csv?accessKey=&secretKey=&collectionId=',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/rest/v1.1/collection/export/csv?accessKey=&secretKey=&collectionId=")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/rest/v1.1/collection/export/csv?accessKey=&secretKey=&collectionId=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/rest/v1.1/collection/export/csv',
  qs: {accessKey: '', secretKey: '', collectionId: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/rest/v1.1/collection/export/csv');

req.query({
  accessKey: '',
  secretKey: '',
  collectionId: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/rest/v1.1/collection/export/csv',
  params: {accessKey: '', secretKey: '', collectionId: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/rest/v1.1/collection/export/csv?accessKey=&secretKey=&collectionId=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/rest/v1.1/collection/export/csv?accessKey=&secretKey=&collectionId="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/rest/v1.1/collection/export/csv?accessKey=&secretKey=&collectionId=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/rest/v1.1/collection/export/csv?accessKey=&secretKey=&collectionId=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/rest/v1.1/collection/export/csv?accessKey=&secretKey=&collectionId=');

echo $response->getBody();

setUrl('{{baseUrl}}/rest/v1.1/collection/export/csv');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'accessKey' => '',
  'secretKey' => '',
  'collectionId' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/rest/v1.1/collection/export/csv');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'accessKey' => '',
  'secretKey' => '',
  'collectionId' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/rest/v1.1/collection/export/csv?accessKey=&secretKey=&collectionId=' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/rest/v1.1/collection/export/csv?accessKey=&secretKey=&collectionId=' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/rest/v1.1/collection/export/csv?accessKey=&secretKey=&collectionId=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/rest/v1.1/collection/export/csv"

querystring = {"accessKey":"","secretKey":"","collectionId":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/rest/v1.1/collection/export/csv"

queryString <- list(
  accessKey = "",
  secretKey = "",
  collectionId = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/rest/v1.1/collection/export/csv?accessKey=&secretKey=&collectionId=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/rest/v1.1/collection/export/csv') do |req|
  req.params['accessKey'] = ''
  req.params['secretKey'] = ''
  req.params['collectionId'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/rest/v1.1/collection/export/csv";

    let querystring = [
        ("accessKey", ""),
        ("secretKey", ""),
        ("collectionId", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/rest/v1.1/collection/export/csv?accessKey=&secretKey=&collectionId='

http GET '{{baseUrl}}/rest/v1.1/collection/export/csv?accessKey=&secretKey=&collectionId='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/rest/v1.1/collection/export/csv?accessKey=&secretKey=&collectionId='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/rest/v1.1/collection/export/csv?accessKey=&secretKey=&collectionId=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Retrieve existing collection content (GET)

{{baseUrl}}/rest/v1.1/collection/:id

QUERY PARAMS

accessKey

secretKey

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/rest/v1.1/collection/:id?accessKey=&secretKey=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/rest/v1.1/collection/:id" {:query-params {:accessKey ""
                                                                                   :secretKey ""}})

require "http/client"

url = "{{baseUrl}}/rest/v1.1/collection/:id?accessKey=&secretKey="

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/rest/v1.1/collection/:id?accessKey=&secretKey="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/rest/v1.1/collection/:id?accessKey=&secretKey=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/rest/v1.1/collection/:id?accessKey=&secretKey="

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/rest/v1.1/collection/:id?accessKey=&secretKey= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/rest/v1.1/collection/:id?accessKey=&secretKey=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/rest/v1.1/collection/:id?accessKey=&secretKey="))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/rest/v1.1/collection/:id?accessKey=&secretKey=")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/rest/v1.1/collection/:id?accessKey=&secretKey=")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

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

xhr.open('GET', '{{baseUrl}}/rest/v1.1/collection/:id?accessKey=&secretKey=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/rest/v1.1/collection/:id',
  params: {accessKey: '', secretKey: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/rest/v1.1/collection/:id?accessKey=&secretKey=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/rest/v1.1/collection/:id?accessKey=&secretKey=',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/rest/v1.1/collection/:id?accessKey=&secretKey=")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/rest/v1.1/collection/:id?accessKey=&secretKey=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/rest/v1.1/collection/:id',
  qs: {accessKey: '', secretKey: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/rest/v1.1/collection/:id');

req.query({
  accessKey: '',
  secretKey: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/rest/v1.1/collection/:id',
  params: {accessKey: '', secretKey: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/rest/v1.1/collection/:id?accessKey=&secretKey=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/rest/v1.1/collection/:id?accessKey=&secretKey="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/rest/v1.1/collection/:id?accessKey=&secretKey=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/rest/v1.1/collection/:id?accessKey=&secretKey=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/rest/v1.1/collection/:id?accessKey=&secretKey=');

echo $response->getBody();

setUrl('{{baseUrl}}/rest/v1.1/collection/:id');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'accessKey' => '',
  'secretKey' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/rest/v1.1/collection/:id');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'accessKey' => '',
  'secretKey' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/rest/v1.1/collection/:id?accessKey=&secretKey=' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/rest/v1.1/collection/:id?accessKey=&secretKey=' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/rest/v1.1/collection/:id?accessKey=&secretKey=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/rest/v1.1/collection/:id"

querystring = {"accessKey":"","secretKey":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/rest/v1.1/collection/:id"

queryString <- list(
  accessKey = "",
  secretKey = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/rest/v1.1/collection/:id?accessKey=&secretKey=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/rest/v1.1/collection/:id') do |req|
  req.params['accessKey'] = ''
  req.params['secretKey'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/rest/v1.1/collection/:id";

    let querystring = [
        ("accessKey", ""),
        ("secretKey", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/rest/v1.1/collection/:id?accessKey=&secretKey='

http GET '{{baseUrl}}/rest/v1.1/collection/:id?accessKey=&secretKey='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/rest/v1.1/collection/:id?accessKey=&secretKey='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/rest/v1.1/collection/:id?accessKey=&secretKey=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Retrieve existing collection content

{{baseUrl}}/rest/v1.1/collection/collection

QUERY PARAMS

accessKey

secretKey

collectionId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/rest/v1.1/collection/collection?accessKey=&secretKey=&collectionId=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/rest/v1.1/collection/collection" {:query-params {:accessKey ""
                                                                                          :secretKey ""
                                                                                          :collectionId ""}})

require "http/client"

url = "{{baseUrl}}/rest/v1.1/collection/collection?accessKey=&secretKey=&collectionId="

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/rest/v1.1/collection/collection?accessKey=&secretKey=&collectionId="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/rest/v1.1/collection/collection?accessKey=&secretKey=&collectionId=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/rest/v1.1/collection/collection?accessKey=&secretKey=&collectionId="

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/rest/v1.1/collection/collection?accessKey=&secretKey=&collectionId= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/rest/v1.1/collection/collection?accessKey=&secretKey=&collectionId=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/rest/v1.1/collection/collection?accessKey=&secretKey=&collectionId="))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/rest/v1.1/collection/collection?accessKey=&secretKey=&collectionId=")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/rest/v1.1/collection/collection?accessKey=&secretKey=&collectionId=")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

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

xhr.open('GET', '{{baseUrl}}/rest/v1.1/collection/collection?accessKey=&secretKey=&collectionId=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/rest/v1.1/collection/collection',
  params: {accessKey: '', secretKey: '', collectionId: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/rest/v1.1/collection/collection?accessKey=&secretKey=&collectionId=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/rest/v1.1/collection/collection?accessKey=&secretKey=&collectionId=',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/rest/v1.1/collection/collection?accessKey=&secretKey=&collectionId=")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/rest/v1.1/collection/collection?accessKey=&secretKey=&collectionId=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/rest/v1.1/collection/collection',
  qs: {accessKey: '', secretKey: '', collectionId: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/rest/v1.1/collection/collection');

req.query({
  accessKey: '',
  secretKey: '',
  collectionId: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/rest/v1.1/collection/collection',
  params: {accessKey: '', secretKey: '', collectionId: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/rest/v1.1/collection/collection?accessKey=&secretKey=&collectionId=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/rest/v1.1/collection/collection?accessKey=&secretKey=&collectionId="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/rest/v1.1/collection/collection?accessKey=&secretKey=&collectionId=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/rest/v1.1/collection/collection?accessKey=&secretKey=&collectionId=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/rest/v1.1/collection/collection?accessKey=&secretKey=&collectionId=');

echo $response->getBody();

setUrl('{{baseUrl}}/rest/v1.1/collection/collection');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'accessKey' => '',
  'secretKey' => '',
  'collectionId' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/rest/v1.1/collection/collection');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'accessKey' => '',
  'secretKey' => '',
  'collectionId' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/rest/v1.1/collection/collection?accessKey=&secretKey=&collectionId=' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/rest/v1.1/collection/collection?accessKey=&secretKey=&collectionId=' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/rest/v1.1/collection/collection?accessKey=&secretKey=&collectionId=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/rest/v1.1/collection/collection"

querystring = {"accessKey":"","secretKey":"","collectionId":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/rest/v1.1/collection/collection"

queryString <- list(
  accessKey = "",
  secretKey = "",
  collectionId = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/rest/v1.1/collection/collection?accessKey=&secretKey=&collectionId=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/rest/v1.1/collection/collection') do |req|
  req.params['accessKey'] = ''
  req.params['secretKey'] = ''
  req.params['collectionId'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/rest/v1.1/collection/collection";

    let querystring = [
        ("accessKey", ""),
        ("secretKey", ""),
        ("collectionId", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/rest/v1.1/collection/collection?accessKey=&secretKey=&collectionId='

http GET '{{baseUrl}}/rest/v1.1/collection/collection?accessKey=&secretKey=&collectionId='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/rest/v1.1/collection/collection?accessKey=&secretKey=&collectionId='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/rest/v1.1/collection/collection?accessKey=&secretKey=&collectionId=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST Update an existing collection with a given id (POST)

{{baseUrl}}/rest/v1.1/collection/:id

QUERY PARAMS

accessKey

secretKey

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/rest/v1.1/collection/:id?accessKey=&secretKey=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/rest/v1.1/collection/:id" {:query-params {:accessKey ""
                                                                                    :secretKey ""}})

require "http/client"

url = "{{baseUrl}}/rest/v1.1/collection/:id?accessKey=&secretKey="

response = HTTP::Client.post url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/rest/v1.1/collection/:id?accessKey=&secretKey="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/rest/v1.1/collection/:id?accessKey=&secretKey=");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/rest/v1.1/collection/:id?accessKey=&secretKey="

	req, _ := http.NewRequest("POST", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/rest/v1.1/collection/:id?accessKey=&secretKey= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/rest/v1.1/collection/:id?accessKey=&secretKey=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/rest/v1.1/collection/:id?accessKey=&secretKey="))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/rest/v1.1/collection/:id?accessKey=&secretKey=")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/rest/v1.1/collection/:id?accessKey=&secretKey=")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

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

xhr.open('POST', '{{baseUrl}}/rest/v1.1/collection/:id?accessKey=&secretKey=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/rest/v1.1/collection/:id',
  params: {accessKey: '', secretKey: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/rest/v1.1/collection/:id?accessKey=&secretKey=';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/rest/v1.1/collection/:id?accessKey=&secretKey=',
  method: 'POST',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/rest/v1.1/collection/:id?accessKey=&secretKey=")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/rest/v1.1/collection/:id?accessKey=&secretKey=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/rest/v1.1/collection/:id',
  qs: {accessKey: '', secretKey: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/rest/v1.1/collection/:id');

req.query({
  accessKey: '',
  secretKey: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/rest/v1.1/collection/:id',
  params: {accessKey: '', secretKey: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/rest/v1.1/collection/:id?accessKey=&secretKey=';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/rest/v1.1/collection/:id?accessKey=&secretKey="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/rest/v1.1/collection/:id?accessKey=&secretKey=" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/rest/v1.1/collection/:id?accessKey=&secretKey=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/rest/v1.1/collection/:id?accessKey=&secretKey=');

echo $response->getBody();

setUrl('{{baseUrl}}/rest/v1.1/collection/:id');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'accessKey' => '',
  'secretKey' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/rest/v1.1/collection/:id');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'accessKey' => '',
  'secretKey' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/rest/v1.1/collection/:id?accessKey=&secretKey=' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/rest/v1.1/collection/:id?accessKey=&secretKey=' -Method POST

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/rest/v1.1/collection/:id?accessKey=&secretKey=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/rest/v1.1/collection/:id"

querystring = {"accessKey":"","secretKey":""}

response = requests.post(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/rest/v1.1/collection/:id"

queryString <- list(
  accessKey = "",
  secretKey = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/rest/v1.1/collection/:id?accessKey=&secretKey=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/rest/v1.1/collection/:id') do |req|
  req.params['accessKey'] = ''
  req.params['secretKey'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/rest/v1.1/collection/:id";

    let querystring = [
        ("accessKey", ""),
        ("secretKey", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.post(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/rest/v1.1/collection/:id?accessKey=&secretKey='

http POST '{{baseUrl}}/rest/v1.1/collection/:id?accessKey=&secretKey='

wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/rest/v1.1/collection/:id?accessKey=&secretKey='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/rest/v1.1/collection/:id?accessKey=&secretKey=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

PATCH Update an existing collection with a given id

{{baseUrl}}/rest/v1.1/collection/:id

QUERY PARAMS

accessKey

secretKey

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/rest/v1.1/collection/:id?accessKey=&secretKey=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/patch "{{baseUrl}}/rest/v1.1/collection/:id" {:query-params {:accessKey ""
                                                                                     :secretKey ""}})

require "http/client"

url = "{{baseUrl}}/rest/v1.1/collection/:id?accessKey=&secretKey="

response = HTTP::Client.patch url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Patch,
    RequestUri = new Uri("{{baseUrl}}/rest/v1.1/collection/:id?accessKey=&secretKey="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/rest/v1.1/collection/:id?accessKey=&secretKey=");
var request = new RestRequest("", Method.Patch);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/rest/v1.1/collection/:id?accessKey=&secretKey="

	req, _ := http.NewRequest("PATCH", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

PATCH /baseUrl/rest/v1.1/collection/:id?accessKey=&secretKey= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/rest/v1.1/collection/:id?accessKey=&secretKey=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/rest/v1.1/collection/:id?accessKey=&secretKey="))
    .method("PATCH", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/rest/v1.1/collection/:id?accessKey=&secretKey=")
  .patch(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.patch("{{baseUrl}}/rest/v1.1/collection/:id?accessKey=&secretKey=")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

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

xhr.open('PATCH', '{{baseUrl}}/rest/v1.1/collection/:id?accessKey=&secretKey=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/rest/v1.1/collection/:id',
  params: {accessKey: '', secretKey: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/rest/v1.1/collection/:id?accessKey=&secretKey=';
const options = {method: 'PATCH'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/rest/v1.1/collection/:id?accessKey=&secretKey=',
  method: 'PATCH',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/rest/v1.1/collection/:id?accessKey=&secretKey=")
  .patch(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PATCH',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/rest/v1.1/collection/:id?accessKey=&secretKey=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/rest/v1.1/collection/:id',
  qs: {accessKey: '', secretKey: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PATCH', '{{baseUrl}}/rest/v1.1/collection/:id');

req.query({
  accessKey: '',
  secretKey: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/rest/v1.1/collection/:id',
  params: {accessKey: '', secretKey: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/rest/v1.1/collection/:id?accessKey=&secretKey=';
const options = {method: 'PATCH'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/rest/v1.1/collection/:id?accessKey=&secretKey="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PATCH"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/rest/v1.1/collection/:id?accessKey=&secretKey=" in

Client.call `PATCH uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/rest/v1.1/collection/:id?accessKey=&secretKey=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PATCH",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PATCH', '{{baseUrl}}/rest/v1.1/collection/:id?accessKey=&secretKey=');

echo $response->getBody();

setUrl('{{baseUrl}}/rest/v1.1/collection/:id');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

$request->setQueryData([
  'accessKey' => '',
  'secretKey' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/rest/v1.1/collection/:id');
$request->setRequestMethod('PATCH');
$request->setQuery(new http\QueryString([
  'accessKey' => '',
  'secretKey' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/rest/v1.1/collection/:id?accessKey=&secretKey=' -Method PATCH

$response = Invoke-RestMethod -Uri '{{baseUrl}}/rest/v1.1/collection/:id?accessKey=&secretKey=' -Method PATCH

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("PATCH", "/baseUrl/rest/v1.1/collection/:id?accessKey=&secretKey=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/rest/v1.1/collection/:id"

querystring = {"accessKey":"","secretKey":""}

response = requests.patch(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/rest/v1.1/collection/:id"

queryString <- list(
  accessKey = "",
  secretKey = ""
)

response <- VERB("PATCH", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/rest/v1.1/collection/:id?accessKey=&secretKey=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Patch.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.patch('/baseUrl/rest/v1.1/collection/:id') do |req|
  req.params['accessKey'] = ''
  req.params['secretKey'] = ''
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/rest/v1.1/collection/:id";

    let querystring = [
        ("accessKey", ""),
        ("secretKey", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PATCH").unwrap(), url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PATCH \
  --url '{{baseUrl}}/rest/v1.1/collection/:id?accessKey=&secretKey='

http PATCH '{{baseUrl}}/rest/v1.1/collection/:id?accessKey=&secretKey='

wget --quiet \
  --method PATCH \
  --output-document \
  - '{{baseUrl}}/rest/v1.1/collection/:id?accessKey=&secretKey='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/rest/v1.1/collection/:id?accessKey=&secretKey=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PATCH"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST Adds (maps) a list of faces, identified by faceHashes, to a profile, identified by profileId

{{baseUrl}}/rest/v1.1/profile/map

QUERY PARAMS

accessKey

secretKey

faceHashes

profileId

collectionId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/rest/v1.1/profile/map?accessKey=&secretKey=&faceHashes=&profileId=&collectionId=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/rest/v1.1/profile/map" {:query-params {:accessKey ""
                                                                                 :secretKey ""
                                                                                 :faceHashes ""
                                                                                 :profileId ""
                                                                                 :collectionId ""}})

require "http/client"

url = "{{baseUrl}}/rest/v1.1/profile/map?accessKey=&secretKey=&faceHashes=&profileId=&collectionId="

response = HTTP::Client.post url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/rest/v1.1/profile/map?accessKey=&secretKey=&faceHashes=&profileId=&collectionId="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/rest/v1.1/profile/map?accessKey=&secretKey=&faceHashes=&profileId=&collectionId=");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/rest/v1.1/profile/map?accessKey=&secretKey=&faceHashes=&profileId=&collectionId="

	req, _ := http.NewRequest("POST", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/rest/v1.1/profile/map?accessKey=&secretKey=&faceHashes=&profileId=&collectionId= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/rest/v1.1/profile/map?accessKey=&secretKey=&faceHashes=&profileId=&collectionId=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/rest/v1.1/profile/map?accessKey=&secretKey=&faceHashes=&profileId=&collectionId="))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/rest/v1.1/profile/map?accessKey=&secretKey=&faceHashes=&profileId=&collectionId=")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/rest/v1.1/profile/map?accessKey=&secretKey=&faceHashes=&profileId=&collectionId=")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

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

xhr.open('POST', '{{baseUrl}}/rest/v1.1/profile/map?accessKey=&secretKey=&faceHashes=&profileId=&collectionId=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/rest/v1.1/profile/map',
  params: {accessKey: '', secretKey: '', faceHashes: '', profileId: '', collectionId: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/rest/v1.1/profile/map?accessKey=&secretKey=&faceHashes=&profileId=&collectionId=';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/rest/v1.1/profile/map?accessKey=&secretKey=&faceHashes=&profileId=&collectionId=',
  method: 'POST',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/rest/v1.1/profile/map?accessKey=&secretKey=&faceHashes=&profileId=&collectionId=")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/rest/v1.1/profile/map?accessKey=&secretKey=&faceHashes=&profileId=&collectionId=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/rest/v1.1/profile/map',
  qs: {accessKey: '', secretKey: '', faceHashes: '', profileId: '', collectionId: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/rest/v1.1/profile/map');

req.query({
  accessKey: '',
  secretKey: '',
  faceHashes: '',
  profileId: '',
  collectionId: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/rest/v1.1/profile/map',
  params: {accessKey: '', secretKey: '', faceHashes: '', profileId: '', collectionId: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/rest/v1.1/profile/map?accessKey=&secretKey=&faceHashes=&profileId=&collectionId=';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/rest/v1.1/profile/map?accessKey=&secretKey=&faceHashes=&profileId=&collectionId="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/rest/v1.1/profile/map?accessKey=&secretKey=&faceHashes=&profileId=&collectionId=" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/rest/v1.1/profile/map?accessKey=&secretKey=&faceHashes=&profileId=&collectionId=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/rest/v1.1/profile/map?accessKey=&secretKey=&faceHashes=&profileId=&collectionId=');

echo $response->getBody();

setUrl('{{baseUrl}}/rest/v1.1/profile/map');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'accessKey' => '',
  'secretKey' => '',
  'faceHashes' => '',
  'profileId' => '',
  'collectionId' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/rest/v1.1/profile/map');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'accessKey' => '',
  'secretKey' => '',
  'faceHashes' => '',
  'profileId' => '',
  'collectionId' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/rest/v1.1/profile/map?accessKey=&secretKey=&faceHashes=&profileId=&collectionId=' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/rest/v1.1/profile/map?accessKey=&secretKey=&faceHashes=&profileId=&collectionId=' -Method POST

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/rest/v1.1/profile/map?accessKey=&secretKey=&faceHashes=&profileId=&collectionId=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/rest/v1.1/profile/map"

querystring = {"accessKey":"","secretKey":"","faceHashes":"","profileId":"","collectionId":""}

response = requests.post(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/rest/v1.1/profile/map"

queryString <- list(
  accessKey = "",
  secretKey = "",
  faceHashes = "",
  profileId = "",
  collectionId = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/rest/v1.1/profile/map?accessKey=&secretKey=&faceHashes=&profileId=&collectionId=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/rest/v1.1/profile/map') do |req|
  req.params['accessKey'] = ''
  req.params['secretKey'] = ''
  req.params['faceHashes'] = ''
  req.params['profileId'] = ''
  req.params['collectionId'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/rest/v1.1/profile/map";

    let querystring = [
        ("accessKey", ""),
        ("secretKey", ""),
        ("faceHashes", ""),
        ("profileId", ""),
        ("collectionId", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.post(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/rest/v1.1/profile/map?accessKey=&secretKey=&faceHashes=&profileId=&collectionId='

http POST '{{baseUrl}}/rest/v1.1/profile/map?accessKey=&secretKey=&faceHashes=&profileId=&collectionId='

wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/rest/v1.1/profile/map?accessKey=&secretKey=&faceHashes=&profileId=&collectionId='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/rest/v1.1/profile/map?accessKey=&secretKey=&faceHashes=&profileId=&collectionId=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST Creates a new profile with no faces associated to it (empty profile)

{{baseUrl}}/rest/v1.1/profile/profile

QUERY PARAMS

accessKey

secretKey

collectionId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/rest/v1.1/profile/profile?accessKey=&secretKey=&collectionId=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/rest/v1.1/profile/profile" {:query-params {:accessKey ""
                                                                                     :secretKey ""
                                                                                     :collectionId ""}})

require "http/client"

url = "{{baseUrl}}/rest/v1.1/profile/profile?accessKey=&secretKey=&collectionId="

response = HTTP::Client.post url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/rest/v1.1/profile/profile?accessKey=&secretKey=&collectionId="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/rest/v1.1/profile/profile?accessKey=&secretKey=&collectionId=");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/rest/v1.1/profile/profile?accessKey=&secretKey=&collectionId="

	req, _ := http.NewRequest("POST", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/rest/v1.1/profile/profile?accessKey=&secretKey=&collectionId= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/rest/v1.1/profile/profile?accessKey=&secretKey=&collectionId=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/rest/v1.1/profile/profile?accessKey=&secretKey=&collectionId="))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/rest/v1.1/profile/profile?accessKey=&secretKey=&collectionId=")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/rest/v1.1/profile/profile?accessKey=&secretKey=&collectionId=")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

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

xhr.open('POST', '{{baseUrl}}/rest/v1.1/profile/profile?accessKey=&secretKey=&collectionId=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/rest/v1.1/profile/profile',
  params: {accessKey: '', secretKey: '', collectionId: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/rest/v1.1/profile/profile?accessKey=&secretKey=&collectionId=';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/rest/v1.1/profile/profile?accessKey=&secretKey=&collectionId=',
  method: 'POST',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/rest/v1.1/profile/profile?accessKey=&secretKey=&collectionId=")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/rest/v1.1/profile/profile?accessKey=&secretKey=&collectionId=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/rest/v1.1/profile/profile',
  qs: {accessKey: '', secretKey: '', collectionId: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/rest/v1.1/profile/profile');

req.query({
  accessKey: '',
  secretKey: '',
  collectionId: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/rest/v1.1/profile/profile',
  params: {accessKey: '', secretKey: '', collectionId: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/rest/v1.1/profile/profile?accessKey=&secretKey=&collectionId=';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/rest/v1.1/profile/profile?accessKey=&secretKey=&collectionId="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/rest/v1.1/profile/profile?accessKey=&secretKey=&collectionId=" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/rest/v1.1/profile/profile?accessKey=&secretKey=&collectionId=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/rest/v1.1/profile/profile?accessKey=&secretKey=&collectionId=');

echo $response->getBody();

setUrl('{{baseUrl}}/rest/v1.1/profile/profile');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'accessKey' => '',
  'secretKey' => '',
  'collectionId' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/rest/v1.1/profile/profile');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'accessKey' => '',
  'secretKey' => '',
  'collectionId' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/rest/v1.1/profile/profile?accessKey=&secretKey=&collectionId=' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/rest/v1.1/profile/profile?accessKey=&secretKey=&collectionId=' -Method POST

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/rest/v1.1/profile/profile?accessKey=&secretKey=&collectionId=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/rest/v1.1/profile/profile"

querystring = {"accessKey":"","secretKey":"","collectionId":""}

response = requests.post(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/rest/v1.1/profile/profile"

queryString <- list(
  accessKey = "",
  secretKey = "",
  collectionId = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/rest/v1.1/profile/profile?accessKey=&secretKey=&collectionId=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/rest/v1.1/profile/profile') do |req|
  req.params['accessKey'] = ''
  req.params['secretKey'] = ''
  req.params['collectionId'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/rest/v1.1/profile/profile";

    let querystring = [
        ("accessKey", ""),
        ("secretKey", ""),
        ("collectionId", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.post(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/rest/v1.1/profile/profile?accessKey=&secretKey=&collectionId='

http POST '{{baseUrl}}/rest/v1.1/profile/profile?accessKey=&secretKey=&collectionId='

wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/rest/v1.1/profile/profile?accessKey=&secretKey=&collectionId='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/rest/v1.1/profile/profile?accessKey=&secretKey=&collectionId=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

DELETE Deletes a profile and unmaps all its faces (DELETE)

{{baseUrl}}/rest/v1.1/profile/:id

QUERY PARAMS

accessKey

secretKey

collectionId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/rest/v1.1/profile/:id?accessKey=&secretKey=&collectionId=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/rest/v1.1/profile/:id" {:query-params {:accessKey ""
                                                                                   :secretKey ""
                                                                                   :collectionId ""}})

require "http/client"

url = "{{baseUrl}}/rest/v1.1/profile/:id?accessKey=&secretKey=&collectionId="

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/rest/v1.1/profile/:id?accessKey=&secretKey=&collectionId="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/rest/v1.1/profile/:id?accessKey=&secretKey=&collectionId=");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/rest/v1.1/profile/:id?accessKey=&secretKey=&collectionId="

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/rest/v1.1/profile/:id?accessKey=&secretKey=&collectionId= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/rest/v1.1/profile/:id?accessKey=&secretKey=&collectionId=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/rest/v1.1/profile/:id?accessKey=&secretKey=&collectionId="))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/rest/v1.1/profile/:id?accessKey=&secretKey=&collectionId=")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/rest/v1.1/profile/:id?accessKey=&secretKey=&collectionId=")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

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

xhr.open('DELETE', '{{baseUrl}}/rest/v1.1/profile/:id?accessKey=&secretKey=&collectionId=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/rest/v1.1/profile/:id',
  params: {accessKey: '', secretKey: '', collectionId: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/rest/v1.1/profile/:id?accessKey=&secretKey=&collectionId=';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/rest/v1.1/profile/:id?accessKey=&secretKey=&collectionId=',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/rest/v1.1/profile/:id?accessKey=&secretKey=&collectionId=")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/rest/v1.1/profile/:id?accessKey=&secretKey=&collectionId=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/rest/v1.1/profile/:id',
  qs: {accessKey: '', secretKey: '', collectionId: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/rest/v1.1/profile/:id');

req.query({
  accessKey: '',
  secretKey: '',
  collectionId: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/rest/v1.1/profile/:id',
  params: {accessKey: '', secretKey: '', collectionId: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/rest/v1.1/profile/:id?accessKey=&secretKey=&collectionId=';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/rest/v1.1/profile/:id?accessKey=&secretKey=&collectionId="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/rest/v1.1/profile/:id?accessKey=&secretKey=&collectionId=" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/rest/v1.1/profile/:id?accessKey=&secretKey=&collectionId=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/rest/v1.1/profile/:id?accessKey=&secretKey=&collectionId=');

echo $response->getBody();

setUrl('{{baseUrl}}/rest/v1.1/profile/:id');
$request->setMethod(HTTP_METH_DELETE);

$request->setQueryData([
  'accessKey' => '',
  'secretKey' => '',
  'collectionId' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/rest/v1.1/profile/:id');
$request->setRequestMethod('DELETE');
$request->setQuery(new http\QueryString([
  'accessKey' => '',
  'secretKey' => '',
  'collectionId' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/rest/v1.1/profile/:id?accessKey=&secretKey=&collectionId=' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/rest/v1.1/profile/:id?accessKey=&secretKey=&collectionId=' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/rest/v1.1/profile/:id?accessKey=&secretKey=&collectionId=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/rest/v1.1/profile/:id"

querystring = {"accessKey":"","secretKey":"","collectionId":""}

response = requests.delete(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/rest/v1.1/profile/:id"

queryString <- list(
  accessKey = "",
  secretKey = "",
  collectionId = ""
)

response <- VERB("DELETE", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/rest/v1.1/profile/:id?accessKey=&secretKey=&collectionId=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/rest/v1.1/profile/:id') do |req|
  req.params['accessKey'] = ''
  req.params['secretKey'] = ''
  req.params['collectionId'] = ''
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/rest/v1.1/profile/:id";

    let querystring = [
        ("accessKey", ""),
        ("secretKey", ""),
        ("collectionId", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url '{{baseUrl}}/rest/v1.1/profile/:id?accessKey=&secretKey=&collectionId='

http DELETE '{{baseUrl}}/rest/v1.1/profile/:id?accessKey=&secretKey=&collectionId='

wget --quiet \
  --method DELETE \
  --output-document \
  - '{{baseUrl}}/rest/v1.1/profile/:id?accessKey=&secretKey=&collectionId='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/rest/v1.1/profile/:id?accessKey=&secretKey=&collectionId=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

DELETE Deletes a profile and unmaps all its faces

{{baseUrl}}/rest/v1.1/profile/profile

QUERY PARAMS

accessKey

secretKey

collectionId

profileId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/rest/v1.1/profile/profile?accessKey=&secretKey=&collectionId=&profileId=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/rest/v1.1/profile/profile" {:query-params {:accessKey ""
                                                                                       :secretKey ""
                                                                                       :collectionId ""
                                                                                       :profileId ""}})

require "http/client"

url = "{{baseUrl}}/rest/v1.1/profile/profile?accessKey=&secretKey=&collectionId=&profileId="

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/rest/v1.1/profile/profile?accessKey=&secretKey=&collectionId=&profileId="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/rest/v1.1/profile/profile?accessKey=&secretKey=&collectionId=&profileId=");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/rest/v1.1/profile/profile?accessKey=&secretKey=&collectionId=&profileId="

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/rest/v1.1/profile/profile?accessKey=&secretKey=&collectionId=&profileId= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/rest/v1.1/profile/profile?accessKey=&secretKey=&collectionId=&profileId=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/rest/v1.1/profile/profile?accessKey=&secretKey=&collectionId=&profileId="))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/rest/v1.1/profile/profile?accessKey=&secretKey=&collectionId=&profileId=")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/rest/v1.1/profile/profile?accessKey=&secretKey=&collectionId=&profileId=")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

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

xhr.open('DELETE', '{{baseUrl}}/rest/v1.1/profile/profile?accessKey=&secretKey=&collectionId=&profileId=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/rest/v1.1/profile/profile',
  params: {accessKey: '', secretKey: '', collectionId: '', profileId: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/rest/v1.1/profile/profile?accessKey=&secretKey=&collectionId=&profileId=';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/rest/v1.1/profile/profile?accessKey=&secretKey=&collectionId=&profileId=',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/rest/v1.1/profile/profile?accessKey=&secretKey=&collectionId=&profileId=")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/rest/v1.1/profile/profile?accessKey=&secretKey=&collectionId=&profileId=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/rest/v1.1/profile/profile',
  qs: {accessKey: '', secretKey: '', collectionId: '', profileId: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/rest/v1.1/profile/profile');

req.query({
  accessKey: '',
  secretKey: '',
  collectionId: '',
  profileId: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/rest/v1.1/profile/profile',
  params: {accessKey: '', secretKey: '', collectionId: '', profileId: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/rest/v1.1/profile/profile?accessKey=&secretKey=&collectionId=&profileId=';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/rest/v1.1/profile/profile?accessKey=&secretKey=&collectionId=&profileId="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/rest/v1.1/profile/profile?accessKey=&secretKey=&collectionId=&profileId=" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/rest/v1.1/profile/profile?accessKey=&secretKey=&collectionId=&profileId=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/rest/v1.1/profile/profile?accessKey=&secretKey=&collectionId=&profileId=');

echo $response->getBody();

setUrl('{{baseUrl}}/rest/v1.1/profile/profile');
$request->setMethod(HTTP_METH_DELETE);

$request->setQueryData([
  'accessKey' => '',
  'secretKey' => '',
  'collectionId' => '',
  'profileId' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/rest/v1.1/profile/profile');
$request->setRequestMethod('DELETE');
$request->setQuery(new http\QueryString([
  'accessKey' => '',
  'secretKey' => '',
  'collectionId' => '',
  'profileId' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/rest/v1.1/profile/profile?accessKey=&secretKey=&collectionId=&profileId=' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/rest/v1.1/profile/profile?accessKey=&secretKey=&collectionId=&profileId=' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/rest/v1.1/profile/profile?accessKey=&secretKey=&collectionId=&profileId=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/rest/v1.1/profile/profile"

querystring = {"accessKey":"","secretKey":"","collectionId":"","profileId":""}

response = requests.delete(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/rest/v1.1/profile/profile"

queryString <- list(
  accessKey = "",
  secretKey = "",
  collectionId = "",
  profileId = ""
)

response <- VERB("DELETE", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/rest/v1.1/profile/profile?accessKey=&secretKey=&collectionId=&profileId=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/rest/v1.1/profile/profile') do |req|
  req.params['accessKey'] = ''
  req.params['secretKey'] = ''
  req.params['collectionId'] = ''
  req.params['profileId'] = ''
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/rest/v1.1/profile/profile";

    let querystring = [
        ("accessKey", ""),
        ("secretKey", ""),
        ("collectionId", ""),
        ("profileId", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url '{{baseUrl}}/rest/v1.1/profile/profile?accessKey=&secretKey=&collectionId=&profileId='

http DELETE '{{baseUrl}}/rest/v1.1/profile/profile?accessKey=&secretKey=&collectionId=&profileId='

wget --quiet \
  --method DELETE \
  --output-document \
  - '{{baseUrl}}/rest/v1.1/profile/profile?accessKey=&secretKey=&collectionId=&profileId='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/rest/v1.1/profile/profile?accessKey=&secretKey=&collectionId=&profileId=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Gets all the faceHashes associated to a profile

{{baseUrl}}/rest/v1.1/profile/map

QUERY PARAMS

accessKey

secretKey

profileId

collectionId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/rest/v1.1/profile/map?accessKey=&secretKey=&profileId=&collectionId=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/rest/v1.1/profile/map" {:query-params {:accessKey ""
                                                                                :secretKey ""
                                                                                :profileId ""
                                                                                :collectionId ""}})

require "http/client"

url = "{{baseUrl}}/rest/v1.1/profile/map?accessKey=&secretKey=&profileId=&collectionId="

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/rest/v1.1/profile/map?accessKey=&secretKey=&profileId=&collectionId="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/rest/v1.1/profile/map?accessKey=&secretKey=&profileId=&collectionId=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/rest/v1.1/profile/map?accessKey=&secretKey=&profileId=&collectionId="

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/rest/v1.1/profile/map?accessKey=&secretKey=&profileId=&collectionId= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/rest/v1.1/profile/map?accessKey=&secretKey=&profileId=&collectionId=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/rest/v1.1/profile/map?accessKey=&secretKey=&profileId=&collectionId="))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/rest/v1.1/profile/map?accessKey=&secretKey=&profileId=&collectionId=")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/rest/v1.1/profile/map?accessKey=&secretKey=&profileId=&collectionId=")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

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

xhr.open('GET', '{{baseUrl}}/rest/v1.1/profile/map?accessKey=&secretKey=&profileId=&collectionId=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/rest/v1.1/profile/map',
  params: {accessKey: '', secretKey: '', profileId: '', collectionId: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/rest/v1.1/profile/map?accessKey=&secretKey=&profileId=&collectionId=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/rest/v1.1/profile/map?accessKey=&secretKey=&profileId=&collectionId=',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/rest/v1.1/profile/map?accessKey=&secretKey=&profileId=&collectionId=")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/rest/v1.1/profile/map?accessKey=&secretKey=&profileId=&collectionId=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/rest/v1.1/profile/map',
  qs: {accessKey: '', secretKey: '', profileId: '', collectionId: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/rest/v1.1/profile/map');

req.query({
  accessKey: '',
  secretKey: '',
  profileId: '',
  collectionId: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/rest/v1.1/profile/map',
  params: {accessKey: '', secretKey: '', profileId: '', collectionId: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/rest/v1.1/profile/map?accessKey=&secretKey=&profileId=&collectionId=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/rest/v1.1/profile/map?accessKey=&secretKey=&profileId=&collectionId="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/rest/v1.1/profile/map?accessKey=&secretKey=&profileId=&collectionId=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/rest/v1.1/profile/map?accessKey=&secretKey=&profileId=&collectionId=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/rest/v1.1/profile/map?accessKey=&secretKey=&profileId=&collectionId=');

echo $response->getBody();

setUrl('{{baseUrl}}/rest/v1.1/profile/map');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'accessKey' => '',
  'secretKey' => '',
  'profileId' => '',
  'collectionId' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/rest/v1.1/profile/map');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'accessKey' => '',
  'secretKey' => '',
  'profileId' => '',
  'collectionId' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/rest/v1.1/profile/map?accessKey=&secretKey=&profileId=&collectionId=' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/rest/v1.1/profile/map?accessKey=&secretKey=&profileId=&collectionId=' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/rest/v1.1/profile/map?accessKey=&secretKey=&profileId=&collectionId=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/rest/v1.1/profile/map"

querystring = {"accessKey":"","secretKey":"","profileId":"","collectionId":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/rest/v1.1/profile/map"

queryString <- list(
  accessKey = "",
  secretKey = "",
  profileId = "",
  collectionId = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/rest/v1.1/profile/map?accessKey=&secretKey=&profileId=&collectionId=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/rest/v1.1/profile/map') do |req|
  req.params['accessKey'] = ''
  req.params['secretKey'] = ''
  req.params['profileId'] = ''
  req.params['collectionId'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/rest/v1.1/profile/map";

    let querystring = [
        ("accessKey", ""),
        ("secretKey", ""),
        ("profileId", ""),
        ("collectionId", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/rest/v1.1/profile/map?accessKey=&secretKey=&profileId=&collectionId='

http GET '{{baseUrl}}/rest/v1.1/profile/map?accessKey=&secretKey=&profileId=&collectionId='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/rest/v1.1/profile/map?accessKey=&secretKey=&profileId=&collectionId='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/rest/v1.1/profile/map?accessKey=&secretKey=&profileId=&collectionId=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Gets classification attributes from a profile

{{baseUrl}}/rest/v1.1/profile/classificationAttributes

QUERY PARAMS

accessKey

secretKey

profileId

collectionId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/rest/v1.1/profile/classificationAttributes?accessKey=&secretKey=&profileId=&collectionId=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/rest/v1.1/profile/classificationAttributes" {:query-params {:accessKey ""
                                                                                                     :secretKey ""
                                                                                                     :profileId ""
                                                                                                     :collectionId ""}})

require "http/client"

url = "{{baseUrl}}/rest/v1.1/profile/classificationAttributes?accessKey=&secretKey=&profileId=&collectionId="

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/rest/v1.1/profile/classificationAttributes?accessKey=&secretKey=&profileId=&collectionId="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/rest/v1.1/profile/classificationAttributes?accessKey=&secretKey=&profileId=&collectionId=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/rest/v1.1/profile/classificationAttributes?accessKey=&secretKey=&profileId=&collectionId="

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/rest/v1.1/profile/classificationAttributes?accessKey=&secretKey=&profileId=&collectionId= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/rest/v1.1/profile/classificationAttributes?accessKey=&secretKey=&profileId=&collectionId=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/rest/v1.1/profile/classificationAttributes?accessKey=&secretKey=&profileId=&collectionId="))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/rest/v1.1/profile/classificationAttributes?accessKey=&secretKey=&profileId=&collectionId=")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/rest/v1.1/profile/classificationAttributes?accessKey=&secretKey=&profileId=&collectionId=")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

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

xhr.open('GET', '{{baseUrl}}/rest/v1.1/profile/classificationAttributes?accessKey=&secretKey=&profileId=&collectionId=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/rest/v1.1/profile/classificationAttributes',
  params: {accessKey: '', secretKey: '', profileId: '', collectionId: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/rest/v1.1/profile/classificationAttributes?accessKey=&secretKey=&profileId=&collectionId=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/rest/v1.1/profile/classificationAttributes?accessKey=&secretKey=&profileId=&collectionId=',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/rest/v1.1/profile/classificationAttributes?accessKey=&secretKey=&profileId=&collectionId=")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/rest/v1.1/profile/classificationAttributes?accessKey=&secretKey=&profileId=&collectionId=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/rest/v1.1/profile/classificationAttributes',
  qs: {accessKey: '', secretKey: '', profileId: '', collectionId: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/rest/v1.1/profile/classificationAttributes');

req.query({
  accessKey: '',
  secretKey: '',
  profileId: '',
  collectionId: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/rest/v1.1/profile/classificationAttributes',
  params: {accessKey: '', secretKey: '', profileId: '', collectionId: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/rest/v1.1/profile/classificationAttributes?accessKey=&secretKey=&profileId=&collectionId=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/rest/v1.1/profile/classificationAttributes?accessKey=&secretKey=&profileId=&collectionId="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/rest/v1.1/profile/classificationAttributes?accessKey=&secretKey=&profileId=&collectionId=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/rest/v1.1/profile/classificationAttributes?accessKey=&secretKey=&profileId=&collectionId=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/rest/v1.1/profile/classificationAttributes?accessKey=&secretKey=&profileId=&collectionId=');

echo $response->getBody();

setUrl('{{baseUrl}}/rest/v1.1/profile/classificationAttributes');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'accessKey' => '',
  'secretKey' => '',
  'profileId' => '',
  'collectionId' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/rest/v1.1/profile/classificationAttributes');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'accessKey' => '',
  'secretKey' => '',
  'profileId' => '',
  'collectionId' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/rest/v1.1/profile/classificationAttributes?accessKey=&secretKey=&profileId=&collectionId=' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/rest/v1.1/profile/classificationAttributes?accessKey=&secretKey=&profileId=&collectionId=' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/rest/v1.1/profile/classificationAttributes?accessKey=&secretKey=&profileId=&collectionId=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/rest/v1.1/profile/classificationAttributes"

querystring = {"accessKey":"","secretKey":"","profileId":"","collectionId":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/rest/v1.1/profile/classificationAttributes"

queryString <- list(
  accessKey = "",
  secretKey = "",
  profileId = "",
  collectionId = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/rest/v1.1/profile/classificationAttributes?accessKey=&secretKey=&profileId=&collectionId=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/rest/v1.1/profile/classificationAttributes') do |req|
  req.params['accessKey'] = ''
  req.params['secretKey'] = ''
  req.params['profileId'] = ''
  req.params['collectionId'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/rest/v1.1/profile/classificationAttributes";

    let querystring = [
        ("accessKey", ""),
        ("secretKey", ""),
        ("profileId", ""),
        ("collectionId", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/rest/v1.1/profile/classificationAttributes?accessKey=&secretKey=&profileId=&collectionId='

http GET '{{baseUrl}}/rest/v1.1/profile/classificationAttributes?accessKey=&secretKey=&profileId=&collectionId='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/rest/v1.1/profile/classificationAttributes?accessKey=&secretKey=&profileId=&collectionId='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/rest/v1.1/profile/classificationAttributes?accessKey=&secretKey=&profileId=&collectionId=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Gets the enrollment status of a profile- information on whether it is suitable for authentication.

{{baseUrl}}/rest/v1.1/profile/enrollmentStatus

QUERY PARAMS

accessKey

secretKey

profileId

collectionId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/rest/v1.1/profile/enrollmentStatus?accessKey=&secretKey=&profileId=&collectionId=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/rest/v1.1/profile/enrollmentStatus" {:query-params {:accessKey ""
                                                                                             :secretKey ""
                                                                                             :profileId ""
                                                                                             :collectionId ""}})

require "http/client"

url = "{{baseUrl}}/rest/v1.1/profile/enrollmentStatus?accessKey=&secretKey=&profileId=&collectionId="

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/rest/v1.1/profile/enrollmentStatus?accessKey=&secretKey=&profileId=&collectionId="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/rest/v1.1/profile/enrollmentStatus?accessKey=&secretKey=&profileId=&collectionId=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/rest/v1.1/profile/enrollmentStatus?accessKey=&secretKey=&profileId=&collectionId="

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/rest/v1.1/profile/enrollmentStatus?accessKey=&secretKey=&profileId=&collectionId= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/rest/v1.1/profile/enrollmentStatus?accessKey=&secretKey=&profileId=&collectionId=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/rest/v1.1/profile/enrollmentStatus?accessKey=&secretKey=&profileId=&collectionId="))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/rest/v1.1/profile/enrollmentStatus?accessKey=&secretKey=&profileId=&collectionId=")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/rest/v1.1/profile/enrollmentStatus?accessKey=&secretKey=&profileId=&collectionId=")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

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

xhr.open('GET', '{{baseUrl}}/rest/v1.1/profile/enrollmentStatus?accessKey=&secretKey=&profileId=&collectionId=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/rest/v1.1/profile/enrollmentStatus',
  params: {accessKey: '', secretKey: '', profileId: '', collectionId: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/rest/v1.1/profile/enrollmentStatus?accessKey=&secretKey=&profileId=&collectionId=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/rest/v1.1/profile/enrollmentStatus?accessKey=&secretKey=&profileId=&collectionId=',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/rest/v1.1/profile/enrollmentStatus?accessKey=&secretKey=&profileId=&collectionId=")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/rest/v1.1/profile/enrollmentStatus?accessKey=&secretKey=&profileId=&collectionId=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/rest/v1.1/profile/enrollmentStatus',
  qs: {accessKey: '', secretKey: '', profileId: '', collectionId: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/rest/v1.1/profile/enrollmentStatus');

req.query({
  accessKey: '',
  secretKey: '',
  profileId: '',
  collectionId: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/rest/v1.1/profile/enrollmentStatus',
  params: {accessKey: '', secretKey: '', profileId: '', collectionId: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/rest/v1.1/profile/enrollmentStatus?accessKey=&secretKey=&profileId=&collectionId=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/rest/v1.1/profile/enrollmentStatus?accessKey=&secretKey=&profileId=&collectionId="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/rest/v1.1/profile/enrollmentStatus?accessKey=&secretKey=&profileId=&collectionId=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/rest/v1.1/profile/enrollmentStatus?accessKey=&secretKey=&profileId=&collectionId=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/rest/v1.1/profile/enrollmentStatus?accessKey=&secretKey=&profileId=&collectionId=');

echo $response->getBody();

setUrl('{{baseUrl}}/rest/v1.1/profile/enrollmentStatus');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'accessKey' => '',
  'secretKey' => '',
  'profileId' => '',
  'collectionId' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/rest/v1.1/profile/enrollmentStatus');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'accessKey' => '',
  'secretKey' => '',
  'profileId' => '',
  'collectionId' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/rest/v1.1/profile/enrollmentStatus?accessKey=&secretKey=&profileId=&collectionId=' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/rest/v1.1/profile/enrollmentStatus?accessKey=&secretKey=&profileId=&collectionId=' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/rest/v1.1/profile/enrollmentStatus?accessKey=&secretKey=&profileId=&collectionId=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/rest/v1.1/profile/enrollmentStatus"

querystring = {"accessKey":"","secretKey":"","profileId":"","collectionId":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/rest/v1.1/profile/enrollmentStatus"

queryString <- list(
  accessKey = "",
  secretKey = "",
  profileId = "",
  collectionId = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/rest/v1.1/profile/enrollmentStatus?accessKey=&secretKey=&profileId=&collectionId=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/rest/v1.1/profile/enrollmentStatus') do |req|
  req.params['accessKey'] = ''
  req.params['secretKey'] = ''
  req.params['profileId'] = ''
  req.params['collectionId'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/rest/v1.1/profile/enrollmentStatus";

    let querystring = [
        ("accessKey", ""),
        ("secretKey", ""),
        ("profileId", ""),
        ("collectionId", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/rest/v1.1/profile/enrollmentStatus?accessKey=&secretKey=&profileId=&collectionId='

http GET '{{baseUrl}}/rest/v1.1/profile/enrollmentStatus?accessKey=&secretKey=&profileId=&collectionId='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/rest/v1.1/profile/enrollmentStatus?accessKey=&secretKey=&profileId=&collectionId='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/rest/v1.1/profile/enrollmentStatus?accessKey=&secretKey=&profileId=&collectionId=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

PUT Maps classification attributes to a profile

{{baseUrl}}/rest/v1.1/profile/classificationAttributes

QUERY PARAMS

accessKey

secretKey

profileId

collectionId

classificationAttributes

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/rest/v1.1/profile/classificationAttributes?accessKey=&secretKey=&profileId=&collectionId=&classificationAttributes=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/rest/v1.1/profile/classificationAttributes" {:query-params {:accessKey ""
                                                                                                     :secretKey ""
                                                                                                     :profileId ""
                                                                                                     :collectionId ""
                                                                                                     :classificationAttributes ""}})

require "http/client"

url = "{{baseUrl}}/rest/v1.1/profile/classificationAttributes?accessKey=&secretKey=&profileId=&collectionId=&classificationAttributes="

response = HTTP::Client.put url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/rest/v1.1/profile/classificationAttributes?accessKey=&secretKey=&profileId=&collectionId=&classificationAttributes="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/rest/v1.1/profile/classificationAttributes?accessKey=&secretKey=&profileId=&collectionId=&classificationAttributes=");
var request = new RestRequest("", Method.Put);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/rest/v1.1/profile/classificationAttributes?accessKey=&secretKey=&profileId=&collectionId=&classificationAttributes="

	req, _ := http.NewRequest("PUT", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

PUT /baseUrl/rest/v1.1/profile/classificationAttributes?accessKey=&secretKey=&profileId=&collectionId=&classificationAttributes= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/rest/v1.1/profile/classificationAttributes?accessKey=&secretKey=&profileId=&collectionId=&classificationAttributes=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/rest/v1.1/profile/classificationAttributes?accessKey=&secretKey=&profileId=&collectionId=&classificationAttributes="))
    .method("PUT", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/rest/v1.1/profile/classificationAttributes?accessKey=&secretKey=&profileId=&collectionId=&classificationAttributes=")
  .put(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/rest/v1.1/profile/classificationAttributes?accessKey=&secretKey=&profileId=&collectionId=&classificationAttributes=")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

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

xhr.open('PUT', '{{baseUrl}}/rest/v1.1/profile/classificationAttributes?accessKey=&secretKey=&profileId=&collectionId=&classificationAttributes=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/rest/v1.1/profile/classificationAttributes',
  params: {
    accessKey: '',
    secretKey: '',
    profileId: '',
    collectionId: '',
    classificationAttributes: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/rest/v1.1/profile/classificationAttributes?accessKey=&secretKey=&profileId=&collectionId=&classificationAttributes=';
const options = {method: 'PUT'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/rest/v1.1/profile/classificationAttributes?accessKey=&secretKey=&profileId=&collectionId=&classificationAttributes=',
  method: 'PUT',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/rest/v1.1/profile/classificationAttributes?accessKey=&secretKey=&profileId=&collectionId=&classificationAttributes=")
  .put(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/rest/v1.1/profile/classificationAttributes?accessKey=&secretKey=&profileId=&collectionId=&classificationAttributes=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/rest/v1.1/profile/classificationAttributes',
  qs: {
    accessKey: '',
    secretKey: '',
    profileId: '',
    collectionId: '',
    classificationAttributes: ''
  }
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/rest/v1.1/profile/classificationAttributes');

req.query({
  accessKey: '',
  secretKey: '',
  profileId: '',
  collectionId: '',
  classificationAttributes: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/rest/v1.1/profile/classificationAttributes',
  params: {
    accessKey: '',
    secretKey: '',
    profileId: '',
    collectionId: '',
    classificationAttributes: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/rest/v1.1/profile/classificationAttributes?accessKey=&secretKey=&profileId=&collectionId=&classificationAttributes=';
const options = {method: 'PUT'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/rest/v1.1/profile/classificationAttributes?accessKey=&secretKey=&profileId=&collectionId=&classificationAttributes="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/rest/v1.1/profile/classificationAttributes?accessKey=&secretKey=&profileId=&collectionId=&classificationAttributes=" in

Client.call `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/rest/v1.1/profile/classificationAttributes?accessKey=&secretKey=&profileId=&collectionId=&classificationAttributes=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/rest/v1.1/profile/classificationAttributes?accessKey=&secretKey=&profileId=&collectionId=&classificationAttributes=');

echo $response->getBody();

setUrl('{{baseUrl}}/rest/v1.1/profile/classificationAttributes');
$request->setMethod(HTTP_METH_PUT);

$request->setQueryData([
  'accessKey' => '',
  'secretKey' => '',
  'profileId' => '',
  'collectionId' => '',
  'classificationAttributes' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/rest/v1.1/profile/classificationAttributes');
$request->setRequestMethod('PUT');
$request->setQuery(new http\QueryString([
  'accessKey' => '',
  'secretKey' => '',
  'profileId' => '',
  'collectionId' => '',
  'classificationAttributes' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/rest/v1.1/profile/classificationAttributes?accessKey=&secretKey=&profileId=&collectionId=&classificationAttributes=' -Method PUT

$response = Invoke-RestMethod -Uri '{{baseUrl}}/rest/v1.1/profile/classificationAttributes?accessKey=&secretKey=&profileId=&collectionId=&classificationAttributes=' -Method PUT

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("PUT", "/baseUrl/rest/v1.1/profile/classificationAttributes?accessKey=&secretKey=&profileId=&collectionId=&classificationAttributes=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/rest/v1.1/profile/classificationAttributes"

querystring = {"accessKey":"","secretKey":"","profileId":"","collectionId":"","classificationAttributes":""}

response = requests.put(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/rest/v1.1/profile/classificationAttributes"

queryString <- list(
  accessKey = "",
  secretKey = "",
  profileId = "",
  collectionId = "",
  classificationAttributes = ""
)

response <- VERB("PUT", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/rest/v1.1/profile/classificationAttributes?accessKey=&secretKey=&profileId=&collectionId=&classificationAttributes=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.put('/baseUrl/rest/v1.1/profile/classificationAttributes') do |req|
  req.params['accessKey'] = ''
  req.params['secretKey'] = ''
  req.params['profileId'] = ''
  req.params['collectionId'] = ''
  req.params['classificationAttributes'] = ''
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/rest/v1.1/profile/classificationAttributes";

    let querystring = [
        ("accessKey", ""),
        ("secretKey", ""),
        ("profileId", ""),
        ("collectionId", ""),
        ("classificationAttributes", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PUT \
  --url '{{baseUrl}}/rest/v1.1/profile/classificationAttributes?accessKey=&secretKey=&profileId=&collectionId=&classificationAttributes='

http PUT '{{baseUrl}}/rest/v1.1/profile/classificationAttributes?accessKey=&secretKey=&profileId=&collectionId=&classificationAttributes='

wget --quiet \
  --method PUT \
  --output-document \
  - '{{baseUrl}}/rest/v1.1/profile/classificationAttributes?accessKey=&secretKey=&profileId=&collectionId=&classificationAttributes='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/rest/v1.1/profile/classificationAttributes?accessKey=&secretKey=&profileId=&collectionId=&classificationAttributes=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

DELETE Removes (unmaps) a list of faces, identified by faceHashes, from a profile, identified by profileId

{{baseUrl}}/rest/v1.1/profile/map

QUERY PARAMS

accessKey

secretKey

faceHashes

profileId

collectionId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/rest/v1.1/profile/map?accessKey=&secretKey=&faceHashes=&profileId=&collectionId=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/rest/v1.1/profile/map" {:query-params {:accessKey ""
                                                                                   :secretKey ""
                                                                                   :faceHashes ""
                                                                                   :profileId ""
                                                                                   :collectionId ""}})

require "http/client"

url = "{{baseUrl}}/rest/v1.1/profile/map?accessKey=&secretKey=&faceHashes=&profileId=&collectionId="

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/rest/v1.1/profile/map?accessKey=&secretKey=&faceHashes=&profileId=&collectionId="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/rest/v1.1/profile/map?accessKey=&secretKey=&faceHashes=&profileId=&collectionId=");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/rest/v1.1/profile/map?accessKey=&secretKey=&faceHashes=&profileId=&collectionId="

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/rest/v1.1/profile/map?accessKey=&secretKey=&faceHashes=&profileId=&collectionId= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/rest/v1.1/profile/map?accessKey=&secretKey=&faceHashes=&profileId=&collectionId=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/rest/v1.1/profile/map?accessKey=&secretKey=&faceHashes=&profileId=&collectionId="))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/rest/v1.1/profile/map?accessKey=&secretKey=&faceHashes=&profileId=&collectionId=")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/rest/v1.1/profile/map?accessKey=&secretKey=&faceHashes=&profileId=&collectionId=")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

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

xhr.open('DELETE', '{{baseUrl}}/rest/v1.1/profile/map?accessKey=&secretKey=&faceHashes=&profileId=&collectionId=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/rest/v1.1/profile/map',
  params: {accessKey: '', secretKey: '', faceHashes: '', profileId: '', collectionId: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/rest/v1.1/profile/map?accessKey=&secretKey=&faceHashes=&profileId=&collectionId=';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/rest/v1.1/profile/map?accessKey=&secretKey=&faceHashes=&profileId=&collectionId=',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/rest/v1.1/profile/map?accessKey=&secretKey=&faceHashes=&profileId=&collectionId=")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/rest/v1.1/profile/map?accessKey=&secretKey=&faceHashes=&profileId=&collectionId=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/rest/v1.1/profile/map',
  qs: {accessKey: '', secretKey: '', faceHashes: '', profileId: '', collectionId: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/rest/v1.1/profile/map');

req.query({
  accessKey: '',
  secretKey: '',
  faceHashes: '',
  profileId: '',
  collectionId: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/rest/v1.1/profile/map',
  params: {accessKey: '', secretKey: '', faceHashes: '', profileId: '', collectionId: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/rest/v1.1/profile/map?accessKey=&secretKey=&faceHashes=&profileId=&collectionId=';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/rest/v1.1/profile/map?accessKey=&secretKey=&faceHashes=&profileId=&collectionId="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/rest/v1.1/profile/map?accessKey=&secretKey=&faceHashes=&profileId=&collectionId=" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/rest/v1.1/profile/map?accessKey=&secretKey=&faceHashes=&profileId=&collectionId=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/rest/v1.1/profile/map?accessKey=&secretKey=&faceHashes=&profileId=&collectionId=');

echo $response->getBody();

setUrl('{{baseUrl}}/rest/v1.1/profile/map');
$request->setMethod(HTTP_METH_DELETE);

$request->setQueryData([
  'accessKey' => '',
  'secretKey' => '',
  'faceHashes' => '',
  'profileId' => '',
  'collectionId' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/rest/v1.1/profile/map');
$request->setRequestMethod('DELETE');
$request->setQuery(new http\QueryString([
  'accessKey' => '',
  'secretKey' => '',
  'faceHashes' => '',
  'profileId' => '',
  'collectionId' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/rest/v1.1/profile/map?accessKey=&secretKey=&faceHashes=&profileId=&collectionId=' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/rest/v1.1/profile/map?accessKey=&secretKey=&faceHashes=&profileId=&collectionId=' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/rest/v1.1/profile/map?accessKey=&secretKey=&faceHashes=&profileId=&collectionId=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/rest/v1.1/profile/map"

querystring = {"accessKey":"","secretKey":"","faceHashes":"","profileId":"","collectionId":""}

response = requests.delete(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/rest/v1.1/profile/map"

queryString <- list(
  accessKey = "",
  secretKey = "",
  faceHashes = "",
  profileId = "",
  collectionId = ""
)

response <- VERB("DELETE", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/rest/v1.1/profile/map?accessKey=&secretKey=&faceHashes=&profileId=&collectionId=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/rest/v1.1/profile/map') do |req|
  req.params['accessKey'] = ''
  req.params['secretKey'] = ''
  req.params['faceHashes'] = ''
  req.params['profileId'] = ''
  req.params['collectionId'] = ''
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/rest/v1.1/profile/map";

    let querystring = [
        ("accessKey", ""),
        ("secretKey", ""),
        ("faceHashes", ""),
        ("profileId", ""),
        ("collectionId", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url '{{baseUrl}}/rest/v1.1/profile/map?accessKey=&secretKey=&faceHashes=&profileId=&collectionId='

http DELETE '{{baseUrl}}/rest/v1.1/profile/map?accessKey=&secretKey=&faceHashes=&profileId=&collectionId='

wget --quiet \
  --method DELETE \
  --output-document \
  - '{{baseUrl}}/rest/v1.1/profile/map?accessKey=&secretKey=&faceHashes=&profileId=&collectionId='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/rest/v1.1/profile/map?accessKey=&secretKey=&faceHashes=&profileId=&collectionId=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

DELETE Removes classification attributes from a profile

{{baseUrl}}/rest/v1.1/profile/classificationAttributes

QUERY PARAMS

accessKey

secretKey

profileId

collectionId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/rest/v1.1/profile/classificationAttributes?accessKey=&secretKey=&profileId=&collectionId=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/rest/v1.1/profile/classificationAttributes" {:query-params {:accessKey ""
                                                                                                        :secretKey ""
                                                                                                        :profileId ""
                                                                                                        :collectionId ""}})

require "http/client"

url = "{{baseUrl}}/rest/v1.1/profile/classificationAttributes?accessKey=&secretKey=&profileId=&collectionId="

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/rest/v1.1/profile/classificationAttributes?accessKey=&secretKey=&profileId=&collectionId="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/rest/v1.1/profile/classificationAttributes?accessKey=&secretKey=&profileId=&collectionId=");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/rest/v1.1/profile/classificationAttributes?accessKey=&secretKey=&profileId=&collectionId="

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/rest/v1.1/profile/classificationAttributes?accessKey=&secretKey=&profileId=&collectionId= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/rest/v1.1/profile/classificationAttributes?accessKey=&secretKey=&profileId=&collectionId=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/rest/v1.1/profile/classificationAttributes?accessKey=&secretKey=&profileId=&collectionId="))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/rest/v1.1/profile/classificationAttributes?accessKey=&secretKey=&profileId=&collectionId=")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/rest/v1.1/profile/classificationAttributes?accessKey=&secretKey=&profileId=&collectionId=")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

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

xhr.open('DELETE', '{{baseUrl}}/rest/v1.1/profile/classificationAttributes?accessKey=&secretKey=&profileId=&collectionId=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/rest/v1.1/profile/classificationAttributes',
  params: {accessKey: '', secretKey: '', profileId: '', collectionId: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/rest/v1.1/profile/classificationAttributes?accessKey=&secretKey=&profileId=&collectionId=';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/rest/v1.1/profile/classificationAttributes?accessKey=&secretKey=&profileId=&collectionId=',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/rest/v1.1/profile/classificationAttributes?accessKey=&secretKey=&profileId=&collectionId=")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/rest/v1.1/profile/classificationAttributes?accessKey=&secretKey=&profileId=&collectionId=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/rest/v1.1/profile/classificationAttributes',
  qs: {accessKey: '', secretKey: '', profileId: '', collectionId: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/rest/v1.1/profile/classificationAttributes');

req.query({
  accessKey: '',
  secretKey: '',
  profileId: '',
  collectionId: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/rest/v1.1/profile/classificationAttributes',
  params: {accessKey: '', secretKey: '', profileId: '', collectionId: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/rest/v1.1/profile/classificationAttributes?accessKey=&secretKey=&profileId=&collectionId=';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/rest/v1.1/profile/classificationAttributes?accessKey=&secretKey=&profileId=&collectionId="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/rest/v1.1/profile/classificationAttributes?accessKey=&secretKey=&profileId=&collectionId=" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/rest/v1.1/profile/classificationAttributes?accessKey=&secretKey=&profileId=&collectionId=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/rest/v1.1/profile/classificationAttributes?accessKey=&secretKey=&profileId=&collectionId=');

echo $response->getBody();

setUrl('{{baseUrl}}/rest/v1.1/profile/classificationAttributes');
$request->setMethod(HTTP_METH_DELETE);

$request->setQueryData([
  'accessKey' => '',
  'secretKey' => '',
  'profileId' => '',
  'collectionId' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/rest/v1.1/profile/classificationAttributes');
$request->setRequestMethod('DELETE');
$request->setQuery(new http\QueryString([
  'accessKey' => '',
  'secretKey' => '',
  'profileId' => '',
  'collectionId' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/rest/v1.1/profile/classificationAttributes?accessKey=&secretKey=&profileId=&collectionId=' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/rest/v1.1/profile/classificationAttributes?accessKey=&secretKey=&profileId=&collectionId=' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/rest/v1.1/profile/classificationAttributes?accessKey=&secretKey=&profileId=&collectionId=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/rest/v1.1/profile/classificationAttributes"

querystring = {"accessKey":"","secretKey":"","profileId":"","collectionId":""}

response = requests.delete(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/rest/v1.1/profile/classificationAttributes"

queryString <- list(
  accessKey = "",
  secretKey = "",
  profileId = "",
  collectionId = ""
)

response <- VERB("DELETE", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/rest/v1.1/profile/classificationAttributes?accessKey=&secretKey=&profileId=&collectionId=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/rest/v1.1/profile/classificationAttributes') do |req|
  req.params['accessKey'] = ''
  req.params['secretKey'] = ''
  req.params['profileId'] = ''
  req.params['collectionId'] = ''
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/rest/v1.1/profile/classificationAttributes";

    let querystring = [
        ("accessKey", ""),
        ("secretKey", ""),
        ("profileId", ""),
        ("collectionId", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url '{{baseUrl}}/rest/v1.1/profile/classificationAttributes?accessKey=&secretKey=&profileId=&collectionId='

http DELETE '{{baseUrl}}/rest/v1.1/profile/classificationAttributes?accessKey=&secretKey=&profileId=&collectionId='

wget --quiet \
  --method DELETE \
  --output-document \
  - '{{baseUrl}}/rest/v1.1/profile/classificationAttributes?accessKey=&secretKey=&profileId=&collectionId='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/rest/v1.1/profile/classificationAttributes?accessKey=&secretKey=&profileId=&collectionId=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Retrieves a profile

{{baseUrl}}/rest/v1.1/profile/:id

QUERY PARAMS

accessKey

secretKey

collectionId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/rest/v1.1/profile/:id?accessKey=&secretKey=&collectionId=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/rest/v1.1/profile/:id" {:query-params {:accessKey ""
                                                                                :secretKey ""
                                                                                :collectionId ""}})

require "http/client"

url = "{{baseUrl}}/rest/v1.1/profile/:id?accessKey=&secretKey=&collectionId="

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/rest/v1.1/profile/:id?accessKey=&secretKey=&collectionId="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/rest/v1.1/profile/:id?accessKey=&secretKey=&collectionId=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/rest/v1.1/profile/:id?accessKey=&secretKey=&collectionId="

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/rest/v1.1/profile/:id?accessKey=&secretKey=&collectionId= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/rest/v1.1/profile/:id?accessKey=&secretKey=&collectionId=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/rest/v1.1/profile/:id?accessKey=&secretKey=&collectionId="))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/rest/v1.1/profile/:id?accessKey=&secretKey=&collectionId=")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/rest/v1.1/profile/:id?accessKey=&secretKey=&collectionId=")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

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

xhr.open('GET', '{{baseUrl}}/rest/v1.1/profile/:id?accessKey=&secretKey=&collectionId=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/rest/v1.1/profile/:id',
  params: {accessKey: '', secretKey: '', collectionId: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/rest/v1.1/profile/:id?accessKey=&secretKey=&collectionId=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/rest/v1.1/profile/:id?accessKey=&secretKey=&collectionId=',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/rest/v1.1/profile/:id?accessKey=&secretKey=&collectionId=")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/rest/v1.1/profile/:id?accessKey=&secretKey=&collectionId=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/rest/v1.1/profile/:id',
  qs: {accessKey: '', secretKey: '', collectionId: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/rest/v1.1/profile/:id');

req.query({
  accessKey: '',
  secretKey: '',
  collectionId: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/rest/v1.1/profile/:id',
  params: {accessKey: '', secretKey: '', collectionId: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/rest/v1.1/profile/:id?accessKey=&secretKey=&collectionId=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/rest/v1.1/profile/:id?accessKey=&secretKey=&collectionId="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/rest/v1.1/profile/:id?accessKey=&secretKey=&collectionId=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/rest/v1.1/profile/:id?accessKey=&secretKey=&collectionId=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/rest/v1.1/profile/:id?accessKey=&secretKey=&collectionId=');

echo $response->getBody();

setUrl('{{baseUrl}}/rest/v1.1/profile/:id');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'accessKey' => '',
  'secretKey' => '',
  'collectionId' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/rest/v1.1/profile/:id');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'accessKey' => '',
  'secretKey' => '',
  'collectionId' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/rest/v1.1/profile/:id?accessKey=&secretKey=&collectionId=' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/rest/v1.1/profile/:id?accessKey=&secretKey=&collectionId=' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/rest/v1.1/profile/:id?accessKey=&secretKey=&collectionId=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/rest/v1.1/profile/:id"

querystring = {"accessKey":"","secretKey":"","collectionId":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/rest/v1.1/profile/:id"

queryString <- list(
  accessKey = "",
  secretKey = "",
  collectionId = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/rest/v1.1/profile/:id?accessKey=&secretKey=&collectionId=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/rest/v1.1/profile/:id') do |req|
  req.params['accessKey'] = ''
  req.params['secretKey'] = ''
  req.params['collectionId'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/rest/v1.1/profile/:id";

    let querystring = [
        ("accessKey", ""),
        ("secretKey", ""),
        ("collectionId", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/rest/v1.1/profile/:id?accessKey=&secretKey=&collectionId='

http GET '{{baseUrl}}/rest/v1.1/profile/:id?accessKey=&secretKey=&collectionId='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/rest/v1.1/profile/:id?accessKey=&secretKey=&collectionId='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/rest/v1.1/profile/:id?accessKey=&secretKey=&collectionId=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

PATCH Update an existing profile with a given id

{{baseUrl}}/rest/v1.1/profile/:id

QUERY PARAMS

accessKey

secretKey

collectionId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/rest/v1.1/profile/:id?accessKey=&secretKey=&collectionId=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/patch "{{baseUrl}}/rest/v1.1/profile/:id" {:query-params {:accessKey ""
                                                                                  :secretKey ""
                                                                                  :collectionId ""}})

require "http/client"

url = "{{baseUrl}}/rest/v1.1/profile/:id?accessKey=&secretKey=&collectionId="

response = HTTP::Client.patch url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Patch,
    RequestUri = new Uri("{{baseUrl}}/rest/v1.1/profile/:id?accessKey=&secretKey=&collectionId="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/rest/v1.1/profile/:id?accessKey=&secretKey=&collectionId=");
var request = new RestRequest("", Method.Patch);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/rest/v1.1/profile/:id?accessKey=&secretKey=&collectionId="

	req, _ := http.NewRequest("PATCH", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

PATCH /baseUrl/rest/v1.1/profile/:id?accessKey=&secretKey=&collectionId= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/rest/v1.1/profile/:id?accessKey=&secretKey=&collectionId=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/rest/v1.1/profile/:id?accessKey=&secretKey=&collectionId="))
    .method("PATCH", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/rest/v1.1/profile/:id?accessKey=&secretKey=&collectionId=")
  .patch(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.patch("{{baseUrl}}/rest/v1.1/profile/:id?accessKey=&secretKey=&collectionId=")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

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

xhr.open('PATCH', '{{baseUrl}}/rest/v1.1/profile/:id?accessKey=&secretKey=&collectionId=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/rest/v1.1/profile/:id',
  params: {accessKey: '', secretKey: '', collectionId: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/rest/v1.1/profile/:id?accessKey=&secretKey=&collectionId=';
const options = {method: 'PATCH'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/rest/v1.1/profile/:id?accessKey=&secretKey=&collectionId=',
  method: 'PATCH',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/rest/v1.1/profile/:id?accessKey=&secretKey=&collectionId=")
  .patch(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PATCH',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/rest/v1.1/profile/:id?accessKey=&secretKey=&collectionId=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/rest/v1.1/profile/:id',
  qs: {accessKey: '', secretKey: '', collectionId: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PATCH', '{{baseUrl}}/rest/v1.1/profile/:id');

req.query({
  accessKey: '',
  secretKey: '',
  collectionId: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/rest/v1.1/profile/:id',
  params: {accessKey: '', secretKey: '', collectionId: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/rest/v1.1/profile/:id?accessKey=&secretKey=&collectionId=';
const options = {method: 'PATCH'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/rest/v1.1/profile/:id?accessKey=&secretKey=&collectionId="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PATCH"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/rest/v1.1/profile/:id?accessKey=&secretKey=&collectionId=" in

Client.call `PATCH uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/rest/v1.1/profile/:id?accessKey=&secretKey=&collectionId=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PATCH",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PATCH', '{{baseUrl}}/rest/v1.1/profile/:id?accessKey=&secretKey=&collectionId=');

echo $response->getBody();

setUrl('{{baseUrl}}/rest/v1.1/profile/:id');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

$request->setQueryData([
  'accessKey' => '',
  'secretKey' => '',
  'collectionId' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/rest/v1.1/profile/:id');
$request->setRequestMethod('PATCH');
$request->setQuery(new http\QueryString([
  'accessKey' => '',
  'secretKey' => '',
  'collectionId' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/rest/v1.1/profile/:id?accessKey=&secretKey=&collectionId=' -Method PATCH

$response = Invoke-RestMethod -Uri '{{baseUrl}}/rest/v1.1/profile/:id?accessKey=&secretKey=&collectionId=' -Method PATCH

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("PATCH", "/baseUrl/rest/v1.1/profile/:id?accessKey=&secretKey=&collectionId=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/rest/v1.1/profile/:id"

querystring = {"accessKey":"","secretKey":"","collectionId":""}

response = requests.patch(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/rest/v1.1/profile/:id"

queryString <- list(
  accessKey = "",
  secretKey = "",
  collectionId = ""
)

response <- VERB("PATCH", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/rest/v1.1/profile/:id?accessKey=&secretKey=&collectionId=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Patch.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.patch('/baseUrl/rest/v1.1/profile/:id') do |req|
  req.params['accessKey'] = ''
  req.params['secretKey'] = ''
  req.params['collectionId'] = ''
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/rest/v1.1/profile/:id";

    let querystring = [
        ("accessKey", ""),
        ("secretKey", ""),
        ("collectionId", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PATCH").unwrap(), url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PATCH \
  --url '{{baseUrl}}/rest/v1.1/profile/:id?accessKey=&secretKey=&collectionId='

http PATCH '{{baseUrl}}/rest/v1.1/profile/:id?accessKey=&secretKey=&collectionId='

wget --quiet \
  --method PATCH \
  --output-document \
  - '{{baseUrl}}/rest/v1.1/profile/:id?accessKey=&secretKey=&collectionId='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/rest/v1.1/profile/:id?accessKey=&secretKey=&collectionId=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PATCH"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

PATCH Cleanup frames older than specified timeframe

{{baseUrl}}/rest/v1.1/stream/cleanup

QUERY PARAMS

accessKey

secretKey

streamId

interval

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/rest/v1.1/stream/cleanup?accessKey=&secretKey=&streamId=&interval=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/patch "{{baseUrl}}/rest/v1.1/stream/cleanup" {:query-params {:accessKey ""
                                                                                     :secretKey ""
                                                                                     :streamId ""
                                                                                     :interval ""}})

require "http/client"

url = "{{baseUrl}}/rest/v1.1/stream/cleanup?accessKey=&secretKey=&streamId=&interval="

response = HTTP::Client.patch url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Patch,
    RequestUri = new Uri("{{baseUrl}}/rest/v1.1/stream/cleanup?accessKey=&secretKey=&streamId=&interval="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/rest/v1.1/stream/cleanup?accessKey=&secretKey=&streamId=&interval=");
var request = new RestRequest("", Method.Patch);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/rest/v1.1/stream/cleanup?accessKey=&secretKey=&streamId=&interval="

	req, _ := http.NewRequest("PATCH", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

PATCH /baseUrl/rest/v1.1/stream/cleanup?accessKey=&secretKey=&streamId=&interval= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/rest/v1.1/stream/cleanup?accessKey=&secretKey=&streamId=&interval=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/rest/v1.1/stream/cleanup?accessKey=&secretKey=&streamId=&interval="))
    .method("PATCH", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/rest/v1.1/stream/cleanup?accessKey=&secretKey=&streamId=&interval=")
  .patch(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.patch("{{baseUrl}}/rest/v1.1/stream/cleanup?accessKey=&secretKey=&streamId=&interval=")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

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

xhr.open('PATCH', '{{baseUrl}}/rest/v1.1/stream/cleanup?accessKey=&secretKey=&streamId=&interval=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/rest/v1.1/stream/cleanup',
  params: {accessKey: '', secretKey: '', streamId: '', interval: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/rest/v1.1/stream/cleanup?accessKey=&secretKey=&streamId=&interval=';
const options = {method: 'PATCH'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/rest/v1.1/stream/cleanup?accessKey=&secretKey=&streamId=&interval=',
  method: 'PATCH',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/rest/v1.1/stream/cleanup?accessKey=&secretKey=&streamId=&interval=")
  .patch(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PATCH',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/rest/v1.1/stream/cleanup?accessKey=&secretKey=&streamId=&interval=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/rest/v1.1/stream/cleanup',
  qs: {accessKey: '', secretKey: '', streamId: '', interval: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PATCH', '{{baseUrl}}/rest/v1.1/stream/cleanup');

req.query({
  accessKey: '',
  secretKey: '',
  streamId: '',
  interval: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/rest/v1.1/stream/cleanup',
  params: {accessKey: '', secretKey: '', streamId: '', interval: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/rest/v1.1/stream/cleanup?accessKey=&secretKey=&streamId=&interval=';
const options = {method: 'PATCH'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/rest/v1.1/stream/cleanup?accessKey=&secretKey=&streamId=&interval="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PATCH"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/rest/v1.1/stream/cleanup?accessKey=&secretKey=&streamId=&interval=" in

Client.call `PATCH uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/rest/v1.1/stream/cleanup?accessKey=&secretKey=&streamId=&interval=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PATCH",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PATCH', '{{baseUrl}}/rest/v1.1/stream/cleanup?accessKey=&secretKey=&streamId=&interval=');

echo $response->getBody();

setUrl('{{baseUrl}}/rest/v1.1/stream/cleanup');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

$request->setQueryData([
  'accessKey' => '',
  'secretKey' => '',
  'streamId' => '',
  'interval' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/rest/v1.1/stream/cleanup');
$request->setRequestMethod('PATCH');
$request->setQuery(new http\QueryString([
  'accessKey' => '',
  'secretKey' => '',
  'streamId' => '',
  'interval' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/rest/v1.1/stream/cleanup?accessKey=&secretKey=&streamId=&interval=' -Method PATCH

$response = Invoke-RestMethod -Uri '{{baseUrl}}/rest/v1.1/stream/cleanup?accessKey=&secretKey=&streamId=&interval=' -Method PATCH

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("PATCH", "/baseUrl/rest/v1.1/stream/cleanup?accessKey=&secretKey=&streamId=&interval=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/rest/v1.1/stream/cleanup"

querystring = {"accessKey":"","secretKey":"","streamId":"","interval":""}

response = requests.patch(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/rest/v1.1/stream/cleanup"

queryString <- list(
  accessKey = "",
  secretKey = "",
  streamId = "",
  interval = ""
)

response <- VERB("PATCH", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/rest/v1.1/stream/cleanup?accessKey=&secretKey=&streamId=&interval=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Patch.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.patch('/baseUrl/rest/v1.1/stream/cleanup') do |req|
  req.params['accessKey'] = ''
  req.params['secretKey'] = ''
  req.params['streamId'] = ''
  req.params['interval'] = ''
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/rest/v1.1/stream/cleanup";

    let querystring = [
        ("accessKey", ""),
        ("secretKey", ""),
        ("streamId", ""),
        ("interval", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PATCH").unwrap(), url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PATCH \
  --url '{{baseUrl}}/rest/v1.1/stream/cleanup?accessKey=&secretKey=&streamId=&interval='

http PATCH '{{baseUrl}}/rest/v1.1/stream/cleanup?accessKey=&secretKey=&streamId=&interval='

wget --quiet \
  --method PATCH \
  --output-document \
  - '{{baseUrl}}/rest/v1.1/stream/cleanup?accessKey=&secretKey=&streamId=&interval='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/rest/v1.1/stream/cleanup?accessKey=&secretKey=&streamId=&interval=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PATCH"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST Create new stream with given name

{{baseUrl}}/rest/v1.1/stream/stream

QUERY PARAMS

accessKey

secretKey

name

url

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/rest/v1.1/stream/stream?accessKey=&secretKey=&name=&url=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/rest/v1.1/stream/stream" {:query-params {:accessKey ""
                                                                                   :secretKey ""
                                                                                   :name ""
                                                                                   :url ""}})

require "http/client"

url = "{{baseUrl}}/rest/v1.1/stream/stream?accessKey=&secretKey=&name=&url="

response = HTTP::Client.post url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/rest/v1.1/stream/stream?accessKey=&secretKey=&name=&url="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/rest/v1.1/stream/stream?accessKey=&secretKey=&name=&url=");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/rest/v1.1/stream/stream?accessKey=&secretKey=&name=&url="

	req, _ := http.NewRequest("POST", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/rest/v1.1/stream/stream?accessKey=&secretKey=&name=&url= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/rest/v1.1/stream/stream?accessKey=&secretKey=&name=&url=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/rest/v1.1/stream/stream?accessKey=&secretKey=&name=&url="))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/rest/v1.1/stream/stream?accessKey=&secretKey=&name=&url=")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/rest/v1.1/stream/stream?accessKey=&secretKey=&name=&url=")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

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

xhr.open('POST', '{{baseUrl}}/rest/v1.1/stream/stream?accessKey=&secretKey=&name=&url=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/rest/v1.1/stream/stream',
  params: {accessKey: '', secretKey: '', name: '', url: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/rest/v1.1/stream/stream?accessKey=&secretKey=&name=&url=';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/rest/v1.1/stream/stream?accessKey=&secretKey=&name=&url=',
  method: 'POST',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/rest/v1.1/stream/stream?accessKey=&secretKey=&name=&url=")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/rest/v1.1/stream/stream?accessKey=&secretKey=&name=&url=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/rest/v1.1/stream/stream',
  qs: {accessKey: '', secretKey: '', name: '', url: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/rest/v1.1/stream/stream');

req.query({
  accessKey: '',
  secretKey: '',
  name: '',
  url: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/rest/v1.1/stream/stream',
  params: {accessKey: '', secretKey: '', name: '', url: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/rest/v1.1/stream/stream?accessKey=&secretKey=&name=&url=';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/rest/v1.1/stream/stream?accessKey=&secretKey=&name=&url="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/rest/v1.1/stream/stream?accessKey=&secretKey=&name=&url=" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/rest/v1.1/stream/stream?accessKey=&secretKey=&name=&url=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/rest/v1.1/stream/stream?accessKey=&secretKey=&name=&url=');

echo $response->getBody();

setUrl('{{baseUrl}}/rest/v1.1/stream/stream');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'accessKey' => '',
  'secretKey' => '',
  'name' => '',
  'url' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/rest/v1.1/stream/stream');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'accessKey' => '',
  'secretKey' => '',
  'name' => '',
  'url' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/rest/v1.1/stream/stream?accessKey=&secretKey=&name=&url=' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/rest/v1.1/stream/stream?accessKey=&secretKey=&name=&url=' -Method POST

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/rest/v1.1/stream/stream?accessKey=&secretKey=&name=&url=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/rest/v1.1/stream/stream"

querystring = {"accessKey":"","secretKey":"","name":"","url":""}

response = requests.post(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/rest/v1.1/stream/stream"

queryString <- list(
  accessKey = "",
  secretKey = "",
  name = "",
  url = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/rest/v1.1/stream/stream?accessKey=&secretKey=&name=&url=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/rest/v1.1/stream/stream') do |req|
  req.params['accessKey'] = ''
  req.params['secretKey'] = ''
  req.params['name'] = ''
  req.params['url'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/rest/v1.1/stream/stream";

    let querystring = [
        ("accessKey", ""),
        ("secretKey", ""),
        ("name", ""),
        ("url", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.post(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/rest/v1.1/stream/stream?accessKey=&secretKey=&name=&url='

http POST '{{baseUrl}}/rest/v1.1/stream/stream?accessKey=&secretKey=&name=&url='

wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/rest/v1.1/stream/stream?accessKey=&secretKey=&name=&url='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/rest/v1.1/stream/stream?accessKey=&secretKey=&name=&url=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

DELETE Delete existing stream

{{baseUrl}}/rest/v1.1/stream/:id

QUERY PARAMS

accessKey

secretKey

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/rest/v1.1/stream/:id?accessKey=&secretKey=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/rest/v1.1/stream/:id" {:query-params {:accessKey ""
                                                                                  :secretKey ""}})

require "http/client"

url = "{{baseUrl}}/rest/v1.1/stream/:id?accessKey=&secretKey="

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/rest/v1.1/stream/:id?accessKey=&secretKey="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/rest/v1.1/stream/:id?accessKey=&secretKey=");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/rest/v1.1/stream/:id?accessKey=&secretKey="

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/rest/v1.1/stream/:id?accessKey=&secretKey= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/rest/v1.1/stream/:id?accessKey=&secretKey=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/rest/v1.1/stream/:id?accessKey=&secretKey="))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/rest/v1.1/stream/:id?accessKey=&secretKey=")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/rest/v1.1/stream/:id?accessKey=&secretKey=")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

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

xhr.open('DELETE', '{{baseUrl}}/rest/v1.1/stream/:id?accessKey=&secretKey=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/rest/v1.1/stream/:id',
  params: {accessKey: '', secretKey: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/rest/v1.1/stream/:id?accessKey=&secretKey=';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/rest/v1.1/stream/:id?accessKey=&secretKey=',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/rest/v1.1/stream/:id?accessKey=&secretKey=")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/rest/v1.1/stream/:id?accessKey=&secretKey=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/rest/v1.1/stream/:id',
  qs: {accessKey: '', secretKey: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/rest/v1.1/stream/:id');

req.query({
  accessKey: '',
  secretKey: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/rest/v1.1/stream/:id',
  params: {accessKey: '', secretKey: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/rest/v1.1/stream/:id?accessKey=&secretKey=';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/rest/v1.1/stream/:id?accessKey=&secretKey="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/rest/v1.1/stream/:id?accessKey=&secretKey=" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/rest/v1.1/stream/:id?accessKey=&secretKey=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/rest/v1.1/stream/:id?accessKey=&secretKey=');

echo $response->getBody();

setUrl('{{baseUrl}}/rest/v1.1/stream/:id');
$request->setMethod(HTTP_METH_DELETE);

$request->setQueryData([
  'accessKey' => '',
  'secretKey' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/rest/v1.1/stream/:id');
$request->setRequestMethod('DELETE');
$request->setQuery(new http\QueryString([
  'accessKey' => '',
  'secretKey' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/rest/v1.1/stream/:id?accessKey=&secretKey=' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/rest/v1.1/stream/:id?accessKey=&secretKey=' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/rest/v1.1/stream/:id?accessKey=&secretKey=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/rest/v1.1/stream/:id"

querystring = {"accessKey":"","secretKey":""}

response = requests.delete(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/rest/v1.1/stream/:id"

queryString <- list(
  accessKey = "",
  secretKey = ""
)

response <- VERB("DELETE", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/rest/v1.1/stream/:id?accessKey=&secretKey=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/rest/v1.1/stream/:id') do |req|
  req.params['accessKey'] = ''
  req.params['secretKey'] = ''
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/rest/v1.1/stream/:id";

    let querystring = [
        ("accessKey", ""),
        ("secretKey", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url '{{baseUrl}}/rest/v1.1/stream/:id?accessKey=&secretKey='

http DELETE '{{baseUrl}}/rest/v1.1/stream/:id?accessKey=&secretKey='

wget --quiet \
  --method DELETE \
  --output-document \
  - '{{baseUrl}}/rest/v1.1/stream/:id?accessKey=&secretKey='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/rest/v1.1/stream/:id?accessKey=&secretKey=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Get an existing stream with a given ID

{{baseUrl}}/rest/v1.1/stream/:streamId

QUERY PARAMS

accessKey

secretKey

streamId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/rest/v1.1/stream/:streamId?accessKey=&secretKey=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/rest/v1.1/stream/:streamId" {:query-params {:accessKey ""
                                                                                     :secretKey ""}})

require "http/client"

url = "{{baseUrl}}/rest/v1.1/stream/:streamId?accessKey=&secretKey="

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/rest/v1.1/stream/:streamId?accessKey=&secretKey="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/rest/v1.1/stream/:streamId?accessKey=&secretKey=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/rest/v1.1/stream/:streamId?accessKey=&secretKey="

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/rest/v1.1/stream/:streamId?accessKey=&secretKey= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/rest/v1.1/stream/:streamId?accessKey=&secretKey=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/rest/v1.1/stream/:streamId?accessKey=&secretKey="))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/rest/v1.1/stream/:streamId?accessKey=&secretKey=")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/rest/v1.1/stream/:streamId?accessKey=&secretKey=")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

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

xhr.open('GET', '{{baseUrl}}/rest/v1.1/stream/:streamId?accessKey=&secretKey=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/rest/v1.1/stream/:streamId',
  params: {accessKey: '', secretKey: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/rest/v1.1/stream/:streamId?accessKey=&secretKey=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/rest/v1.1/stream/:streamId?accessKey=&secretKey=',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/rest/v1.1/stream/:streamId?accessKey=&secretKey=")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/rest/v1.1/stream/:streamId?accessKey=&secretKey=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/rest/v1.1/stream/:streamId',
  qs: {accessKey: '', secretKey: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/rest/v1.1/stream/:streamId');

req.query({
  accessKey: '',
  secretKey: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/rest/v1.1/stream/:streamId',
  params: {accessKey: '', secretKey: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/rest/v1.1/stream/:streamId?accessKey=&secretKey=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/rest/v1.1/stream/:streamId?accessKey=&secretKey="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/rest/v1.1/stream/:streamId?accessKey=&secretKey=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/rest/v1.1/stream/:streamId?accessKey=&secretKey=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/rest/v1.1/stream/:streamId?accessKey=&secretKey=');

echo $response->getBody();

setUrl('{{baseUrl}}/rest/v1.1/stream/:streamId');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'accessKey' => '',
  'secretKey' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/rest/v1.1/stream/:streamId');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'accessKey' => '',
  'secretKey' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/rest/v1.1/stream/:streamId?accessKey=&secretKey=' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/rest/v1.1/stream/:streamId?accessKey=&secretKey=' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/rest/v1.1/stream/:streamId?accessKey=&secretKey=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/rest/v1.1/stream/:streamId"

querystring = {"accessKey":"","secretKey":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/rest/v1.1/stream/:streamId"

queryString <- list(
  accessKey = "",
  secretKey = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/rest/v1.1/stream/:streamId?accessKey=&secretKey=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/rest/v1.1/stream/:streamId') do |req|
  req.params['accessKey'] = ''
  req.params['secretKey'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/rest/v1.1/stream/:streamId";

    let querystring = [
        ("accessKey", ""),
        ("secretKey", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/rest/v1.1/stream/:streamId?accessKey=&secretKey='

http GET '{{baseUrl}}/rest/v1.1/stream/:streamId?accessKey=&secretKey='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/rest/v1.1/stream/:streamId?accessKey=&secretKey='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/rest/v1.1/stream/:streamId?accessKey=&secretKey=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Get individual frame image

{{baseUrl}}/rest/v1.1/stream/frameImage

QUERY PARAMS

accessKey

secretKey

streamId

timestamp

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/rest/v1.1/stream/frameImage?accessKey=&secretKey=&streamId=×tamp=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/rest/v1.1/stream/frameImage" {:query-params {:accessKey ""
                                                                                      :secretKey ""
                                                                                      :streamId ""
                                                                                      :timestamp ""}})

require "http/client"

url = "{{baseUrl}}/rest/v1.1/stream/frameImage?accessKey=&secretKey=&streamId=×tamp="

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/rest/v1.1/stream/frameImage?accessKey=&secretKey=&streamId=×tamp="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/rest/v1.1/stream/frameImage?accessKey=&secretKey=&streamId=×tamp=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/rest/v1.1/stream/frameImage?accessKey=&secretKey=&streamId=×tamp="

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/rest/v1.1/stream/frameImage?accessKey=&secretKey=&streamId=×tamp= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/rest/v1.1/stream/frameImage?accessKey=&secretKey=&streamId=×tamp=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/rest/v1.1/stream/frameImage?accessKey=&secretKey=&streamId=×tamp="))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/rest/v1.1/stream/frameImage?accessKey=&secretKey=&streamId=×tamp=")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/rest/v1.1/stream/frameImage?accessKey=&secretKey=&streamId=×tamp=")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

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

xhr.open('GET', '{{baseUrl}}/rest/v1.1/stream/frameImage?accessKey=&secretKey=&streamId=×tamp=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/rest/v1.1/stream/frameImage',
  params: {accessKey: '', secretKey: '', streamId: '', timestamp: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/rest/v1.1/stream/frameImage?accessKey=&secretKey=&streamId=×tamp=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/rest/v1.1/stream/frameImage?accessKey=&secretKey=&streamId=×tamp=',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/rest/v1.1/stream/frameImage?accessKey=&secretKey=&streamId=×tamp=")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/rest/v1.1/stream/frameImage?accessKey=&secretKey=&streamId=×tamp=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/rest/v1.1/stream/frameImage',
  qs: {accessKey: '', secretKey: '', streamId: '', timestamp: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/rest/v1.1/stream/frameImage');

req.query({
  accessKey: '',
  secretKey: '',
  streamId: '',
  timestamp: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/rest/v1.1/stream/frameImage',
  params: {accessKey: '', secretKey: '', streamId: '', timestamp: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/rest/v1.1/stream/frameImage?accessKey=&secretKey=&streamId=×tamp=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/rest/v1.1/stream/frameImage?accessKey=&secretKey=&streamId=×tamp="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/rest/v1.1/stream/frameImage?accessKey=&secretKey=&streamId=×tamp=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/rest/v1.1/stream/frameImage?accessKey=&secretKey=&streamId=×tamp=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/rest/v1.1/stream/frameImage?accessKey=&secretKey=&streamId=×tamp=');

echo $response->getBody();

setUrl('{{baseUrl}}/rest/v1.1/stream/frameImage');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'accessKey' => '',
  'secretKey' => '',
  'streamId' => '',
  'timestamp' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/rest/v1.1/stream/frameImage');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'accessKey' => '',
  'secretKey' => '',
  'streamId' => '',
  'timestamp' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/rest/v1.1/stream/frameImage?accessKey=&secretKey=&streamId=×tamp=' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/rest/v1.1/stream/frameImage?accessKey=&secretKey=&streamId=×tamp=' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/rest/v1.1/stream/frameImage?accessKey=&secretKey=&streamId=×tamp=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/rest/v1.1/stream/frameImage"

querystring = {"accessKey":"","secretKey":"","streamId":"","timestamp":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/rest/v1.1/stream/frameImage"

queryString <- list(
  accessKey = "",
  secretKey = "",
  streamId = "",
  timestamp = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/rest/v1.1/stream/frameImage?accessKey=&secretKey=&streamId=×tamp=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/rest/v1.1/stream/frameImage') do |req|
  req.params['accessKey'] = ''
  req.params['secretKey'] = ''
  req.params['streamId'] = ''
  req.params['timestamp'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/rest/v1.1/stream/frameImage";

    let querystring = [
        ("accessKey", ""),
        ("secretKey", ""),
        ("streamId", ""),
        ("timestamp", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/rest/v1.1/stream/frameImage?accessKey=&secretKey=&streamId=×tamp='

http GET '{{baseUrl}}/rest/v1.1/stream/frameImage?accessKey=&secretKey=&streamId=×tamp='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/rest/v1.1/stream/frameImage?accessKey=&secretKey=&streamId=×tamp='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/rest/v1.1/stream/frameImage?accessKey=&secretKey=&streamId=×tamp=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Get last N recognized individuals from stream

{{baseUrl}}/rest/v1.1/stream/attendance

QUERY PARAMS

accessKey

secretKey

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/rest/v1.1/stream/attendance?accessKey=&secretKey=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/rest/v1.1/stream/attendance" {:query-params {:accessKey ""
                                                                                      :secretKey ""}})

require "http/client"

url = "{{baseUrl}}/rest/v1.1/stream/attendance?accessKey=&secretKey="

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/rest/v1.1/stream/attendance?accessKey=&secretKey="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/rest/v1.1/stream/attendance?accessKey=&secretKey=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/rest/v1.1/stream/attendance?accessKey=&secretKey="

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/rest/v1.1/stream/attendance?accessKey=&secretKey= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/rest/v1.1/stream/attendance?accessKey=&secretKey=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/rest/v1.1/stream/attendance?accessKey=&secretKey="))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/rest/v1.1/stream/attendance?accessKey=&secretKey=")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/rest/v1.1/stream/attendance?accessKey=&secretKey=")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

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

xhr.open('GET', '{{baseUrl}}/rest/v1.1/stream/attendance?accessKey=&secretKey=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/rest/v1.1/stream/attendance',
  params: {accessKey: '', secretKey: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/rest/v1.1/stream/attendance?accessKey=&secretKey=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/rest/v1.1/stream/attendance?accessKey=&secretKey=',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/rest/v1.1/stream/attendance?accessKey=&secretKey=")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/rest/v1.1/stream/attendance?accessKey=&secretKey=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/rest/v1.1/stream/attendance',
  qs: {accessKey: '', secretKey: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/rest/v1.1/stream/attendance');

req.query({
  accessKey: '',
  secretKey: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/rest/v1.1/stream/attendance',
  params: {accessKey: '', secretKey: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/rest/v1.1/stream/attendance?accessKey=&secretKey=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/rest/v1.1/stream/attendance?accessKey=&secretKey="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/rest/v1.1/stream/attendance?accessKey=&secretKey=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/rest/v1.1/stream/attendance?accessKey=&secretKey=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/rest/v1.1/stream/attendance?accessKey=&secretKey=');

echo $response->getBody();

setUrl('{{baseUrl}}/rest/v1.1/stream/attendance');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'accessKey' => '',
  'secretKey' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/rest/v1.1/stream/attendance');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'accessKey' => '',
  'secretKey' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/rest/v1.1/stream/attendance?accessKey=&secretKey=' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/rest/v1.1/stream/attendance?accessKey=&secretKey=' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/rest/v1.1/stream/attendance?accessKey=&secretKey=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/rest/v1.1/stream/attendance"

querystring = {"accessKey":"","secretKey":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/rest/v1.1/stream/attendance"

queryString <- list(
  accessKey = "",
  secretKey = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/rest/v1.1/stream/attendance?accessKey=&secretKey=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/rest/v1.1/stream/attendance') do |req|
  req.params['accessKey'] = ''
  req.params['secretKey'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/rest/v1.1/stream/attendance";

    let querystring = [
        ("accessKey", ""),
        ("secretKey", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/rest/v1.1/stream/attendance?accessKey=&secretKey='

http GET '{{baseUrl}}/rest/v1.1/stream/attendance?accessKey=&secretKey='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/rest/v1.1/stream/attendance?accessKey=&secretKey='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/rest/v1.1/stream/attendance?accessKey=&secretKey=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Get last processed N frames from stream

{{baseUrl}}/rest/v1.1/stream/frames

QUERY PARAMS

accessKey

secretKey

streamId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/rest/v1.1/stream/frames?accessKey=&secretKey=&streamId=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/rest/v1.1/stream/frames" {:query-params {:accessKey ""
                                                                                  :secretKey ""
                                                                                  :streamId ""}})

require "http/client"

url = "{{baseUrl}}/rest/v1.1/stream/frames?accessKey=&secretKey=&streamId="

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/rest/v1.1/stream/frames?accessKey=&secretKey=&streamId="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/rest/v1.1/stream/frames?accessKey=&secretKey=&streamId=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/rest/v1.1/stream/frames?accessKey=&secretKey=&streamId="

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/rest/v1.1/stream/frames?accessKey=&secretKey=&streamId= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/rest/v1.1/stream/frames?accessKey=&secretKey=&streamId=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/rest/v1.1/stream/frames?accessKey=&secretKey=&streamId="))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/rest/v1.1/stream/frames?accessKey=&secretKey=&streamId=")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/rest/v1.1/stream/frames?accessKey=&secretKey=&streamId=")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

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

xhr.open('GET', '{{baseUrl}}/rest/v1.1/stream/frames?accessKey=&secretKey=&streamId=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/rest/v1.1/stream/frames',
  params: {accessKey: '', secretKey: '', streamId: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/rest/v1.1/stream/frames?accessKey=&secretKey=&streamId=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/rest/v1.1/stream/frames?accessKey=&secretKey=&streamId=',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/rest/v1.1/stream/frames?accessKey=&secretKey=&streamId=")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/rest/v1.1/stream/frames?accessKey=&secretKey=&streamId=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/rest/v1.1/stream/frames',
  qs: {accessKey: '', secretKey: '', streamId: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/rest/v1.1/stream/frames');

req.query({
  accessKey: '',
  secretKey: '',
  streamId: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/rest/v1.1/stream/frames',
  params: {accessKey: '', secretKey: '', streamId: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/rest/v1.1/stream/frames?accessKey=&secretKey=&streamId=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/rest/v1.1/stream/frames?accessKey=&secretKey=&streamId="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/rest/v1.1/stream/frames?accessKey=&secretKey=&streamId=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/rest/v1.1/stream/frames?accessKey=&secretKey=&streamId=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/rest/v1.1/stream/frames?accessKey=&secretKey=&streamId=');

echo $response->getBody();

setUrl('{{baseUrl}}/rest/v1.1/stream/frames');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'accessKey' => '',
  'secretKey' => '',
  'streamId' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/rest/v1.1/stream/frames');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'accessKey' => '',
  'secretKey' => '',
  'streamId' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/rest/v1.1/stream/frames?accessKey=&secretKey=&streamId=' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/rest/v1.1/stream/frames?accessKey=&secretKey=&streamId=' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/rest/v1.1/stream/frames?accessKey=&secretKey=&streamId=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/rest/v1.1/stream/frames"

querystring = {"accessKey":"","secretKey":"","streamId":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/rest/v1.1/stream/frames"

queryString <- list(
  accessKey = "",
  secretKey = "",
  streamId = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/rest/v1.1/stream/frames?accessKey=&secretKey=&streamId=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/rest/v1.1/stream/frames') do |req|
  req.params['accessKey'] = ''
  req.params['secretKey'] = ''
  req.params['streamId'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/rest/v1.1/stream/frames";

    let querystring = [
        ("accessKey", ""),
        ("secretKey", ""),
        ("streamId", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/rest/v1.1/stream/frames?accessKey=&secretKey=&streamId='

http GET '{{baseUrl}}/rest/v1.1/stream/frames?accessKey=&secretKey=&streamId='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/rest/v1.1/stream/frames?accessKey=&secretKey=&streamId='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/rest/v1.1/stream/frames?accessKey=&secretKey=&streamId=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Show status of all streams from account

{{baseUrl}}/rest/v1.1/stream/all

QUERY PARAMS

accessKey

secretKey

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/rest/v1.1/stream/all?accessKey=&secretKey=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/rest/v1.1/stream/all" {:query-params {:accessKey ""
                                                                               :secretKey ""}})

require "http/client"

url = "{{baseUrl}}/rest/v1.1/stream/all?accessKey=&secretKey="

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/rest/v1.1/stream/all?accessKey=&secretKey="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/rest/v1.1/stream/all?accessKey=&secretKey=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/rest/v1.1/stream/all?accessKey=&secretKey="

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/rest/v1.1/stream/all?accessKey=&secretKey= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/rest/v1.1/stream/all?accessKey=&secretKey=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/rest/v1.1/stream/all?accessKey=&secretKey="))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/rest/v1.1/stream/all?accessKey=&secretKey=")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/rest/v1.1/stream/all?accessKey=&secretKey=")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

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

xhr.open('GET', '{{baseUrl}}/rest/v1.1/stream/all?accessKey=&secretKey=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/rest/v1.1/stream/all',
  params: {accessKey: '', secretKey: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/rest/v1.1/stream/all?accessKey=&secretKey=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/rest/v1.1/stream/all?accessKey=&secretKey=',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/rest/v1.1/stream/all?accessKey=&secretKey=")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/rest/v1.1/stream/all?accessKey=&secretKey=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/rest/v1.1/stream/all',
  qs: {accessKey: '', secretKey: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/rest/v1.1/stream/all');

req.query({
  accessKey: '',
  secretKey: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/rest/v1.1/stream/all',
  params: {accessKey: '', secretKey: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/rest/v1.1/stream/all?accessKey=&secretKey=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/rest/v1.1/stream/all?accessKey=&secretKey="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/rest/v1.1/stream/all?accessKey=&secretKey=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/rest/v1.1/stream/all?accessKey=&secretKey=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/rest/v1.1/stream/all?accessKey=&secretKey=');

echo $response->getBody();

setUrl('{{baseUrl}}/rest/v1.1/stream/all');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'accessKey' => '',
  'secretKey' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/rest/v1.1/stream/all');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'accessKey' => '',
  'secretKey' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/rest/v1.1/stream/all?accessKey=&secretKey=' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/rest/v1.1/stream/all?accessKey=&secretKey=' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/rest/v1.1/stream/all?accessKey=&secretKey=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/rest/v1.1/stream/all"

querystring = {"accessKey":"","secretKey":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/rest/v1.1/stream/all"

queryString <- list(
  accessKey = "",
  secretKey = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/rest/v1.1/stream/all?accessKey=&secretKey=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/rest/v1.1/stream/all') do |req|
  req.params['accessKey'] = ''
  req.params['secretKey'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/rest/v1.1/stream/all";

    let querystring = [
        ("accessKey", ""),
        ("secretKey", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/rest/v1.1/stream/all?accessKey=&secretKey='

http GET '{{baseUrl}}/rest/v1.1/stream/all?accessKey=&secretKey='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/rest/v1.1/stream/all?accessKey=&secretKey='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/rest/v1.1/stream/all?accessKey=&secretKey=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

PATCH Start existing stream

{{baseUrl}}/rest/v1.1/stream/start

QUERY PARAMS

accessKey

secretKey

streamId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/rest/v1.1/stream/start?accessKey=&secretKey=&streamId=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/patch "{{baseUrl}}/rest/v1.1/stream/start" {:query-params {:accessKey ""
                                                                                   :secretKey ""
                                                                                   :streamId ""}})

require "http/client"

url = "{{baseUrl}}/rest/v1.1/stream/start?accessKey=&secretKey=&streamId="

response = HTTP::Client.patch url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Patch,
    RequestUri = new Uri("{{baseUrl}}/rest/v1.1/stream/start?accessKey=&secretKey=&streamId="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/rest/v1.1/stream/start?accessKey=&secretKey=&streamId=");
var request = new RestRequest("", Method.Patch);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/rest/v1.1/stream/start?accessKey=&secretKey=&streamId="

	req, _ := http.NewRequest("PATCH", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

PATCH /baseUrl/rest/v1.1/stream/start?accessKey=&secretKey=&streamId= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/rest/v1.1/stream/start?accessKey=&secretKey=&streamId=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/rest/v1.1/stream/start?accessKey=&secretKey=&streamId="))
    .method("PATCH", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/rest/v1.1/stream/start?accessKey=&secretKey=&streamId=")
  .patch(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.patch("{{baseUrl}}/rest/v1.1/stream/start?accessKey=&secretKey=&streamId=")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

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

xhr.open('PATCH', '{{baseUrl}}/rest/v1.1/stream/start?accessKey=&secretKey=&streamId=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/rest/v1.1/stream/start',
  params: {accessKey: '', secretKey: '', streamId: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/rest/v1.1/stream/start?accessKey=&secretKey=&streamId=';
const options = {method: 'PATCH'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/rest/v1.1/stream/start?accessKey=&secretKey=&streamId=',
  method: 'PATCH',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/rest/v1.1/stream/start?accessKey=&secretKey=&streamId=")
  .patch(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PATCH',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/rest/v1.1/stream/start?accessKey=&secretKey=&streamId=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/rest/v1.1/stream/start',
  qs: {accessKey: '', secretKey: '', streamId: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PATCH', '{{baseUrl}}/rest/v1.1/stream/start');

req.query({
  accessKey: '',
  secretKey: '',
  streamId: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/rest/v1.1/stream/start',
  params: {accessKey: '', secretKey: '', streamId: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/rest/v1.1/stream/start?accessKey=&secretKey=&streamId=';
const options = {method: 'PATCH'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/rest/v1.1/stream/start?accessKey=&secretKey=&streamId="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PATCH"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/rest/v1.1/stream/start?accessKey=&secretKey=&streamId=" in

Client.call `PATCH uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/rest/v1.1/stream/start?accessKey=&secretKey=&streamId=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PATCH",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PATCH', '{{baseUrl}}/rest/v1.1/stream/start?accessKey=&secretKey=&streamId=');

echo $response->getBody();

setUrl('{{baseUrl}}/rest/v1.1/stream/start');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

$request->setQueryData([
  'accessKey' => '',
  'secretKey' => '',
  'streamId' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/rest/v1.1/stream/start');
$request->setRequestMethod('PATCH');
$request->setQuery(new http\QueryString([
  'accessKey' => '',
  'secretKey' => '',
  'streamId' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/rest/v1.1/stream/start?accessKey=&secretKey=&streamId=' -Method PATCH

$response = Invoke-RestMethod -Uri '{{baseUrl}}/rest/v1.1/stream/start?accessKey=&secretKey=&streamId=' -Method PATCH

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("PATCH", "/baseUrl/rest/v1.1/stream/start?accessKey=&secretKey=&streamId=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/rest/v1.1/stream/start"

querystring = {"accessKey":"","secretKey":"","streamId":""}

response = requests.patch(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/rest/v1.1/stream/start"

queryString <- list(
  accessKey = "",
  secretKey = "",
  streamId = ""
)

response <- VERB("PATCH", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/rest/v1.1/stream/start?accessKey=&secretKey=&streamId=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Patch.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.patch('/baseUrl/rest/v1.1/stream/start') do |req|
  req.params['accessKey'] = ''
  req.params['secretKey'] = ''
  req.params['streamId'] = ''
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/rest/v1.1/stream/start";

    let querystring = [
        ("accessKey", ""),
        ("secretKey", ""),
        ("streamId", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PATCH").unwrap(), url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PATCH \
  --url '{{baseUrl}}/rest/v1.1/stream/start?accessKey=&secretKey=&streamId='

http PATCH '{{baseUrl}}/rest/v1.1/stream/start?accessKey=&secretKey=&streamId='

wget --quiet \
  --method PATCH \
  --output-document \
  - '{{baseUrl}}/rest/v1.1/stream/start?accessKey=&secretKey=&streamId='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/rest/v1.1/stream/start?accessKey=&secretKey=&streamId=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PATCH"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

PATCH Stop existing stream

{{baseUrl}}/rest/v1.1/stream/stop

QUERY PARAMS

accessKey

secretKey

streamId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/rest/v1.1/stream/stop?accessKey=&secretKey=&streamId=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/patch "{{baseUrl}}/rest/v1.1/stream/stop" {:query-params {:accessKey ""
                                                                                  :secretKey ""
                                                                                  :streamId ""}})

require "http/client"

url = "{{baseUrl}}/rest/v1.1/stream/stop?accessKey=&secretKey=&streamId="

response = HTTP::Client.patch url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Patch,
    RequestUri = new Uri("{{baseUrl}}/rest/v1.1/stream/stop?accessKey=&secretKey=&streamId="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/rest/v1.1/stream/stop?accessKey=&secretKey=&streamId=");
var request = new RestRequest("", Method.Patch);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/rest/v1.1/stream/stop?accessKey=&secretKey=&streamId="

	req, _ := http.NewRequest("PATCH", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

PATCH /baseUrl/rest/v1.1/stream/stop?accessKey=&secretKey=&streamId= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/rest/v1.1/stream/stop?accessKey=&secretKey=&streamId=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/rest/v1.1/stream/stop?accessKey=&secretKey=&streamId="))
    .method("PATCH", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/rest/v1.1/stream/stop?accessKey=&secretKey=&streamId=")
  .patch(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.patch("{{baseUrl}}/rest/v1.1/stream/stop?accessKey=&secretKey=&streamId=")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

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

xhr.open('PATCH', '{{baseUrl}}/rest/v1.1/stream/stop?accessKey=&secretKey=&streamId=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/rest/v1.1/stream/stop',
  params: {accessKey: '', secretKey: '', streamId: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/rest/v1.1/stream/stop?accessKey=&secretKey=&streamId=';
const options = {method: 'PATCH'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/rest/v1.1/stream/stop?accessKey=&secretKey=&streamId=',
  method: 'PATCH',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/rest/v1.1/stream/stop?accessKey=&secretKey=&streamId=")
  .patch(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PATCH',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/rest/v1.1/stream/stop?accessKey=&secretKey=&streamId=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/rest/v1.1/stream/stop',
  qs: {accessKey: '', secretKey: '', streamId: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PATCH', '{{baseUrl}}/rest/v1.1/stream/stop');

req.query({
  accessKey: '',
  secretKey: '',
  streamId: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/rest/v1.1/stream/stop',
  params: {accessKey: '', secretKey: '', streamId: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/rest/v1.1/stream/stop?accessKey=&secretKey=&streamId=';
const options = {method: 'PATCH'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/rest/v1.1/stream/stop?accessKey=&secretKey=&streamId="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PATCH"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/rest/v1.1/stream/stop?accessKey=&secretKey=&streamId=" in

Client.call `PATCH uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/rest/v1.1/stream/stop?accessKey=&secretKey=&streamId=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PATCH",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PATCH', '{{baseUrl}}/rest/v1.1/stream/stop?accessKey=&secretKey=&streamId=');

echo $response->getBody();

setUrl('{{baseUrl}}/rest/v1.1/stream/stop');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

$request->setQueryData([
  'accessKey' => '',
  'secretKey' => '',
  'streamId' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/rest/v1.1/stream/stop');
$request->setRequestMethod('PATCH');
$request->setQuery(new http\QueryString([
  'accessKey' => '',
  'secretKey' => '',
  'streamId' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/rest/v1.1/stream/stop?accessKey=&secretKey=&streamId=' -Method PATCH

$response = Invoke-RestMethod -Uri '{{baseUrl}}/rest/v1.1/stream/stop?accessKey=&secretKey=&streamId=' -Method PATCH

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("PATCH", "/baseUrl/rest/v1.1/stream/stop?accessKey=&secretKey=&streamId=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/rest/v1.1/stream/stop"

querystring = {"accessKey":"","secretKey":"","streamId":""}

response = requests.patch(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/rest/v1.1/stream/stop"

queryString <- list(
  accessKey = "",
  secretKey = "",
  streamId = ""
)

response <- VERB("PATCH", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/rest/v1.1/stream/stop?accessKey=&secretKey=&streamId=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Patch.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.patch('/baseUrl/rest/v1.1/stream/stop') do |req|
  req.params['accessKey'] = ''
  req.params['secretKey'] = ''
  req.params['streamId'] = ''
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/rest/v1.1/stream/stop";

    let querystring = [
        ("accessKey", ""),
        ("secretKey", ""),
        ("streamId", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PATCH").unwrap(), url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PATCH \
  --url '{{baseUrl}}/rest/v1.1/stream/stop?accessKey=&secretKey=&streamId='

http PATCH '{{baseUrl}}/rest/v1.1/stream/stop?accessKey=&secretKey=&streamId='

wget --quiet \
  --method PATCH \
  --output-document \
  - '{{baseUrl}}/rest/v1.1/stream/stop?accessKey=&secretKey=&streamId='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/rest/v1.1/stream/stop?accessKey=&secretKey=&streamId=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PATCH"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

PATCH Update an existing stream with a given ID

{{baseUrl}}/rest/v1.1/stream/:streamId

QUERY PARAMS

accessKey

secretKey

streamId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/rest/v1.1/stream/:streamId?accessKey=&secretKey=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/patch "{{baseUrl}}/rest/v1.1/stream/:streamId" {:query-params {:accessKey ""
                                                                                       :secretKey ""}})

require "http/client"

url = "{{baseUrl}}/rest/v1.1/stream/:streamId?accessKey=&secretKey="

response = HTTP::Client.patch url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Patch,
    RequestUri = new Uri("{{baseUrl}}/rest/v1.1/stream/:streamId?accessKey=&secretKey="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/rest/v1.1/stream/:streamId?accessKey=&secretKey=");
var request = new RestRequest("", Method.Patch);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/rest/v1.1/stream/:streamId?accessKey=&secretKey="

	req, _ := http.NewRequest("PATCH", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

PATCH /baseUrl/rest/v1.1/stream/:streamId?accessKey=&secretKey= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/rest/v1.1/stream/:streamId?accessKey=&secretKey=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/rest/v1.1/stream/:streamId?accessKey=&secretKey="))
    .method("PATCH", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/rest/v1.1/stream/:streamId?accessKey=&secretKey=")
  .patch(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.patch("{{baseUrl}}/rest/v1.1/stream/:streamId?accessKey=&secretKey=")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

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

xhr.open('PATCH', '{{baseUrl}}/rest/v1.1/stream/:streamId?accessKey=&secretKey=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/rest/v1.1/stream/:streamId',
  params: {accessKey: '', secretKey: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/rest/v1.1/stream/:streamId?accessKey=&secretKey=';
const options = {method: 'PATCH'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/rest/v1.1/stream/:streamId?accessKey=&secretKey=',
  method: 'PATCH',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/rest/v1.1/stream/:streamId?accessKey=&secretKey=")
  .patch(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PATCH',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/rest/v1.1/stream/:streamId?accessKey=&secretKey=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/rest/v1.1/stream/:streamId',
  qs: {accessKey: '', secretKey: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PATCH', '{{baseUrl}}/rest/v1.1/stream/:streamId');

req.query({
  accessKey: '',
  secretKey: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/rest/v1.1/stream/:streamId',
  params: {accessKey: '', secretKey: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/rest/v1.1/stream/:streamId?accessKey=&secretKey=';
const options = {method: 'PATCH'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/rest/v1.1/stream/:streamId?accessKey=&secretKey="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PATCH"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/rest/v1.1/stream/:streamId?accessKey=&secretKey=" in

Client.call `PATCH uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/rest/v1.1/stream/:streamId?accessKey=&secretKey=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PATCH",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PATCH', '{{baseUrl}}/rest/v1.1/stream/:streamId?accessKey=&secretKey=');

echo $response->getBody();

setUrl('{{baseUrl}}/rest/v1.1/stream/:streamId');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

$request->setQueryData([
  'accessKey' => '',
  'secretKey' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/rest/v1.1/stream/:streamId');
$request->setRequestMethod('PATCH');
$request->setQuery(new http\QueryString([
  'accessKey' => '',
  'secretKey' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/rest/v1.1/stream/:streamId?accessKey=&secretKey=' -Method PATCH

$response = Invoke-RestMethod -Uri '{{baseUrl}}/rest/v1.1/stream/:streamId?accessKey=&secretKey=' -Method PATCH

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("PATCH", "/baseUrl/rest/v1.1/stream/:streamId?accessKey=&secretKey=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/rest/v1.1/stream/:streamId"

querystring = {"accessKey":"","secretKey":""}

response = requests.patch(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/rest/v1.1/stream/:streamId"

queryString <- list(
  accessKey = "",
  secretKey = ""
)

response <- VERB("PATCH", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/rest/v1.1/stream/:streamId?accessKey=&secretKey=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Patch.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.patch('/baseUrl/rest/v1.1/stream/:streamId') do |req|
  req.params['accessKey'] = ''
  req.params['secretKey'] = ''
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/rest/v1.1/stream/:streamId";

    let querystring = [
        ("accessKey", ""),
        ("secretKey", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PATCH").unwrap(), url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PATCH \
  --url '{{baseUrl}}/rest/v1.1/stream/:streamId?accessKey=&secretKey='

http PATCH '{{baseUrl}}/rest/v1.1/stream/:streamId?accessKey=&secretKey='

wget --quiet \
  --method PATCH \
  --output-document \
  - '{{baseUrl}}/rest/v1.1/stream/:streamId?accessKey=&secretKey='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/rest/v1.1/stream/:streamId?accessKey=&secretKey=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PATCH"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()