SKIL Documentation

Skymind Intelligence Layer

The community edition of the Skymind Intelligence Layer (SKIL) is free. It takes data science projects from prototype to production quickly and easily. SKIL bridges the gap between the Python ecosystem and the JVM with a cross-team platform for Data Scientists, Data Engineers, and DevOps/IT. It is an automation tool for machine-learning workflows that enables easy training on Spark-GPU clusters, experiment tracking, one-click deployment of trained models, model performance monitoring and more.

Get Started
Suggest Edits

Post JSON credentials and obtain a JWT authorization token.

 
posthttp://localhost:9008/login
curl --request POST \
  --url http://localhost:9008/login
import requests

url = "http://localhost:9008/login"

response = requests.request("POST", url)

print(response.text)
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("http://localhost:9008/login")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
var client = new RestClient("http://localhost:9008/login");
var request = new RestRequest(Method.POST);
IRestResponse response = client.Execute(request);
var request = require("request");

var options = { method: 'POST', url: 'http://localhost:9008/login' };

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

  console.log(body);
});
var data = JSON.stringify(false);

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

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

xhr.open("POST", "http://localhost:9008/login");

xhr.send(data);
#import <Foundation/Foundation.h>

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"http://localhost:9008/login"]
                                                       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];
<?php

$curl = curl_init();

curl_setopt_array($curl, array(
  CURLOPT_PORT => "9008",
  CURLOPT_URL => "http://localhost:9008/login",
  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;
}
require 'uri'
require 'net/http'

url = URI("http://localhost:9008/login")

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

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

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

let request = NSMutableURLRequest(url: NSURL(string: "http://localhost:9008/login")! 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)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
package main

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

func main() {

	url := "http://localhost:9008/login"

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

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

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

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

}
A binary file was returned

You couldn't be authenticated

Try the API to see results

Body Params

userId
string
password
string

Response

successful operation

tokenstring

Token received from the authentication server.

Invalid credentials

Suggest Edits

Register a new user

 

Header Auth

 Authentication is required for this endpoint.
posthttp://localhost:9008/user/register
curl --request POST \
  --url http://localhost:9008/user/register
import requests

url = "http://localhost:9008/user/register"

response = requests.request("POST", url)

print(response.text)
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("http://localhost:9008/user/register")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
var client = new RestClient("http://localhost:9008/user/register");
var request = new RestRequest(Method.POST);
IRestResponse response = client.Execute(request);
var request = require("request");

var options = { method: 'POST', url: 'http://localhost:9008/user/register' };

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

  console.log(body);
});
var data = JSON.stringify(false);

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

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

xhr.open("POST", "http://localhost:9008/user/register");

xhr.send(data);
#import <Foundation/Foundation.h>

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"http://localhost:9008/user/register"]
                                                       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];
<?php

$curl = curl_init();

curl_setopt_array($curl, array(
  CURLOPT_PORT => "9008",
  CURLOPT_URL => "http://localhost:9008/user/register",
  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;
}
require 'uri'
require 'net/http'

url = URI("http://localhost:9008/user/register")

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

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

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

let request = NSMutableURLRequest(url: NSURL(string: "http://localhost:9008/user/register")! 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)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
package main

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

func main() {

	url := "http://localhost:9008/user/register"

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

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

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

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

}
A binary file was returned

You couldn't be authenticated

Try the API to see results

Body Params

userId
string
userName
string
password
string
role
string

User's role such as [user, admin, trial]

scope
string

User's scope such as [all, skil, zeppelin]

Response

User added successfully.

userIdstring
userNamestring
passwordstring
rolestring

User's role such as [user, admin, trial]

scopestring

User's scope such as [all, skil, zeppelin]

Suggest Edits

Get a user by user ID

 

Header Auth

 Authentication is required for this endpoint.
gethttp://localhost:9008/user/userId
curl --request GET \
  --url http://localhost:9008/user/userId
import requests

url = "http://localhost:9008/user/userId"

response = requests.request("GET", url)

print(response.text)
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("http://localhost:9008/user/userId")
  .get()
  .build();

Response response = client.newCall(request).execute();
var client = new RestClient("http://localhost:9008/user/userId");
var request = new RestRequest(Method.GET);
IRestResponse response = client.Execute(request);
var request = require("request");

var options = { method: 'GET',
  url: 'http://localhost:9008/user/userId' };

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

  console.log(body);
});
var data = JSON.stringify(false);

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

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

xhr.open("GET", "http://localhost:9008/user/userId");

xhr.send(data);
#import <Foundation/Foundation.h>

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"http://localhost:9008/user/userId"]
                                                       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];
<?php

$curl = curl_init();

curl_setopt_array($curl, array(
  CURLOPT_PORT => "9008",
  CURLOPT_URL => "http://localhost:9008/user/userId",
  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;
}
require 'uri'
require 'net/http'

url = URI("http://localhost:9008/user/userId")

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

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

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

let request = NSMutableURLRequest(url: NSURL(string: "http://localhost:9008/user/userId")! 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)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
package main

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

func main() {

	url := "http://localhost:9008/user/userId"

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

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

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

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

}
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

userId
string
required

User's ID

Response

Successfully received the user details

userIdstring
userNamestring
passwordstring
rolestring

User's role such as [user, admin, trial]

scopestring

User's scope such as [all, skil, zeppelin]

Suggest Edits

Update a user

 

Header Auth

 Authentication is required for this endpoint.
puthttp://localhost:9008/user
curl --request PUT \
  --url http://localhost:9008/user
import requests

url = "http://localhost:9008/user"

response = requests.request("PUT", url)

print(response.text)
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("http://localhost:9008/user")
  .put(null)
  .build();

Response response = client.newCall(request).execute();
var client = new RestClient("http://localhost:9008/user");
var request = new RestRequest(Method.PUT);
IRestResponse response = client.Execute(request);
var request = require("request");

var options = { method: 'PUT', url: 'http://localhost:9008/user' };

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

  console.log(body);
});
var data = JSON.stringify(false);

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

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

xhr.open("PUT", "http://localhost:9008/user");

xhr.send(data);
#import <Foundation/Foundation.h>

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"http://localhost:9008/user"]
                                                       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];
<?php

$curl = curl_init();

curl_setopt_array($curl, array(
  CURLOPT_PORT => "9008",
  CURLOPT_URL => "http://localhost:9008/user",
  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;
}
require 'uri'
require 'net/http'

url = URI("http://localhost:9008/user")

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

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

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

let request = NSMutableURLRequest(url: NSURL(string: "http://localhost:9008/user")! 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)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
package main

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

func main() {

	url := "http://localhost:9008/user"

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

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

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

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

}
A binary file was returned

You couldn't be authenticated

Try the API to see results

Body Params

userId
string
userName
string
password
string
role
string

User's role such as [user, admin, trial]

scope
string

User's scope such as [all, skil, zeppelin]

Response

User updated successfully.

userIdstring
userNamestring
passwordstring
rolestring

User's role such as [user, admin, trial]

scopestring

User's scope such as [all, skil, zeppelin]

Suggest Edits

Change user's password

 

Header Auth

 Authentication is required for this endpoint.
posthttp://localhost:9008/user/userId/password
curl --request POST \
  --url http://localhost:9008/user/userId/password
import requests

url = "http://localhost:9008/user/userId/password"

response = requests.request("POST", url)

print(response.text)
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("http://localhost:9008/user/userId/password")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
var client = new RestClient("http://localhost:9008/user/userId/password");
var request = new RestRequest(Method.POST);
IRestResponse response = client.Execute(request);
var request = require("request");

var options = { method: 'POST',
  url: 'http://localhost:9008/user/userId/password' };

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

  console.log(body);
});
var data = JSON.stringify(false);

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

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

xhr.open("POST", "http://localhost:9008/user/userId/password");

xhr.send(data);
#import <Foundation/Foundation.h>

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"http://localhost:9008/user/userId/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];
<?php

$curl = curl_init();

curl_setopt_array($curl, array(
  CURLOPT_PORT => "9008",
  CURLOPT_URL => "http://localhost:9008/user/userId/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;
}
require 'uri'
require 'net/http'

url = URI("http://localhost:9008/user/userId/password")

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

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

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

let request = NSMutableURLRequest(url: NSURL(string: "http://localhost:9008/user/userId/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)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
package main

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

func main() {

	url := "http://localhost:9008/user/userId/password"

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

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

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

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

}
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

userId
string
required

User's ID

Body Params

password
string

Response

Updated user.

userIdstring
userNamestring
passwordstring
rolestring

User's role such as [user, admin, trial]

scopestring

User's scope such as [all, skil, zeppelin]

Suggest Edits

Get auth policy

 

Header Auth

 Authentication is required for this endpoint.
gethttp://localhost:9008/auth/policy
curl --request GET \
  --url http://localhost:9008/auth/policy
import requests

url = "http://localhost:9008/auth/policy"

response = requests.request("GET", url)

print(response.text)
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("http://localhost:9008/auth/policy")
  .get()
  .build();

Response response = client.newCall(request).execute();
var client = new RestClient("http://localhost:9008/auth/policy");
var request = new RestRequest(Method.GET);
IRestResponse response = client.Execute(request);
var request = require("request");

var options = { method: 'GET', url: 'http://localhost:9008/auth/policy' };

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

  console.log(body);
});
var data = JSON.stringify(false);

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

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

xhr.open("GET", "http://localhost:9008/auth/policy");

xhr.send(data);
#import <Foundation/Foundation.h>

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"http://localhost:9008/auth/policy"]
                                                       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];
