Authentication

 

Check row ACLs.

 
post/Acl/CheckRowRight
curl --request POST \
  --url https://example.com/Acl/CheckRowRight
var request = require("request");

var options = { method: 'POST', url: 'https://example.com/Acl/CheckRowRight' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/Acl/CheckRowRight")

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

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

response = http.request(request)
puts response.read_body
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", "https://example.com/Acl/CheckRowRight");

xhr.send(data);
import requests

url = "https://example.com/Acl/CheckRowRight"

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

print(response.text)
A binary file was returned

You couldn't be authenticated

No response examples available

Body Params

RowKey
string
required

The unique identifier.

Rights
boolean
required

The right on the item.

Table
array of strings
required

Sql table to examine.

Response

API-Result

ErrorIDstring

Unique support identifier for this occurrence of an error

Resultboolean

Did the row right check succeed.

Messagestring

Error message text on failure, may be null

successboolean

Indicates API success or failure

Gets a users access rights.

 
posthttps://example.com/Acl/GetAce
curl --request POST \
  --url https://example.com/Acl/GetAce
var request = require("request");

var options = { method: 'POST', url: 'https://example.com/Acl/GetAce' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/Acl/GetAce")

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

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

response = http.request(request)
puts response.read_body
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", "https://example.com/Acl/GetAce");

xhr.send(data);
import requests

url = "https://example.com/Acl/GetAce"

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

print(response.text)
A binary file was returned

You couldn't be authenticated

No response examples available

Body Params

ID
integer
required

The ace item ID.

Response

API-Result

ErrorIDstring

Unique support identifier for this occurrence of an error

Resultobject

The ace object.

Messagestring

Error message text on failure, may be null

successboolean

Indicates API success or failure

Get a collection of access rights.

 
posthttps://example.com/Acl/GetCollectionAces
curl --request POST \
  --url https://example.com/Acl/GetCollectionAces
var request = require("request");

var options = { method: 'POST',
  url: 'https://example.com/Acl/GetCollectionAces' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/Acl/GetCollectionAces")

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

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

response = http.request(request)
puts response.read_body
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", "https://example.com/Acl/GetCollectionAces");

xhr.send(data);
import requests

url = "https://example.com/Acl/GetCollectionAces"

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

print(response.text)
A binary file was returned

You couldn't be authenticated

No response examples available

Body Params

RowKey
string
required

Unique identifier.

ReduceSysadmin
boolean
required

Prevent generic cloud admin accounts from having access (default=false).

Table
array of strings
required

The table to access.

Response

API-Result

ErrorIDstring

Unique support identifier for this occurrence of an error

Resultarray

A list of access collections.

Messagestring

Error message text on failure, may be null

successboolean

Indicates API success or failure

Gets the collection access rights based on the input parameters.

 
posthttps://example.com/Acl/GetCollectionAcesHelper
curl --request POST \
  --url 'https://example.com/Acl/GetCollectionAcesHelper?table=table&rowkey=rowkey&reduceSysadmin=reduceSysadmin'
var request = require("request");

var options = { method: 'POST',
  url: 'https://example.com/Acl/GetCollectionAcesHelper',
  qs:
   { table: 'table',
     rowkey: 'rowkey',
     reduceSysadmin: 'reduceSysadmin' } };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/Acl/GetCollectionAcesHelper?table=table&rowkey=rowkey&reduceSysadmin=reduceSysadmin")

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

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

response = http.request(request)
puts response.read_body
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", "https://example.com/Acl/GetCollectionAcesHelper?table=table&rowkey=rowkey&reduceSysadmin=reduceSysadmin");

xhr.send(data);
import requests

url = "https://example.com/Acl/GetCollectionAcesHelper"

querystring = {"table":"table","rowkey":"rowkey","reduceSysadmin":"reduceSysadmin"}

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

print(response.text)
A binary file was returned

You couldn't be authenticated

No response examples available

Query Params

table
string
required

The table to look in for the item.

rowkey
string
required

The unique identifier for the item.

reduceSysadmin
string
required

Prevent generic cloud admin accounts from having access.

Response

API-Result

ErrorIDstring

Unique support identifier for this occurrence of an error

Result

Resulting object, if any, of the call

Messagestring

Error message text on failure, may be null

successboolean

Indicates API success or failure

Retrieves a list of who has what rights for the directory.

 
posthttps://example.com/Acl/GetDirAces
curl --request POST \
  --url https://example.com/Acl/GetDirAces
var request = require("request");

var options = { method: 'POST', url: 'https://example.com/Acl/GetDirAces' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/Acl/GetDirAces")

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

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

response = http.request(request)
puts response.read_body
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", "https://example.com/Acl/GetDirAces");

xhr.send(data);
import requests

url = "https://example.com/Acl/GetDirAces"

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

print(response.text)
A binary file was returned

You couldn't be authenticated

No response examples available

Body Params

Path
string
required

Path to the folder being examined.

Inherit
boolean

Use inheritance (default=true).

Response

API-Result

ErrorIDstring

Unique support identifier for this occurrence of an error

Resultarray

List of directory access rights.

Messagestring

Error message text on failure, may be null

successboolean

Indicates API success or failure

Gets a list of directory rights.

 
posthttps://example.com/Acl/GetEffectiveDirRights
curl --request POST \
  --url https://example.com/Acl/GetEffectiveDirRights
var request = require("request");

var options = { method: 'POST',
  url: 'https://example.com/Acl/GetEffectiveDirRights' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/Acl/GetEffectiveDirRights")

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

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

response = http.request(request)
puts response.read_body
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", "https://example.com/Acl/GetEffectiveDirRights");

xhr.send(data);
import requests

url = "https://example.com/Acl/GetEffectiveDirRights"

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

print(response.text)
A binary file was returned

You couldn't be authenticated

No response examples available

Body Params

Paths
array of strings
required

A list of directories.

Response

API-Result

ErrorIDstring

Unique support identifier for this occurrence of an error

Resultarray

A list of directory rights.

Messagestring

Error message text on failure, may be null

successboolean

Indicates API success or failure

Gets a list of file rights.

 
posthttps://example.com/Acl/GetEffectiveFileRights
curl --request POST \
  --url https://example.com/Acl/GetEffectiveFileRights
var request = require("request");

var options = { method: 'POST',
  url: 'https://example.com/Acl/GetEffectiveFileRights' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/Acl/GetEffectiveFileRights")

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

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

response = http.request(request)
puts response.read_body
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", "https://example.com/Acl/GetEffectiveFileRights");

xhr.send(data);
import requests

url = "https://example.com/Acl/GetEffectiveFileRights"

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

print(response.text)
A binary file was returned

You couldn't be authenticated

No response examples available

Body Params

Paths
array of strings
required

List of files to examine for rights.

Response

API-Result

ErrorIDstring

Unique support identifier for this occurrence of an error

Resultarray

List of file rights.

Messagestring

Error message text on failure, may be null

successboolean

Indicates API success or failure

Gets ACLs on a file.

 
posthttps://example.com/Acl/GetFileAces
curl --request POST \
  --url https://example.com/Acl/GetFileAces
var request = require("request");

var options = { method: 'POST', url: 'https://example.com/Acl/GetFileAces' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/Acl/GetFileAces")

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

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

response = http.request(request)
puts response.read_body
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", "https://example.com/Acl/GetFileAces");

xhr.send(data);
import requests

url = "https://example.com/Acl/GetFileAces"

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

print(response.text)
A binary file was returned

You couldn't be authenticated

No response examples available

Body Params

Inherit
boolean
required

Use inheritance.

Paths
array of strings
required

Path to the file.

Response

API-Result

ErrorIDstring

Unique support identifier for this occurrence of an error

Resultarray

List of access files.

Messagestring

Error message text on failure, may be null

successboolean

Indicates API success or failure

Gets the access rights for a row.

 
posthttps://example.com/Acl/GetRowAces
curl --request POST \
  --url https://example.com/Acl/GetRowAces
var request = require("request");

var options = { method: 'POST', url: 'https://example.com/Acl/GetRowAces' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/Acl/GetRowAces")

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

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

response = http.request(request)
puts response.read_body
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", "https://example.com/Acl/GetRowAces");

xhr.send(data);
import requests

url = "https://example.com/Acl/GetRowAces"

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

print(response.text)
A binary file was returned

You couldn't be authenticated

No response examples available

Body Params

RowKey
string
required

The unique identifier.

ReduceSysadmin
boolean

Prevent generic cloud admin accounts from having access (default=false).

Inherit
boolean

Use inheritance (default=true).

Table
string
required

The sql table to examine.

Response

API-Result

ErrorIDstring

Unique support identifier for this occurrence of an error

Resultarray

List of row rights.

Messagestring

Error message text on failure, may be null

successboolean

Indicates API success or failure

Gets the row access rights based on the input parameters.

 
posthttps://example.com/Acl/GetRowAcesHelper
curl --request POST \
  --url 'https://example.com/Acl/GetRowAcesHelper?reduceSys=reduceSys&inherit=inherit&table=table&rk=rk'
var request = require("request");

var options = { method: 'POST',
  url: 'https://example.com/Acl/GetRowAcesHelper',
  qs:
   { reduceSys: 'reduceSys',
     inherit: 'inherit',
     table: 'table',
     rk: 'rk' } };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/Acl/GetRowAcesHelper?reduceSys=reduceSys&inherit=inherit&table=table&rk=rk")

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

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

response = http.request(request)
puts response.read_body
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", "https://example.com/Acl/GetRowAcesHelper?reduceSys=reduceSys&inherit=inherit&table=table&rk=rk");

xhr.send(data);
import requests

url = "https://example.com/Acl/GetRowAcesHelper"

querystring = {"reduceSys":"reduceSys","inherit":"inherit","table":"table","rk":"rk"}

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

print(response.text)
A binary file was returned

You couldn't be authenticated

No response examples available

Query Params

reduceSys
string
required

Don't assume administrators have sysadmin permission.

inherit
string
required

Use inheritance.

table
string
required

The table to look for the item.

rk
string
required

The item of interest's row key.

Response

API-Result

ErrorIDstring

Unique support identifier for this occurrence of an error

Result

Resulting object, if any, of the call

Messagestring

Error message text on failure, may be null

successboolean

Indicates API success or failure

Get gateway management information.

 
posthttps://example.com/Gateway/GetGatewayManagementInfo
curl --request POST \
  --url https://example.com/Gateway/GetGatewayManagementInfo
var request = require("request");

var options = { method: 'POST',
  url: 'https://example.com/Gateway/GetGatewayManagementInfo' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/Gateway/GetGatewayManagementInfo")

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

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

response = http.request(request)
puts response.read_body
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", "https://example.com/Gateway/GetGatewayManagementInfo");

xhr.send(data);
import requests

url = "https://example.com/Gateway/GetGatewayManagementInfo"

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

print(response.text)
A binary file was returned

You couldn't be authenticated

No response examples available

Body Params

_RowKey
string
required

The application unique identifier to probe.

ConfigureGatewayState
string

The security certificate to decrypt the payload.

Response

API-Result

ErrorIDstring

Unique support identifier for this occurrence of an error

Resultobject

Gate way management information.

Messagestring

Error message text on failure, may be null

successboolean

Indicates API success or failure

Probes the gateway for the specified app to test the endpoint host certificate.

If it's not trusted by either the proxy or us, we need to know what to do
(Exception for the given cert, or fail).

 
posthttps://example.com/Gateway/ProbeGatewayPipeline
curl --request POST \
  --url https://example.com/Gateway/ProbeGatewayPipeline
var request = require("request");

var options = { method: 'POST',
  url: 'https://example.com/Gateway/ProbeGatewayPipeline' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/Gateway/ProbeGatewayPipeline")

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

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

response = http.request(request)
puts response.read_body
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", "https://example.com/Gateway/ProbeGatewayPipeline");

xhr.send(data);
import requests

url = "https://example.com/Gateway/ProbeGatewayPipeline"

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

print(response.text)
A binary file was returned

You couldn't be authenticated

No response examples available

Body Params

_RowKey
string
required

The application unique identifier to probe.

ConfigureGatewayState
string

The security certificate to decrypt the payload.

Response

API-Result

ErrorIDstring

Unique support identifier for this occurrence of an error

Resultobject

Results from the gateway probe.

Messagestring

Error message text on failure, may be null

successboolean

Indicates API success or failure

Authenticates a request.

Calls defined by RFC(s). May alternately redirect to another login page or throw an exceptoin depending on success.
See the OAuth2 spec https://oauth.net/2/

 
posthttps://example.com/OAuth2/Authorize
curl --request POST \
  --url 'https://example.com/OAuth2/Authorize?bounce=bounce'
var request = require("request");

var options = { method: 'POST',
  url: 'https://example.com/OAuth2/Authorize',
  qs: { bounce: 'bounce' } };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/OAuth2/Authorize?bounce=bounce")

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

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

response = http.request(request)
puts response.read_body
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", "https://example.com/OAuth2/Authorize?bounce=bounce");

xhr.send(data);
import requests

url = "https://example.com/OAuth2/Authorize"

querystring = {"bounce":"bounce"}

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

print(response.text)
A binary file was returned

You couldn't be authenticated

No response examples available

Query Params

bounce
string
required

Value used to determine if authentication has occured.

Response

API-Result

ErrorIDstring

Unique support identifier for this occurrence of an error

Resultobject

ActionResult from processing the request.

Messagestring

Error message text on failure, may be null

successboolean

Indicates API success or failure

Confirm

Calls defined by RFC(s).
See the OAuth2 spec https://oauth.net/2/

 
posthttps://example.com/OAuth2/Confirm
curl --request POST \
  --url 'https://example.com/OAuth2/Confirm?bounce=bounce&result=result&scopes=scopes'
var request = require("request");

var options = { method: 'POST',
  url: 'https://example.com/OAuth2/Confirm',
  qs:
   { bounce: 'bounce',
     result: 'result',
     scopes: 'scopes' } };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/OAuth2/Confirm?bounce=bounce&result=result&scopes=scopes")

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

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

response = http.request(request)
puts response.read_body
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", "https://example.com/OAuth2/Confirm?bounce=bounce&result=result&scopes=scopes");

xhr.send(data);
import requests

url = "https://example.com/OAuth2/Confirm"

querystring = {"bounce":"bounce","result":"result","scopes":"scopes"}

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

print(response.text)
A binary file was returned

You couldn't be authenticated

No response examples available

Query Params

bounce
string
required

Value used to determine if authentication has occured.

result
string
required

Has user denied confirmation.

scopes
string
required

Comma delimited list of scope ids.

Response

API-Result

ErrorIDstring

Unique support identifier for this occurrence of an error

Resultobject

ActionResult from saving user confirmation.

Messagestring

Error message text on failure, may be null

successboolean

Indicates API success or failure

Introspect.

See the OAuth2 spec https://oauth.net/2/

 
posthttps://example.com/OAuth2/Introspect
curl --request POST \
  --url https://example.com/OAuth2/Introspect
var request = require("request");

var options = { method: 'POST', url: 'https://example.com/OAuth2/Introspect' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/OAuth2/Introspect")

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

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

response = http.request(request)
puts response.read_body
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", "https://example.com/OAuth2/Introspect");

xhr.send(data);
import requests

url = "https://example.com/OAuth2/Introspect"

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

print(response.text)
A binary file was returned

You couldn't be authenticated

No response examples available

Body Params

token
string
required

The authentication token to process.

Response

API-Result

ErrorIDstring

Unique support identifier for this occurrence of an error

Resultobject

Normalized information about the token.

Result.expstring

When does the token expire.

Result.scopestring

The scope of the token.

Result.substring

The user's unique identifier.

Messagestring

Error message text on failure, may be null

successboolean

Indicates API success or failure

Keys

See the OAuth2 spec https://oauth.net/2/

 
posthttps://example.com/OAuth2/Keys
curl --request POST \
  --url https://example.com/OAuth2/Keys
var request = require("request");

var options = { method: 'POST', url: 'https://example.com/OAuth2/Keys' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/OAuth2/Keys")

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

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

response = http.request(request)
puts response.read_body
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", "https://example.com/OAuth2/Keys");

xhr.send(data);
import requests

url = "https://example.com/OAuth2/Keys"

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

print(response.text)
A binary file was returned

You couldn't be authenticated

No response examples available

Body Params

customerid
object

The id used to determine the tenant.

Response

API-Result

ErrorIDstring

Unique support identifier for this occurrence of an error

Resultarray

A list of keys

Messagestring

Error message text on failure, may be null

successboolean

Indicates API success or failure

Revoke.

See the OAuth2 spec https://oauth.net/2/

 
posthttps://example.com/OAuth2/Revoke
curl --request POST \
  --url https://example.com/OAuth2/Revoke
var request = require("request");

var options = { method: 'POST', url: 'https://example.com/OAuth2/Revoke' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/OAuth2/Revoke")

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

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

response = http.request(request)
puts response.read_body
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", "https://example.com/OAuth2/Revoke");

xhr.send(data);
import requests

url = "https://example.com/OAuth2/Revoke"

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

print(response.text)
A binary file was returned

You couldn't be authenticated

No response examples available

Response

API-Result

ErrorIDstring

Unique support identifier for this occurrence of an error

Resultboolean

Did the revoke work.

Messagestring

Error message text on failure, may be null

successboolean

Indicates API success or failure

Gets a token based on grant type.

See the OAuth2 spec https://oauth.net/2/

 
posthttps://example.com/OAuth2/Token
curl --request POST \
  --url https://example.com/OAuth2/Token
var request = require("request");

var options = { method: 'POST', url: 'https://example.com/OAuth2/Token' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/OAuth2/Token")

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

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

response = http.request(request)
puts response.read_body
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", "https://example.com/OAuth2/Token");

xhr.send(data);
import requests

url = "https://example.com/OAuth2/Token"

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

print(response.text)
A binary file was returned

You couldn't be authenticated

No response examples available

Body Params

grant_type
string
required

Grant what type of token.

Response

API-Result

ErrorIDstring

Unique support identifier for this occurrence of an error

Resultobject

The token

Result.expires_ininteger

How long is the token good.

Result.scopestring

The scope of the token.

Result.access_tokenstring

The token unique identifier.

Result.token_typestring

The type of token.

Result.id_tokenstring

The token id.

Result.refresh_tokenstring

The token refresh.

Result.statestring

The state of the token.

Messagestring

Error message text on failure, may be null

successboolean

Indicates API success or failure

This returns the contents of the bearer token used.

Not anonymous.
See the OAuth2 spec https://oauth.net/2/

 
posthttps://example.com/OAuth2/UserInfo
curl --request POST \
  --url https://example.com/OAuth2/UserInfo
var request = require("request");

var options = { method: 'POST', url: 'https://example.com/OAuth2/UserInfo' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/OAuth2/UserInfo")

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

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

response = http.request(request)
puts response.read_body
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", "https://example.com/OAuth2/UserInfo");

xhr.send(data);
import requests

url = "https://example.com/OAuth2/UserInfo"

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

print(response.text)
A binary file was returned

You couldn't be authenticated

No response examples available

Body Params

Scopes
array of strings
required

A list of scope ids.

Response

API-Result

ErrorIDstring

Unique support identifier for this occurrence of an error

Resultobject

The contents of the bearer token.

Result.audstring

The profile client id.

Result.Uuidstring

The unique identifier for the user.

Result.unique_namestring

The user name.

Messagestring

Error message text on failure, may be null

successboolean

Indicates API success or failure

Attempt to advance the state of an authentication session.

When things are going smoothly, you can expect to get a 'StartNextChallenge' or 'LoginSuccess' response, however the system may (at any time)
return a new Mfa Package which may add, remove or change challenges. Failure cases typically result in an 'Undefined' error message when things are
misconfigured and a "LoginFailure' message when incorrect answers have terminated the session (which may have been sent in previous calls to this API).

 
posthttps://example.com/Security/AdvanceAuthentication
curl --request POST \
  --url https://example.com/Security/AdvanceAuthentication
var request = require("request");

var options = { method: 'POST',
  url: 'https://example.com/Security/AdvanceAuthentication' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/Security/AdvanceAuthentication")

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

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

response = http.request(request)
puts response.read_body
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", "https://example.com/Security/AdvanceAuthentication");

xhr.send(data);
import requests

url = "https://example.com/Security/AdvanceAuthentication"

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

print(response.text)
A binary file was returned

You couldn't be authenticated

No response examples available

Body Params

TenantId
string

Tenant ID/suffix returned by the call that started the authentication session

Action
string
required

What action to take with respect to the supplied MechanismId (answer it, send ood challenge, wait for oob response, etc.).

PersistentLogin
boolean

Flag indicating if the user's session should persist after closing the browser

SessionId
string
required

Session ID returned by the call that started the authentication session

MechanismId
string
required

Mechanism ID that you wish to advance.

Answer
string

For answerable mechanisms, the value that will satisfy the qustion (password, security code, etc.)

Response

API-Result

ErrorIDstring

Unique support identifier for this occurrence of an error

Resultobject

Login complete, login failed, move to next challenge or an updated authentication package.

Messagestring

Error message text on failure, may be null

successboolean

Indicates API success or failure

Advances a forgot username session (similar to MFA advance authentication).

Handles and mfa-like package with a single challenge (special case 'ForgotUsername' package).

 
posthttps://example.com/Security/AdvanceForgotUsername
curl --request POST \
  --url https://example.com/Security/AdvanceForgotUsername
var request = require("request");

var options = { method: 'POST',
  url: 'https://example.com/Security/AdvanceForgotUsername' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/Security/AdvanceForgotUsername")

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

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

response = http.request(request)
puts response.read_body
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", "https://example.com/Security/AdvanceForgotUsername");

xhr.send(data);
import requests

url = "https://example.com/Security/AdvanceForgotUsername"

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

print(response.text)
A binary file was returned

You couldn't be authenticated

No response examples available

Body Params

TenantId
string
required

The tenant id.

Action
string
required

The payload key action.

Answer
string
required

The answer.

Response

API-Result

ErrorIDstring

Unique support identifier for this occurrence of an error

Resultobject

An MFA return code (for success or failure).

Messagestring

Error message text on failure, may be null

successboolean

Indicates API success or failure

Terminate an incomplete session started with StartAuthentication or StartChallenge.

Does not affect completed authentication sessions.

 
posthttps://example.com/Security/CleanupAuthentication
curl --request POST \
  --url https://example.com/Security/CleanupAuthentication
var request = require("request");

var options = { method: 'POST',
  url: 'https://example.com/Security/CleanupAuthentication' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/Security/CleanupAuthentication")

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

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

response = http.request(request)
puts response.read_body
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", "https://example.com/Security/CleanupAuthentication");

xhr.send(data);
import requests

url = "https://example.com/Security/CleanupAuthentication"

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

print(response.text)
A binary file was returned

You couldn't be authenticated

No response examples available

Body Params

TenantId
string
required

Tenant ID/suffix returned by the call that started the authentication session

SessionId
string
required

Session ID returned by the call that started the authentication session

Response

API-Result

ErrorIDstring

Unique support identifier for this occurrence of an error

Resultobject

Standard result

Messagestring

Error message text on failure, may be null

successboolean

Indicates API success or failure

Allows OAuth2 clients to perform on-demand step-up authentication challenges.

Uses custom policy key modifiers to choose auth rules and profiles.

 
posthttps://example.com/Security/OnDemandChallenge
curl --request POST \
  --url https://example.com/Security/OnDemandChallenge
var request = require("request");

var options = { method: 'POST',
  url: 'https://example.com/Security/OnDemandChallenge' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/Security/OnDemandChallenge")

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

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

response = http.request(request)
puts response.read_body
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", "https://example.com/Security/OnDemandChallenge");

xhr.send(data);
import requests

url = "https://example.com/Security/OnDemandChallenge"

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

print(response.text)
A binary file was returned

You couldn't be authenticated

No response examples available

Body Params

User
string
required

Username of the user to challenge on behalf of.

PolicyModifier
string
required

The policy modifier key to use for deterministic selection of an Authentication Profile.

Response

API-Result

ErrorIDstring

Unique support identifier for this occurrence of an error

Resultobject

Login success (or error) message or an Authentication package to guide client through the MFA process.

Messagestring

Error message text on failure, may be null

successboolean

Indicates API success or failure

Continues user authentication.

Continued after receiving authentication results from the identity provider.

 
posthttps://example.com/Security/ResumeFromExtIdpAuth
curl --request POST \
  --url 'https://example.com/Security/ResumeFromExtIdpAuth?ExtIdpAuthChallengeState=ExtIdpAuthChallengeState'
var request = require("request");

var options = { method: 'POST',
  url: 'https://example.com/Security/ResumeFromExtIdpAuth',
  qs:
   { ExtIdpAuthChallengeState: 'ExtIdpAuthChallengeState' } };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/Security/ResumeFromExtIdpAuth?ExtIdpAuthChallengeState=ExtIdpAuthChallengeState")

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

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

response = http.request(request)
puts response.read_body
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", "https://example.com/Security/ResumeFromExtIdpAuth?ExtIdpAuthChallengeState=ExtIdpAuthChallengeState");

xhr.send(data);
import requests

url = "https://example.com/Security/ResumeFromExtIdpAuth"

querystring = {"ExtIdpAuthChallengeState":"ExtIdpAuthChallengeState"}

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

print(response.text)
A binary file was returned

You couldn't be authenticated

No response examples available

Query Params

ExtIdpAuthChallengeState
string
required

The current Idp challenge state.

Body Params

ExtIdpAuthChallengeState
string
required

The Idp authentication challenge state.

Response

API-Result

ErrorIDstring

Unique support identifier for this occurrence of an error

Resultobject

The next step (if there is one) for the user authentication.

Messagestring

Error message text on failure, may be null

successboolean

Indicates API success or failure

Starts a user authentication session.

The authentication package returned is a complex structure that guides the caller through the authentication process. Multiple calls to AdvanceAuthentication
may be required to complete the process.

 
posthttps://example.com/Security/StartAuthentication
curl --request POST \
  --url https://example.com/Security/StartAuthentication
var request = require("request");

var options = { method: 'POST',
  url: 'https://example.com/Security/StartAuthentication' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/Security/StartAuthentication")

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

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

response = http.request(request)
puts response.read_body
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", "https://example.com/Security/StartAuthentication");

xhr.send(data);
import requests

url = "https://example.com/Security/StartAuthentication"

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

print(response.text)
A binary file was returned

You couldn't be authenticated

No response examples available

Body Params

TenantId
string

Tenant ID/suffix of the user who is logging in. If this field is not provided, the user name must identify the tenant

Version
string
required

Version of the data being sent. Options: 1.0

ApplicationId
string

Placeholder - unused at this time

MfaRequestor
string

Placeholder - unused at this time

User
string
required

Name of the user who is attempting to authenticate.

Response

API-Result

ErrorIDstring

Unique support identifier for this occurrence of an error

Resultobject

Login success (or error) message or an Authentication package to guide client through the MFA process.

Messagestring

Error message text on failure, may be null

successboolean

Indicates API success or failure

Starts a step-up authentication challenge session.

The authentication package returned is a complex structure that guides the caller through the authentication process. Multiple calls to AdvanceAuthentication
may be required to complete the process.

 
posthttps://example.com/Security/StartChallenge
curl --request POST \
  --url https://example.com/Security/StartChallenge
var request = require("request");

var options = { method: 'POST',
  url: 'https://example.com/Security/StartChallenge' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/Security/StartChallenge")

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

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

response = http.request(request)
puts response.read_body
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", "https://example.com/Security/StartChallenge");

xhr.send(data);
import requests

url = "https://example.com/Security/StartChallenge"

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

print(response.text)
A binary file was returned

You couldn't be authenticated

No response examples available

Body Params

Version
string
required

Version of the data being sent. Options: 1.0

ChallengeStateId
string
required

ChallengeId returned by other REST calls.

Response

API-Result

ErrorIDstring

Unique support identifier for this occurrence of an error

Resultobject

Login success (or error) message or an Authentication package to guide client through the MFA process.

Messagestring

Error message text on failure, may be null

successboolean

Indicates API success or failure

Starts a forgot username session that looks similar to an MFA authentication session.

Returns an mfa package with a single challenge (special case 'ForgotUsername' package). The tenant Id is derived from the URL - there is no way to specify it otherwise.

 
posthttps://example.com/Security/StartForgotUsername
curl --request POST \
  --url https://example.com/Security/StartForgotUsername
var request = require("request");

var options = { method: 'POST',
  url: 'https://example.com/Security/StartForgotUsername' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/Security/StartForgotUsername")

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

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

response = http.request(request)
puts response.read_body
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", "https://example.com/Security/StartForgotUsername");

xhr.send(data);
import requests

url = "https://example.com/Security/StartForgotUsername"

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

print(response.text)
A binary file was returned

You couldn't be authenticated

No response examples available

Body Params

Version
string
required

The payload key version.

Response

API-Result

ErrorIDstring

Unique support identifier for this occurrence of an error

Resultobject

An Authentication package to guide client through the Forgot Username MFA process.

Messagestring

Error message text on failure, may be null

successboolean

Indicates API success or failure

Submit OATH OTP code for the specify user

The request must be made using a tenant-specific URL.

 
posthttps://example.com/Security/SubmitOathOtpCode
curl --request POST \
  --url 'https://example.com/Security/SubmitOathOtpCode?otpCode=otpCode&userUuid=userUuid'
var request = require("request");

var options = { method: 'POST',
  url: 'https://example.com/Security/SubmitOathOtpCode',
  qs:
   { otpCode: 'otpCode',
     userUuid: 'userUuid' } };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/Security/SubmitOathOtpCode?otpCode=otpCode&userUuid=userUuid")

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

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

response = http.request(request)
puts response.read_body
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", "https://example.com/Security/SubmitOathOtpCode?otpCode=otpCode&userUuid=userUuid");

xhr.send(data);
import requests

url = "https://example.com/Security/SubmitOathOtpCode"

querystring = {"otpCode":"otpCode","userUuid":"userUuid"}

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

print(response.text)
A binary file was returned

You couldn't be authenticated

No response examples available

Query Params

otpCode
string
required

OATH One time password.

userUuid
string
required

Uuid for the authentication user.

Body Params

otpCode
string
required

OATH One time password.

userUuid
string
required

Uuid for the authentication user.

Response

API-Result

ErrorIDstring

Unique support identifier for this occurrence of an error

Resultobject

Standard JSON response.

Messagestring

Error message text on failure, may be null

successboolean

Indicates API success or failure

Answer registration challenge.

 
posthttps://example.com/U2f/AnswerRegistrationChallenge
curl --request POST \
  --url 'https://example.com/U2f/AnswerRegistrationChallenge?rawRegisterResponse=rawRegisterResponse'
var request = require("request");

var options = { method: 'POST',
  url: 'https://example.com/U2f/AnswerRegistrationChallenge',
  qs:
   { rawRegisterResponse: 'rawRegisterResponse' } };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/U2f/AnswerRegistrationChallenge?rawRegisterResponse=rawRegisterResponse")

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

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

response = http.request(request)
puts response.read_body
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", "https://example.com/U2f/AnswerRegistrationChallenge?rawRegisterResponse=rawRegisterResponse");

xhr.send(data);
import requests

url = "https://example.com/U2f/AnswerRegistrationChallenge"

querystring = {"rawRegisterResponse":"rawRegisterResponse"}

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

print(response.text)
A binary file was returned

You couldn't be authenticated

No response examples available

Query Params

rawRegisterResponse
string
required

The raw registation response.

Body Params

ClientData
string
required

The client data.

RegistrationData
string
required

The registration data.

Challenge
string
required

The registration challenge.

Response

API-Result

ErrorIDstring

Unique support identifier for this occurrence of an error

Resultobject

Standard JSON response.

Messagestring

Error message text on failure, may be null

successboolean

Indicates API success or failure

Deletes the U2f device.

 
posthttps://example.com/U2f/DeleteU2fDevice
curl --request POST \
  --url 'https://example.com/U2f/DeleteU2fDevice?keyHandle=keyHandle'
var request = require("request");

var options = { method: 'POST',
  url: 'https://example.com/U2f/DeleteU2fDevice',
  qs: { keyHandle: 'keyHandle' } };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/U2f/DeleteU2fDevice?keyHandle=keyHandle")

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

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

response = http.request(request)
puts response.read_body
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", "https://example.com/U2f/DeleteU2fDevice?keyHandle=keyHandle");

xhr.send(data);
import requests

url = "https://example.com/U2f/DeleteU2fDevice"

querystring = {"keyHandle":"keyHandle"}

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

print(response.text)
A binary file was returned

You couldn't be authenticated

No response examples available

Query Params

keyHandle
string
required

The device key to delete.

Response

API-Result

ErrorIDstring

Unique support identifier for this occurrence of an error

Resultobject

Standard JSON response.

Messagestring

Error message text on failure, may be null

successboolean

Indicates API success or failure

Delete a list of U2f devices.

 
posthttps://example.com/U2f/DeleteU2fDevices
curl --request POST \
  --url https://example.com/U2f/DeleteU2fDevices
var request = require("request");

var options = { method: 'POST',
  url: 'https://example.com/U2f/DeleteU2fDevices' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/U2f/DeleteU2fDevices")

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

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

response = http.request(request)
puts response.read_body
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", "https://example.com/U2f/DeleteU2fDevices");

xhr.send(data);
import requests

url = "https://example.com/U2f/DeleteU2fDevices"

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

print(response.text)
A binary file was returned

You couldn't be authenticated

No response examples available

Body Params

KeyHandles
array of strings
required

A list of handles to U2f devices.

Response

API-Result

ErrorIDstring

Unique support identifier for this occurrence of an error

Resultobject

Standard JSON response.

Messagestring

Error message text on failure, may be null

successboolean

Indicates API success or failure

Get the trusted facet list for the tenant.

 
posthttps://example.com/U2f/Facets
curl --request POST \
  --url https://example.com/U2f/Facets
var request = require("request");

var options = { method: 'POST', url: 'https://example.com/U2f/Facets' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/U2f/Facets")

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

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

response = http.request(request)
puts response.read_body
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", "https://example.com/U2f/Facets");

xhr.send(data);
import requests

url = "https://example.com/U2f/Facets"

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

print(response.text)
A binary file was returned

You couldn't be authenticated

No response examples available

Response

API-Result

ErrorIDstring

Unique support identifier for this occurrence of an error

Resultobject

The trusted facets for the tenant.

Messagestring

Error message text on failure, may be null

successboolean

Indicates API success or failure

Get registration challenge.

 
posthttps://example.com/U2f/GetRegistrationChallenge
curl --request POST \
  --url 'https://example.com/U2f/GetRegistrationChallenge?userDefinedName=userDefinedName'
var request = require("request");

var options = { method: 'POST',
  url: 'https://example.com/U2f/GetRegistrationChallenge',
  qs: { userDefinedName: 'userDefinedName' } };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/U2f/GetRegistrationChallenge?userDefinedName=userDefinedName")

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

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

response = http.request(request)
puts response.read_body
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", "https://example.com/U2f/GetRegistrationChallenge?userDefinedName=userDefinedName");

xhr.send(data);
import requests

url = "https://example.com/U2f/GetRegistrationChallenge"

querystring = {"userDefinedName":"userDefinedName"}

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

print(response.text)
A binary file was returned

You couldn't be authenticated

No response examples available

Query Params

userDefinedName
string
required

The user defined name.

Response

API-Result

ErrorIDstring

Unique support identifier for this occurrence of an error

Resultobject

The registration challenge.

Result.AppIdstring

The application id.

Result.Devicesarray

A list of devices.

Result.Challengestring

The challenge.

Messagestring

Error message text on failure, may be null

successboolean

Indicates API success or failure

Gets a list of U2f devices.

 
posthttps://example.com/U2f/GetU2fDevices
curl --request POST \
  --url https://example.com/U2f/GetU2fDevices
var request = require("request");

var options = { method: 'POST', url: 'https://example.com/U2f/GetU2fDevices' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/U2f/GetU2fDevices")

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

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

response = http.request(request)
puts response.read_body
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", "https://example.com/U2f/GetU2fDevices");

xhr.send(data);
import requests

url = "https://example.com/U2f/GetU2fDevices"

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

print(response.text)
A binary file was returned

You couldn't be authenticated

No response examples available

Response

API-Result

ErrorIDstring

Unique support identifier for this occurrence of an error

Resultarray

The list of U2f devices in UI Query Response format.

Messagestring

Error message text on failure, may be null

successboolean

Indicates API success or failure

Gets a list of U2f devices for the current user.

 
posthttps://example.com/U2f/GetU2fDevicesForUser
curl --request POST \
  --url https://example.com/U2f/GetU2fDevicesForUser
var request = require("request");

var options = { method: 'POST',
  url: 'https://example.com/U2f/GetU2fDevicesForUser' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/U2f/GetU2fDevicesForUser")

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

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

response = http.request(request)
puts response.read_body
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", "https://example.com/U2f/GetU2fDevicesForUser");

xhr.send(data);
import requests

url = "https://example.com/U2f/GetU2fDevicesForUser"

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

print(response.text)
A binary file was returned

You couldn't be authenticated

No response examples available

Response

API-Result

ErrorIDstring

Unique support identifier for this occurrence of an error

Resultarray

The list of U2f devices for the current user in UI Query Response format.

Messagestring

Error message text on failure, may be null

successboolean

Indicates API success or failure

User Management

 

Gets a list of row rights.

Only returns value if current user has at least read-rights.

 
posthttps://example.com/Acl/GetEffectiveRowRights
curl --request POST \
  --url https://example.com/Acl/GetEffectiveRowRights
var request = require("request");

var options = { method: 'POST',
  url: 'https://example.com/Acl/GetEffectiveRowRights' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/Acl/GetEffectiveRowRights")

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

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

response = http.request(request)
puts response.read_body
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", "https://example.com/Acl/GetEffectiveRowRights");

xhr.send(data);
import requests

url = "https://example.com/Acl/GetEffectiveRowRights"

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

print(response.text)
A binary file was returned

You couldn't be authenticated

No response examples available

Body Params

Rows
array of objects
required

Row rights of the user to look for.

Response

API-Result

ErrorIDstring

Unique support identifier for this occurrence of an error

Resultarray

A list of user rights.

Messagestring

Error message text on failure, may be null

successboolean

Indicates API success or failure

Deprecated -- Delete a list of users with permission check.

Deprecated -- use UserMgmt/RemoveUsers() instead.

 
posthttps://example.com/CDirectoryService/BulkDeleteUsers
curl --request POST \
  --url https://example.com/CDirectoryService/BulkDeleteUsers
var request = require("request");

var options = { method: 'POST',
  url: 'https://example.com/CDirectoryService/BulkDeleteUsers' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/CDirectoryService/BulkDeleteUsers")

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

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

response = http.request(request)
puts response.read_body
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", "https://example.com/CDirectoryService/BulkDeleteUsers");

xhr.send(data);
import requests

url = "https://example.com/CDirectoryService/BulkDeleteUsers"

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

print(response.text)
A binary file was returned

You couldn't be authenticated

No response examples available

Body Params

Users
string
required

List of users for removal.

Response

API-Result

ErrorIDstring

Unique support identifier for this occurrence of an error

Resultboolean

Success or failure of the delete.

Messagestring

Error message text on failure, may be null

successboolean

Indicates API success or failure

Create new users in the Cloud Directory Service based on data read from files.

You must be a system administrator or have user management permissions.
Specifying 'ServiceUser' will override the 'InEveryBodyRole' property if both are provided.

            The file(s) must conform to the following format:
 
posthttps://example.com/CDirectoryService/CreateUserBulk
curl --request POST \
  --url https://example.com/CDirectoryService/CreateUserBulk
var request = require("request");

var options = { method: 'POST',
  url: 'https://example.com/CDirectoryService/CreateUserBulk' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/CDirectoryService/CreateUserBulk")

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

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

response = http.request(request)
puts response.read_body
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", "https://example.com/CDirectoryService/CreateUserBulk");

xhr.send(data);
import requests

url = "https://example.com/CDirectoryService/CreateUserBulk"

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

print(response.text)
A binary file was returned

You couldn't be authenticated

No response examples available

Body Params

InEverybodyRole
boolean

Place user in Everybody role (default=true).

SendSmsInvite
boolean

Send user an sms invite to enroll their mobile device in the protal (default=false).

InSysAdminRole
boolean

Place user in System Adminstrator role (default=false).

Description
string

Description of user (default=null).

Name
string
required

Name of user.

MobileNumber
string

User's mobile number (default=null); note this field is required if SendSmsInvite is true.

Password
string

URL encoded password of the user (default=randomly generated strong password).

CmaRedirectedUserUuid
string

Centrify mobile authenticator redirected user uuid.

ServiceUser
boolean

User is a service user (default=false).

OfficeNumber
string

User's office number (default=null).

ReportsTo
string

Uuid of user this user reports to (default=null).

SendEmailInvite
boolean

Send user an email invite to the portal (default=true).

HomeNumber
string

User's home number (default=null).

DisplayName
string

Display name of user (default=null).

ForcePasswordChangeNext
boolean

Force password change at first login (default=true).

PasswordNeverExpire
boolean

User's password never expires (default=false).

Mail
string

Email of user (default=null); note this field is required if 'SendEmailInvite' is true.

Response

API-Result

ErrorIDstring

Unique support identifier for this occurrence of an error

Resultstring

Success or fail, if fail includes -'d list of filenames that failed.

Messagestring

Error message text on failure, may be null

successboolean

Indicates API success or failure

Delete user after permission check (DEPRECATED)

 
posthttps://example.com/CDirectoryService/Delete
curl --request POST \
  --url 'https://example.com/CDirectoryService/Delete?id=id'
var request = require("request");

var options = { method: 'POST',
  url: 'https://example.com/CDirectoryService/Delete',
  qs: { id: 'id' } };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/CDirectoryService/Delete?id=id")

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

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

response = http.request(request)
puts response.read_body
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", "https://example.com/CDirectoryService/Delete?id=id");

xhr.send(data);
import requests

url = "https://example.com/CDirectoryService/Delete"

querystring = {"id":"id"}

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

print(response.text)
A binary file was returned

You couldn't be authenticated

No response examples available

Query Params

id
string
required

User UUID or Name to delete.

Response

API-Result

ErrorIDstring

Unique support identifier for this occurrence of an error

Resultboolean

Success or failure of the delete.

Messagestring

Error message text on failure, may be null

successboolean

Indicates API success or failure

Exempt a specified user from MFA login for a period of time.

You must be a system administrator or have user management permissions. User is exempt from MFA login for a specified amount of time.

 
posthttps://example.com/CDirectoryService/ExemptUserFromMfa
curl --request POST \
  --url 'https://example.com/CDirectoryService/ExemptUserFromMfa?ID=ID'
var request = require("request");

var options = { method: 'POST',
  url: 'https://example.com/CDirectoryService/ExemptUserFromMfa',
  qs: { ID: 'ID' } };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/CDirectoryService/ExemptUserFromMfa?ID=ID")

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

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

response = http.request(request)
puts response.read_body
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", "https://example.com/CDirectoryService/ExemptUserFromMfa?ID=ID");

xhr.send(data);
import requests

url = "https://example.com/CDirectoryService/ExemptUserFromMfa"

querystring = {"ID":"ID"}

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

print(response.text)
A binary file was returned

You couldn't be authenticated

No response examples available

Query Params

ID
string
required

User UUID to except from MFA

timespan
integer

Amount of time to exempt the user from MFA (default=10 minutes)

Response

API-Result

ErrorIDstring

Unique support identifier for this occurrence of an error

Resultobject

Standard result

Messagestring

Error message text on failure, may be null

successboolean

Indicates API success or failure

Get details for the current user.

 
posthttps://example.com/CDirectoryService/GetUserAttributes
curl --request POST \
  --url https://example.com/CDirectoryService/GetUserAttributes
var request = require("request");

var options = { method: 'POST',
  url: 'https://example.com/CDirectoryService/GetUserAttributes' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/CDirectoryService/GetUserAttributes")

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

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

response = http.request(request)
puts response.read_body
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", "https://example.com/CDirectoryService/GetUserAttributes");

xhr.send(data);
import requests

url = "https://example.com/CDirectoryService/GetUserAttributes"

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

print(response.text)
A binary file was returned

You couldn't be authenticated

No response examples available

Response

API-Result

ErrorIDstring

Unique support identifier for this occurrence of an error

Resultobject

Cloud user details

Result.InEverybodyRoleboolean

Is user in the Everybody role?

Result.Descriptionstring

User description

Result.Namestring

User name

Result.MobileNumberstring

User mobile phone number

Result.LastPasswordChangeDatestring

Date/time user last changed their password

Result.OfficeNumberstring

User office phone number

Result.PictureUristring

File system path to user picture file

Result.ReportsTostring

User reports to user UUID.

Result.HomeNumberstring

User home phone number

Result.DisplayNamestring

User display name

Result.Aliasstring

Login suffix of the user

Result.Statestring

User state (locked, enabled, expired)

Result.PasswordNeverExpireboolean

Does the user's password never expire?

Result.Uuidstring

User UUID

Result.Mailstring

User email

Messagestring

Error message text on failure, may be null

successboolean

Indicates API success or failure

Reads users from a csv file(s).

 
posthttps://example.com/CDirectoryService/GetUsersFromCsvFile
curl --request POST \
  --url https://example.com/CDirectoryService/GetUsersFromCsvFile
var request = require("request");

var options = { method: 'POST',
  url: 'https://example.com/CDirectoryService/GetUsersFromCsvFile' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/CDirectoryService/GetUsersFromCsvFile")

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

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

response = http.request(request)
puts response.read_body
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", "https://example.com/CDirectoryService/GetUsersFromCsvFile");

xhr.send(data);
import requests

url = "https://example.com/CDirectoryService/GetUsersFromCsvFile"

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

print(response.text)
A binary file was returned

You couldn't be authenticated

No response examples available

Body Params

FileName
object
required

The csv file containing user information.

FileName.InEverybodyRole
boolean

Place user in Everybody role (default=true).

FileName.SendSmsInvite
boolean

Send user an sms invite to enroll their mobile device in the protal (default=false).

FileName.InSysAdminRole
boolean

Place user in System Adminstrator role (default=false).

FileName.Description
string

Description of user (default=null).

FileName.Name
string

Name of user.

FileName.MobileNumber
string

User's mobile number (default=null); note this field is required if SendSmsInvite is true.

FileName.Password
string

URL encoded password of the user (default=randomly generated strong password).

FileName.CmaRedirectedUserUuid
string

Centrify mobile authenticator redirected user uuid.

FileName.ServiceUser
boolean

User is a service user (default=false).

FileName.OfficeNumber
string

User's office number (default=null).

FileName.ReportsTo
string

Uuid of user this user reports to (default=null).

FileName.SendEmailInvite
boolean

Send user an email invite to the portal (default=true).

FileName.HomeNumber
string

User's home number (default=null).

FileName.DisplayName
string

Display name of user (default=null).

FileName.ForcePasswordChangeNext
boolean

Force password change at first login (default=true).

FileName.PasswordNeverExpire
boolean

User's password never expires (default=false).

FileName.Mail
string

Email of user (default=null); note this field is required if 'SendEmailInvite' is true.

Response

API-Result

ErrorIDstring

Unique support identifier for this occurrence of an error

Resultstring

QueryResult in UI format.

Messagestring

Error message text on failure, may be null

successboolean

Indicates API success or failure

Refresh a user's cached identity.

You must be a system administrator or have user management permissions. User cached identity in the cloud is reloaded from their directory service.
Useful when user details have changed in their remote directory service, but have not yet been pushed to the cloud.

 
posthttps://example.com/CDirectoryService/RefreshToken
curl --request POST \
  --url 'https://example.com/CDirectoryService/RefreshToken?ID=ID'
var request = require("request");

var options = { method: 'POST',
  url: 'https://example.com/CDirectoryService/RefreshToken',
  qs: { ID: 'ID' } };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/CDirectoryService/RefreshToken?ID=ID")

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

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

response = http.request(request)
puts response.read_body
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", "https://example.com/CDirectoryService/RefreshToken?ID=ID");

xhr.send(data);
import requests

url = "https://example.com/CDirectoryService/RefreshToken"

querystring = {"ID":"ID"}

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

print(response.text)
A binary file was returned

You couldn't be authenticated

No response examples available

Query Params

ID
string
required

User UUID to refresh

directoryServiceUuid
string

UUID of the user's directory service (default=null)

Response

API-Result

ErrorIDstring

Unique support identifier for this occurrence of an error

Resultobject

Standard result

Messagestring

Error message text on failure, may be null

successboolean

Indicates API success or failure

Create a Bulk User Import scheduled task to process the uploaded file.

Seems to be second part of a two part call.

 
posthttps://example.com/CDirectoryService/SubmitUploadedFile
curl --request POST \
  --url https://example.com/CDirectoryService/SubmitUploadedFile
var request = require("request");

var options = { method: 'POST',
  url: 'https://example.com/CDirectoryService/SubmitUploadedFile' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/CDirectoryService/SubmitUploadedFile")

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

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

response = http.request(request)
puts response.read_body
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", "https://example.com/CDirectoryService/SubmitUploadedFile");

xhr.send(data);
import requests

url = "https://example.com/CDirectoryService/SubmitUploadedFile"

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

print(response.text)
A binary file was returned

You couldn't be authenticated

No response examples available

Body Params

File
object
required

File containing the users to be created by the scheduled task, uploaded in the form-data, not as JSON.

Response

API-Result

ErrorIDstring

Unique support identifier for this occurrence of an error

Resultboolean

Success or failure of job creation.

Messagestring

Error message text on failure, may be null

successboolean

Indicates API success or failure

Retreives a list of users that are members of a specific federated group.

 
posthttps://example.com/Federation/GetFederatedGroupMembers
curl --request POST \
  --url https://example.com/Federation/GetFederatedGroupMembers
var request = require("request");

var options = { method: 'POST',
  url: 'https://example.com/Federation/GetFederatedGroupMembers' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/Federation/GetFederatedGroupMembers")

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

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

response = http.request(request)
puts response.read_body
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", "https://example.com/Federation/GetFederatedGroupMembers");

xhr.send(data);
import requests

url = "https://example.com/Federation/GetFederatedGroupMembers"

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

print(response.text)
A binary file was returned

You couldn't be authenticated

No response examples available

Body Params

Group
string
required

UUID of the group

PageNumber
integer

Zero indexed page number of the results to fetch (use 0 when requesting all rows).

PageSize
integer

Number of records to return (use 0 when requesting all rows).

Response

API-Result

ErrorIDstring

Unique support identifier for this occurrence of an error

Resultobject

A list of users that are members of the federated group.

Messagestring

Error message text on failure, may be null

successboolean

Indicates API success or failure

Retrieves the Federated Group Memberships for a specfic user.

 
posthttps://example.com/Federation/GetFederatedGroupsForUser
curl --request POST \
  --url https://example.com/Federation/GetFederatedGroupsForUser
var request = require("request");

var options = { method: 'POST',
  url: 'https://example.com/Federation/GetFederatedGroupsForUser' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/Federation/GetFederatedGroupsForUser")

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

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

response = http.request(request)
puts response.read_body
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", "https://example.com/Federation/GetFederatedGroupsForUser");

xhr.send(data);
import requests

url = "https://example.com/Federation/GetFederatedGroupsForUser"

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

print(response.text)
A binary file was returned

You couldn't be authenticated

No response examples available

Body Params

User
string
required

UUID of the user

Response

API-Result

ErrorIDstring

Unique support identifier for this occurrence of an error

Resultobject

The list of Federated Groups that the user is a member of.

Messagestring

Error message text on failure, may be null

successboolean

Indicates API success or failure

Revokes federated group membership from a specific group for a specific user.

 
posthttps://example.com/Federation/RemoveUserFromFederatedGroup
curl --request POST \
  --url https://example.com/Federation/RemoveUserFromFederatedGroup
var request = require("request");

var options = { method: 'POST',
  url:
   'https://example.com/Federation/RemoveUserFromFederatedGroup' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/Federation/RemoveUserFromFederatedGroup")

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

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

response = http.request(request)
puts response.read_body
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", "https://example.com/Federation/RemoveUserFromFederatedGroup");

xhr.send(data);
import requests

url = "https://example.com/Federation/RemoveUserFromFederatedGroup"

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

print(response.text)
A binary file was returned

You couldn't be authenticated

No response examples available

Body Params

Federation
string

UUID of the federation that granted membership previously and we're now revoking membership from. If omitted, the user will be removed from the group completely (no memberships will remain granted from any federation)

Group
string
required

UUID of the group

User
string
required

UUID of the user

Response

API-Result

ErrorIDstring

Unique support identifier for this occurrence of an error

Resultobject

Standard results.

Messagestring

Error message text on failure, may be null

successboolean

Indicates API success or failure

Refresh current user's cached identity.

User cached identity in the cloud is reloaded from their directory service. Useful when user details have changed in their remote directory service, but have not yet been pushed to the cloud.

 
posthttps://example.com/Security/RefreshToken
curl --request POST \
  --url https://example.com/Security/RefreshToken
var request = require("request");

var options = { method: 'POST',
  url: 'https://example.com/Security/RefreshToken' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/Security/RefreshToken")

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

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

response = http.request(request)
puts response.read_body
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", "https://example.com/Security/RefreshToken");

xhr.send(data);
import requests

url = "https://example.com/Security/RefreshToken"

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

print(response.text)
A binary file was returned

You couldn't be authenticated

No response examples available

Response

API-Result

ErrorIDstring

Unique support identifier for this occurrence of an error

Resultobject

Standard result

Messagestring

Error message text on failure, may be null

successboolean

Indicates API success or failure

Delete admin security question.

 
posthttps://example.com/TenantConfig/DeleteAdminSecurityQuestion
curl --request POST \
  --url 'https://example.com/TenantConfig/DeleteAdminSecurityQuestion?Id=Id'
var request = require("request");

var options = { method: 'POST',
  url:
   'https://example.com/TenantConfig/DeleteAdminSecurityQuestion',
  qs: { Id: 'Id' } };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/TenantConfig/DeleteAdminSecurityQuestion?Id=Id")

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

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

response = http.request(request)
puts response.read_body
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", "https://example.com/TenantConfig/DeleteAdminSecurityQuestion?Id=Id");

xhr.send(data);
import requests

url = "https://example.com/TenantConfig/DeleteAdminSecurityQuestion"

querystring = {"Id":"Id"}

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

print(response.text)
A binary file was returned

You couldn't be authenticated

No response examples available

Query Params

Id
string
required

Uuid of the question to delete.

Body Params

Id
string
required

Uuid of the question to delete

Response

API-Result

ErrorIDstring

Unique support identifier for this occurrence of an error

Resultobject

Standard result

Messagestring

Error message text on failure, may be null

successboolean

Indicates API success or failure

Get a specific admin security question

 
posthttps://example.com/TenantConfig/GetAdminSecurityQuestion
curl --request POST \
  --url 'https://example.com/TenantConfig/GetAdminSecurityQuestion?Id=Id'
var request = require("request");

var options = { method: 'POST',
  url: 'https://example.com/TenantConfig/GetAdminSecurityQuestion',
  qs: { Id: 'Id' } };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/TenantConfig/GetAdminSecurityQuestion?Id=Id")

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

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

response = http.request(request)
puts response.read_body
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", "https://example.com/TenantConfig/GetAdminSecurityQuestion?Id=Id");

xhr.send(data);
import requests

url = "https://example.com/TenantConfig/GetAdminSecurityQuestion"

querystring = {"Id":"Id"}

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

print(response.text)
A binary file was returned

You couldn't be authenticated

No response examples available

Query Params

Id
string
required

Uuid of the question.

Response

API-Result

ErrorIDstring

Unique support identifier for this occurrence of an error

Resultobject
          Admin Security Question withs the following properties
          {
            description: "Admin Security Question",
            properties: {
              Uuid: { description: "Question Uuid", type: "string" },
              Question: { "description": "Text of the question", type: "string" },
              Culture: { "description": "Culture of the question, 'all' implies all cultures", type: "string" }
            }
          }
Messagestring

Error message text on failure, may be null

successboolean

Indicates API success or failure

Get admin security questions

 
posthttps://example.com/TenantConfig/GetAdminSecurityQuestions
curl --request POST \
  --url https://example.com/TenantConfig/GetAdminSecurityQuestions
var request = require("request");

var options = { method: 'POST',
  url: 'https://example.com/TenantConfig/GetAdminSecurityQuestions' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/TenantConfig/GetAdminSecurityQuestions")

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

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

response = http.request(request)
puts response.read_body
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", "https://example.com/TenantConfig/GetAdminSecurityQuestions");

xhr.send(data);
import requests

url = "https://example.com/TenantConfig/GetAdminSecurityQuestions"

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

print(response.text)
A binary file was returned

You couldn't be authenticated

No response examples available

Response

API-Result

ErrorIDstring

Unique support identifier for this occurrence of an error

Resultobject
          List of Admin Security Questions; each entry is has the following properties
          {
            description: "Admin Security Question",
            properties: {
              Uuid: { description: "Question Uuid", type: "string" },
              Question: { "description": "Text of the question", type: "string" }
              Culture: { "description": "Culture of the question, 'all' implies all cultures", type: "string" }
            }
          }
Messagestring

Error message text on failure, may be null

successboolean

Indicates API success or failure

Add admin security question.

 
posthttps://example.com/TenantConfig/SetAdminSecurityQuestion
curl --request POST \
  --url https://example.com/TenantConfig/SetAdminSecurityQuestion
var request = require("request");

var options = { method: 'POST',
  url: 'https://example.com/TenantConfig/SetAdminSecurityQuestion' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/TenantConfig/SetAdminSecurityQuestion")

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

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

response = http.request(request)
puts response.read_body
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", "https://example.com/TenantConfig/SetAdminSecurityQuestion");

xhr.send(data);
import requests

url = "https://example.com/TenantConfig/SetAdminSecurityQuestion"

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

print(response.text)
A binary file was returned

You couldn't be authenticated

No response examples available

Body Params

Culture
string

Culture of the question to add.

Question
string
required

Test of the question to add.

Response

API-Result

ErrorIDstring

Unique support identifier for this occurrence of an error

Resultobject

Standard result

Messagestring

Error message text on failure, may be null

successboolean

Indicates API success or failure

Runs a risk check for the current user.

You must be logged in and the tenant must have the Adaptive MFA entitlement enabled.

 
posthttps://example.com/UserMgmt/AnalyzeAdaptiveMfaRisk
curl --request POST \
  --url https://example.com/UserMgmt/AnalyzeAdaptiveMfaRisk
var request = require("request");

var options = { method: 'POST',
  url: 'https://example.com/UserMgmt/AnalyzeAdaptiveMfaRisk' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/UserMgmt/AnalyzeAdaptiveMfaRisk")

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

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

response = http.request(request)
puts response.read_body
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", "https://example.com/UserMgmt/AnalyzeAdaptiveMfaRisk");

xhr.send(data);
import requests

url = "https://example.com/UserMgmt/AnalyzeAdaptiveMfaRisk"

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

print(response.text)
A binary file was returned

You couldn't be authenticated

No response examples available

Response

API-Result

ErrorIDstring

Unique support identifier for this occurrence of an error

Resultobject

Risk level returned by the risk check, 'SystemUnavailable' indicates an error of some kind.

Messagestring

Error message text on failure, may be null

successboolean

Indicates API success or failure

Check to see if a user can edit attributes.

 
posthttps://example.com/UserMgmt/CanEditUserAttributes
curl --request POST \
  --url https://example.com/UserMgmt/CanEditUserAttributes
var request = require("request");

var options = { method: 'POST',
  url: 'https://example.com/UserMgmt/CanEditUserAttributes' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/UserMgmt/CanEditUserAttributes")

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

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

response = http.request(request)
puts response.read_body
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", "https://example.com/UserMgmt/CanEditUserAttributes");

xhr.send(data);
import requests

url = "https://example.com/UserMgmt/CanEditUserAttributes"

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

print(response.text)
A binary file was returned

You couldn't be authenticated

No response examples available

Query Params

ID
string

User UUID or name to check (default=current user)

directoryServiceUuid
string

Directory service UUID of the user (default=null)

Response

API-Result

ErrorIDstring

Unique support identifier for this occurrence of an error

Resultobject

Standard result

Messagestring

Error message text on failure, may be null

successboolean

Indicates API success or failure

Update user attributes

 
posthttps://example.com/UserMgmt/ChangeUserAttributes
curl --request POST \
  --url https://example.com/UserMgmt/ChangeUserAttributes
var request = require("request");

var options = { method: 'POST',
  url: 'https://example.com/UserMgmt/ChangeUserAttributes' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/UserMgmt/ChangeUserAttributes")

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

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

response = http.request(request)
puts response.read_body
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", "https://example.com/UserMgmt/ChangeUserAttributes");

xhr.send(data);
import requests

url = "https://example.com/UserMgmt/ChangeUserAttributes"

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

print(response.text)
A binary file was returned

You couldn't be authenticated

No response examples available

Body Params

CmaRedirectedUserUuid
string

Reidrected user uuid

ID
string
required

User UUID or name to set redirection for

Response

API-Result

ErrorIDstring

Unique support identifier for this occurrence of an error

Resultobject

Standard result

Messagestring

Error message text on failure, may be null

successboolean

Indicates API success or failure

Change the password for the current user.

 
posthttps://example.com/UserMgmt/ChangeUserPassword
curl --request POST \
  --url https://example.com/UserMgmt/ChangeUserPassword
var request = require("request");

var options = { method: 'POST',
  url: 'https://example.com/UserMgmt/ChangeUserPassword' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/UserMgmt/ChangeUserPassword")

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

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

response = http.request(request)
puts response.read_body
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", "https://example.com/UserMgmt/ChangeUserPassword");

xhr.send(data);
import requests

url = "https://example.com/UserMgmt/ChangeUserPassword"

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

print(response.text)
A binary file was returned

You couldn't be authenticated

No response examples available

Body Params

oldPassword
string
required

Current password

newPassword
string
required

New password

Response

API-Result

ErrorIDstring

Unique support identifier for this occurrence of an error

Resultobject

Standard result

Messagestring

Error message text on failure, may be null

successboolean

Indicates API success or failure

Query all directory services for users, groups, and/or roles using a json query string.

Either a 'user', a 'group', or a 'role' query must be specified. If no directoryServices are specified, all available
directory services will be searched.

 
posthttps://example.com/UserMgmt/DirectoryServiceQuery
curl --request POST \
  --url https://example.com/UserMgmt/DirectoryServiceQuery
var request = require("request");

var options = { method: 'POST',
  url: 'https://example.com/UserMgmt/DirectoryServiceQuery' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/UserMgmt/DirectoryServiceQuery")

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

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

response = http.request(request)
puts response.read_body
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", "https://example.com/UserMgmt/DirectoryServiceQuery");

xhr.send(data);
import requests

url = "https://example.com/UserMgmt/DirectoryServiceQuery"

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

print(response.text)
A binary file was returned

You couldn't be authenticated

No response examples available

Body Params

roles
string
required

Json query for the roles table

group
string
required

Json query for the dsgroups table

directoryServices
array of objects
required

string list of diretory service uuids to limit search to

user
string
required

Json query for the dsusers table

Response

API-Result

ErrorIDstring

Unique support identifier for this occurrence of an error

Resultobject

Query results

Result.Exceptionsobject

Any exceptions that occurred

Result.Exceptions.Rolesobject

Exception for role query

Result.Exceptions.Groupobject

Exception for group query

Result.Exceptions.Userobject

Exception for user query

Result.Rolesobject

Query results for role query

Result.Groupobject

Query results for group query

Result.Userobject

Query results for user query

Messagestring

Error message text on failure, may be null

successboolean

Indicates API success or failure

Get the cached entity.

 
posthttps://example.com/UserMgmt/GetCachedEntity
curl --request POST \
  --url 'https://example.com/UserMgmt/GetCachedEntity?uuidOrName=uuidOrName'
var request = require("request");

var options = { method: 'POST',
  url: 'https://example.com/UserMgmt/GetCachedEntity',
  qs: { uuidOrName: 'uuidOrName' } };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/UserMgmt/GetCachedEntity?uuidOrName=uuidOrName")

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

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

response = http.request(request)
puts response.read_body
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", "https://example.com/UserMgmt/GetCachedEntity?uuidOrName=uuidOrName");

xhr.send(data);
import requests

url = "https://example.com/UserMgmt/GetCachedEntity"

querystring = {"uuidOrName":"uuidOrName"}

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

print(response.text)
A binary file was returned

You couldn't be authenticated

No response examples available

Query Params

uuidOrName
string
required

Unique identifier or name of entity.

Response

API-Result

ErrorIDstring

Unique support identifier for this occurrence of an error

Resultobject

The cached entity.

Result.Uuidstring

The entities unique identifier.

Result.Emailstring

The entities email address.

Result.CanonicalNamestring

The entities canonical name.

Result.Sidstring

The entities sid.

Result.DistinguishedNamestring

The entities distinguished name.

Result.typestring

The entities classification.

Result.SamAccountNamestring

The entities sam account name.

Messagestring

Error message text on failure, may be null

successboolean

Indicates API success or failure

Get the cached user.

 
posthttps://example.com/UserMgmt/GetCachedUser
curl --request POST \
  --url 'https://example.com/UserMgmt/GetCachedUser?uuidOrName=uuidOrName'
var request = require("request");

var options = { method: 'POST',
  url: 'https://example.com/UserMgmt/GetCachedUser',
  qs: { uuidOrName: 'uuidOrName' } };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/UserMgmt/GetCachedUser?uuidOrName=uuidOrName")

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

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

response = http.request(request)
puts response.read_body
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", "https://example.com/UserMgmt/GetCachedUser?uuidOrName=uuidOrName");

xhr.send(data);
import requests

url = "https://example.com/UserMgmt/GetCachedUser"

querystring = {"uuidOrName":"uuidOrName"}

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

print(response.text)
A binary file was returned

You couldn't be authenticated

No response examples available

Query Params

uuidOrName
string
required

Unique identifier or name of user.

Response

API-Result

ErrorIDstring

Unique support identifier for this occurrence of an error

Resultobject

The cached user.

Result.Uuidstring

The user unique identifier.

Result.Emailstring

The user email address.

Result.CanonicalNamestring

The user canonical name.

Result.Sidstring

The user sid.

Result.DistinguishedNamestring

The user distinguished name.

Result.typestring

The user classification.

Result.SamAccountNamestring

The user sam account name.

Messagestring

Error message text on failure, may be null

successboolean

Indicates API success or failure

Get security questions for the current user

Specified user must be you or you must have user management permissions.

 
posthttps://example.com/UserMgmt/GetSecurityQuestions
curl --request POST \
  --url 'https://example.com/UserMgmt/GetSecurityQuestions?id=id&addAdminQuestions=addAdminQuestions'
var request = require("request");

var options = { method: 'POST',
  url: 'https://example.com/UserMgmt/GetSecurityQuestions',
  qs:
   { id: 'id',
     addAdminQuestions: 'addAdminQuestions' } };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/UserMgmt/GetSecurityQuestions?id=id&addAdminQuestions=addAdminQuestions")

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

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

response = http.request(request)
puts response.read_body
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", "https://example.com/UserMgmt/GetSecurityQuestions?id=id&addAdminQuestions=addAdminQuestions");

xhr.send(data);
import requests

url = "https://example.com/UserMgmt/GetSecurityQuestions"

querystring = {"id":"id","addAdminQuestions":"addAdminQuestions"}

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

print(response.text)
A binary file was returned

You couldn't be authenticated

No response examples available

Query Params

id
string
required

User id

addAdminQuestions
string
required

are admin questions to be added

Body Params

addAdminQuestions
boolean

Add list of available administrator questions in response

Id
string

User UUID or name to get security questions for

Response

API-Result

ErrorIDstring

Unique support identifier for this occurrence of an error

Resultobject

DataEntity with user security questions data

Result.AnswerMinLengthinteger

Minimum length in characters of answers

Result.Questionsobject

Security questions for user; list of entities with following properties.

Result.Questions.Uuidstring

Question identifier

Result.Questions.QuestionTextstring

Question text

Result.MaxQuestionsinteger

Max questions allowed for user

Result.MinAdminQuestionsinteger

Minimum admin questions required for user

Result.AdminQuestionsobject

Available administrator questions; list of entities with following properties.

Result.AdminQuestions.Culturestring

Culture of the question, 'all' implies all cultures

Result.AdminQuestions.Uuidstring

Question Uuid

Result.AdminQuestions.Questionstring

Text of the question

Result.MinUserQuestionsinteger

Minimum user questions required for user

Messagestring

Error message text on failure, may be null

successboolean

Indicates API success or failure

Fetch attributes for a specified user.

Attributes will vary depending on the type of the directory service the user belongs to.

 
posthttps://example.com/UserMgmt/GetUserAttributes
curl --request POST \
  --url https://example.com/UserMgmt/GetUserAttributes
var request = require("request");

var options = { method: 'POST',
  url: 'https://example.com/UserMgmt/GetUserAttributes' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/UserMgmt/GetUserAttributes")

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

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

response = http.request(request)
puts response.read_body
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", "https://example.com/UserMgmt/GetUserAttributes");

xhr.send(data);
import requests

url = "https://example.com/UserMgmt/GetUserAttributes"

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

print(response.text)
A binary file was returned

You couldn't be authenticated

No response examples available

Query Params

ID
string

User UUID to fetch attributes for (default=current user)

directoryServiceUuid
string

Directory service UUID of the user (default=null)

Response

API-Result

ErrorIDstring

Unique support identifier for this occurrence of an error

Resultobject

User Attributes results

Result.propertynobject

nth property of the user (name varies)

Result.property2object

Second property of the user (name varies)

Result.directoryServiceUuidstring

UUID of the directory service the user is from

Result....object

More properties (name varies)

Result.property1object

First property of the user (name varies)

Messagestring

Error message text on failure, may be null

successboolean

Indicates API success or failure

Get certificate info for a given user.

Returns Thumbprint and certificate type information for all certificates issued to the user.
Specified user must be you or you must be a system administrator or have user management permissions.

 
posthttps://example.com/UserMgmt/GetUserCertificateInfo
curl --request POST \
  --url 'https://example.com/UserMgmt/GetUserCertificateInfo?user=user'
var request = require("request");

var options = { method: 'POST',
  url: 'https://example.com/UserMgmt/GetUserCertificateInfo',
  qs: { user: 'user' } };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/UserMgmt/GetUserCertificateInfo?user=user")

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

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

response = http.request(request)
puts response.read_body
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", "https://example.com/UserMgmt/GetUserCertificateInfo?user=user");

xhr.send(data);
import requests

url = "https://example.com/UserMgmt/GetUserCertificateInfo"

querystring = {"user":"user"}

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

print(response.text)
A binary file was returned

You couldn't be authenticated

No response examples available

Query Params

user
string
required

The name or uuid of the user to fetch certificate info for.

Response

API-Result

ErrorIDstring

Unique support identifier for this occurrence of an error

Resultobject

User certificate information. Dictionary of string key to string value, where keys are the certificate thumbprint and values are the certificate type.

Messagestring

Error message text on failure, may be null

successboolean

Indicates API success or failure

Fetch the reporting hierarchy for a specified user.

Attributes will vary depending on the type of the directory service the user belongs to.

 
posthttps://example.com/UserMgmt/GetUserHierarchy
curl --request POST \
  --url https://example.com/UserMgmt/GetUserHierarchy
var request = require("request");

var options = { method: 'POST',
  url: 'https://example.com/UserMgmt/GetUserHierarchy' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/UserMgmt/GetUserHierarchy")

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

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

response = http.request(request)
puts response.read_body
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", "https://example.com/UserMgmt/GetUserHierarchy");

xhr.send(data);
import requests

url = "https://example.com/UserMgmt/GetUserHierarchy"

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

print(response.text)
A binary file was returned

You couldn't be authenticated

No response examples available

Query Params

ID
string

User UUID to fetch hierarchy for (default=current user)

Response

API-Result

ErrorIDstring

Unique support identifier for this occurrence of an error

Resultobject

User Attributes results

Result.propertynobject

nth property of the user (name varies)

Result.property2object

Second property of the user (name varies)

Result.directoryServiceUuidstring

UUID of the directory service the user is from

Result....object

More properties (name varies)

Result.property1object

First property of the user (name varies)

Messagestring

Error message text on failure, may be null

successboolean

Indicates API success or failure

Get additional info for a specified user.

Specified user must be you or you must be a system administrator or have user management permissions. Note that this call is somewhat costly and its use should be minimized (cache the results as needed).

 
posthttps://example.com/UserMgmt/GetUserInfo
curl --request POST \
  --url https://example.com/UserMgmt/GetUserInfo
var request = require("request");

var options = { method: 'POST',
  url: 'https://example.com/UserMgmt/GetUserInfo' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/UserMgmt/GetUserInfo")

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

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

response = http.request(request)
puts response.read_body
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", "https://example.com/UserMgmt/GetUserInfo");

xhr.send(data);
import requests

url = "https://example.com/UserMgmt/GetUserInfo"

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

print(response.text)
A binary file was returned

You couldn't be authenticated

No response examples available

Query Params

ID
string

User UUID to fetch attributes for (default=current user)

Response

API-Result

ErrorIDstring

Unique support identifier for this occurrence of an error

Resultobject

User additional information

Result.DirectoryServiceIdstring

Directory service UUID

Result.ThirdPartyOathConfiguredboolean

Has a third party OATH token been configured for this user?

Result.SecurityKeyConfiguredboolean

Has the user configured a U2F Security Key?

Result.EmailAddressstring

User email address

Result.HasPictureboolean

User has a picture available

Result.Settingsobject

Contains internal state for the Portal Web UI; this property can be ignored.

Result.LastPasswordChangeDatestring

Last date/time user changed their password

Result.DisplayNamestring

User display name

Result.PreferredCulturestring

User's preferred culture if any in culture code format (e.g. fr)

Result.PasswordExpDatestring

Date/time user's password will expire

Result.MobileNumberstring

User mobile phone number

Result.DirectoryServiceLocalizedNamestring

Directory service name localized to user's preferred language

Result.DirectoryServiceNamestring

Directory service name

Result.DirectoryServiceTypestring

Directory service type

Result.MfaSetupWizardSettingsobject

Contains settings that guide MFA setup

Result.IsSysAdminboolean

Is user a system administrator

Result.SecurityQuestionstring

Does user have security questions? 'yes' if so, null if not

Result.CanChangePasswordboolean

Can user change their password

Result.Namestring

User name

Result.Idstring

User UUID

Result.PasswordResetFlaginteger

Password reset state: 0=no reset needed, 1=Reset required, 2=Reset optional, 3=Reset warning

Result.SecurityQuestionsLastUpdatestring

Date/time user last updated their security questions

Result.DisplayPreferredCulturestring

User's preferred culture if any in display format (e.g. French - français)

Result.EnablePurchasedLicenseMenuboolean

Does the user have the right to view licenses?

Result.PhonePinLastChangeDatestring

Date/time user last set their phone PIN

Result.SqEnabledboolean

Are security questions enabled for this user

Result.TenantIdstring

Tenant id of the user

Result.PasswordChangeSoftDaysinteger

Days before a user should be warned to change a near to expiring password

Result.PasswordChangeHardHoursinteger

Hours before a user should be prompted to change an near to expiring password

Messagestring

Error message text on failure, may be null

successboolean

Indicates API success or failure

Fetch a cloud user's picture.

Specified user must be you or you must be a system administrator or have user management permissions.

 
posthttps://example.com/UserMgmt/GetUserPicture
curl --request POST \
  --url 'https://example.com/UserMgmt/GetUserPicture?ID=ID'
var request = require("request");

var options = { method: 'POST',
  url: 'https://example.com/UserMgmt/GetUserPicture',
  qs: { ID: 'ID' } };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/UserMgmt/GetUserPicture?ID=ID")

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

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

response = http.request(request)
puts response.read_body
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", "https://example.com/UserMgmt/GetUserPicture?ID=ID");

xhr.send(data);
import requests

url = "https://example.com/UserMgmt/GetUserPicture"

querystring = {"ID":"ID"}

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

print(response.text)
A binary file was returned

You couldn't be authenticated

No response examples available

Query Params

ID
string
required

User UUID or name to fetch picture for

directoryServiceUuid
string

UUID of the user's directory service (default=null)

Response

API-Result

ErrorIDstring

Unique support identifier for this occurrence of an error

Resultobject

User's picture file if one is available

Messagestring

Error message text on failure, may be null

successboolean

Indicates API success or failure

Gets user roles and administrative rights.

The list consists of all user roles and associated administrative rights associated with a role.

 
posthttps://example.com/UserMgmt/GetUsersRolesAndAdministrativeRights
curl --request POST \
  --url 'https://example.com/UserMgmt/GetUsersRolesAndAdministrativeRights?id=id'
var request = require("request");

var options = { method: 'POST',
  url:
   'https://example.com/UserMgmt/GetUsersRolesAndAdministrativeRights',
  qs: { id: 'id' } };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/UserMgmt/GetUsersRolesAndAdministrativeRights?id=id")

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

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

response = http.request(request)
puts response.read_body
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", "https://example.com/UserMgmt/GetUsersRolesAndAdministrativeRights?id=id");

xhr.send(data);
import requests

url = "https://example.com/UserMgmt/GetUsersRolesAndAdministrativeRights"

querystring = {"id":"id"}

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

print(response.text)
A binary file was returned

You couldn't be authenticated

No response examples available

Query Params

id
string
required

UUID of User

Response

API-Result

ErrorIDstring

Unique support identifier for this occurrence of an error

Resultobject
         Standard Redrock data format, with the following columns:
             ID : The role UUID
             Name: The role name
             Description: The role description
             AdministrativeRights : List of objects that have
               Description: localized name of the administrative right
               Path: file that describes the administrative right

             ** Obsolete columns - Exist for backward compatibility **
             Role : The role UUID
             RoleName: The role name
Messagestring

Error message text on failure, may be null

successboolean

Indicates API success or failure

Invite one or more users to the cloud portal.

You must be a system administrator or have user management permissions.

 
posthttps://example.com/UserMgmt/InviteUsers
curl --request POST \
  --url https://example.com/UserMgmt/InviteUsers
var request = require("request");

var options = { method: 'POST',
  url: 'https://example.com/UserMgmt/InviteUsers' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/UserMgmt/InviteUsers")

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

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

response = http.request(request)
puts response.read_body
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", "https://example.com/UserMgmt/InviteUsers");

xhr.send(data);
import requests

url = "https://example.com/UserMgmt/InviteUsers"

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

print(response.text)
A binary file was returned

You couldn't be authenticated

No response examples available

Body Params

SmsInvite
boolean

Send SMS invitations to invited entities if possible (default=false)

Entities
array of objects
required

Users or groups to invite; each entry is a dictionary including 'Type' (User, Group, Role), 'Guid' (entity UUID), and 'Name' (entity name, only applicable to User entities)

Role
string

Add each invited user to this role name if specified (default=null)

GroupInvite
boolean

For invited groups, send a single email invitation to the group rather than to each user within the group (default=true)

EmailInvite
boolean
required

Send email invitations to invited entities if possible (default=true)

Response

API-Result

ErrorIDstring

Unique support identifier for this occurrence of an error

Resultobject

Standard result

Messagestring

Error message text on failure, may be null

successboolean

Indicates API success or failure

Checks to see if a given user is cloud locked.

You must be a system administrator, have user management permissions, or be checking yourself.

 
posthttps://example.com/UserMgmt/IsUserCloudLocked
curl --request POST \
  --url 'https://example.com/UserMgmt/IsUserCloudLocked?user=user'
var request = require("request");

var options = { method: 'POST',
  url: 'https://example.com/UserMgmt/IsUserCloudLocked',
  qs: { user: 'user' } };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/UserMgmt/IsUserCloudLocked?user=user")

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

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

response = http.request(request)
puts response.read_body
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", "https://example.com/UserMgmt/IsUserCloudLocked?user=user");

xhr.send(data);
import requests

url = "https://example.com/UserMgmt/IsUserCloudLocked"

querystring = {"user":"user"}

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

print(response.text)
A binary file was returned

You couldn't be authenticated

No response examples available

Query Params

user
string
required

The name or uuid of the user to check.

Response

API-Result

ErrorIDstring

Unique support identifier for this occurrence of an error

Resultobject

Standard result

Messagestring

Error message text on failure, may be null

successboolean

Indicates API success or failure

Determine if the current user can (or cannot...) satisfy the requisite MFA challenges.

 
posthttps://example.com/UserMgmt/IsUserLockedOutByPolicy