<?php

$curl = curl_init();

curl_setopt_array($curl, array(
  CURLOPT_PORT => "9008",
  CURLOPT_URL => "http://localhost:9008/auth/policy",
  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;
}
require 'uri'
require 'net/http'

url = URI("http://localhost:9008/auth/policy")

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

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

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

let request = NSMutableURLRequest(url: NSURL(string: "http://localhost:9008/auth/policy")! 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)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
package main

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

func main() {

	url := "http://localhost:9008/auth/policy"

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

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

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

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

}
A binary file was returned

You couldn't be authenticated

Try the API to see results

Response

AuthPolicy object

@classstring
Suggest Edits

Update auth policy

 

Header Auth

 Authentication is required for this endpoint.
puthttp://localhost:9008/auth/policy
curl --request PUT \
  --url http://localhost:9008/auth/policy
import requests

url = "http://localhost:9008/auth/policy"

response = requests.request("PUT", url)

print(response.text)
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("http://localhost:9008/auth/policy")
  .put(null)
  .build();

Response response = client.newCall(request).execute();
var client = new RestClient("http://localhost:9008/auth/policy");
var request = new RestRequest(Method.PUT);
IRestResponse response = client.Execute(request);
var request = require("request");

var options = { method: 'PUT', url: 'http://localhost:9008/auth/policy' };

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

  console.log(body);
});
var data = JSON.stringify(false);

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

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

xhr.open("PUT", "http://localhost:9008/auth/policy");

xhr.send(data);
#import <Foundation/Foundation.h>

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"http://localhost:9008/auth/policy"]
                                                       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];
<?php

$curl = curl_init();

curl_setopt_array($curl, array(
  CURLOPT_PORT => "9008",
  CURLOPT_URL => "http://localhost:9008/auth/policy",
  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;
}
require 'uri'
require 'net/http'

url = URI("http://localhost:9008/auth/policy")

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

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

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

let request = NSMutableURLRequest(url: NSURL(string: "http://localhost:9008/auth/policy")! 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)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
package main

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

func main() {

	url := "http://localhost:9008/auth/policy"

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

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

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

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

}
A binary file was returned

You couldn't be authenticated

Try the API to see results

Body Params

@class
string

Response

Update AuthPolicy object

@classstring
Suggest Edits

Generate new auth token

 

Header Auth

 Authentication is required for this endpoint.
posthttp://localhost:9008/auth/token
curl --request POST \
  --url http://localhost:9008/auth/token
import requests

url = "http://localhost:9008/auth/token"

response = requests.request("POST", url)

print(response.text)
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("http://localhost:9008/auth/token")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
var client = new RestClient("http://localhost:9008/auth/token");
var request = new RestRequest(Method.POST);
IRestResponse response = client.Execute(request);
var request = require("request");

var options = { method: 'POST', url: 'http://localhost:9008/auth/token' };

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

  console.log(body);
});
var data = JSON.stringify(false);

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

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

xhr.open("POST", "http://localhost:9008/auth/token");

xhr.send(data);
#import <Foundation/Foundation.h>

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"http://localhost:9008/auth/token"]
                                                       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];
<?php

$curl = curl_init();

curl_setopt_array($curl, array(
  CURLOPT_PORT => "9008",
  CURLOPT_URL => "http://localhost:9008/auth/token",
  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;
}
require 'uri'
require 'net/http'

url = URI("http://localhost:9008/auth/token")

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

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

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

let request = NSMutableURLRequest(url: NSURL(string: "http://localhost:9008/auth/token")! 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)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
package main

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

func main() {

	url := "http://localhost:9008/auth/token"

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

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

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

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

}
A binary file was returned

You couldn't be authenticated

Try the API to see results

Body Params

userId
string
expiry
int64

Response

Generated auth token.

tokenIdinteger
issuedinteger
expireinteger
tokenstring
userIdstring
isRevokedinteger
Suggest Edits

Get auth tokens for a user.

 

Header Auth

 Authentication is required for this endpoint.
gethttp://localhost:9008/auth/userId/tokens
curl --request GET \
  --url http://localhost:9008/auth/userId/tokens
import requests

url = "http://localhost:9008/auth/userId/tokens"

response = requests.request("GET", url)

print(response.text)
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("http://localhost:9008/auth/userId/tokens")
  .get()
  .build();

Response response = client.newCall(request).execute();
var client = new RestClient("http://localhost:9008/auth/userId/tokens");
var request = new RestRequest(Method.GET);
IRestResponse response = client.Execute(request);
var request = require("request");

var options = { method: 'GET',
  url: 'http://localhost:9008/auth/userId/tokens' };

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

  console.log(body);
});
var data = JSON.stringify(false);

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

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

xhr.open("GET", "http://localhost:9008/auth/userId/tokens");

xhr.send(data);
#import <Foundation/Foundation.h>

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"http://localhost:9008/auth/userId/tokens"]
                                                       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];
<?php

$curl = curl_init();

curl_setopt_array($curl, array(
  CURLOPT_PORT => "9008",
  CURLOPT_URL => "http://localhost:9008/auth/userId/tokens",
  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;
}
require 'uri'
require 'net/http'

url = URI("http://localhost:9008/auth/userId/tokens")

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

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

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

let request = NSMutableURLRequest(url: NSURL(string: "http://localhost:9008/auth/userId/tokens")! 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)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
package main

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

func main() {

	url := "http://localhost:9008/auth/userId/tokens"

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

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

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

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

}
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

userId
string
required

User's ID

Query Params

onlyValid
boolean

True if you only want the valid tokens.

Response

Successfully received the user auth tokens.

Suggest Edits

Revoke a user token.

 

Header Auth

 Authentication is required for this endpoint.
deletehttp://localhost:9008/auth/token/tokenId
curl --request DELETE \
  --url http://localhost:9008/auth/token/tokenId
import requests

url = "http://localhost:9008/auth/token/tokenId"

response = requests.request("DELETE", url)

print(response.text)
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("http://localhost:9008/auth/token/tokenId")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();
var client = new RestClient("http://localhost:9008/auth/token/tokenId");
var request = new RestRequest(Method.DELETE);
IRestResponse response = client.Execute(request);
var request = require("request");

var options = { method: 'DELETE',
  url: 'http://localhost:9008/auth/token/tokenId' };

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

  console.log(body);
});
var data = JSON.stringify(false);

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

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

xhr.open("DELETE", "http://localhost:9008/auth/token/tokenId");

xhr.send(data);
#import <Foundation/Foundation.h>

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"http://localhost:9008/auth/token/tokenId"]
                                                       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];
<?php

$curl = curl_init();

curl_setopt_array($curl, array(
  CURLOPT_PORT => "9008",
  CURLOPT_URL => "http://localhost:9008/auth/token/tokenId",
  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;
}
require 'uri'
require 'net/http'

url = URI("http://localhost:9008/auth/token/tokenId")

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

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

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

let request = NSMutableURLRequest(url: NSURL(string: "http://localhost:9008/auth/token/tokenId")! 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)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
package main

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

func main() {

	url := "http://localhost:9008/auth/token/tokenId"

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

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

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

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

}
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

tokenId
int64
required

Token ID

Response

The revoked token object.

tokenIdinteger
issuedinteger
expireinteger
tokenstring
userIdstring
isRevokedinteger
Suggest Edits

Get all users.

 

Header Auth

 Authentication is required for this endpoint.
gethttp://localhost:9008/security/users
curl --request GET \
  --url http://localhost:9008/security/users
import requests

url = "http://localhost:9008/security/users"

response = requests.request("GET", url)

print(response.text)
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("http://localhost:9008/security/users")
  .get()
  .build();

Response response = client.newCall(request).execute();
var client = new RestClient("http://localhost:9008/security/users");
var request = new RestRequest(Method.GET);
IRestResponse response = client.Execute(request);
var request = require("request");

var options = { method: 'GET', url: 'http://localhost:9008/security/users' };

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

  console.log(body);
});
var data = JSON.stringify(false);

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

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

xhr.open("GET", "http://localhost:9008/security/users");

xhr.send(data);
#import <Foundation/Foundation.h>

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"http://localhost:9008/security/users"]
                                                       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];
<?php

$curl = curl_init();

curl_setopt_array($curl, array(
  CURLOPT_PORT => "9008",
  CURLOPT_URL => "http://localhost:9008/security/users",
  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;
}
require 'uri'
require 'net/http'

url = URI("http://localhost:9008/security/users")

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

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

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

let request = NSMutableURLRequest(url: NSURL(string: "http://localhost:9008/security/users")! 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)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
package main

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

func main() {

	url := "http://localhost:9008/security/users"

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

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

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

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

}
A binary file was returned

You couldn't be authenticated

Try the API to see results

Response

Successfully received all users.

Suggest Edits

Get all roles.

 

Header Auth

 Authentication is required for this endpoint.
gethttp://localhost:9008/security/roles
curl --request GET \
  --url http://localhost:9008/security/roles
import requests

url = "http://localhost:9008/security/roles"

response = requests.request("GET", url)

print(response.text)
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("http://localhost:9008/security/roles")
  .get()
  .build();

Response response = client.newCall(request).execute();
var client = new RestClient("http://localhost:9008/security/roles");
var request = new RestRequest(Method.GET);
IRestResponse response = client.Execute(request);
var request = require("request");

var options = { method: 'GET', url: 'http://localhost:9008/security/roles' };

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

  console.log(body);
});
var data = JSON.stringify(false);

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

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

xhr.open("GET", "http://localhost:9008/security/roles");

xhr.send(data);
#import <Foundation/Foundation.h>

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"http://localhost:9008/security/roles"]
                                                       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];
<?php

$curl = curl_init();

curl_setopt_array($curl, array(
  CURLOPT_PORT => "9008",
  CURLOPT_URL => "http://localhost:9008/security/roles",
  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;
}
require 'uri'
require 'net/http'

url = URI("http://localhost:9008/security/roles")

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

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

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

let request = NSMutableURLRequest(url: NSURL(string: "http://localhost:9008/security/roles")! 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)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
package main

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

func main() {

	url := "http://localhost:9008/security/roles"

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

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

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

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

}
A binary file was returned

You couldn't be authenticated

Try the API to see results

Response

Successfully received all roles.

Suggest Edits

Utilities

 
Suggest Edits

Upload a model file to SKIL for import.

 

Header Auth

 Authentication is required for this endpoint.
posthttp://localhost:9008/api/upload/model
curl --request POST \
  --url http://localhost:9008/api/upload/model
import requests

url = "http://localhost:9008/api/upload/model"

response = requests.request("POST", url)

print(response.text)
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("http://localhost:9008/api/upload/model")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
var client = new RestClient("http://localhost:9008/api/upload/model");
var request = new RestRequest(Method.POST);
IRestResponse response = client.Execute(request);
var request = require("request");

var options = { method: 'POST',
  url: 'http://localhost:9008/api/upload/model' };

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

  console.log(body);
});
var data = JSON.stringify(false);

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

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

xhr.open("POST", "http://localhost:9008/api/upload/model");

xhr.send(data);
#import <Foundation/Foundation.h>

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"http://localhost:9008/api/upload/model"]
                                                       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];
<?php

$curl = curl_init();

curl_setopt_array($curl, array(
  CURLOPT_PORT => "9008",
  CURLOPT_URL => "http://localhost:9008/api/upload/model",
  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;
}
require 'uri'
require 'net/http'

url = URI("http://localhost:9008/api/upload/model")

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

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

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

let request = NSMutableURLRequest(url: NSURL(string: "http://localhost:9008/api/upload/model")! 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)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
package main

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

func main() {

	url := "http://localhost:9008/api/upload/model"

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

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

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

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

}
A binary file was returned

You couldn't be authenticated

Try the API to see results

Form Data

file
file

The file to upload.

Response

successful operation

fileUploadResponseListarray
Suggest Edits

Transform

 
Suggest Edits

Gets the JSON string of the deployed transform process (CSV or Image)

 

Header Auth

 Authentication is required for this endpoint.
gethttp://localhost:9008/endpoints/deploymentName/datavec/transformName/versionName/transformprocess
curl --request GET \
  --url http://localhost:9008/endpoints/deploymentName/datavec/transformName/default/transformprocess
import requests

url = "http://localhost:9008/endpoints/deploymentName/datavec/transformName/default/transformprocess"

response = requests.request("GET", url)

print(response.text)
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("http://localhost:9008/endpoints/deploymentName/datavec/transformName/default/transformprocess")
  .get()
  .build();

Response response = client.newCall(request).execute();
var client = new RestClient("http://localhost:9008/endpoints/deploymentName/datavec/transformName/default/transformprocess");
var request = new RestRequest(Method.GET);
IRestResponse response = client.Execute(request);
var request = require("request");

var options = { method: 'GET',
  url: 'http://localhost:9008/endpoints/deploymentName/datavec/transformName/default/transformprocess' };

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

  console.log(body);
});
var data = JSON.stringify(false);

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

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

xhr.open("GET", "http://localhost:9008/endpoints/deploymentName/datavec/transformName/default/transformprocess");

xhr.send(data);
#import <Foundation/Foundation.h>

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"http://localhost:9008/endpoints/deploymentName/datavec/transformName/default/transformprocess"]
                                                       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];
<?php

$curl = curl_init();

curl_setopt_array($curl, array(
  CURLOPT_PORT => "9008",
  CURLOPT_URL => "http://localhost:9008/endpoints/deploymentName/datavec/transformName/default/transformprocess",
  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;
}
require 'uri'
require 'net/http'

url = URI("http://localhost:9008/endpoints/deploymentName/datavec/transformName/default/transformprocess")

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

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

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

let request = NSMutableURLRequest(url: NSURL(string: "http://localhost:9008/endpoints/deploymentName/datavec/transformName/default/transformprocess")! 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)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
package main

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

func main() {

	url := "http://localhost:9008/endpoints/deploymentName/datavec/transformName/default/transformprocess"

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

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

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

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

}
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

deploymentName
string
required

Name of the deployment group

versionName
string
required

Version name of the endpoint. The default value is "default"

transformName
string
required

ID or name of the deployed transform

Response

the deployed transform process

the transform process is probably null

internal server error

Suggest Edits

Sets the deployed (CSV or Image) transform process through the provided JSON string

 

Header Auth

 Authentication is required for this endpoint.
posthttp://localhost:9008/endpoints/deploymentName/datavec/transformName/versionName/transformprocess
curl --request POST \
  --url http://localhost:9008/endpoints/deploymentName/datavec/transformName/default/transformprocess \
  --header 'content-type: Content-Type'
import requests

url = "http://localhost:9008/endpoints/deploymentName/datavec/transformName/default/transformprocess"

headers = {'content-type': 'Content-Type'}

response = requests.request("POST", url, headers=headers)

print(response.text)
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("http://localhost:9008/endpoints/deploymentName/datavec/transformName/default/transformprocess")
  .post(null)
  .addHeader("content-type", "Content-Type")
  .build();

Response response = client.newCall(request).execute();
var client = new RestClient("http://localhost:9008/endpoints/deploymentName/datavec/transformName/default/transformprocess");
var request = new RestRequest(Method.POST);
request.AddHeader("content-type", "Content-Type");
IRestResponse response = client.Execute(request);
var request = require("request");

var options = { method: 'POST',
  url: 'http://localhost:9008/endpoints/deploymentName/datavec/transformName/default/transformprocess',
  headers: { 'content-type': 'Content-Type' } };

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

  console.log(body);
});
var data = JSON.stringify(false);

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

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

xhr.open("POST", "http://localhost:9008/endpoints/deploymentName/datavec/transformName/default/transformprocess");
xhr.setRequestHeader("content-type", "Content-Type");

xhr.send(data);
#import <Foundation/Foundation.h>

NSDictionary *headers = @{ @"content-type": @"Content-Type" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"http://localhost:9008/endpoints/deploymentName/datavec/transformName/default/transformprocess"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];

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];
<?php

$curl = curl_init();

curl_setopt_array($curl, array(
  CURLOPT_PORT => "9008",
  CURLOPT_URL => "http://localhost:9008/endpoints/deploymentName/datavec/transformName/default/transformprocess",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_HTTPHEADER => array(
    "content-type: Content-Type"
  ),
));

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
require 'uri'
require 'net/http'

url = URI("http://localhost:9008/endpoints/deploymentName/datavec/transformName/default/transformprocess")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'Content-Type'

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

let headers = ["content-type": "Content-Type"]

let request = NSMutableURLRequest(url: NSURL(string: "http://localhost:9008/endpoints/deploymentName/datavec/transformName/default/transformprocess")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers

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

dataTask.resume()
package main

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

func main() {

	url := "http://localhost:9008/endpoints/deploymentName/datavec/transformName/default/transformprocess"

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

	req.Header.Add("content-type", "Content-Type")

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

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

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

}
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

deploymentName
string
required

Name of the deployment group

versionName
string
required

Version name of the endpoint. The default value is "default"

transformName
string
required

ID or name of the deployed transform

Headers

Content-Type
string
required

The Content-Type should be application/json.

Response

transform process set successfully

internal server error

Suggest Edits

Takes SingleCSVRecord as input and returns the transformed array as SingleCSVRecord

Takes a SingleCSVRecord object and transforms it into the desired format

 

Header Auth

 Authentication is required for this endpoint.
posthttp://localhost:9008/endpoints/deploymentName/datavec/transformName/versionName/transformincremental
curl --request POST \
  --url http://localhost:9008/endpoints/deploymentName/datavec/transformName/default/transformincremental
import requests

url = "http://localhost:9008/endpoints/deploymentName/datavec/transformName/default/transformincremental"

response = requests.request("POST", url)

print(response.text)
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("http://localhost:9008/endpoints/deploymentName/datavec/transformName/default/transformincremental")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
var client = new RestClient("http://localhost:9008/endpoints/deploymentName/datavec/transformName/default/transformincremental");
var request = new RestRequest(Method.POST);
IRestResponse response = client.Execute(request);
var request = require("request");

var options = { method: 'POST',
  url: 'http://localhost:9008/endpoints/deploymentName/datavec/transformName/default/transformincremental' };

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

  console.log(body);
});
var data = JSON.stringify(false);

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

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

xhr.open("POST", "http://localhost:9008/endpoints/deploymentName/datavec/transformName/default/transformincremental");

xhr.send(data);
#import <Foundation/Foundation.h>

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"http://localhost:9008/endpoints/deploymentName/datavec/transformName/default/transformincremental"]
                                                       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];
<?php

$curl = curl_init();

curl_setopt_array($curl, array(
  CURLOPT_PORT => "9008",
  CURLOPT_URL => "http://localhost:9008/endpoints/deploymentName/datavec/transformName/default/transformincremental",
  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;
}
require 'uri'
require 'net/http'

url = URI("http://localhost:9008/endpoints/deploymentName/datavec/transformName/default/transformincremental")

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

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

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

let request = NSMutableURLRequest(url: NSURL(string: "http://localhost:9008/endpoints/deploymentName/datavec/transformName/default/transformincremental")! 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)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
package main

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

func main() {

	url := "http://localhost:9008/endpoints/deploymentName/datavec/transformName/default/transformincremental"

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

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

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

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

}
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

deploymentName
string
required

Name of the deployment group

versionName
string
required

Version name of the endpoint. The default value is "default"

transformName
string
required

ID or name of the deployed transform

Body Params

values
array of strings

Response

Array transformed and returned successfully

valuesarray

internal server error during transforming the array

Suggest Edits

Takes a BatchCSVRecord and returns the transformed array as BatchCSVRecord

Takes a batch of SingleCSVRecord object and transforms it into the desired format

 

Header Auth

 Authentication is required for this endpoint.
posthttp://localhost:9008/endpoints/deploymentName/datavec/transformName/versionName/transform
curl --request POST \
  --url http://localhost:9008/endpoints/deploymentName/datavec/transformName/default/transform
import requests

url = "http://localhost:9008/endpoints/deploymentName/datavec/transformName/default/transform"

response = requests.request("POST", url)

print(response.text)
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("http://localhost:9008/endpoints/deploymentName/datavec/transformName/default/transform")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
var client = new RestClient("http://localhost:9008/endpoints/deploymentName/datavec/transformName/default/transform");
var request = new RestRequest(Method.POST);
IRestResponse response = client.Execute(request);
var request = require("request");

var options = { method: 'POST',
  url: 'http://localhost:9008/endpoints/deploymentName/datavec/transformName/default/transform' };

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

  console.log(body);
});
var data = JSON.stringify(false);

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

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

xhr.open("POST", "http://localhost:9008/endpoints/deploymentName/datavec/transformName/default/transform");

xhr.send(data);
#import <Foundation/Foundation.h>

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"http://localhost:9008/endpoints/deploymentName/datavec/transformName/default/transform"]
                                                       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];
<?php

$curl = curl_init();

curl_setopt_array($curl, array(
  CURLOPT_PORT => "9008",
  CURLOPT_URL => "http://localhost:9008/endpoints/deploymentName/datavec/transformName/default/transform",
  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;
}
require 'uri'
require 'net/http'

url = URI("http://localhost:9008/endpoints/deploymentName/datavec/transformName/default/transform")

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

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

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

let request = NSMutableURLRequest(url: NSURL(string: "http://localhost:9008/endpoints/deploymentName/datavec/transformName/default/transform")! 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)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
package main

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

func main() {

	url := "http://localhost:9008/endpoints/deploymentName/datavec/transformName/default/transform"

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

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

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

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

}
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

deploymentName
string
required

Name of the deployment group

versionName
string
required

Version name of the endpoint. The default value is "default"

transformName
string
required

ID or name of the deployed transform

Body Params

records
array of objects
values

Response

array transformed and returned successfully

recordsarray

internal server error during transforming the array

Suggest Edits

Same as /transformincremental but returns Base64NDArrayBody.

 

Header Auth

 Authentication is required for this endpoint.
posthttp://localhost:9008/endpoints/deploymentName/datavec/transformName/versionName/transformincrementalarray
curl --request POST \
  --url http://localhost:9008/endpoints/deploymentName/datavec/transformName/default/transformincrementalarray
import requests

url = "http://localhost:9008/endpoints/deploymentName/datavec/transformName/default/transformincrementalarray"

response = requests.request("POST", url)

print(response.text)
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("http://localhost:9008/endpoints/deploymentName/datavec/transformName/default/transformincrementalarray")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
var client = new RestClient("http://localhost:9008/endpoints/deploymentName/datavec/transformName/default/transformincrementalarray");
var request = new RestRequest(Method.POST);
IRestResponse response = client.Execute(request);
var request = require("request");

var options = { method: 'POST',
  url: 'http://localhost:9008/endpoints/deploymentName/datavec/transformName/default/transformincrementalarray' };

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

  console.log(body);
});
var data = JSON.stringify(false);

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

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

xhr.open("POST", "http://localhost:9008/endpoints/deploymentName/datavec/transformName/default/transformincrementalarray");

xhr.send(data);
#import <Foundation/Foundation.h>

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"http://localhost:9008/endpoints/deploymentName/datavec/transformName/default/transformincrementalarray"]
                                                       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];
<?php

$curl = curl_init();

curl_setopt_array($curl, array(
  CURLOPT_PORT => "9008",
  CURLOPT_URL => "http://localhost:9008/endpoints/deploymentName/datavec/transformName/default/transformincrementalarray",
  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;
}
require 'uri'
require 'net/http'

url = URI("http://localhost:9008/endpoints/deploymentName/datavec/transformName/default/transformincrementalarray")

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

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

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

let request = NSMutableURLRequest(url: NSURL(string: "http://localhost:9008/endpoints/deploymentName/datavec/transformName/default/transformincrementalarray")! 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)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
package main

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

func main() {

	url := "http://localhost:9008/endpoints/deploymentName/datavec/transformName/default/transformincrementalarray"

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

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

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

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

}
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

deploymentName
string
required

Name of the deployment group

versionName
string
required

Version name of the endpoint. The default value is "default"

transformName
string
required

ID or name of the deployed transform

Body Params

values
array of strings
uri
string

Response

array transformed and returned successfully

ndarraystring

internal server error during transforming the array

Suggest Edits

Takes a batch input arrays and transforms it

 

Header Auth

 Authentication is required for this endpoint.
posthttp://localhost:9008/endpoints/deploymentName/datavec/transformName/versionName/transformarray
curl --request POST \
  --url http://localhost:9008/endpoints/deploymentName/datavec/transformName/default/transformarray
import requests

url = "http://localhost:9008/endpoints/deploymentName/datavec/transformName/default/transformarray"

response = requests.request("POST", url)

print(response.text)
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("http://localhost:9008/endpoints/deploymentName/datavec/transformName/default/transformarray")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
var client = new RestClient("http://localhost:9008/endpoints/deploymentName/datavec/transformName/default/transformarray");
var request = new RestRequest(Method.POST);
IRestResponse response = client.Execute(request);
var request = require("request");

var options = { method: 'POST',
  url: 'http://localhost:9008/endpoints/deploymentName/datavec/transformName/default/transformarray' };

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

  console.log(body);
});
var data = JSON.stringify(false);

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

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

xhr.open("POST", "http://localhost:9008/endpoints/deploymentName/datavec/transformName/default/transformarray");

xhr.send(data);
#import <Foundation/Foundation.h>

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"http://localhost:9008/endpoints/deploymentName/datavec/transformName/default/transformarray"]
                                                       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];
<?php

$curl = curl_init();

curl_setopt_array($curl, array(
  CURLOPT_PORT => "9008",
  CURLOPT_URL => "http://localhost:9008/endpoints/deploymentName/datavec/transformName/default/transformarray",
  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;
}
require 'uri'
require 'net/http'

url = URI("http://localhost:9008/endpoints/deploymentName/datavec/transformName/default/transformarray")

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

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

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

let request = NSMutableURLRequest(url: NSURL(string: "http://localhost:9008/endpoints/deploymentName/datavec/transformName/default/transformarray")! 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)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
package main

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

func main() {

	url := "http://localhost:9008/endpoints/deploymentName/datavec/transformName/default/transformarray"

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

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

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

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

}
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

deploymentName
string
required

Name of the deployment group

versionName
string
required

Version name of the endpoint. The default value is "default"

transformName
string
required

ID or name of the deployed transform

Body Params

records
array of objects
values
uri

Response

array transformed and returned successfully

ndarraystring

internal server error during transforming the array

Suggest Edits

Takes a single multipart image file to transform and returns Base64NDArrayBody

Takes a single multipart image file and transforms it into the desired format and returns it in the form of Base64NDArrayBody

 

Header Auth

 Authentication is required for this endpoint.
posthttp://localhost:9008/endpoints/deploymentName/datavec/imageTransformName/versionName/transformincrementalimage
curl --request POST \
  --url http://localhost:9008/endpoints/deploymentName/datavec/imageTransformName/default/transformincrementalimage
import requests

url = "http://localhost:9008/endpoints/deploymentName/datavec/imageTransformName/default/transformincrementalimage"

response = requests.request("POST", url)

print(response.text)
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("http://localhost:9008/endpoints/deploymentName/datavec/imageTransformName/default/transformincrementalimage")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
var client = new RestClient("http://localhost:9008/endpoints/deploymentName/datavec/imageTransformName/default/transformincrementalimage");
var request = new RestRequest(Method.POST);
IRestResponse response = client.Execute(request);
var request = require("request");

var options = { method: 'POST',
  url: 'http://localhost:9008/endpoints/deploymentName/datavec/imageTransformName/default/transformincrementalimage' };

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

  console.log(body);
});
var data = JSON.stringify(false);

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

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

xhr.open("POST", "http://localhost:9008/endpoints/deploymentName/datavec/imageTransformName/default/transformincrementalimage");

xhr.send(data);
#import <Foundation/Foundation.h>

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"http://localhost:9008/endpoints/deploymentName/datavec/imageTransformName/default/transformincrementalimage"]
                                                       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];
<?php

$curl = curl_init();

curl_setopt_array($curl, array(
  CURLOPT_PORT => "9008",
  CURLOPT_URL => "http://localhost:9008/endpoints/deploymentName/datavec/imageTransformName/default/transformincrementalimage",
  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;
}
require 'uri'
require 'net/http'

url = URI("http://localhost:9008/endpoints/deploymentName/datavec/imageTransformName/default/transformincrementalimage")

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

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

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

let request = NSMutableURLRequest(url: NSURL(string: "http://localhost:9008/endpoints/deploymentName/datavec/imageTransformName/default/transformincrementalimage")! 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)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
package main

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

func main() {

	url := "http://localhost:9008/endpoints/deploymentName/datavec/imageTransformName/default/transformincrementalimage"

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

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

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

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

}
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

deploymentName
string
required

Name of the deployment group

versionName
string
required

Version name of the endpoint. The default value is "default"

imageTransformName
string
required

ID or name of the deployed image transform

Form Data

file
file
required

The image file to upload

Response

array transformed and returned successfully

ndarraystring

No uploaded file found or the file couldn't be loaded

internal server error during transforming the array

Suggest Edits

Takes multiple multipart image file to transform and returns Base64NDArrayBody

Takes multiple multipart image file and transforms it into the desired format and returns it in the form of Base64NDArrayBody

 

Header Auth

 Authentication is required for this endpoint.
posthttp://localhost:9008/endpoints/deploymentName/datavec/imageTransformName/versionName/transformimage
curl --request POST \
  --url http://localhost:9008/endpoints/deploymentName/datavec/imageTransformName/default/transformimage
import requests

url = "http://localhost:9008/endpoints/deploymentName/datavec/imageTransformName/default/transformimage"

response = requests.request("POST", url)

print(response.text)
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("http://localhost:9008/endpoints/deploymentName/datavec/imageTransformName/default/transformimage")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
var client = new RestClient("http://localhost:9008/endpoints/deploymentName/datavec/imageTransformName/default/transformimage");
var request = new RestRequest(Method.POST);
IRestResponse response = client.Execute(request);
var request = require("request");

var options = { method: 'POST',
  url: 'http://localhost:9008/endpoints/deploymentName/datavec/imageTransformName/default/transformimage' };

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

  console.log(body);
});
var data = JSON.stringify(false);

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

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

xhr.open("POST", "http://localhost:9008/endpoints/deploymentName/datavec/imageTransformName/default/transformimage");

xhr.send(data);
#import <Foundation/Foundation.h>

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"http://localhost:9008/endpoints/deploymentName/datavec/imageTransformName/default/transformimage"]
                                                       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];
<?php

$curl = curl_init();

curl_setopt_array($curl, array(
  CURLOPT_PORT => "9008",
  CURLOPT_URL => "http://localhost:9008/endpoints/deploymentName/datavec/imageTransformName/default/transformimage",
  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;
}
require 'uri'
require 'net/http'

url = URI("http://localhost:9008/endpoints/deploymentName/datavec/imageTransformName/default/transformimage")

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

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

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

let request = NSMutableURLRequest(url: NSURL(string: "http://localhost:9008/endpoints/deploymentName/datavec/imageTransformName/default/transformimage")! 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)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
package main

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

func main() {

	url := "http://localhost:9008/endpoints/deploymentName/datavec/imageTransformName/default/transformimage"

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

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

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

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

}
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

deploymentName
string
required

Name of the deployment group

versionName
string
required

Version name of the endpoint. The default value is "default"

imageTransformName
string
required

ID or name of the deployed image transform

Form Data

files
array of strings
required

The image files to upload

Response

array transformed and returned successfully

ndarraystring

No uploaded files found

internal server error during transforming the array

Suggest Edits

Runs knn on the given index with the given k

Runs knn on the given index with the given k (note that this is for data already within the existing dataset not new data)

 

Header Auth

 Authentication is required for this endpoint.
posthttp://localhost:9008/endpoints/deploymentName/knn/knnName/versionName/knn
curl --request POST \
  --url http://localhost:9008/endpoints/deploymentName/knn/knnName/default/knn
import requests

url = "http://localhost:9008/endpoints/deploymentName/knn/knnName/default/knn"

response = requests.request("POST", url)

print(response.text)
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("http://localhost:9008/endpoints/deploymentName/knn/knnName/default/knn")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
var client = new RestClient("http://localhost:9008/endpoints/deploymentName/knn/knnName/default/knn");
var request = new RestRequest(Method.POST);
IRestResponse response = client.Execute(request);
var request = require("request");

var options = { method: 'POST',
  url: 'http://localhost:9008/endpoints/deploymentName/knn/knnName/default/knn' };

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

  console.log(body);
});
var data = JSON.stringify(false);

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

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

xhr.open("POST", "http://localhost:9008/endpoints/deploymentName/knn/knnName/default/knn");

xhr.send(data);
#import <Foundation/Foundation.h>

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"http://localhost:9008/endpoints/deploymentName/knn/knnName/default/knn"]
                                                       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];
<?php

$curl = curl_init();

curl_setopt_array($curl, array(
  CURLOPT_PORT => "9008",
  CURLOPT_URL => "http://localhost:9008/endpoints/deploymentName/knn/knnName/default/knn",
  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;
}
require 'uri'
require 'net/http'

url = URI("http://localhost:9008/endpoints/deploymentName/knn/knnName/default/knn")

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

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

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

let request = NSMutableURLRequest(url: NSURL(string: "http://localhost:9008/endpoints/deploymentName/knn/knnName/default/knn")! 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)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
package main

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

func main() {

	url := "http://localhost:9008/endpoints/deploymentName/knn/knnName/default/knn"

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

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

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

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

}
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

deploymentName
string
required

Name of the deployment group

versionName
string
required

Version name of the endpoint. The default value is "default"

knnName
string
required

ID or name of the deployed knn

Body Params

k
integer

the number of results

inputIndex
integer

the index of the EXISTING ndarray to run a search on

Response

successful operation

resultsarray

Invalid input

Internal server error

Suggest Edits

Run a k nearest neighbors search on a NEW data point

 

Header Auth

 Authentication is required for this endpoint.
posthttp://localhost:9008/endpoints/deploymentName/knn/knnName/versionName/knnnew
curl --request POST \
  --url http://localhost:9008/endpoints/deploymentName/knn/knnName/default/knnnew
import requests

url = "http://localhost:9008/endpoints/deploymentName/knn/knnName/default/knnnew"

response = requests.request("POST", url)

print(response.text)
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("http://localhost:9008/endpoints/deploymentName/knn/knnName/default/knnnew")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
var client = new RestClient("http://localhost:9008/endpoints/deploymentName/knn/knnName/default/knnnew");
var request = new RestRequest(Method.POST);
IRestResponse response = client.Execute(request);
var request = require("request");

var options = { method: 'POST',
  url: 'http://localhost:9008/endpoints/deploymentName/knn/knnName/default/knnnew' };

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

  console.log(body);
});
var data = JSON.stringify(false);

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

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

xhr.open("POST", "http://localhost:9008/endpoints/deploymentName/knn/knnName/default/knnnew");

xhr.send(data);
#import <Foundation/Foundation.h>

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"http://localhost:9008/endpoints/deploymentName/knn/knnName/default/knnnew"]
                                                       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];
<?php

$curl = curl_init();

curl_setopt_array($curl, array(
  CURLOPT_PORT => "9008",
  CURLOPT_URL => "http://localhost:9008/endpoints/deploymentName/knn/knnName/default/knnnew",
  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;
}
require 'uri'
require 'net/http'

url = URI("http://localhost:9008/endpoints/deploymentName/knn/knnName/default/knnnew")

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

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

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

let request = NSMutableURLRequest(url: NSURL(string: "http://localhost:9008/endpoints/deploymentName/knn/knnName/default/knnnew")! 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)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
package main

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

func main() {

	url := "http://localhost:9008/endpoints/deploymentName/knn/knnName/default/knnnew"

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

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

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

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

}
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

deploymentName
string
required

Name of the deployment group

versionName
string
required

Version name of the endpoint. The default value is "default"

knnName
string
required

ID or name of the deployed knn

Body Params

ndarray
string

the array to run the search on. Note that this must be a row vector

k
integer

the number of results to retrieve

forceFillK
boolean

If 'True' it will brute force search for running search relative to a target but forced to fill the result list until the desired k is matched.

Response

successful operation

resultsarray

Invalid input

Internal server error

Suggest Edits

Inference

 
Suggest Edits

Run inference on the input array.

 

Header Auth

 Authentication is required for this endpoint.
posthttp://localhost:9008/endpoints/deploymentName/model/modelName/versionName/predict
curl --request POST \
  --url http://localhost:9008/endpoints/deploymentName/model/modelName/default/predict
import requests

url = "http://localhost:9008/endpoints/deploymentName/model/modelName/default/predict"

response = requests.request("POST", url)

print(response.text)
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("http://localhost:9008/endpoints/deploymentName/model/modelName/default/predict")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
var client = new RestClient("http://localhost:9008/endpoints/deploymentName/model/modelName/default/predict");
var request = new RestRequest(Method.POST);
IRestResponse response = client.Execute(request);
var request = require("request");

var options = { method: 'POST',
  url: 'http://localhost:9008/endpoints/deploymentName/model/modelName/default/predict' };

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

  console.log(body);
});
var data = JSON.stringify(false);

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

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

xhr.open("POST", "http://localhost:9008/endpoints/deploymentName/model/modelName/default/predict");

xhr.send(data);
#import <Foundation/Foundation.h>

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"http://localhost:9008/endpoints/deploymentName/model/modelName/default/predict"]
                                                       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];
<?php

$curl = curl_init();

curl_setopt_array($curl, array(
  CURLOPT_PORT => "9008",
  CURLOPT_URL => "http://localhost:9008/endpoints/deploymentName/model/modelName/default/predict",
  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;
}
require 'uri'
require 'net/http'

url = URI("http://localhost:9008/endpoints/deploymentName/model/modelName/default/predict")

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

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

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

let request = NSMutableURLRequest(url: NSURL(string: "http://localhost:9008/endpoints/deploymentName/model/modelName/default/predict")! 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)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
package main

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

func main() {

	url := "http://localhost:9008/endpoints/deploymentName/model/modelName/default/predict"

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

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

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

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

}
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

deploymentName
string
required

Name of the deployment group

versionName
string
required

Version name of the endpoint. The default value is "default"

modelName
string
required

ID or name of the deployed model

Body Params

id
string
needsPreProcessing
boolean
prediction
object
 
prediction.array
string
prediction.shape
array of integers
prediction.ordering
string
prediction.data
array of numbers
prediction.dataType
string
inputMask
object
 
inputMask.array
string
inputMask.shape
array of integers
inputMask.ordering
string
inputMask.data
array of numbers
inputMask.dataType
string

Response

successful operation

idstring
needsPreProcessingboolean
predictionobject
prediction.arraystring
prediction.shapearray
prediction.orderingstring
prediction.dataarray
prediction.dataTypestring
inputMaskobject
inputMask.arraystring
inputMask.shapearray
inputMask.orderingstring
inputMask.dataarray
inputMask.dataTypestring

Invalid input

Invalid deployment or model name

Suggest Edits

Run inference on the input array, using input image file from multipart form data.

 

Header Auth

 Authentication is required for this endpoint.
posthttp://localhost:9008/endpoints/deploymentName/model/modelName/versionName/predictimage
curl --request POST \
  --url http://localhost:9008/endpoints/deploymentName/model/modelName/default/predictimage
import requests

url = "http://localhost:9008/endpoints/deploymentName/model/modelName/default/predictimage"

response = requests.request("POST", url)

print(response.text)
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("http://localhost:9008/endpoints/deploymentName/model/modelName/default/predictimage")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
var client = new RestClient("http://localhost:9008/endpoints/deploymentName/model/modelName/default/predictimage");
var request = new RestRequest(Method.POST);
IRestResponse response = client.Execute(request);
var request = require("request");

var options = { method: 'POST',
  url: 'http://localhost:9008/endpoints/deploymentName/model/modelName/default/predictimage' };

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

  console.log(body);
});
var data = JSON.stringify(false);

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

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

xhr.open("POST", "http://localhost:9008/endpoints/deploymentName/model/modelName/default/predictimage");

xhr.send(data);
#import <Foundation/Foundation.h>

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"http://localhost:9008/endpoints/deploymentName/model/modelName/default/predictimage"]
                                                       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];
<?php

$curl = curl_init();

curl_setopt_array($curl, array(
  CURLOPT_PORT => "9008",
  CURLOPT_URL => "http://localhost:9008/endpoints/deploymentName/model/modelName/default/predictimage",
  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;
}
require 'uri'
require 'net/http'

url = URI("http://localhost:9008/endpoints/deploymentName/model/modelName/default/predictimage")

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

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

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

let request = NSMutableURLRequest(url: NSURL(string: "http://localhost:9008/endpoints/deploymentName/model/modelName/default/predictimage")! 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)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
package main

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

func main() {

	url := "http://localhost:9008/endpoints/deploymentName/model/modelName/default/predictimage"

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

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

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

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

}
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

deploymentName
string
required

Name of the deployment group

versionName
string
required

Version name of the endpoint. The default value is "default"

modelName
string
required

ID or name of the deployed model

Form Data

image
file

The file to upload.

Response

successful operation

idstring
needsPreProcessingboolean
predictionobject
prediction.arraystring
prediction.shapearray
prediction.orderingstring
prediction.dataarray
prediction.dataTypestring
inputMaskobject
inputMask.arraystring
inputMask.shapearray
inputMask.orderingstring
inputMask.dataarray
inputMask.dataTypestring

Error generating prediction

Suggest Edits

Get the output from the network, based on the given INDArray[] input

Networks with multiple input/output are supported via this method. A Normalizer will be used if needsPreProcessing is set to true. The output/returned array of INDArray will be the raw predictions, and consequently this method can be used for classification or regression networks, with any type of output layer (standard, time series / RnnOutputLayer, etc).

 

Header Auth

 Authentication is required for this endpoint.
posthttp://localhost:9008/endpoints/deploymentName/model/modelName/versionName/multipredict
curl --request POST \
  --url http://localhost:9008/endpoints/deploymentName/model/modelName/default/multipredict
import requests

url = "http://localhost:9008/endpoints/deploymentName/model/modelName/default/multipredict"

response = requests.request("POST", url)

print(response.text)
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("http://localhost:9008/endpoints/deploymentName/model/modelName/default/multipredict")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
var client = new RestClient("http://localhost:9008/endpoints/deploymentName/model/modelName/default/multipredict");
var request = new RestRequest(Method.POST);
IRestResponse response = client.Execute(request);
var request = require("request");

var options = { method: 'POST',
  url: 'http://localhost:9008/endpoints/deploymentName/model/modelName/default/multipredict' };

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

  console.log(body);
});
var data = JSON.stringify(false);

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

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

xhr.open("POST", "http://localhost:9008/endpoints/deploymentName/model/modelName/default/multipredict");

xhr.send(data);
#import <Foundation/Foundation.h>

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"http://localhost:9008/endpoints/deploymentName/model/modelName/default/multipredict"]
                                                       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];
<?php

$curl = curl_init();

curl_setopt_array($curl, array(
  CURLOPT_PORT => "9008",
  CURLOPT_URL => "http://localhost:9008/endpoints/deploymentName/model/modelName/default/multipredict",
  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;
}
require 'uri'
require 'net/http'

url = URI("http://localhost:9008/endpoints/deploymentName/model/modelName/default/multipredict")

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

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

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

let request = NSMutableURLRequest(url: NSURL(string: "http://localhost:9008/endpoints/deploymentName/model/modelName/default/multipredict")! 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)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
package main

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

func main() {

	url := "http://localhost:9008/endpoints/deploymentName/model/modelName/default/multipredict"

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

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

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

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

}
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

deploymentName
string
required

Name of the deployment group

versionName
string
required

Version name of the endpoint. The default value is "default"

modelName
string
required

ID or name of the deployed model

Body Params

id
string
needsPreProcessing
boolean
inputs
array of objects
array
shape
ordering
data
dataType
inputMasks
array of objects
array
shape
ordering
data
dataType

Response

successful operation

idstring
needsPreProcessingboolean
outputsarray

Error generating prediction

Suggest Edits

Get the output from the network using the given image file using the /multipredict endpoint's method

Networks with multiple input/output are supported via this method. A Normalizer will be used if needsPreProcessing is set to true. The output/returned array of INDArray will be the raw predictions, and consequently this method can be used for classification or regression networks, with any type of output layer (standard, time series / RnnOutputLayer, etc).

 

Header Auth

 Authentication is required for this endpoint.
posthttp://localhost:9008/endpoints/deploymentName/model/modelName/versionName/multipredictimage
curl --request POST \
  --url http://localhost:9008/endpoints/deploymentName/model/modelName/default/multipredictimage
import requests

url = "http://localhost:9008/endpoints/deploymentName/model/modelName/default/multipredictimage"

response = requests.request("POST", url)

print(response.text)
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("http://localhost:9008/endpoints/deploymentName/model/modelName/default/multipredictimage")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
var client = new RestClient("http://localhost:9008/endpoints/deploymentName/model/modelName/default/multipredictimage");
var request = new RestRequest(Method.POST);
IRestResponse response = client.Execute(request);
var request = require("request");

var options = { method: 'POST',
  url: 'http://localhost:9008/endpoints/deploymentName/model/modelName/default/multipredictimage' };

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

  console.log(body);
});
var data = JSON.stringify(false);

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

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

xhr.open("POST", "http://localhost:9008/endpoints/deploymentName/model/modelName/default/multipredictimage");

xhr.send(data);
#import <Foundation/Foundation.h>

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"http://localhost:9008/endpoints/deploymentName/model/modelName/default/multipredictimage"]
                                                       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];
<?php

$curl = curl_init();

curl_setopt_array($curl, array(
  CURLOPT_PORT => "9008",
  CURLOPT_URL => "http://localhost:9008/endpoints/deploymentName/model/modelName/default/multipredictimage",
  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;
}
require 'uri'
require 'net/http'

url = URI("http://localhost:9008/endpoints/deploymentName/model/modelName/default/multipredictimage")

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

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

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

let request = NSMutableURLRequest(url: NSURL(string: "http://localhost:9008/endpoints/deploymentName/model/modelName/default/multipredictimage")! 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)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
package main

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

func main() {

	url := "http://localhost:9008/endpoints/deploymentName/model/modelName/default/multipredictimage"

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

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

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

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

}
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

deploymentName
string
required

Name of the deployment group

versionName
string
required

Version name of the endpoint. The default value is "default"

modelName
string
required

ID or name of the deployed model

Form Data

file
file
required

The image file to run the prediction on

id
string
required

The id of the request (could be self generated)

needs_preprocessing
boolean
required

Whether or not the preprocessing is required (either 'true' or 'false')

Response

successful operation

idstring
needsPreProcessingboolean
outputsarray

Error generating prediction

Suggest Edits

Use the deployed model to classify the input

 

Header Auth

 Authentication is required for this endpoint.
posthttp://localhost:9008/endpoints/deploymentName/model/modelName/versionName/classify
curl --request POST \
  --url http://localhost:9008/endpoints/deploymentName/model/modelName/default/classify
import requests

url = "http://localhost:9008/endpoints/deploymentName/model/modelName/default/classify"

response = requests.request("POST", url)

print(response.text)
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("http://localhost:9008/endpoints/deploymentName/model/modelName/default/classify")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
var client = new RestClient("http://localhost:9008/endpoints/deploymentName/model/modelName/default/classify");
var request = new RestRequest(Method.POST);
IRestResponse response = client.Execute(request);
var request = require("request");

var options = { method: 'POST',
  url: 'http://localhost:9008/endpoints/deploymentName/model/modelName/default/classify' };

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

  console.log(body);
});
var data = JSON.stringify(false);

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

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

xhr.open("POST", "http://localhost:9008/endpoints/deploymentName/model/modelName/default/classify");

xhr.send(data);
#import <Foundation/Foundation.h>

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"http://localhost:9008/endpoints/deploymentName/model/modelName/default/classify"]
                                                       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];
<?php

$curl = curl_init();

curl_setopt_array($curl, array(
  CURLOPT_PORT => "9008",
  CURLOPT_URL => "http://localhost:9008/endpoints/deploymentName/model/modelName/default/classify",
  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;
}
require 'uri'
require 'net/http'

url = URI("http://localhost:9008/endpoints/deploymentName/model/modelName/default/classify")

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

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

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

let request = NSMutableURLRequest(url: NSURL(string: "http://localhost:9008/endpoints/deploymentName/model/modelName/default/classify")! 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)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
package main

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

func main() {

	url := "http://localhost:9008/endpoints/deploymentName/model/modelName/default/classify"

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

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

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

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

}
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

deploymentName
string
required

Name of the deployment group

versionName
string
required

Version name of the endpoint. The default value is "default"

modelName
string
required

ID or name of the deployed model

Body Params

id
string
needsPreProcessing
boolean
prediction
object
 
prediction.array
string
prediction.shape
array of integers
prediction.ordering
string
prediction.data
array of numbers
prediction.dataType
string
inputMask
object
 
inputMask.array
string
inputMask.shape
array of integers
inputMask.ordering
string
inputMask.data
array of numbers
inputMask.dataType
string

Response

successful operation

resultsarray

index classification results for the minibatch

probabilitiesarray

max probabilities for the batch items

minibatchIdstring

minibatch ID

Invalid input

Invalid deployment or model name

Suggest Edits

Use the deployed model to classify the input, using input image file from multipart form data.

 

Header Auth

 Authentication is required for this endpoint.
posthttp://localhost:9008/endpoints/deploymentName/model/modelName/versionName/classifyimage
curl --request POST \
  --url http://localhost:9008/endpoints/deploymentName/model/modelName/default/classifyimage
import requests

url = "http://localhost:9008/endpoints/deploymentName/model/modelName/default/classifyimage"

response = requests.request("POST", url)

print(response.text)
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("http://localhost:9008/endpoints/deploymentName/model/modelName/default/classifyimage")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
var client = new RestClient("http://localhost:9008/endpoints/deploymentName/model/modelName/default/classifyimage");
var request = new RestRequest(Method.POST);
IRestResponse response = client.Execute(request);
var request = require("request");

var options = { method: 'POST',
  url: 'http://localhost:9008/endpoints/deploymentName/model/modelName/default/classifyimage' };

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

  console.log(body);
});
var data = JSON.stringify(false);

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

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

xhr.open("POST", "http://localhost:9008/endpoints/deploymentName/model/modelName/default/classifyimage");

xhr.send(data);
#import <Foundation/Foundation.h>

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"http://localhost:9008/endpoints/deploymentName/model/modelName/default/classifyimage"]
                                                       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];
<?php

$curl = curl_init();

curl_setopt_array($curl, array(
  CURLOPT_PORT => "9008",
  CURLOPT_URL => "http://localhost:9008/endpoints/deploymentName/model/modelName/default/classifyimage",
  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;
}
require 'uri'
require 'net/http'

url = URI("http://localhost:9008/endpoints/deploymentName/model/modelName/default/classifyimage")

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

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

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

let request = NSMutableURLRequest(url: NSURL(string: "http://localhost:9008/endpoints/deploymentName/model/modelName/default/classifyimage")! 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)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
package main

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

func main() {

	url := "http://localhost:9008/endpoints/deploymentName/model/modelName/default/classifyimage"

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

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

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

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

}
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

deploymentName
string
required

Name of the deployment group

versionName
string
required

Version name of the endpoint. The default value is "default"

modelName
string
required

ID or name of the deployed model

Form Data

image
file

The file to upload.

Response

successful operation

resultsarray

index classification results for the minibatch

probabilitiesarray

max probabilities for the batch items

minibatchIdstring

minibatch ID

Error generating classification

Suggest Edits

Same as /classify but returns the output as Base64NDArrayBody

 

Header Auth

 Authentication is required for this endpoint.
posthttp://localhost:9008/endpoints/deploymentName/model/modelName/versionName/classifyarray
curl --request POST \
  --url http://localhost:9008/endpoints/deploymentName/model/modelName/default/classifyarray
import requests

url = "http://localhost:9008/endpoints/deploymentName/model/modelName/default/classifyarray"

response = requests.request("POST", url)

print(response.text)
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("http://localhost:9008/endpoints/deploymentName/model/modelName/default/classifyarray")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
var client = new RestClient("http://localhost:9008/endpoints/deploymentName/model/modelName/default/classifyarray");
var request = new RestRequest(Method.POST);
IRestResponse response = client.Execute(request);
var request = require("request");

var options = { method: 'POST',
  url: 'http://localhost:9008/endpoints/deploymentName/model/modelName/default/classifyarray' };

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

  console.log(body);
});
var data = JSON.stringify(false);

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

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

xhr.open("POST", "http://localhost:9008/endpoints/deploymentName/model/modelName/default/classifyarray");

xhr.send(data);
#import <Foundation/Foundation.h>

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"http://localhost:9008/endpoints/deploymentName/model/modelName/default/classifyarray"]
                                                       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];
<?php

$curl = curl_init();

curl_setopt_array($curl, array(
  CURLOPT_PORT => "9008",
  CURLOPT_URL => "http://localhost:9008/endpoints/deploymentName/model/modelName/default/classifyarray",
  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;
}
require 'uri'
require 'net/http'

url = URI("http://localhost:9008/endpoints/deploymentName/model/modelName/default/classifyarray")

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

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

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

let request = NSMutableURLRequest(url: NSURL(string: "http://localhost:9008/endpoints/deploymentName/model/modelName/default/classifyarray")! 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)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
package main

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

func main() {

	url := "http://localhost:9008/endpoints/deploymentName/model/modelName/default/classifyarray"

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

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

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

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

}
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

deploymentName
string
required

Name of the deployment group

versionName
string
required

Version name of the endpoint. The default value is "default"

modelName
string
required

ID or name of the deployed model

Body Params

id
string
needsPreProcessing
boolean
prediction
object
 
prediction.array
string
prediction.shape
array of integers
prediction.ordering
string
prediction.data
array of numbers
prediction.dataType
string
inputMask
object
 
inputMask.array
string
inputMask.shape
array of integers
inputMask.ordering
string
inputMask.data
array of numbers
inputMask.dataType
string

Response

successful operation

ndarraystring

Invalid input

Invalid deployment or model name

Suggest Edits

Represents all of the labels for a given classification

 

Header Auth

 Authentication is required for this endpoint.
posthttp://localhost:9008/endpoints/deploymentName/model/modelName/versionName/multiclassify
curl --request POST \
  --url http://localhost:9008/endpoints/deploymentName/model/modelName/default/multiclassify
import requests

url = "http://localhost:9008/endpoints/deploymentName/model/modelName/default/multiclassify"

response = requests.request("POST", url)

print(response.text)
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("http://localhost:9008/endpoints/deploymentName/model/modelName/default/multiclassify")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
var client = new RestClient("http://localhost:9008/endpoints/deploymentName/model/modelName/default/multiclassify");
var request = new RestRequest(Method.POST);
IRestResponse response = client.Execute(request);
var request = require("request");

var options = { method: 'POST',
  url: 'http://localhost:9008/endpoints/deploymentName/model/modelName/default/multiclassify' };

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

  console.log(body);
});
var data = JSON.stringify(false);

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

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

xhr.open("POST", "http://localhost:9008/endpoints/deploymentName/model/modelName/default/multiclassify");

xhr.send(data);
#import <Foundation/Foundation.h>

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"http://localhost:9008/endpoints/deploymentName/model/modelName/default/multiclassify"]
                                                       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];
<?php

$curl = curl_init();

curl_setopt_array($curl, array(
  CURLOPT_PORT => "9008",
  CURLOPT_URL => "http://localhost:9008/endpoints/deploymentName/model/modelName/default/multiclassify",
  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;
}
require 'uri'
require 'net/http'

url = URI("http://localhost:9008/endpoints/deploymentName/model/modelName/default/multiclassify")

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

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

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

let request = NSMutableURLRequest(url: NSURL(string: "http://localhost:9008/endpoints/deploymentName/model/modelName/default/multiclassify")! 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)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
package main

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

func main() {

	url := "http://localhost:9008/endpoints/deploymentName/model/modelName/default/multiclassify"

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

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

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

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

}
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

deploymentName
string
required

Name of the deployment group

versionName
string
required

Version name of the endpoint. The default value is "default"

modelName
string
required

ID or name of the deployed model

Body Params

id
string
needsPreProcessing
boolean
prediction
object
 
prediction.array
string
prediction.shape
array of integers
prediction.ordering
string
prediction.data
array of numbers
prediction.dataType
string
inputMask
object
 
inputMask.array
string
inputMask.shape
array of integers
inputMask.ordering
string
inputMask.data
array of numbers
inputMask.dataType
string

Response

successful operation

rankedOutcomesarray
maxOutcomesarray
probabilitiesarray

Invalid input

Invalid deployment or model name

Suggest Edits

Set the model to be served

 

Header Auth

 Authentication is required for this endpoint.
posthttp://localhost:9008/endpoints/deploymentName/model/modelName/versionName/modelset
curl --request POST \
  --url http://localhost:9008/endpoints/deploymentName/model/modelName/default/modelset
import requests

url = "http://localhost:9008/endpoints/deploymentName/model/modelName/default/modelset"

response = requests.request("POST", url)

print(response.text)
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("http://localhost:9008/endpoints/deploymentName/model/modelName/default/modelset")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
var client = new RestClient("http://localhost:9008/endpoints/deploymentName/model/modelName/default/modelset");
var request = new RestRequest(Method.POST);
IRestResponse response = client.Execute(request);
var request = require("request");

var options = { method: 'POST',
  url: 'http://localhost:9008/endpoints/deploymentName/model/modelName/default/modelset' };

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

  console.log(body);
});
var data = JSON.stringify(false);

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

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

xhr.open("POST", "http://localhost:9008/endpoints/deploymentName/model/modelName/default/modelset");

xhr.send(data);
#import <Foundation/Foundation.h>

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"http://localhost:9008/endpoints/deploymentName/model/modelName/default/modelset"]
                                                       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];
<?php

$curl = curl_init();

curl_setopt_array($curl, array(
  CURLOPT_PORT => "9008",
  CURLOPT_URL => "http://localhost:9008/endpoints/deploymentName/model/modelName/default/modelset",
  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;
}
require 'uri'
require 'net/http'

url = URI("http://localhost:9008/endpoints/deploymentName/model/modelName/default/modelset")

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

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

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

let request = NSMutableURLRequest(url: NSURL(string: "http://localhost:9008/endpoints/deploymentName/model/modelName/default/modelset")! 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)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
package main

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

func main() {

	url := "http://localhost:9008/endpoints/deploymentName/model/modelName/default/modelset"

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

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

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

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

}
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

deploymentName
string
required

Name of the deployment group

versionName
string
required

Version name of the endpoint. The default value is "default"

modelName
string
required

ID or name of the deployed model

Form Data

file
file

The model file to upload (.pb file)

Response

Model set successfully

statusinteger

100 - Model set successfully.
200 - Model Updated Successfully.
201 - Model Update Failed.

Error setting model

Suggest Edits

Update the model to be served

 

Header Auth

 Authentication is required for this endpoint.
posthttp://localhost:9008/endpoints/deploymentName/model/modelName/versionName/modelupdate
curl --request POST \
  --url http://localhost:9008/endpoints/deploymentName/model/modelName/default/modelupdate
import requests

url = "http://localhost:9008/endpoints/deploymentName/model/modelName/default/modelupdate"

response = requests.request("POST", url)

print(response.text)
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("http://localhost:9008/endpoints/deploymentName/model/modelName/default/modelupdate")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
var client = new RestClient("http://localhost:9008/endpoints/deploymentName/model/modelName/default/modelupdate");
var request = new RestRequest(Method.POST);
IRestResponse response = client.Execute(request);
var request = require("request");

var options = { method: 'POST',
  url: 'http://localhost:9008/endpoints/deploymentName/model/modelName/default/modelupdate' };

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

  console.log(body);
});
var data = JSON.stringify(false);

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

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

xhr.open("POST", "http://localhost:9008/endpoints/deploymentName/model/modelName/default/modelupdate");

xhr.send(data);
#import <Foundation/Foundation.h>

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"http://localhost:9008/endpoints/deploymentName/model/modelName/default/modelupdate"]
                                                       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];
<?php

$curl = curl_init();

curl_setopt_array($curl, array(
  CURLOPT_PORT => "9008",
  CURLOPT_URL => "http://localhost:9008/endpoints/deploymentName/model/modelName/default/modelupdate",
  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;
}
require 'uri'
require 'net/http'

url = URI("http://localhost:9008/endpoints/deploymentName/model/modelName/default/modelupdate")

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

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

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

let request = NSMutableURLRequest(url: NSURL(string: "http://localhost:9008/endpoints/deploymentName/model/modelName/default/modelupdate")! 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)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
package main

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

func main() {

	url := "http://localhost:9008/endpoints/deploymentName/model/modelName/default/modelupdate"

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

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

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

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

}
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

deploymentName
string
required

Name of the deployment group

versionName
string
required

Version name of the endpoint. The default value is "default"

modelName
string
required

ID or name of the deployed model

Form Data

file
file
required

The model file to update with (.pb file)

Response

Model updated successfully or model update failed

statusinteger

100 - Model set successfully.
200 - Model Updated Successfully.
201 - Model Update Failed.

Error updating model

Suggest Edits

Run inference on the input and returns it as a JsonArrayResponse

 

Header Auth

 Authentication is required for this endpoint.
posthttp://localhost:9008/endpoints/deploymentName/model/modelName/versionName/jsonarray
curl --request POST \
  --url http://localhost:9008/endpoints/deploymentName/model/modelName/default/jsonarray
import requests

url = "http://localhost:9008/endpoints/deploymentName/model/modelName/default/jsonarray"

response = requests.request("POST", url)

print(response.text)
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("http://localhost:9008/endpoints/deploymentName/model/modelName/default/jsonarray")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
var client = new RestClient("http://localhost:9008/endpoints/deploymentName/model/modelName/default/jsonarray");
var request = new RestRequest(Method.POST);
IRestResponse response = client.Execute(request);
var request = require("request");

var options = { method: 'POST',
  url: 'http://localhost:9008/endpoints/deploymentName/model/modelName/default/jsonarray' };

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

  console.log(body);
});
var data = JSON.stringify(false);

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

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

xhr.open("POST", "http://localhost:9008/endpoints/deploymentName/model/modelName/default/jsonarray");

xhr.send(data);
#import <Foundation/Foundation.h>

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"http://localhost:9008/endpoints/deploymentName/model/modelName/default/jsonarray"]
                                                       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];
<?php

$curl = curl_init();

curl_setopt_array($curl, array(
  CURLOPT_PORT => "9008",
  CURLOPT_URL => "http://localhost:9008/endpoints/deploymentName/model/modelName/default/jsonarray",
  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;
}