NAV Navigation
Back to Docs
Shell HTTP JavaScript Node.JS Ruby Python Java Go

Cloudentity Authorization Control Plane API v1.1.0

Scroll down for code samples, example requests and responses. Select a language for code samples from the tabs above or the mobile navigation menu.

Cloudentity Authorization Control Plane API

Base URLs:

Authentication

Scope Scope Description
Scope Scope Description
introspect_tokens introspect_tokens
list_clients_with_access list_clients_with_access
manage_consents manage_consents
revoke_client_access revoke_client_access
revoke_tokens revoke_tokens
view_consents view_consents
Scope Scope Description
Scope Scope Description
Scope Scope Description
manage_consents manage_consents
manage_logins manage_logins
read_gateway_configuration read_gateway_configuration
view_consents view_consents

admin

listConsentActions

Code samples

# You can also use wget
curl -X GET https://localhost:8443/api/admin/{tid}/actions \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://localhost:8443/api/admin/{tid}/actions HTTP/1.1
Host: localhost:8443
Accept: application/json

var headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: 'https://localhost:8443/api/admin/{tid}/actions',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

fetch('https://localhost:8443/api/admin/{tid}/actions',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.get 'https://localhost:8443/api/admin/{tid}/actions',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://localhost:8443/api/admin/{tid}/actions', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://localhost:8443/api/admin/{tid}/actions");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {access-token}"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://localhost:8443/api/admin/{tid}/actions", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /api/admin/{tid}/actions

List consent actions

Parameters

Name In Type Required Description
tid path string true Tenant id

Example responses

200 Response

{
  "consent_actions": [
    {
      "description": "Consents required by application X",
      "id": "1",
      "name": "application_x",
      "tenant_id": "default"
    }
  ]
}

Responses

Status Meaning Description Schema
200 OK

ConsentActions

ConsentActions
401 Unauthorized

HttpError

Error
403 Forbidden

HttpError

Error

createConsentAction

Code samples

# You can also use wget
curl -X POST https://localhost:8443/api/admin/{tid}/actions \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

POST https://localhost:8443/api/admin/{tid}/actions HTTP/1.1
Host: localhost:8443
Content-Type: application/json
Accept: application/json

var headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: 'https://localhost:8443/api/admin/{tid}/actions',
  method: 'post',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');
const inputBody = '{
  "consents": [
    {
      "can_be_withdrawn": false,
      "description": "End User License Agreement",
      "id": "1",
      "internal_services": [
        {
          "name": "string",
          "purposes": [
            {
              "name": "Core Function",
              "primary": true
            }
          ]
        }
      ],
      "name": "EULA",
      "pii_categories": [
        {
          "name": "HIPAA"
        }
      ],
      "required": false,
      "tenant_id": "default",
      "third_party_services": [
        {
          "name": "string",
          "purposes": [
            {
              "name": "Core Function",
              "primary": true
            }
          ]
        }
      ],
      "update_existing_grants": "explicitAll",
      "valid_from": "2019-12-11T13:44:28.772101Z",
      "version": 1
    }
  ],
  "description": "Consents required by application X",
  "id": "1",
  "name": "application_x",
  "tenant_id": "default"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

fetch('https://localhost:8443/api/admin/{tid}/actions',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.post 'https://localhost:8443/api/admin/{tid}/actions',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.post('https://localhost:8443/api/admin/{tid}/actions', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://localhost:8443/api/admin/{tid}/actions");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {access-token}"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://localhost:8443/api/admin/{tid}/actions", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /api/admin/{tid}/actions

Create consent action.

Consent action allows to group list of consents. A Tenant Application asking for the consent it can ask for +by the action name+ instead of asking for a list of consents directly. It allows for cleaner abstraction and adds the ability to dynamically configure the consents required for particular applications.

ID and Name are required fields.

For each consent provide id and specify if it is required.

Body parameter

{
  "consents": [
    {
      "can_be_withdrawn": false,
      "description": "End User License Agreement",
      "id": "1",
      "internal_services": [
        {
          "name": "string",
          "purposes": [
            {
              "name": "Core Function",
              "primary": true
            }
          ]
        }
      ],
      "name": "EULA",
      "pii_categories": [
        {
          "name": "HIPAA"
        }
      ],
      "required": false,
      "tenant_id": "default",
      "third_party_services": [
        {
          "name": "string",
          "purposes": [
            {
              "name": "Core Function",
              "primary": true
            }
          ]
        }
      ],
      "update_existing_grants": "explicitAll",
      "valid_from": "2019-12-11T13:44:28.772101Z",
      "version": 1
    }
  ],
  "description": "Consents required by application X",
  "id": "1",
  "name": "application_x",
  "tenant_id": "default"
}

Parameters

Name In Type Required Description
tid path string true Tenant id
body body ConsentActionWithConsents true none

Example responses

201 Response

{
  "consents": [
    {
      "can_be_withdrawn": false,
      "description": "End User License Agreement",
      "id": "1",
      "internal_services": [
        {
          "name": "string",
          "purposes": [
            {
              "name": "Core Function",
              "primary": true
            }
          ]
        }
      ],
      "name": "EULA",
      "pii_categories": [
        {
          "name": "HIPAA"
        }
      ],
      "required": false,
      "tenant_id": "default",
      "third_party_services": [
        {
          "name": "string",
          "purposes": [
            {
              "name": "Core Function",
              "primary": true
            }
          ]
        }
      ],
      "update_existing_grants": "explicitAll",
      "valid_from": "2019-12-11T13:44:28.772101Z",
      "version": 1
    }
  ],
  "description": "Consents required by application X",
  "id": "1",
  "name": "application_x",
  "tenant_id": "default"
}

Responses

Status Meaning Description Schema
201 Created

ConsentActionWithConsents

ConsentActionWithConsents
401 Unauthorized

HttpError

Error
403 Forbidden

HttpError

Error
404 Not Found

HttpError

Error
409 Conflict

HttpError

Error
422 Unprocessable Entity

HttpError

Error

getConsentAction

Code samples

# You can also use wget
curl -X GET https://localhost:8443/api/admin/{tid}/actions/{action} \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://localhost:8443/api/admin/{tid}/actions/{action} HTTP/1.1
Host: localhost:8443
Accept: application/json

var headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: 'https://localhost:8443/api/admin/{tid}/actions/{action}',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

fetch('https://localhost:8443/api/admin/{tid}/actions/{action}',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.get 'https://localhost:8443/api/admin/{tid}/actions/{action}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://localhost:8443/api/admin/{tid}/actions/{action}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://localhost:8443/api/admin/{tid}/actions/{action}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {access-token}"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://localhost:8443/api/admin/{tid}/actions/{action}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /api/admin/{tid}/actions/{action}

Get consent action with consents

Parameters

Name In Type Required Description
tid path string true Tenant id
action path string true none

Example responses

200 Response

{
  "consents": [
    {
      "can_be_withdrawn": false,
      "description": "End User License Agreement",
      "id": "1",
      "internal_services": [
        {
          "name": "string",
          "purposes": [
            {
              "name": "Core Function",
              "primary": true
            }
          ]
        }
      ],
      "name": "EULA",
      "pii_categories": [
        {
          "name": "HIPAA"
        }
      ],
      "required": false,
      "tenant_id": "default",
      "third_party_services": [
        {
          "name": "string",
          "purposes": [
            {
              "name": "Core Function",
              "primary": true
            }
          ]
        }
      ],
      "update_existing_grants": "explicitAll",
      "valid_from": "2019-12-11T13:44:28.772101Z",
      "version": 1
    }
  ],
  "description": "Consents required by application X",
  "id": "1",
  "name": "application_x",
  "tenant_id": "default"
}

Responses

Status Meaning Description Schema
200 OK

ConsentActionWithConsents

ConsentActionWithConsents
401 Unauthorized

HttpError

Error
403 Forbidden

HttpError

Error
404 Not Found

HttpError

Error

updateConsentAction

Code samples

# You can also use wget
curl -X PUT https://localhost:8443/api/admin/{tid}/actions/{action} \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

PUT https://localhost:8443/api/admin/{tid}/actions/{action} HTTP/1.1
Host: localhost:8443
Content-Type: application/json
Accept: application/json

var headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: 'https://localhost:8443/api/admin/{tid}/actions/{action}',
  method: 'put',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');
const inputBody = '{
  "consents": [
    {
      "can_be_withdrawn": false,
      "description": "End User License Agreement",
      "id": "1",
      "internal_services": [
        {
          "name": "string",
          "purposes": [
            {
              "name": "Core Function",
              "primary": true
            }
          ]
        }
      ],
      "name": "EULA",
      "pii_categories": [
        {
          "name": "HIPAA"
        }
      ],
      "required": false,
      "tenant_id": "default",
      "third_party_services": [
        {
          "name": "string",
          "purposes": [
            {
              "name": "Core Function",
              "primary": true
            }
          ]
        }
      ],
      "update_existing_grants": "explicitAll",
      "valid_from": "2019-12-11T13:44:28.772101Z",
      "version": 1
    }
  ],
  "description": "Consents required by application X",
  "id": "1",
  "name": "application_x",
  "tenant_id": "default"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

fetch('https://localhost:8443/api/admin/{tid}/actions/{action}',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.put 'https://localhost:8443/api/admin/{tid}/actions/{action}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.put('https://localhost:8443/api/admin/{tid}/actions/{action}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://localhost:8443/api/admin/{tid}/actions/{action}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PUT");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {access-token}"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "https://localhost:8443/api/admin/{tid}/actions/{action}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

PUT /api/admin/{tid}/actions/{action}

Update consent action

Body parameter

{
  "consents": [
    {
      "can_be_withdrawn": false,
      "description": "End User License Agreement",
      "id": "1",
      "internal_services": [
        {
          "name": "string",
          "purposes": [
            {
              "name": "Core Function",
              "primary": true
            }
          ]
        }
      ],
      "name": "EULA",
      "pii_categories": [
        {
          "name": "HIPAA"
        }
      ],
      "required": false,
      "tenant_id": "default",
      "third_party_services": [
        {
          "name": "string",
          "purposes": [
            {
              "name": "Core Function",
              "primary": true
            }
          ]
        }
      ],
      "update_existing_grants": "explicitAll",
      "valid_from": "2019-12-11T13:44:28.772101Z",
      "version": 1
    }
  ],
  "description": "Consents required by application X",
  "id": "1",
  "name": "application_x",
  "tenant_id": "default"
}

Parameters

Name In Type Required Description
tid path string true Tenant id
action path string true none
body body ConsentActionWithConsents false none

Example responses

201 Response

{
  "consents": [
    {
      "can_be_withdrawn": false,
      "description": "End User License Agreement",
      "id": "1",
      "internal_services": [
        {
          "name": "string",
          "purposes": [
            {
              "name": "Core Function",
              "primary": true
            }
          ]
        }
      ],
      "name": "EULA",
      "pii_categories": [
        {
          "name": "HIPAA"
        }
      ],
      "required": false,
      "tenant_id": "default",
      "third_party_services": [
        {
          "name": "string",
          "purposes": [
            {
              "name": "Core Function",
              "primary": true
            }
          ]
        }
      ],
      "update_existing_grants": "explicitAll",
      "valid_from": "2019-12-11T13:44:28.772101Z",
      "version": 1
    }
  ],
  "description": "Consents required by application X",
  "id": "1",
  "name": "application_x",
  "tenant_id": "default"
}

Responses

Status Meaning Description Schema
201 Created

ConsentActionWithConsents

ConsentActionWithConsents
401 Unauthorized

HttpError

Error
403 Forbidden

HttpError

Error
404 Not Found

HttpError

Error
409 Conflict

HttpError

Error
422 Unprocessable Entity

HttpError

Error

deleteConsentAction

Code samples

# You can also use wget
curl -X DELETE https://localhost:8443/api/admin/{tid}/actions/{action} \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

DELETE https://localhost:8443/api/admin/{tid}/actions/{action} HTTP/1.1
Host: localhost:8443
Accept: application/json

var headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: 'https://localhost:8443/api/admin/{tid}/actions/{action}',
  method: 'delete',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

fetch('https://localhost:8443/api/admin/{tid}/actions/{action}',
{
  method: 'DELETE',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.delete 'https://localhost:8443/api/admin/{tid}/actions/{action}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.delete('https://localhost:8443/api/admin/{tid}/actions/{action}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://localhost:8443/api/admin/{tid}/actions/{action}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("DELETE");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {access-token}"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "https://localhost:8443/api/admin/{tid}/actions/{action}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

DELETE /api/admin/{tid}/actions/{action}

Delete consent action

Parameters

Name In Type Required Description
tid path string true Tenant id
action path string true none

Example responses

401 Response

{
  "details": {},
  "error": "string",
  "status_code": 0
}

Responses

Status Meaning Description Schema
204 No Content

ConsentAction has been deleted

None
401 Unauthorized

HttpError

Error
403 Forbidden

HttpError

Error
404 Not Found

HttpError

Error

createAPI

Code samples

# You can also use wget
curl -X POST https://localhost:8443/api/admin/{tid}/apis \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

POST https://localhost:8443/api/admin/{tid}/apis HTTP/1.1
Host: localhost:8443
Content-Type: application/json
Accept: application/json

var headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: 'https://localhost:8443/api/admin/{tid}/apis',
  method: 'post',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');
const inputBody = '{
  "can_have_policy": true,
  "data_classifications": [
    "string"
  ],
  "id": "1",
  "method": "GET",
  "path": "/pets",
  "policy_id": "block",
  "position": 1,
  "server_id": "default",
  "service_id": "1",
  "tenant_id": "default"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

fetch('https://localhost:8443/api/admin/{tid}/apis',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.post 'https://localhost:8443/api/admin/{tid}/apis',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.post('https://localhost:8443/api/admin/{tid}/apis', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://localhost:8443/api/admin/{tid}/apis");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {access-token}"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://localhost:8443/api/admin/{tid}/apis", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /api/admin/{tid}/apis

Create API

It is not possible to create APIs for a service with imported specification.

Body parameter

{
  "can_have_policy": true,
  "data_classifications": [
    "string"
  ],
  "id": "1",
  "method": "GET",
  "path": "/pets",
  "policy_id": "block",
  "position": 1,
  "server_id": "default",
  "service_id": "1",
  "tenant_id": "default"
}

Parameters

Name In Type Required Description
tid path string true Tenant id
body body API false APIBody

Example responses

201 Response

{
  "can_have_policy": true,
  "data_classifications": [
    "string"
  ],
  "id": "1",
  "method": "GET",
  "path": "/pets",
  "policy_id": "block",
  "position": 1,
  "server_id": "default",
  "service_id": "1",
  "tenant_id": "default"
}

Responses

Status Meaning Description Schema
201 Created

API

API
400 Bad Request

HttpError

Error
401 Unauthorized

HttpError

Error
403 Forbidden

HttpError

Error
404 Not Found

HttpError

Error
422 Unprocessable Entity

HttpError

Error

getAPI

Code samples

# You can also use wget
curl -X GET https://localhost:8443/api/admin/{tid}/apis/{api} \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://localhost:8443/api/admin/{tid}/apis/{api} HTTP/1.1
Host: localhost:8443
Accept: application/json

var headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: 'https://localhost:8443/api/admin/{tid}/apis/{api}',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

fetch('https://localhost:8443/api/admin/{tid}/apis/{api}',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.get 'https://localhost:8443/api/admin/{tid}/apis/{api}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://localhost:8443/api/admin/{tid}/apis/{api}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://localhost:8443/api/admin/{tid}/apis/{api}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {access-token}"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://localhost:8443/api/admin/{tid}/apis/{api}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /api/admin/{tid}/apis/{api}

Get API

Parameters

Name In Type Required Description
tid path string true Tenant id
api path string true none

Example responses

200 Response

{
  "can_have_policy": true,
  "data_classifications": [
    "string"
  ],
  "id": "1",
  "method": "GET",
  "path": "/pets",
  "policy_id": "block",
  "position": 1,
  "server_id": "default",
  "service_id": "1",
  "tenant_id": "default"
}

Responses

Status Meaning Description Schema
200 OK

API

API
401 Unauthorized

HttpError

Error
403 Forbidden

HttpError

Error
404 Not Found

HttpError

Error

updateAPI

Code samples

# You can also use wget
curl -X PUT https://localhost:8443/api/admin/{tid}/apis/{api} \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

PUT https://localhost:8443/api/admin/{tid}/apis/{api} HTTP/1.1
Host: localhost:8443
Content-Type: application/json
Accept: application/json

var headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: 'https://localhost:8443/api/admin/{tid}/apis/{api}',
  method: 'put',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');
const inputBody = '{
  "data_classifications": [
    "string"
  ],
  "policy_id": "block"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

fetch('https://localhost:8443/api/admin/{tid}/apis/{api}',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.put 'https://localhost:8443/api/admin/{tid}/apis/{api}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.put('https://localhost:8443/api/admin/{tid}/apis/{api}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://localhost:8443/api/admin/{tid}/apis/{api}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PUT");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {access-token}"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "https://localhost:8443/api/admin/{tid}/apis/{api}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

PUT /api/admin/{tid}/apis/{api}

Update API.

Body parameter

{
  "data_classifications": [
    "string"
  ],
  "policy_id": "block"
}

Parameters

Name In Type Required Description
tid path string true Tenant id
api path string true API ID
body body UpdateAPIRequest false APIBody

Example responses

200 Response

{
  "can_have_policy": true,
  "data_classifications": [
    "string"
  ],
  "id": "1",
  "method": "GET",
  "path": "/pets",
  "policy_id": "block",
  "position": 1,
  "server_id": "default",
  "service_id": "1",
  "tenant_id": "default"
}

Responses

Status Meaning Description Schema
200 OK

API

API
400 Bad Request

HttpError

Error
401 Unauthorized

HttpError

Error
403 Forbidden

HttpError

Error
404 Not Found

HttpError

Error
422 Unprocessable Entity

HttpError

Error

deleteAPI

Code samples

# You can also use wget
curl -X DELETE https://localhost:8443/api/admin/{tid}/apis/{api} \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

DELETE https://localhost:8443/api/admin/{tid}/apis/{api} HTTP/1.1
Host: localhost:8443
Accept: application/json

var headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: 'https://localhost:8443/api/admin/{tid}/apis/{api}',
  method: 'delete',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

fetch('https://localhost:8443/api/admin/{tid}/apis/{api}',
{
  method: 'DELETE',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.delete 'https://localhost:8443/api/admin/{tid}/apis/{api}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.delete('https://localhost:8443/api/admin/{tid}/apis/{api}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://localhost:8443/api/admin/{tid}/apis/{api}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("DELETE");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {access-token}"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "https://localhost:8443/api/admin/{tid}/apis/{api}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

DELETE /api/admin/{tid}/apis/{api}

Delete API

If this API was created by import specification operation then it is not possible to delete it.

Parameters

Name In Type Required Description
tid path string true Tenant id
api path string true none

Example responses

401 Response

{
  "details": {},
  "error": "string",
  "status_code": 0
}

Responses

Status Meaning Description Schema
204 No Content

API has been deleted

None
401 Unauthorized

HttpError

Error
403 Forbidden

HttpError

Error
404 Not Found

HttpError

Error

createClaim

Code samples

# You can also use wget
curl -X POST https://localhost:8443/api/admin/{tid}/claims \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

POST https://localhost:8443/api/admin/{tid}/claims HTTP/1.1
Host: localhost:8443
Content-Type: application/json
Accept: application/json

var headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: 'https://localhost:8443/api/admin/{tid}/claims',
  method: 'post',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');
const inputBody = '{
  "authorization_server_id": "default",
  "id": "1",
  "mapping": "email",
  "name": "email",
  "scopes": [
    "email",
    "email_verified"
  ],
  "tenant_id": "default",
  "type": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

fetch('https://localhost:8443/api/admin/{tid}/claims',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.post 'https://localhost:8443/api/admin/{tid}/claims',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.post('https://localhost:8443/api/admin/{tid}/claims', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://localhost:8443/api/admin/{tid}/claims");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {access-token}"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://localhost:8443/api/admin/{tid}/claims", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /api/admin/{tid}/claims

Create claim.

Claim allows to add custom attribute to outgoing id / access token.

Authorization Server, Name, Mapping and Type are required fields.

ID if not provided will be generated.

Body parameter

{
  "authorization_server_id": "default",
  "id": "1",
  "mapping": "email",
  "name": "email",
  "scopes": [
    "email",
    "email_verified"
  ],
  "tenant_id": "default",
  "type": "string"
}

Parameters

Name In Type Required Description
tid path string true Tenant id
body body Claim false none

Example responses

201 Response

{
  "authorization_server_id": "default",
  "id": "1",
  "mapping": "email",
  "name": "email",
  "scopes": [
    "email",
    "email_verified"
  ],
  "tenant_id": "default",
  "type": "string"
}

Responses

Status Meaning Description Schema
201 Created

Claim

Claim
401 Unauthorized

HttpError

Error
403 Forbidden

HttpError

Error
404 Not Found

HttpError

Error
409 Conflict

HttpError

Error
422 Unprocessable Entity

HttpError

Error

updateClaim

Code samples

# You can also use wget
curl -X PUT https://localhost:8443/api/admin/{tid}/claims/{claim} \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

PUT https://localhost:8443/api/admin/{tid}/claims/{claim} HTTP/1.1
Host: localhost:8443
Content-Type: application/json
Accept: application/json

var headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: 'https://localhost:8443/api/admin/{tid}/claims/{claim}',
  method: 'put',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');
const inputBody = '{
  "authorization_server_id": "default",
  "id": "1",
  "mapping": "email",
  "name": "email",
  "scopes": [
    "email",
    "email_verified"
  ],
  "tenant_id": "default",
  "type": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

fetch('https://localhost:8443/api/admin/{tid}/claims/{claim}',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.put 'https://localhost:8443/api/admin/{tid}/claims/{claim}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.put('https://localhost:8443/api/admin/{tid}/claims/{claim}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://localhost:8443/api/admin/{tid}/claims/{claim}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PUT");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {access-token}"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "https://localhost:8443/api/admin/{tid}/claims/{claim}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

PUT /api/admin/{tid}/claims/{claim}

Update claim

Body parameter

{
  "authorization_server_id": "default",
  "id": "1",
  "mapping": "email",
  "name": "email",
  "scopes": [
    "email",
    "email_verified"
  ],
  "tenant_id": "default",
  "type": "string"
}

Parameters

Name In Type Required Description
tid path string true Tenant id
claim path string true none
body body Claim false none

Example responses

200 Response

{
  "authorization_server_id": "default",
  "id": "1",
  "mapping": "email",
  "name": "email",
  "scopes": [
    "email",
    "email_verified"
  ],
  "tenant_id": "default",
  "type": "string"
}

Responses

Status Meaning Description Schema
200 OK

Claim

Claim
400 Bad Request

HttpError

Error
401 Unauthorized

HttpError

Error
403 Forbidden

HttpError

Error
404 Not Found

HttpError

Error
422 Unprocessable Entity

HttpError

Error

deleteClaim

Code samples

# You can also use wget
curl -X DELETE https://localhost:8443/api/admin/{tid}/claims/{claim} \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

DELETE https://localhost:8443/api/admin/{tid}/claims/{claim} HTTP/1.1
Host: localhost:8443
Accept: application/json

var headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: 'https://localhost:8443/api/admin/{tid}/claims/{claim}',
  method: 'delete',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

fetch('https://localhost:8443/api/admin/{tid}/claims/{claim}',
{
  method: 'DELETE',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.delete 'https://localhost:8443/api/admin/{tid}/claims/{claim}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.delete('https://localhost:8443/api/admin/{tid}/claims/{claim}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://localhost:8443/api/admin/{tid}/claims/{claim}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("DELETE");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {access-token}"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "https://localhost:8443/api/admin/{tid}/claims/{claim}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

DELETE /api/admin/{tid}/claims/{claim}

Delete claim

Parameters

Name In Type Required Description
tid path string true Tenant id
claim path string true none

Example responses

401 Response

{
  "details": {},
  "error": "string",
  "status_code": 0
}

Responses

Status Meaning Description Schema
204 No Content

Claim has been deleted

None
401 Unauthorized

HttpError

Error
403 Forbidden

HttpError

Error
404 Not Found

HttpError

Error

createClient

Code samples

# You can also use wget
curl -X POST https://localhost:8443/api/admin/{tid}/clients \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

POST https://localhost:8443/api/admin/{tid}/clients HTTP/1.1
Host: localhost:8443
Content-Type: application/json
Accept: application/json

var headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: 'https://localhost:8443/api/admin/{tid}/clients',
  method: 'post',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');
const inputBody = '{
  "audience": [
    "string"
  ],
  "authorization_server_id": "default",
  "client_hashed_secret": "string",
  "client_id": "string",
  "client_id_issued_at": 0,
  "client_name": "My app",
  "client_secret": "string",
  "client_secret_expires_at": 0,
  "client_uri": "string",
  "description": "string",
  "developer_id": "string",
  "grant_types": [
    "password",
    "refresh_token",
    "client_credentials",
    "implicit",
    "authorization_code"
  ],
  "jwks": {
    "keys": []
  },
  "jwks_uri": "string",
  "logo_uri": "string",
  "policy_uri": "string",
  "privacy": {
    "scopes": {
      "property1": {
        "pii_categories": [
          {
            "name": "HIPAA"
          }
        ],
        "purpose": "string"
      },
      "property2": {
        "pii_categories": [
          {
            "name": "HIPAA"
          }
        ],
        "purpose": "string"
      }
    }
  },
  "public": true,
  "redirect_uris": [
    "https://example.com/callback"
  ],
  "request_object_signing_alg": "none",
  "request_uris": [
    "string"
  ],
  "response_types": [
    "token",
    "id_token",
    "code"
  ],
  "scope": "email offline_access openid",
  "scopes": [
    "email",
    "offline_access",
    "openid"
  ],
  "sector_identifier_uri": "https://api.jsonbin.io/b/5db6ef08688fed59d2841f1e",
  "system": false,
  "tenant_id": "string",
  "tls_client_auth_san_dns": "string",
  "tls_client_auth_san_email": "string",
  "tls_client_auth_san_ip": "string",
  "tls_client_auth_san_uri": "string",
  "tls_client_auth_subject_dn": "string",
  "tls_client_certificate_bound_access_tokens": true,
  "token_endpoint_auth_method": "client_secret_basic",
  "token_endpoint_signing_alg": "string",
  "tos_uri": "string",
  "trusted": true,
  "userinfo_signed_response_alg": "none"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

fetch('https://localhost:8443/api/admin/{tid}/clients',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.post 'https://localhost:8443/api/admin/{tid}/clients',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.post('https://localhost:8443/api/admin/{tid}/clients', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://localhost:8443/api/admin/{tid}/clients");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {access-token}"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://localhost:8443/api/admin/{tid}/clients", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /api/admin/{tid}/clients

Create new OAuth client.

Client must be created under existing tenant and authorization server.

Authorization server id must be provided in the request body.

Client id and secret can be provided, otherwise are generated.

If grant type is not set, client will get authorization code grant type assigned with code as response type.

Default token authentication method is client_secret_basic.

Body parameter

{
  "audience": [
    "string"
  ],
  "authorization_server_id": "default",
  "client_hashed_secret": "string",
  "client_id": "string",
  "client_id_issued_at": 0,
  "client_name": "My app",
  "client_secret": "string",
  "client_secret_expires_at": 0,
  "client_uri": "string",
  "description": "string",
  "developer_id": "string",
  "grant_types": [
    "password",
    "refresh_token",
    "client_credentials",
    "implicit",
    "authorization_code"
  ],
  "jwks": {
    "keys": []
  },
  "jwks_uri": "string",
  "logo_uri": "string",
  "policy_uri": "string",
  "privacy": {
    "scopes": {
      "property1": {
        "pii_categories": [
          {
            "name": "HIPAA"
          }
        ],
        "purpose": "string"
      },
      "property2": {
        "pii_categories": [
          {
            "name": "HIPAA"
          }
        ],
        "purpose": "string"
      }
    }
  },
  "public": true,
  "redirect_uris": [
    "https://example.com/callback"
  ],
  "request_object_signing_alg": "none",
  "request_uris": [
    "string"
  ],
  "response_types": [
    "token",
    "id_token",
    "code"
  ],
  "scope": "email offline_access openid",
  "scopes": [
    "email",
    "offline_access",
    "openid"
  ],
  "sector_identifier_uri": "https://api.jsonbin.io/b/5db6ef08688fed59d2841f1e",
  "system": false,
  "tenant_id": "string",
  "tls_client_auth_san_dns": "string",
  "tls_client_auth_san_email": "string",
  "tls_client_auth_san_ip": "string",
  "tls_client_auth_san_uri": "string",
  "tls_client_auth_subject_dn": "string",
  "tls_client_certificate_bound_access_tokens": true,
  "token_endpoint_auth_method": "client_secret_basic",
  "token_endpoint_signing_alg": "string",
  "tos_uri": "string",
  "trusted": true,
  "userinfo_signed_response_alg": "none"
}

Parameters

Name In Type Required Description
tid path string true Tenant id
body body Client false none

Example responses

201 Response

{
  "audience": [
    "string"
  ],
  "authorization_server_id": "default",
  "client_hashed_secret": "string",
  "client_id": "string",
  "client_id_issued_at": 0,
  "client_name": "My app",
  "client_secret": "string",
  "client_secret_expires_at": 0,
  "client_uri": "string",
  "description": "string",
  "developer_id": "string",
  "grant_types": [
    "password",
    "refresh_token",
    "client_credentials",
    "implicit",
    "authorization_code"
  ],
  "jwks": {
    "keys": []
  },
  "jwks_uri": "string",
  "logo_uri": "string",
  "policy_uri": "string",
  "privacy": {
    "scopes": {
      "property1": {
        "pii_categories": [
          {
            "name": "HIPAA"
          }
        ],
        "purpose": "string"
      },
      "property2": {
        "pii_categories": [
          {
            "name": "HIPAA"
          }
        ],
        "purpose": "string"
      }
    }
  },
  "public": true,
  "redirect_uris": [
    "https://example.com/callback"
  ],
  "request_object_signing_alg": "none",
  "request_uris": [
    "string"
  ],
  "response_types": [
    "token",
    "id_token",
    "code"
  ],
  "scope": "email offline_access openid",
  "scopes": [
    "email",
    "offline_access",
    "openid"
  ],
  "sector_identifier_uri": "https://api.jsonbin.io/b/5db6ef08688fed59d2841f1e",
  "system": false,
  "tenant_id": "string",
  "tls_client_auth_san_dns": "string",
  "tls_client_auth_san_email": "string",
  "tls_client_auth_san_ip": "string",
  "tls_client_auth_san_uri": "string",
  "tls_client_auth_subject_dn": "string",
  "tls_client_certificate_bound_access_tokens": true,
  "token_endpoint_auth_method": "client_secret_basic",
  "token_endpoint_signing_alg": "string",
  "tos_uri": "string",
  "trusted": true,
  "userinfo_signed_response_alg": "none"
}

Responses

Status Meaning Description Schema
201 Created

Client

Client
401 Unauthorized

HttpError

Error
403 Forbidden

HttpError

Error
404 Not Found

HttpError

Error
409 Conflict

HttpError

Error
422 Unprocessable Entity

HttpError

Error

getClient

Code samples

# You can also use wget
curl -X GET https://localhost:8443/api/admin/{tid}/clients/{cid} \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://localhost:8443/api/admin/{tid}/clients/{cid} HTTP/1.1
Host: localhost:8443
Accept: application/json

var headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: 'https://localhost:8443/api/admin/{tid}/clients/{cid}',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

fetch('https://localhost:8443/api/admin/{tid}/clients/{cid}',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.get 'https://localhost:8443/api/admin/{tid}/clients/{cid}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://localhost:8443/api/admin/{tid}/clients/{cid}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://localhost:8443/api/admin/{tid}/clients/{cid}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {access-token}"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://localhost:8443/api/admin/{tid}/clients/{cid}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /api/admin/{tid}/clients/{cid}

Get client. If client has been created by a developer, client's secret will be empty.

Parameters

Name In Type Required Description
tid path string true Tenant id
cid path string true Client id

Example responses

200 Response

{
  "audience": [
    "string"
  ],
  "authorization_server_id": "default",
  "client_hashed_secret": "string",
  "client_id": "string",
  "client_id_issued_at": 0,
  "client_name": "My app",
  "client_secret": "string",
  "client_secret_expires_at": 0,
  "client_uri": "string",
  "description": "string",
  "developer_id": "string",
  "grant_types": [
    "password",
    "refresh_token",
    "client_credentials",
    "implicit",
    "authorization_code"
  ],
  "jwks": {
    "keys": []
  },
  "jwks_uri": "string",
  "logo_uri": "string",
  "policy_uri": "string",
  "privacy": {
    "scopes": {
      "property1": {
        "pii_categories": [
          {
            "name": "HIPAA"
          }
        ],
        "purpose": "string"
      },
      "property2": {
        "pii_categories": [
          {
            "name": "HIPAA"
          }
        ],
        "purpose": "string"
      }
    }
  },
  "public": true,
  "redirect_uris": [
    "https://example.com/callback"
  ],
  "request_object_signing_alg": "none",
  "request_uris": [
    "string"
  ],
  "response_types": [
    "token",
    "id_token",
    "code"
  ],
  "scope": "email offline_access openid",
  "scopes": [
    "email",
    "offline_access",
    "openid"
  ],
  "sector_identifier_uri": "https://api.jsonbin.io/b/5db6ef08688fed59d2841f1e",
  "system": false,
  "tenant_id": "string",
  "tls_client_auth_san_dns": "string",
  "tls_client_auth_san_email": "string",
  "tls_client_auth_san_ip": "string",
  "tls_client_auth_san_uri": "string",
  "tls_client_auth_subject_dn": "string",
  "tls_client_certificate_bound_access_tokens": true,
  "token_endpoint_auth_method": "client_secret_basic",
  "token_endpoint_signing_alg": "string",
  "tos_uri": "string",
  "trusted": true,
  "userinfo_signed_response_alg": "none"
}

Responses

Status Meaning Description Schema
200 OK

Client

Client
401 Unauthorized

HttpError

Error
403 Forbidden

HttpError

Error
404 Not Found

HttpError

Error

updateClient

Code samples

# You can also use wget
curl -X PUT https://localhost:8443/api/admin/{tid}/clients/{cid} \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

PUT https://localhost:8443/api/admin/{tid}/clients/{cid} HTTP/1.1
Host: localhost:8443
Content-Type: application/json
Accept: application/json

var headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: 'https://localhost:8443/api/admin/{tid}/clients/{cid}',
  method: 'put',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');
const inputBody = '{
  "audience": [
    "string"
  ],
  "authorization_server_id": "default",
  "client_hashed_secret": "string",
  "client_id": "string",
  "client_id_issued_at": 0,
  "client_name": "My app",
  "client_secret": "string",
  "client_secret_expires_at": 0,
  "client_uri": "string",
  "description": "string",
  "developer_id": "string",
  "grant_types": [
    "password",
    "refresh_token",
    "client_credentials",
    "implicit",
    "authorization_code"
  ],
  "jwks": {
    "keys": []
  },
  "jwks_uri": "string",
  "logo_uri": "string",
  "policy_uri": "string",
  "privacy": {
    "scopes": {
      "property1": {
        "pii_categories": [
          {
            "name": "HIPAA"
          }
        ],
        "purpose": "string"
      },
      "property2": {
        "pii_categories": [
          {
            "name": "HIPAA"
          }
        ],
        "purpose": "string"
      }
    }
  },
  "public": true,
  "redirect_uris": [
    "https://example.com/callback"
  ],
  "request_object_signing_alg": "none",
  "request_uris": [
    "string"
  ],
  "response_types": [
    "token",
    "id_token",
    "code"
  ],
  "scope": "email offline_access openid",
  "scopes": [
    "email",
    "offline_access",
    "openid"
  ],
  "sector_identifier_uri": "https://api.jsonbin.io/b/5db6ef08688fed59d2841f1e",
  "system": false,
  "tenant_id": "string",
  "tls_client_auth_san_dns": "string",
  "tls_client_auth_san_email": "string",
  "tls_client_auth_san_ip": "string",
  "tls_client_auth_san_uri": "string",
  "tls_client_auth_subject_dn": "string",
  "tls_client_certificate_bound_access_tokens": true,
  "token_endpoint_auth_method": "client_secret_basic",
  "token_endpoint_signing_alg": "string",
  "tos_uri": "string",
  "trusted": true,
  "userinfo_signed_response_alg": "none"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

fetch('https://localhost:8443/api/admin/{tid}/clients/{cid}',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.put 'https://localhost:8443/api/admin/{tid}/clients/{cid}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.put('https://localhost:8443/api/admin/{tid}/clients/{cid}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://localhost:8443/api/admin/{tid}/clients/{cid}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PUT");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {access-token}"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "https://localhost:8443/api/admin/{tid}/clients/{cid}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

PUT /api/admin/{tid}/clients/{cid}

Update client

Body parameter

{
  "audience": [
    "string"
  ],
  "authorization_server_id": "default",
  "client_hashed_secret": "string",
  "client_id": "string",
  "client_id_issued_at": 0,
  "client_name": "My app",
  "client_secret": "string",
  "client_secret_expires_at": 0,
  "client_uri": "string",
  "description": "string",
  "developer_id": "string",
  "grant_types": [
    "password",
    "refresh_token",
    "client_credentials",
    "implicit",
    "authorization_code"
  ],
  "jwks": {
    "keys": []
  },
  "jwks_uri": "string",
  "logo_uri": "string",
  "policy_uri": "string",
  "privacy": {
    "scopes": {
      "property1": {
        "pii_categories": [
          {
            "name": "HIPAA"
          }
        ],
        "purpose": "string"
      },
      "property2": {
        "pii_categories": [
          {
            "name": "HIPAA"
          }
        ],
        "purpose": "string"
      }
    }
  },
  "public": true,
  "redirect_uris": [
    "https://example.com/callback"
  ],
  "request_object_signing_alg": "none",
  "request_uris": [
    "string"
  ],
  "response_types": [
    "token",
    "id_token",
    "code"
  ],
  "scope": "email offline_access openid",
  "scopes": [
    "email",
    "offline_access",
    "openid"
  ],
  "sector_identifier_uri": "https://api.jsonbin.io/b/5db6ef08688fed59d2841f1e",
  "system": false,
  "tenant_id": "string",
  "tls_client_auth_san_dns": "string",
  "tls_client_auth_san_email": "string",
  "tls_client_auth_san_ip": "string",
  "tls_client_auth_san_uri": "string",
  "tls_client_auth_subject_dn": "string",
  "tls_client_certificate_bound_access_tokens": true,
  "token_endpoint_auth_method": "client_secret_basic",
  "token_endpoint_signing_alg": "string",
  "tos_uri": "string",
  "trusted": true,
  "userinfo_signed_response_alg": "none"
}

Parameters

Name In Type Required Description
tid path string true Tenant id
cid path string true Client id
body body Client false none

Example responses

200 Response

{
  "audience": [
    "string"
  ],
  "authorization_server_id": "default",
  "client_hashed_secret": "string",
  "client_id": "string",
  "client_id_issued_at": 0,
  "client_name": "My app",
  "client_secret": "string",
  "client_secret_expires_at": 0,
  "client_uri": "string",
  "description": "string",
  "developer_id": "string",
  "grant_types": [
    "password",
    "refresh_token",
    "client_credentials",
    "implicit",
    "authorization_code"
  ],
  "jwks": {
    "keys": []
  },
  "jwks_uri": "string",
  "logo_uri": "string",
  "policy_uri": "string",
  "privacy": {
    "scopes": {
      "property1": {
        "pii_categories": [
          {
            "name": "HIPAA"
          }
        ],
        "purpose": "string"
      },
      "property2": {
        "pii_categories": [
          {
            "name": "HIPAA"
          }
        ],
        "purpose": "string"
      }
    }
  },
  "public": true,
  "redirect_uris": [
    "https://example.com/callback"
  ],
  "request_object_signing_alg": "none",
  "request_uris": [
    "string"
  ],
  "response_types": [
    "token",
    "id_token",
    "code"
  ],
  "scope": "email offline_access openid",
  "scopes": [
    "email",
    "offline_access",
    "openid"
  ],
  "sector_identifier_uri": "https://api.jsonbin.io/b/5db6ef08688fed59d2841f1e",
  "system": false,
  "tenant_id": "string",
  "tls_client_auth_san_dns": "string",
  "tls_client_auth_san_email": "string",
  "tls_client_auth_san_ip": "string",
  "tls_client_auth_san_uri": "string",
  "tls_client_auth_subject_dn": "string",
  "tls_client_certificate_bound_access_tokens": true,
  "token_endpoint_auth_method": "client_secret_basic",
  "token_endpoint_signing_alg": "string",
  "tos_uri": "string",
  "trusted": true,
  "userinfo_signed_response_alg": "none"
}

Responses

Status Meaning Description Schema
200 OK

Client

Client
400 Bad Request

HttpError

Error
401 Unauthorized

HttpError

Error
403 Forbidden

HttpError

Error
404 Not Found

HttpError

Error
422 Unprocessable Entity

HttpError

Error

deleteClient

Code samples

# You can also use wget
curl -X DELETE https://localhost:8443/api/admin/{tid}/clients/{cid} \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

DELETE https://localhost:8443/api/admin/{tid}/clients/{cid} HTTP/1.1
Host: localhost:8443
Accept: application/json

var headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: 'https://localhost:8443/api/admin/{tid}/clients/{cid}',
  method: 'delete',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

fetch('https://localhost:8443/api/admin/{tid}/clients/{cid}',
{
  method: 'DELETE',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.delete 'https://localhost:8443/api/admin/{tid}/clients/{cid}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.delete('https://localhost:8443/api/admin/{tid}/clients/{cid}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://localhost:8443/api/admin/{tid}/clients/{cid}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("DELETE");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {access-token}"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "https://localhost:8443/api/admin/{tid}/clients/{cid}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

DELETE /api/admin/{tid}/clients/{cid}

Delete client

Parameters

Name In Type Required Description
tid path string true Tenant id
cid path string true Client id

Example responses

400 Response

{
  "details": {},
  "error": "string",
  "status_code": 0
}

Responses

Status Meaning Description Schema
204 No Content

Client has been deleted

None
400 Bad Request

HttpError

Error
401 Unauthorized

HttpError

Error
403 Forbidden

HttpError

Error
404 Not Found

HttpError

Error

listConsents

Code samples

# You can also use wget
curl -X GET https://localhost:8443/api/admin/{tid}/consents \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://localhost:8443/api/admin/{tid}/consents HTTP/1.1
Host: localhost:8443
Accept: application/json

var headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: 'https://localhost:8443/api/admin/{tid}/consents',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

fetch('https://localhost:8443/api/admin/{tid}/consents',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.get 'https://localhost:8443/api/admin/{tid}/consents',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://localhost:8443/api/admin/{tid}/consents', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://localhost:8443/api/admin/{tid}/consents");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {access-token}"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://localhost:8443/api/admin/{tid}/consents", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /api/admin/{tid}/consents

List consents

Parameters

Name In Type Required Description
tid path string true Tenant id

Example responses

200 Response

{
  "consents": [
    {
      "can_be_withdrawn": false,
      "description": "End User License Agreement",
      "id": "1",
      "internal_services": [
        {
          "name": "string",
          "purposes": [
            {
              "name": "Core Function",
              "primary": true
            }
          ]
        }
      ],
      "name": "EULA",
      "pii_categories": [
        {
          "name": "HIPAA"
        }
      ],
      "tenant_id": "default",
      "third_party_services": [
        {
          "name": "string",
          "purposes": [
            {
              "name": "Core Function",
              "primary": true
            }
          ]
        }
      ],
      "update_existing_grants": "explicitAll",
      "valid_from": "2019-12-11T13:44:28.772101Z",
      "version": 1
    }
  ]
}

Responses

Status Meaning Description Schema
200 OK

Consents

Consents
401 Unauthorized

HttpError

Error
403 Forbidden

HttpError

Error

createConsent

Code samples

# You can also use wget
curl -X POST https://localhost:8443/api/admin/{tid}/consents \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

POST https://localhost:8443/api/admin/{tid}/consents HTTP/1.1
Host: localhost:8443
Content-Type: application/json
Accept: application/json

var headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: 'https://localhost:8443/api/admin/{tid}/consents',
  method: 'post',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');
const inputBody = '{
  "can_be_withdrawn": false,
  "description": "End User License Agreement",
  "id": "1",
  "internal_services": [
    {
      "name": "string",
      "purposes": [
        {
          "name": "Core Function",
          "primary": true
        }
      ]
    }
  ],
  "name": "EULA",
  "pii_categories": [
    {
      "name": "HIPAA"
    }
  ],
  "tenant_id": "default",
  "third_party_services": [
    {
      "name": "string",
      "purposes": [
        {
          "name": "Core Function",
          "primary": true
        }
      ]
    }
  ],
  "update_existing_grants": "explicitAll",
  "valid_from": "2019-12-11T13:44:28.772101Z",
  "version": 1
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

fetch('https://localhost:8443/api/admin/{tid}/consents',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.post 'https://localhost:8443/api/admin/{tid}/consents',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.post('https://localhost:8443/api/admin/{tid}/consents', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://localhost:8443/api/admin/{tid}/consents");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {access-token}"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://localhost:8443/api/admin/{tid}/consents", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /api/admin/{tid}/consents

Create consent.

Consents are created per tenant.

ID, Name and UpdateExistingGrants strategy are required fields when creating a new consent.

UpdateExistingGrants has the following options:

explicitAll - all the existing grants should not be updated. It is required that the user grants the consent explicitly.

implicitAll - all previously existing consent grants should be updated, to the new version of the consent, but all of those grants should be implicit from the moment on.

keepCurrent - if a previously existing consent grant was set implicitly, it is automatically updated and a new consent grant is produced, which is also implicit. if a previously existing consent grant was set explicitly, it should not be updated. It is required that the user grants the consent explicitly.

Body parameter

{
  "can_be_withdrawn": false,
  "description": "End User License Agreement",
  "id": "1",
  "internal_services": [
    {
      "name": "string",
      "purposes": [
        {
          "name": "Core Function",
          "primary": true
        }
      ]
    }
  ],
  "name": "EULA",
  "pii_categories": [
    {
      "name": "HIPAA"
    }
  ],
  "tenant_id": "default",
  "third_party_services": [
    {
      "name": "string",
      "purposes": [
        {
          "name": "Core Function",
          "primary": true
        }
      ]
    }
  ],
  "update_existing_grants": "explicitAll",
  "valid_from": "2019-12-11T13:44:28.772101Z",
  "version": 1
}

Parameters

Name In Type Required Description
tid path string true Tenant id
body body Consent true none

Example responses

201 Response

{
  "can_be_withdrawn": false,
  "description": "End User License Agreement",
  "id": "1",
  "internal_services": [
    {
      "name": "string",
      "purposes": [
        {
          "name": "Core Function",
          "primary": true
        }
      ]
    }
  ],
  "name": "EULA",
  "pii_categories": [
    {
      "name": "HIPAA"
    }
  ],
  "tenant_id": "default",
  "third_party_services": [
    {
      "name": "string",
      "purposes": [
        {
          "name": "Core Function",
          "primary": true
        }
      ]
    }
  ],
  "update_existing_grants": "explicitAll",
  "valid_from": "2019-12-11T13:44:28.772101Z",
  "version": 1
}

Responses

Status Meaning Description Schema
201 Created

Consent

Consent
401 Unauthorized

HttpError

Error
403 Forbidden

HttpError

Error
404 Not Found

HttpError

Error
409 Conflict

HttpError

Error
422 Unprocessable Entity

HttpError

Error

getConsent

Code samples

# You can also use wget
curl -X GET https://localhost:8443/api/admin/{tid}/consents/{consent} \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://localhost:8443/api/admin/{tid}/consents/{consent} HTTP/1.1
Host: localhost:8443
Accept: application/json

var headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: 'https://localhost:8443/api/admin/{tid}/consents/{consent}',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

fetch('https://localhost:8443/api/admin/{tid}/consents/{consent}',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.get 'https://localhost:8443/api/admin/{tid}/consents/{consent}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://localhost:8443/api/admin/{tid}/consents/{consent}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://localhost:8443/api/admin/{tid}/consents/{consent}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {access-token}"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://localhost:8443/api/admin/{tid}/consents/{consent}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /api/admin/{tid}/consents/{consent}

Get consent details

Parameters

Name In Type Required Description
tid path string true Tenant id
consent path string true none

Example responses

200 Response

{
  "can_be_withdrawn": false,
  "description": "End User License Agreement",
  "id": "1",
  "internal_services": [
    {
      "name": "string",
      "purposes": [
        {
          "name": "Core Function",
          "primary": true
        }
      ]
    }
  ],
  "name": "EULA",
  "pii_categories": [
    {
      "name": "HIPAA"
    }
  ],
  "tenant_id": "default",
  "third_party_services": [
    {
      "name": "string",
      "purposes": [
        {
          "name": "Core Function",
          "primary": true
        }
      ]
    }
  ],
  "update_existing_grants": "explicitAll",
  "valid_from": "2019-12-11T13:44:28.772101Z",
  "version": 1
}

Responses

Status Meaning Description Schema
200 OK

Consent

Consent
401 Unauthorized

HttpError

Error
403 Forbidden

HttpError

Error
404 Not Found

HttpError

Error

updateConsent

Code samples

# You can also use wget
curl -X PUT https://localhost:8443/api/admin/{tid}/consents/{consent} \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

PUT https://localhost:8443/api/admin/{tid}/consents/{consent} HTTP/1.1
Host: localhost:8443
Content-Type: application/json
Accept: application/json

var headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: 'https://localhost:8443/api/admin/{tid}/consents/{consent}',
  method: 'put',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');
const inputBody = '{
  "can_be_withdrawn": false,
  "description": "End User License Agreement",
  "id": "1",
  "internal_services": [
    {
      "name": "string",
      "purposes": [
        {
          "name": "Core Function",
          "primary": true
        }
      ]
    }
  ],
  "name": "EULA",
  "pii_categories": [
    {
      "name": "HIPAA"
    }
  ],
  "tenant_id": "default",
  "third_party_services": [
    {
      "name": "string",
      "purposes": [
        {
          "name": "Core Function",
          "primary": true
        }
      ]
    }
  ],
  "update_existing_grants": "explicitAll",
  "valid_from": "2019-12-11T13:44:28.772101Z",
  "version": 1
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

fetch('https://localhost:8443/api/admin/{tid}/consents/{consent}',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.put 'https://localhost:8443/api/admin/{tid}/consents/{consent}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.put('https://localhost:8443/api/admin/{tid}/consents/{consent}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://localhost:8443/api/admin/{tid}/consents/{consent}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PUT");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {access-token}"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "https://localhost:8443/api/admin/{tid}/consents/{consent}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

PUT /api/admin/{tid}/consents/{consent}

Update consent

Every time consent is updated, its version is incremented.

If ValidFrom attribute is not provided it will be set to current time.

Body parameter

{
  "can_be_withdrawn": false,
  "description": "End User License Agreement",
  "id": "1",
  "internal_services": [
    {
      "name": "string",
      "purposes": [
        {
          "name": "Core Function",
          "primary": true
        }
      ]
    }
  ],
  "name": "EULA",
  "pii_categories": [
    {
      "name": "HIPAA"
    }
  ],
  "tenant_id": "default",
  "third_party_services": [
    {
      "name": "string",
      "purposes": [
        {
          "name": "Core Function",
          "primary": true
        }
      ]
    }
  ],
  "update_existing_grants": "explicitAll",
  "valid_from": "2019-12-11T13:44:28.772101Z",
  "version": 1
}

Parameters

Name In Type Required Description
tid path string true Tenant id
consent path string true none
body body Consent false none

Example responses

201 Response

{
  "can_be_withdrawn": false,
  "description": "End User License Agreement",
  "id": "1",
  "internal_services": [
    {
      "name": "string",
      "purposes": [
        {
          "name": "Core Function",
          "primary": true
        }
      ]
    }
  ],
  "name": "EULA",
  "pii_categories": [
    {
      "name": "HIPAA"
    }
  ],
  "tenant_id": "default",
  "third_party_services": [
    {
      "name": "string",
      "purposes": [
        {
          "name": "Core Function",
          "primary": true
        }
      ]
    }
  ],
  "update_existing_grants": "explicitAll",
  "valid_from": "2019-12-11T13:44:28.772101Z",
  "version": 1
}

Responses

Status Meaning Description Schema
201 Created

Consent

Consent
401 Unauthorized

HttpError

Error
403 Forbidden

HttpError

Error
404 Not Found

HttpError

Error
409 Conflict

HttpError

Error
422 Unprocessable Entity

HttpError

Error

deleteConsent

Code samples

# You can also use wget
curl -X DELETE https://localhost:8443/api/admin/{tid}/consents/{consent} \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

DELETE https://localhost:8443/api/admin/{tid}/consents/{consent} HTTP/1.1
Host: localhost:8443
Accept: application/json

var headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: 'https://localhost:8443/api/admin/{tid}/consents/{consent}',
  method: 'delete',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

fetch('https://localhost:8443/api/admin/{tid}/consents/{consent}',
{
  method: 'DELETE',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.delete 'https://localhost:8443/api/admin/{tid}/consents/{consent}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.delete('https://localhost:8443/api/admin/{tid}/consents/{consent}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://localhost:8443/api/admin/{tid}/consents/{consent}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("DELETE");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {access-token}"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "https://localhost:8443/api/admin/{tid}/consents/{consent}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

DELETE /api/admin/{tid}/consents/{consent}

Delete consent

Parameters

Name In Type Required Description
tid path string true Tenant id
consent path string true none

Example responses

401 Response

{
  "details": {},
  "error": "string",
  "status_code": 0
}

Responses

Status Meaning Description Schema
204 No Content

Consent has been deleted

None
401 Unauthorized

HttpError

Error
403 Forbidden

HttpError

Error
404 Not Found

HttpError

Error

listPrivacyLedgerEventsBySubject

Code samples

# You can also use wget
curl -X GET https://localhost:8443/api/admin/{tid}/events \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://localhost:8443/api/admin/{tid}/events HTTP/1.1
Host: localhost:8443
Accept: application/json

var headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: 'https://localhost:8443/api/admin/{tid}/events',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

fetch('https://localhost:8443/api/admin/{tid}/events',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.get 'https://localhost:8443/api/admin/{tid}/events',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://localhost:8443/api/admin/{tid}/events', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://localhost:8443/api/admin/{tid}/events");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {access-token}"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://localhost:8443/api/admin/{tid}/events", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /api/admin/{tid}/events

List privacy ledger events.

Parameters

Name In Type Required Description
tid path string true Tenant id
sub query string(subject) false Subject
from query integer(int64) false Query events from timestamp (default 0)
to query integer(int64) false Query events to timestamp (default current time)

Example responses

200 Response

{
  "events": [
    {
      "date": "2020-05-14T07:47:23Z",
      "id": "string",
      "payload": {
        "consent_granted": {
          "collection_timestamp": 1257894000000000000,
          "consent": {
            "can_be_withdrawn": false,
            "description": "End User License Agreement",
            "id": "1",
            "internal_services": [
              {
                "name": "string",
                "purposes": [
                  {
                    "name": "Core Function",
                    "primary": true
                  }
                ]
              }
            ],
            "name": "EULA",
            "pii_categories": [
              {
                "name": "HIPAA"
              }
            ],
            "tenant_id": "default",
            "third_party_services": [
              {
                "name": "string",
                "purposes": [
                  {
                    "name": "Core Function",
                    "primary": true
                  }
                ]
              }
            ],
            "update_existing_grants": "explicitAll",
            "valid_from": "2019-12-11T13:44:28.772101Z",
            "version": 1
          },
          "consent_grant_act_id": "27fa83a8-d0a6-48da-8529-42105bfa0ede",
          "consent_id": "1",
          "context": {
            "device": {
              "property1": {},
              "property2": {}
            },
            "ip": "52.14.142.76",
            "location": [
              25.2084,
              55.2719
            ]
          },
          "given_at": "2020-05-14T07:47:23Z",
          "grant_type": "implicit",
          "language": "en",
          "subject": "peter",
          "tenant_id": "default",
          "triggered_by_action": "1",
          "version": 1
        },
        "consent_revoked": {
          "collection_timestamp": 1257894000000000000,
          "consent": {
            "can_be_withdrawn": false,
            "description": "End User License Agreement",
            "id": "1",
            "internal_services": [
              {
                "name": "string",
                "purposes": [
                  {
                    "name": "Core Function",
                    "primary": true
                  }
                ]
              }
            ],
            "name": "EULA",
            "pii_categories": [
              {
                "name": "HIPAA"
              }
            ],
            "tenant_id": "default",
            "third_party_services": [
              {
                "name": "string",
                "purposes": [
                  {
                    "name": "Core Function",
                    "primary": true
                  }
                ]
              }
            ],
            "update_existing_grants": "explicitAll",
            "valid_from": "2019-12-11T13:44:28.772101Z",
            "version": 1
          },
          "consent_grant_act_id": "27fa83a8-d0a6-48da-8529-42105bfa0ede",
          "consent_id": "1",
          "context": {
            "device": {
              "property1": {},
              "property2": {}
            },
            "ip": "52.14.142.76",
            "location": [
              25.2084,
              55.2719
            ]
          },
          "given_at": "2020-05-14T07:47:23Z",
          "grant_type": "implicit",
          "language": "en",
          "subject": "peter",
          "tenant_id": "default",
          "triggered_by_action": "1",
          "version": 1
        },
        "event_type": "string"
      },
      "payload_signature": "string",
      "subject": "string",
      "tenant_id": "string"
    }
  ]
}

Responses

Status Meaning Description Schema
200 OK

PrivacyLedgerEvents

PrivacyLedgerEvents
401 Unauthorized

HttpError

Error
403 Forbidden

HttpError

Error
404 Not Found

HttpError

Error

createGateway

Code samples

# You can also use wget
curl -X POST https://localhost:8443/api/admin/{tid}/gateways \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

POST https://localhost:8443/api/admin/{tid}/gateways HTTP/1.1
Host: localhost:8443
Content-Type: application/json
Accept: application/json

var headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: 'https://localhost:8443/api/admin/{tid}/gateways',
  method: 'post',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');
const inputBody = '{
  "description": "string",
  "name": "Cloudentity Pyron",
  "server_id": "string",
  "type": "pyron"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

fetch('https://localhost:8443/api/admin/{tid}/gateways',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.post 'https://localhost:8443/api/admin/{tid}/gateways',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.post('https://localhost:8443/api/admin/{tid}/gateways', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://localhost:8443/api/admin/{tid}/gateways");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {access-token}"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://localhost:8443/api/admin/{tid}/gateways", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /api/admin/{tid}/gateways

Create gateway.

Body parameter

{
  "description": "string",
  "name": "Cloudentity Pyron",
  "server_id": "string",
  "type": "pyron"
}

Parameters

Name In Type Required Description
tid path string true Tenant id
body body CreateGatewayRequest false none

Example responses

201 Response

{
  "authorization_server_id": "default",
  "client": {
    "audience": [
      "string"
    ],
    "authorization_server_id": "default",
    "client_hashed_secret": "string",
    "client_id": "string",
    "client_id_issued_at": 0,
    "client_name": "My app",
    "client_secret": "string",
    "client_secret_expires_at": 0,
    "client_uri": "string",
    "description": "string",
    "developer_id": "string",
    "grant_types": [
      "password",
      "refresh_token",
      "client_credentials",
      "implicit",
      "authorization_code"
    ],
    "jwks": {
      "keys": []
    },
    "jwks_uri": "string",
    "logo_uri": "string",
    "policy_uri": "string",
    "privacy": {
      "scopes": {
        "property1": {
          "pii_categories": [
            {
              "name": "HIPAA"
            }
          ],
          "purpose": "string"
        },
        "property2": {
          "pii_categories": [
            {
              "name": "HIPAA"
            }
          ],
          "purpose": "string"
        }
      }
    },
    "public": true,
    "redirect_uris": [
      "https://example.com/callback"
    ],
    "request_object_signing_alg": "none",
    "request_uris": [
      "string"
    ],
    "response_types": [
      "token",
      "id_token",
      "code"
    ],
    "scope": "email offline_access openid",
    "scopes": [
      "email",
      "offline_access",
      "openid"
    ],
    "sector_identifier_uri": "https://api.jsonbin.io/b/5db6ef08688fed59d2841f1e",
    "system": false,
    "tenant_id": "string",
    "tls_client_auth_san_dns": "string",
    "tls_client_auth_san_email": "string",
    "tls_client_auth_san_ip": "string",
    "tls_client_auth_san_uri": "string",
    "tls_client_auth_subject_dn": "string",
    "tls_client_certificate_bound_access_tokens": true,
    "token_endpoint_auth_method": "client_secret_basic",
    "token_endpoint_signing_alg": "string",
    "tos_uri": "string",
    "trusted": true,
    "userinfo_signed_response_alg": "none"
  },
  "client_id": "string",
  "description": "string",
  "id": "1",
  "issuer_url": "string",
  "last_active": "2020-05-14T07:47:23Z",
  "name": "Cloudentity Pyron",
  "server_url": "string",
  "tenant_id": "default",
  "type": "pyron"
}

Responses

Status Meaning Description Schema
201 Created

GatewayWithClient

GatewayWithClient
401 Unauthorized

HttpError

Error
403 Forbidden

HttpError

Error
404 Not Found

HttpError

Error
409 Conflict

HttpError

Error
422 Unprocessable Entity

HttpError

Error

getGateway

Code samples

# You can also use wget
curl -X GET https://localhost:8443/api/admin/{tid}/gateways/{gw} \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://localhost:8443/api/admin/{tid}/gateways/{gw} HTTP/1.1
Host: localhost:8443
Accept: application/json

var headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: 'https://localhost:8443/api/admin/{tid}/gateways/{gw}',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

fetch('https://localhost:8443/api/admin/{tid}/gateways/{gw}',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.get 'https://localhost:8443/api/admin/{tid}/gateways/{gw}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://localhost:8443/api/admin/{tid}/gateways/{gw}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://localhost:8443/api/admin/{tid}/gateways/{gw}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {access-token}"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://localhost:8443/api/admin/{tid}/gateways/{gw}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /api/admin/{tid}/gateways/{gw}

Get gateway

Parameters

Name In Type Required Description
tid path string true Tenant id
gw path string true Gateway id

Example responses

200 Response

{
  "authorization_server_id": "default",
  "client": {
    "audience": [
      "string"
    ],
    "authorization_server_id": "default",
    "client_hashed_secret": "string",
    "client_id": "string",
    "client_id_issued_at": 0,
    "client_name": "My app",
    "client_secret": "string",
    "client_secret_expires_at": 0,
    "client_uri": "string",
    "description": "string",
    "developer_id": "string",
    "grant_types": [
      "password",
      "refresh_token",
      "client_credentials",
      "implicit",
      "authorization_code"
    ],
    "jwks": {
      "keys": []
    },
    "jwks_uri": "string",
    "logo_uri": "string",
    "policy_uri": "string",
    "privacy": {
      "scopes": {
        "property1": {
          "pii_categories": [
            {
              "name": "HIPAA"
            }
          ],
          "purpose": "string"
        },
        "property2": {
          "pii_categories": [
            {
              "name": "HIPAA"
            }
          ],
          "purpose": "string"
        }
      }
    },
    "public": true,
    "redirect_uris": [
      "https://example.com/callback"
    ],
    "request_object_signing_alg": "none",
    "request_uris": [
      "string"
    ],
    "response_types": [
      "token",
      "id_token",
      "code"
    ],
    "scope": "email offline_access openid",
    "scopes": [
      "email",
      "offline_access",
      "openid"
    ],
    "sector_identifier_uri": "https://api.jsonbin.io/b/5db6ef08688fed59d2841f1e",
    "system": false,
    "tenant_id": "string",
    "tls_client_auth_san_dns": "string",
    "tls_client_auth_san_email": "string",
    "tls_client_auth_san_ip": "string",
    "tls_client_auth_san_uri": "string",
    "tls_client_auth_subject_dn": "string",
    "tls_client_certificate_bound_access_tokens": true,
    "token_endpoint_auth_method": "client_secret_basic",
    "token_endpoint_signing_alg": "string",
    "tos_uri": "string",
    "trusted": true,
    "userinfo_signed_response_alg": "none"
  },
  "client_id": "string",
  "description": "string",
  "id": "1",
  "issuer_url": "string",
  "last_active": "2020-05-14T07:47:23Z",
  "name": "Cloudentity Pyron",
  "server_url": "string",
  "tenant_id": "default",
  "type": "pyron"
}

Responses

Status Meaning Description Schema
200 OK

GatewayWithClient

GatewayWithClient
401 Unauthorized

HttpError

Error
403 Forbidden

HttpError

Error
404 Not Found

HttpError

Error

updateGateway

Code samples

# You can also use wget
curl -X PUT https://localhost:8443/api/admin/{tid}/gateways/{gw} \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

PUT https://localhost:8443/api/admin/{tid}/gateways/{gw} HTTP/1.1
Host: localhost:8443
Content-Type: application/json
Accept: application/json

var headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: 'https://localhost:8443/api/admin/{tid}/gateways/{gw}',
  method: 'put',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');
const inputBody = '{
  "description": "string",
  "name": "Cloudentity Pyron"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

fetch('https://localhost:8443/api/admin/{tid}/gateways/{gw}',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.put 'https://localhost:8443/api/admin/{tid}/gateways/{gw}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.put('https://localhost:8443/api/admin/{tid}/gateways/{gw}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://localhost:8443/api/admin/{tid}/gateways/{gw}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PUT");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {access-token}"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "https://localhost:8443/api/admin/{tid}/gateways/{gw}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

PUT /api/admin/{tid}/gateways/{gw}

Update gateway

Body parameter

{
  "description": "string",
  "name": "Cloudentity Pyron"
}

Parameters

Name In Type Required Description
tid path string true Tenant id
gw path string true none
body body UpdateGatewayRequest false none

Example responses

200 Response

{
  "authorization_server_id": "default",
  "client_id": "string",
  "description": "string",
  "id": "1",
  "last_active": "2020-05-14T07:47:23Z",
  "name": "Cloudentity Pyron",
  "tenant_id": "default",
  "type": "pyron"
}

Responses

Status Meaning Description Schema
200 OK

Gateway

Gateway
400 Bad Request

HttpError

Error
401 Unauthorized

HttpError

Error
403 Forbidden

HttpError

Error
404 Not Found

HttpError

Error
422 Unprocessable Entity

HttpError

Error

deleteGateway

Code samples

# You can also use wget
curl -X DELETE https://localhost:8443/api/admin/{tid}/gateways/{gw} \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

DELETE https://localhost:8443/api/admin/{tid}/gateways/{gw} HTTP/1.1
Host: localhost:8443
Accept: application/json

var headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: 'https://localhost:8443/api/admin/{tid}/gateways/{gw}',
  method: 'delete',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

fetch('https://localhost:8443/api/admin/{tid}/gateways/{gw}',
{
  method: 'DELETE',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.delete 'https://localhost:8443/api/admin/{tid}/gateways/{gw}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.delete('https://localhost:8443/api/admin/{tid}/gateways/{gw}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://localhost:8443/api/admin/{tid}/gateways/{gw}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("DELETE");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {access-token}"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "https://localhost:8443/api/admin/{tid}/gateways/{gw}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

DELETE /api/admin/{tid}/gateways/{gw}

Delete gateway.

This removes configuration for all services connected to this gateway.

Parameters

Name In Type Required Description
tid path string true Tenant id
gw path string true none

Example responses

401 Response

{
  "details": {},
  "error": "string",
  "status_code": 0
}

Responses

Status Meaning Description Schema
204 No Content

Gateway has been deleted

None
401 Unauthorized

HttpError

Error
403 Forbidden

HttpError

Error
404 Not Found

HttpError

Error

getGatewayPackage

Code samples

# You can also use wget
curl -X GET https://localhost:8443/api/admin/{tid}/gateways/{gw}/package \
  -H 'Accept: application/octet-stream' \
  -H 'Authorization: Bearer {access-token}'

GET https://localhost:8443/api/admin/{tid}/gateways/{gw}/package HTTP/1.1
Host: localhost:8443
Accept: application/octet-stream

var headers = {
  'Accept':'application/octet-stream',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: 'https://localhost:8443/api/admin/{tid}/gateways/{gw}/package',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'application/octet-stream',
  'Authorization':'Bearer {access-token}'

};

fetch('https://localhost:8443/api/admin/{tid}/gateways/{gw}/package',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/octet-stream',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.get 'https://localhost:8443/api/admin/{tid}/gateways/{gw}/package',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/octet-stream',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://localhost:8443/api/admin/{tid}/gateways/{gw}/package', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://localhost:8443/api/admin/{tid}/gateways/{gw}/package");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/octet-stream"},
        "Authorization": []string{"Bearer {access-token}"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://localhost:8443/api/admin/{tid}/gateways/{gw}/package", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /api/admin/{tid}/gateways/{gw}/package

Get package for a gateway

Parameters

Name In Type Required Description
tid path string true Tenant id
gw path string true Gateway id

Example responses

200 Response

Responses

Status Meaning Description Schema
200 OK

Gateway package

string
400 Bad Request

HttpError

Error
401 Unauthorized

HttpError

Error
403 Forbidden

HttpError

Error
404 Not Found

HttpError

Error

listPolicies

Code samples

# You can also use wget
curl -X GET https://localhost:8443/api/admin/{tid}/policies \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://localhost:8443/api/admin/{tid}/policies HTTP/1.1
Host: localhost:8443
Accept: application/json

var headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: 'https://localhost:8443/api/admin/{tid}/policies',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

fetch('https://localhost:8443/api/admin/{tid}/policies',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.get 'https://localhost:8443/api/admin/{tid}/policies',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://localhost:8443/api/admin/{tid}/policies', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://localhost:8443/api/admin/{tid}/policies");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {access-token}"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://localhost:8443/api/admin/{tid}/policies", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /api/admin/{tid}/policies

List policies.

Parameters

Name In Type Required Description
tid path string true Tenant id

Example responses

200 Response

{
  "policies": [
    {
      "id": "1",
      "policy_name": "check_consent",
      "tenant_id": "default",
      "validators": [
        {
          "conf": {
            "property1": {},
            "property2": {}
          },
          "name": "identity-context",
          "recovery": [
            {
              "id": "string",
              "type": "string"
            }
          ]
        }
      ]
    }
  ]
}

Responses

Status Meaning Description Schema
200 OK

Policies

Policies
401 Unauthorized

HttpError

Error
403 Forbidden

HttpError

Error

createPolicy

Code samples

# You can also use wget
curl -X POST https://localhost:8443/api/admin/{tid}/policies \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

POST https://localhost:8443/api/admin/{tid}/policies HTTP/1.1
Host: localhost:8443
Content-Type: application/json
Accept: application/json

var headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: 'https://localhost:8443/api/admin/{tid}/policies',
  method: 'post',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');
const inputBody = '{
  "id": "1",
  "policy_name": "check_consent",
  "tenant_id": "default",
  "validators": [
    {
      "conf": {
        "property1": {},
        "property2": {}
      },
      "name": "identity-context",
      "recovery": [
        {
          "id": "string",
          "type": "string"
        }
      ]
    }
  ]
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

fetch('https://localhost:8443/api/admin/{tid}/policies',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.post 'https://localhost:8443/api/admin/{tid}/policies',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.post('https://localhost:8443/api/admin/{tid}/policies', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://localhost:8443/api/admin/{tid}/policies");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {access-token}"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://localhost:8443/api/admin/{tid}/policies", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /api/admin/{tid}/policies

Create policy.

Policies are created per tenant.

ID and Name are required fields.

Sample validators which can be used to build policies: identity-context, consent, header, true, false.

Body parameter

{
  "id": "1",
  "policy_name": "check_consent",
  "tenant_id": "default",
  "validators": [
    {
      "conf": {
        "property1": {},
        "property2": {}
      },
      "name": "identity-context",
      "recovery": [
        {
          "id": "string",
          "type": "string"
        }
      ]
    }
  ]
}

Parameters

Name In Type Required Description
tid path string true Tenant id
body body Policy false none

Example responses

201 Response

{
  "id": "1",
  "policy_name": "check_consent",
  "tenant_id": "default",
  "validators": [
    {
      "conf": {
        "property1": {},
        "property2": {}
      },
      "name": "identity-context",
      "recovery": [
        {
          "id": "string",
          "type": "string"
        }
      ]
    }
  ]
}

Responses

Status Meaning Description Schema
201 Created

Policy

Policy
401 Unauthorized

HttpError

Error
403 Forbidden

HttpError

Error
404 Not Found

HttpError

Error
409 Conflict

HttpError

Error
422 Unprocessable Entity

HttpError

Error

getPolicy

Code samples

# You can also use wget
curl -X GET https://localhost:8443/api/admin/{tid}/policies/{pid} \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://localhost:8443/api/admin/{tid}/policies/{pid} HTTP/1.1
Host: localhost:8443
Accept: application/json

var headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: 'https://localhost:8443/api/admin/{tid}/policies/{pid}',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

fetch('https://localhost:8443/api/admin/{tid}/policies/{pid}',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.get 'https://localhost:8443/api/admin/{tid}/policies/{pid}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://localhost:8443/api/admin/{tid}/policies/{pid}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://localhost:8443/api/admin/{tid}/policies/{pid}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {access-token}"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://localhost:8443/api/admin/{tid}/policies/{pid}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /api/admin/{tid}/policies/{pid}

Get policy.

Parameters

Name In Type Required Description
tid path string true Tenant id
pid path string true none

Example responses

200 Response

{
  "id": "1",
  "policy_name": "check_consent",
  "tenant_id": "default",
  "validators": [
    {
      "conf": {
        "property1": {},
        "property2": {}
      },
      "name": "identity-context",
      "recovery": [
        {
          "id": "string",
          "type": "string"
        }
      ]
    }
  ]
}

Responses

Status Meaning Description Schema
200 OK

Policy

Policy
401 Unauthorized

HttpError

Error
403 Forbidden

HttpError

Error
404 Not Found

HttpError

Error

updatePolicy

Code samples

# You can also use wget
curl -X PUT https://localhost:8443/api/admin/{tid}/policies/{pid} \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

PUT https://localhost:8443/api/admin/{tid}/policies/{pid} HTTP/1.1
Host: localhost:8443
Content-Type: application/json
Accept: application/json

var headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: 'https://localhost:8443/api/admin/{tid}/policies/{pid}',
  method: 'put',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');
const inputBody = '{
  "id": "1",
  "policy_name": "check_consent",
  "tenant_id": "default",
  "validators": [
    {
      "conf": {
        "property1": {},
        "property2": {}
      },
      "name": "identity-context",
      "recovery": [
        {
          "id": "string",
          "type": "string"
        }
      ]
    }
  ]
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

fetch('https://localhost:8443/api/admin/{tid}/policies/{pid}',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.put 'https://localhost:8443/api/admin/{tid}/policies/{pid}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.put('https://localhost:8443/api/admin/{tid}/policies/{pid}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://localhost:8443/api/admin/{tid}/policies/{pid}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PUT");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {access-token}"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "https://localhost:8443/api/admin/{tid}/policies/{pid}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

PUT /api/admin/{tid}/policies/{pid}

Update policy

Body parameter

{
  "id": "1",
  "policy_name": "check_consent",
  "tenant_id": "default",
  "validators": [
    {
      "conf": {
        "property1": {},
        "property2": {}
      },
      "name": "identity-context",
      "recovery": [
        {
          "id": "string",
          "type": "string"
        }
      ]
    }
  ]
}

Parameters

Name In Type Required Description
tid path string true Tenant id
pid path string true none
body body Policy false none

Example responses

201 Response

{
  "id": "1",
  "policy_name": "check_consent",
  "tenant_id": "default",
  "validators": [
    {
      "conf": {
        "property1": {},
        "property2": {}
      },
      "name": "identity-context",
      "recovery": [
        {
          "id": "string",
          "type": "string"
        }
      ]
    }
  ]
}

Responses

Status Meaning Description Schema
201 Created

Policy

Policy
401 Unauthorized

HttpError

Error
403 Forbidden

HttpError

Error
404 Not Found

HttpError

Error
409 Conflict

HttpError

Error
422 Unprocessable Entity

HttpError

Error

deletePolicy

Code samples

# You can also use wget
curl -X DELETE https://localhost:8443/api/admin/{tid}/policies/{pid} \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

DELETE https://localhost:8443/api/admin/{tid}/policies/{pid} HTTP/1.1
Host: localhost:8443
Accept: application/json

var headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: 'https://localhost:8443/api/admin/{tid}/policies/{pid}',
  method: 'delete',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

fetch('https://localhost:8443/api/admin/{tid}/policies/{pid}',
{
  method: 'DELETE',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.delete 'https://localhost:8443/api/admin/{tid}/policies/{pid}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.delete('https://localhost:8443/api/admin/{tid}/policies/{pid}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://localhost:8443/api/admin/{tid}/policies/{pid}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("DELETE");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {access-token}"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "https://localhost:8443/api/admin/{tid}/policies/{pid}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

DELETE /api/admin/{tid}/policies/{pid}

Delete policy.

A policy can't be removed if it's in use.

Parameters

Name In Type Required Description
tid path string true Tenant id
pid path string true none

Example responses

400 Response

{
  "details": {},
  "error": "string",
  "status_code": 0
}

Responses

Status Meaning Description Schema
204 No Content

Policy has been deleted

None
400 Bad Request

HttpError

Error
401 Unauthorized

HttpError

Error
403 Forbidden

HttpError

Error
404 Not Found

HttpError

Error

createScope

Code samples

# You can also use wget
curl -X POST https://localhost:8443/api/admin/{tid}/scopes \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

POST https://localhost:8443/api/admin/{tid}/scopes HTTP/1.1
Host: localhost:8443
Content-Type: application/json
Accept: application/json

var headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: 'https://localhost:8443/api/admin/{tid}/scopes',
  method: 'post',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');
const inputBody = '{
  "authorization_server_id": "default",
  "description": "This scope value requests offline access using refresh token",
  "developer_policy_id": "block",
  "display_name": "Offline Access",
  "id": "1",
  "name": "offline_access",
  "service_id": "1",
  "tenant_id": "default",
  "user_policy_id": "block"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

fetch('https://localhost:8443/api/admin/{tid}/scopes',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.post 'https://localhost:8443/api/admin/{tid}/scopes',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.post('https://localhost:8443/api/admin/{tid}/scopes', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://localhost:8443/api/admin/{tid}/scopes");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {access-token}"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://localhost:8443/api/admin/{tid}/scopes", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /api/admin/{tid}/scopes

Create scope

Scope name is required. If scope id is not provided, will be generated. If you want to assign scope to a service, provide service id.

Body parameter

{
  "authorization_server_id": "default",
  "description": "This scope value requests offline access using refresh token",
  "developer_policy_id": "block",
  "display_name": "Offline Access",
  "id": "1",
  "name": "offline_access",
  "service_id": "1",
  "tenant_id": "default",
  "user_policy_id": "block"
}

Parameters

Name In Type Required Description
tid path string true Tenant id
body body ScopeWithServiceID false none

Example responses

201 Response

{
  "authorization_server_id": "default",
  "description": "This scope value requests offline access using refresh token",
  "developer_policy_id": "block",
  "display_name": "Offline Access",
  "id": "1",
  "name": "offline_access",
  "tenant_id": "default",
  "user_policy_id": "block"
}

Responses

Status Meaning Description Schema
201 Created

Scope

Scope
400 Bad Request

HttpError

Error
401 Unauthorized

HttpError

Error
403 Forbidden

HttpError

Error
404 Not Found

HttpError

Error
409 Conflict

HttpError

Error
422 Unprocessable Entity

HttpError

Error

getScope

Code samples

# You can also use wget
curl -X GET https://localhost:8443/api/admin/{tid}/scopes/{scp} \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://localhost:8443/api/admin/{tid}/scopes/{scp} HTTP/1.1
Host: localhost:8443
Accept: application/json

var headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: 'https://localhost:8443/api/admin/{tid}/scopes/{scp}',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

fetch('https://localhost:8443/api/admin/{tid}/scopes/{scp}',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.get 'https://localhost:8443/api/admin/{tid}/scopes/{scp}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://localhost:8443/api/admin/{tid}/scopes/{scp}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://localhost:8443/api/admin/{tid}/scopes/{scp}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {access-token}"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://localhost:8443/api/admin/{tid}/scopes/{scp}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /api/admin/{tid}/scopes/{scp}

Get scope

Parameters

Name In Type Required Description
tid path string true Tenant id
scp path string true none

Example responses

200 Response

{
  "authorization_server_id": "default",
  "description": "This scope value requests offline access using refresh token",
  "developer_policy_id": "block",
  "display_name": "Offline Access",
  "id": "1",
  "name": "offline_access",
  "service": {
    "authorization_server_id": "default",
    "description": "Service description",
    "gateway_id": "string",
    "id": "1",
    "name": "Sample service",
    "tenant_id": "default",
    "with_specification": true
  },
  "tenant_id": "default",
  "user_policy_id": "block",
  "with_service": true
}

Responses

Status Meaning Description Schema
200 OK

ScopeWithService

ScopeWithService
401 Unauthorized

HttpError

Error
403 Forbidden

HttpError

Error
404 Not Found

HttpError

Error

updateScope

Code samples

# You can also use wget
curl -X PUT https://localhost:8443/api/admin/{tid}/scopes/{scp} \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

PUT https://localhost:8443/api/admin/{tid}/scopes/{scp} HTTP/1.1
Host: localhost:8443
Content-Type: application/json
Accept: application/json

var headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: 'https://localhost:8443/api/admin/{tid}/scopes/{scp}',
  method: 'put',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');
const inputBody = '{
  "authorization_server_id": "default",
  "description": "This scope value requests offline access using refresh token",
  "developer_policy_id": "block",
  "display_name": "Offline Access",
  "id": "1",
  "name": "offline_access",
  "tenant_id": "default",
  "user_policy_id": "block"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

fetch('https://localhost:8443/api/admin/{tid}/scopes/{scp}',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.put 'https://localhost:8443/api/admin/{tid}/scopes/{scp}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.put('https://localhost:8443/api/admin/{tid}/scopes/{scp}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://localhost:8443/api/admin/{tid}/scopes/{scp}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PUT");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {access-token}"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "https://localhost:8443/api/admin/{tid}/scopes/{scp}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

PUT /api/admin/{tid}/scopes/{scp}

Update scope

Body parameter

{
  "authorization_server_id": "default",
  "description": "This scope value requests offline access using refresh token",
  "developer_policy_id": "block",
  "display_name": "Offline Access",
  "id": "1",
  "name": "offline_access",
  "tenant_id": "default",
  "user_policy_id": "block"
}

Parameters

Name In Type Required Description
tid path string true Tenant id
scp path string true none
body body Scope false none

Example responses

200 Response

{
  "authorization_server_id": "default",
  "description": "This scope value requests offline access using refresh token",
  "developer_policy_id": "block",
  "display_name": "Offline Access",
  "id": "1",
  "name": "offline_access",
  "tenant_id": "default",
  "user_policy_id": "block"
}

Responses

Status Meaning Description Schema
200 OK

Scope

Scope
400 Bad Request

HttpError

Error
401 Unauthorized

HttpError

Error
403 Forbidden

HttpError

Error
404 Not Found

HttpError

Error
422 Unprocessable Entity

HttpError

Error

deleteScope

Code samples

# You can also use wget
curl -X DELETE https://localhost:8443/api/admin/{tid}/scopes/{scp} \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

DELETE https://localhost:8443/api/admin/{tid}/scopes/{scp} HTTP/1.1
Host: localhost:8443
Accept: application/json

var headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: 'https://localhost:8443/api/admin/{tid}/scopes/{scp}',
  method: 'delete',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

fetch('https://localhost:8443/api/admin/{tid}/scopes/{scp}',
{
  method: 'DELETE',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.delete 'https://localhost:8443/api/admin/{tid}/scopes/{scp}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.delete('https://localhost:8443/api/admin/{tid}/scopes/{scp}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://localhost:8443/api/admin/{tid}/scopes/{scp}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("DELETE");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {access-token}"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "https://localhost:8443/api/admin/{tid}/scopes/{scp}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

DELETE /api/admin/{tid}/scopes/{scp}

Delete scope

Parameters

Name In Type Required Description
tid path string true Tenant id
scp path string true none

Example responses

401 Response

{
  "details": {},
  "error": "string",
  "status_code": 0
}

Responses

Status Meaning Description Schema
204 No Content

Scope has been deleted

None
401 Unauthorized

HttpError

Error
403 Forbidden

HttpError

Error
404 Not Found

HttpError

Error

listAuthorizationServers

Code samples

# You can also use wget
curl -X GET https://localhost:8443/api/admin/{tid}/servers \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://localhost:8443/api/admin/{tid}/servers HTTP/1.1
Host: localhost:8443
Accept: application/json

var headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: 'https://localhost:8443/api/admin/{tid}/servers',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

fetch('https://localhost:8443/api/admin/{tid}/servers',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.get 'https://localhost:8443/api/admin/{tid}/servers',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://localhost:8443/api/admin/{tid}/servers', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://localhost:8443/api/admin/{tid}/servers");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {access-token}"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://localhost:8443/api/admin/{tid}/servers", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /api/admin/{tid}/servers

List authorization servers

Parameters

Name In Type Required Description
tid path string true Tenant id

Example responses

200 Response

{
  "servers": [
    {
      "access_token_ttl": "1h10m30s",
      "authentications": {
        "methods": [
          {
            "attributes": [
              {
                "description": "string",
                "name": "string"
              }
            ],
            "azure": {
              "client_id": "client",
              "client_secret": "secret",
              "fetch_groups": true,
              "get_user": true,
              "group_name_format": "id",
              "only_security_groups": true,
              "redirect_url": "https://example.com/callback",
              "scopes": [
                "email",
                "profile",
                "openid"
              ],
              "tenant": "123-312-123"
            },
            "cognito": {
              "client_id": "client",
              "client_secret": "secret",
              "get_user_info": true,
              "pool_id": "us-east-1_Q8WSOH11B",
              "redirect_url": "https://example.com/callback",
              "region": "us-east-1",
              "scopes": [
                "email",
                "profile",
                "openid"
              ]
            },
            "custom": {
              "login_url": "https://example.com/login"
            },
            "disabled": false,
            "id": "oidc",
            "mappings": [
              {
                "source": "access_token",
                "target": "."
              }
            ],
            "method": "string",
            "name": "OIDC",
            "oidc": {
              "client_id": "client",
              "client_secret": "secret",
              "get_user_info": true,
              "issuer_url": "string",
              "redirect_url": "https://example.com/callback",
              "scopes": [
                "email",
                "profile",
                "openid"
              ]
            },
            "static": {
              "hint": true,
              "users": [
                {
                  "authentication_context": {
                    "property1": {},
                    "property2": {}
                  },
                  "password": "secret",
                  "username": "peter"
                }
              ]
            }
          }
        ]
      },
      "authorization_code_ttl": "10m0s",
      "cookie_max_age": "1h10m30s",
      "developer_policy_id": "string",
      "enable_dynamic_client_registration": false,
      "enforce_pkce": false,
      "grant_types": [
        "authorization_code",
        "implicit",
        "refresh_token",
        "client_credentials"
      ],
      "id": "935ab21c-b20a-11e9-a2a3-2a2ae2dbcce4",
      "id_token_ttl": "1h10m30s",
      "issuer_url": "http://example.com/default/default",
      "jwks": {
        "keys": []
      },
      "key_type": "rsa",
      "logo_uri": "string",
      "name": "Sample authorization server",
      "profiles": [
        "fapi_rw"
      ],
      "refresh_token_ttl": "720h0m0s",
      "rotated_secrets": [
        "jFpwIvuKJP46J71WqszPv1SrzoUr-cSILP9EPdlClB4"
      ],
      "secret": "hW5WhKX_7w7BLwUQ6mn7Cp70_OoKI_F1y1hLS5U8lIU",
      "system": false,
      "tenant_id": "string",
      "user_policy_id": "string"
    }
  ]
}

Responses

Status Meaning Description Schema
200 OK

Servers

Servers
401 Unauthorized

HttpError

Error
403 Forbidden

HttpError

Error
404 Not Found

HttpError

Error

createAuthorizationServer

Code samples

# You can also use wget
curl -X POST https://localhost:8443/api/admin/{tid}/servers \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

POST https://localhost:8443/api/admin/{tid}/servers HTTP/1.1
Host: localhost:8443
Content-Type: application/json
Accept: application/json

var headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: 'https://localhost:8443/api/admin/{tid}/servers',
  method: 'post',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');
const inputBody = '{
  "access_token_ttl": "1h10m30s",
  "authentications": {
    "methods": [
      {
        "attributes": [
          {
            "description": "string",
            "name": "string"
          }
        ],
        "azure": {
          "client_id": "client",
          "client_secret": "secret",
          "fetch_groups": true,
          "get_user": true,
          "group_name_format": "id",
          "only_security_groups": true,
          "redirect_url": "https://example.com/callback",
          "scopes": [
            "email",
            "profile",
            "openid"
          ],
          "tenant": "123-312-123"
        },
        "cognito": {
          "client_id": "client",
          "client_secret": "secret",
          "get_user_info": true,
          "pool_id": "us-east-1_Q8WSOH11B",
          "redirect_url": "https://example.com/callback",
          "region": "us-east-1",
          "scopes": [
            "email",
            "profile",
            "openid"
          ]
        },
        "custom": {
          "login_url": "https://example.com/login"
        },
        "disabled": false,
        "id": "oidc",
        "mappings": [
          {
            "source": "access_token",
            "target": "."
          }
        ],
        "method": "string",
        "name": "OIDC",
        "oidc": {
          "client_id": "client",
          "client_secret": "secret",
          "get_user_info": true,
          "issuer_url": "string",
          "redirect_url": "https://example.com/callback",
          "scopes": [
            "email",
            "profile",
            "openid"
          ]
        },
        "static": {
          "hint": true,
          "users": [
            {
              "authentication_context": {
                "property1": {},
                "property2": {}
              },
              "password": "secret",
              "username": "peter"
            }
          ]
        }
      }
    ]
  },
  "authorization_code_ttl": "10m0s",
  "cookie_max_age": "1h10m30s",
  "developer_policy_id": "string",
  "enable_dynamic_client_registration": false,
  "enforce_pkce": false,
  "grant_types": [
    "authorization_code",
    "implicit",
    "refresh_token",
    "client_credentials"
  ],
  "id": "935ab21c-b20a-11e9-a2a3-2a2ae2dbcce4",
  "id_token_ttl": "1h10m30s",
  "issuer_url": "http://example.com/default/default",
  "jwks": {
    "keys": []
  },
  "key_type": "rsa",
  "logo_uri": "string",
  "name": "Sample authorization server",
  "profiles": [
    "fapi_rw"
  ],
  "refresh_token_ttl": "720h0m0s",
  "rotated_secrets": [
    "jFpwIvuKJP46J71WqszPv1SrzoUr-cSILP9EPdlClB4"
  ],
  "secret": "hW5WhKX_7w7BLwUQ6mn7Cp70_OoKI_F1y1hLS5U8lIU",
  "system": false,
  "tenant_id": "string",
  "user_policy_id": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

fetch('https://localhost:8443/api/admin/{tid}/servers',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.post 'https://localhost:8443/api/admin/{tid}/servers',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.post('https://localhost:8443/api/admin/{tid}/servers', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://localhost:8443/api/admin/{tid}/servers");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {access-token}"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://localhost:8443/api/admin/{tid}/servers", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /api/admin/{tid}/servers

Create authorization server

Multiple authorization servers with unique id can be created within a tenant. If id and secret are not provided, will be generated. Secret if provided must have at least 32 characters.

You can set what grant types will be supported by authorization server. The defaults are: {"grant_types": ["authorization_code", "implicit", "client_credentials", "refresh_token"]}

If jwks keys are not provided explicitly, will be generated based on provided key_type algorithm (rsa by default).

TTLs for tokens and authorization code can be customized. The defaults are:

authorization_code_ttl - 10 minutes access_token_ttl - 1 hour id_token_ttl - 1 hour refresh_token_ttl - 30 days

If you want to enable dynamic client registration set {"enable_dynamic_client_registration": true}.

If you want to create FAPI read write compliant server set: {"profiles"": ["fapi_rw"]}.

If you want to enforce PKCE set {"enforce_pkce": true}.

Body parameter

{
  "access_token_ttl": "1h10m30s",
  "authentications": {
    "methods": [
      {
        "attributes": [
          {
            "description": "string",
            "name": "string"
          }
        ],
        "azure": {
          "client_id": "client",
          "client_secret": "secret",
          "fetch_groups": true,
          "get_user": true,
          "group_name_format": "id",
          "only_security_groups": true,
          "redirect_url": "https://example.com/callback",
          "scopes": [
            "email",
            "profile",
            "openid"
          ],
          "tenant": "123-312-123"
        },
        "cognito": {
          "client_id": "client",
          "client_secret": "secret",
          "get_user_info": true,
          "pool_id": "us-east-1_Q8WSOH11B",
          "redirect_url": "https://example.com/callback",
          "region": "us-east-1",
          "scopes": [
            "email",
            "profile",
            "openid"
          ]
        },
        "custom": {
          "login_url": "https://example.com/login"
        },
        "disabled": false,
        "id": "oidc",
        "mappings": [
          {
            "source": "access_token",
            "target": "."
          }
        ],
        "method": "string",
        "name": "OIDC",
        "oidc": {
          "client_id": "client",
          "client_secret": "secret",
          "get_user_info": true,
          "issuer_url": "string",
          "redirect_url": "https://example.com/callback",
          "scopes": [
            "email",
            "profile",
            "openid"
          ]
        },
        "static": {
          "hint": true,
          "users": [
            {
              "authentication_context": {
                "property1": {},
                "property2": {}
              },
              "password": "secret",
              "username": "peter"
            }
          ]
        }
      }
    ]
  },
  "authorization_code_ttl": "10m0s",
  "cookie_max_age": "1h10m30s",
  "developer_policy_id": "string",
  "enable_dynamic_client_registration": false,
  "enforce_pkce": false,
  "grant_types": [
    "authorization_code",
    "implicit",
    "refresh_token",
    "client_credentials"
  ],
  "id": "935ab21c-b20a-11e9-a2a3-2a2ae2dbcce4",
  "id_token_ttl": "1h10m30s",
  "issuer_url": "http://example.com/default/default",
  "jwks": {
    "keys": []
  },
  "key_type": "rsa",
  "logo_uri": "string",
  "name": "Sample authorization server",
  "profiles": [
    "fapi_rw"
  ],
  "refresh_token_ttl": "720h0m0s",
  "rotated_secrets": [
    "jFpwIvuKJP46J71WqszPv1SrzoUr-cSILP9EPdlClB4"
  ],
  "secret": "hW5WhKX_7w7BLwUQ6mn7Cp70_OoKI_F1y1hLS5U8lIU",
  "system": false,
  "tenant_id": "string",
  "user_policy_id": "string"
}

Parameters

Name In Type Required Description
tid path string true Tenant id
body body Server false none

Example responses

201 Response

{
  "access_token_ttl": "1h10m30s",
  "authentications": {
    "methods": [
      {
        "attributes": [
          {
            "description": "string",
            "name": "string"
          }
        ],
        "azure": {
          "client_id": "client",
          "client_secret": "secret",
          "fetch_groups": true,
          "get_user": true,
          "group_name_format": "id",
          "only_security_groups": true,
          "redirect_url": "https://example.com/callback",
          "scopes": [
            "email",
            "profile",
            "openid"
          ],
          "tenant": "123-312-123"
        },
        "cognito": {
          "client_id": "client",
          "client_secret": "secret",
          "get_user_info": true,
          "pool_id": "us-east-1_Q8WSOH11B",
          "redirect_url": "https://example.com/callback",
          "region": "us-east-1",
          "scopes": [
            "email",
            "profile",
            "openid"
          ]
        },
        "custom": {
          "login_url": "https://example.com/login"
        },
        "disabled": false,
        "id": "oidc",
        "mappings": [
          {
            "source": "access_token",
            "target": "."
          }
        ],
        "method": "string",
        "name": "OIDC",
        "oidc": {
          "client_id": "client",
          "client_secret": "secret",
          "get_user_info": true,
          "issuer_url": "string",
          "redirect_url": "https://example.com/callback",
          "scopes": [
            "email",
            "profile",
            "openid"
          ]
        },
        "static": {
          "hint": true,
          "users": [
            {
              "authentication_context": {
                "property1": {},
                "property2": {}
              },
              "password": "secret",
              "username": "peter"
            }
          ]
        }
      }
    ]
  },
  "authorization_code_ttl": "10m0s",
  "cookie_max_age": "1h10m30s",
  "developer_policy_id": "string",
  "enable_dynamic_client_registration": false,
  "enforce_pkce": false,
  "grant_types": [
    "authorization_code",
    "implicit",
    "refresh_token",
    "client_credentials"
  ],
  "id": "935ab21c-b20a-11e9-a2a3-2a2ae2dbcce4",
  "id_token_ttl": "1h10m30s",
  "issuer_url": "http://example.com/default/default",
  "jwks": {
    "keys": []
  },
  "key_type": "rsa",
  "logo_uri": "string",
  "name": "Sample authorization server",
  "profiles": [
    "fapi_rw"
  ],
  "refresh_token_ttl": "720h0m0s",
  "rotated_secrets": [
    "jFpwIvuKJP46J71WqszPv1SrzoUr-cSILP9EPdlClB4"
  ],
  "secret": "hW5WhKX_7w7BLwUQ6mn7Cp70_OoKI_F1y1hLS5U8lIU",
  "system": false,
  "tenant_id": "string",
  "user_policy_id": "string"
}

Responses

Status Meaning Description Schema
201 Created

Server

Server
400 Bad Request

HttpError

Error
401 Unauthorized

HttpError

Error
403 Forbidden

HttpError

Error
404 Not Found

HttpError

Error
409 Conflict

HttpError

Error
422 Unprocessable Entity

HttpError

Error

getAuthorizationServer

Code samples

# You can also use wget
curl -X GET https://localhost:8443/api/admin/{tid}/servers/{aid} \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://localhost:8443/api/admin/{tid}/servers/{aid} HTTP/1.1
Host: localhost:8443
Accept: application/json

var headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: 'https://localhost:8443/api/admin/{tid}/servers/{aid}',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

fetch('https://localhost:8443/api/admin/{tid}/servers/{aid}',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.get 'https://localhost:8443/api/admin/{tid}/servers/{aid}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://localhost:8443/api/admin/{tid}/servers/{aid}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://localhost:8443/api/admin/{tid}/servers/{aid}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {access-token}"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://localhost:8443/api/admin/{tid}/servers/{aid}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /api/admin/{tid}/servers/{aid}

Get authorization server

Parameters

Name In Type Required Description
tid path string true Tenant id
aid path string true Authorization server id

Example responses

200 Response

{
  "access_token_ttl": "1h10m30s",
  "authentications": {
    "methods": [
      {
        "attributes": [
          {
            "description": "string",
            "name": "string"
          }
        ],
        "azure": {
          "client_id": "client",
          "client_secret": "secret",
          "fetch_groups": true,
          "get_user": true,
          "group_name_format": "id",
          "only_security_groups": true,
          "redirect_url": "https://example.com/callback",
          "scopes": [
            "email",
            "profile",
            "openid"
          ],
          "tenant": "123-312-123"
        },
        "cognito": {
          "client_id": "client",
          "client_secret": "secret",
          "get_user_info": true,
          "pool_id": "us-east-1_Q8WSOH11B",
          "redirect_url": "https://example.com/callback",
          "region": "us-east-1",
          "scopes": [
            "email",
            "profile",
            "openid"
          ]
        },
        "custom": {
          "login_url": "https://example.com/login"
        },
        "disabled": false,
        "id": "oidc",
        "mappings": [
          {
            "source": "access_token",
            "target": "."
          }
        ],
        "method": "string",
        "name": "OIDC",
        "oidc": {
          "client_id": "client",
          "client_secret": "secret",
          "get_user_info": true,
          "issuer_url": "string",
          "redirect_url": "https://example.com/callback",
          "scopes": [
            "email",
            "profile",
            "openid"
          ]
        },
        "static": {
          "hint": true,
          "users": [
            {
              "authentication_context": {
                "property1": {},
                "property2": {}
              },
              "password": "secret",
              "username": "peter"
            }
          ]
        }
      }
    ]
  },
  "authorization_code_ttl": "10m0s",
  "cookie_max_age": "1h10m30s",
  "developer_policy_id": "string",
  "enable_dynamic_client_registration": false,
  "enforce_pkce": false,
  "grant_types": [
    "authorization_code",
    "implicit",
    "refresh_token",
    "client_credentials"
  ],
  "id": "935ab21c-b20a-11e9-a2a3-2a2ae2dbcce4",
  "id_token_ttl": "1h10m30s",
  "issuer_url": "http://example.com/default/default",
  "jwks": {
    "keys": []
  },
  "key_type": "rsa",
  "logo_uri": "string",
  "name": "Sample authorization server",
  "profiles": [
    "fapi_rw"
  ],
  "refresh_token_ttl": "720h0m0s",
  "rotated_secrets": [
    "jFpwIvuKJP46J71WqszPv1SrzoUr-cSILP9EPdlClB4"
  ],
  "secret": "hW5WhKX_7w7BLwUQ6mn7Cp70_OoKI_F1y1hLS5U8lIU",
  "system": false,
  "tenant_id": "string",
  "user_policy_id": "string"
}

Responses

Status Meaning Description Schema
200 OK

Server

Server
401 Unauthorized

HttpError

Error
403 Forbidden

HttpError

Error
404 Not Found

HttpError

Error

updateAuthorizationServer

Code samples

# You can also use wget
curl -X PUT https://localhost:8443/api/admin/{tid}/servers/{aid} \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

PUT https://localhost:8443/api/admin/{tid}/servers/{aid} HTTP/1.1
Host: localhost:8443
Content-Type: application/json
Accept: application/json

var headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: 'https://localhost:8443/api/admin/{tid}/servers/{aid}',
  method: 'put',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');
const inputBody = '{
  "access_token_ttl": "1h10m30s",
  "authentications": {
    "methods": [
      {
        "attributes": [
          {
            "description": "string",
            "name": "string"
          }
        ],
        "azure": {
          "client_id": "client",
          "client_secret": "secret",
          "fetch_groups": true,
          "get_user": true,
          "group_name_format": "id",
          "only_security_groups": true,
          "redirect_url": "https://example.com/callback",
          "scopes": [
            "email",
            "profile",
            "openid"
          ],
          "tenant": "123-312-123"
        },
        "cognito": {
          "client_id": "client",
          "client_secret": "secret",
          "get_user_info": true,
          "pool_id": "us-east-1_Q8WSOH11B",
          "redirect_url": "https://example.com/callback",
          "region": "us-east-1",
          "scopes": [
            "email",
            "profile",
            "openid"
          ]
        },
        "custom": {
          "login_url": "https://example.com/login"
        },
        "disabled": false,
        "id": "oidc",
        "mappings": [
          {
            "source": "access_token",
            "target": "."
          }
        ],
        "method": "string",
        "name": "OIDC",
        "oidc": {
          "client_id": "client",
          "client_secret": "secret",
          "get_user_info": true,
          "issuer_url": "string",
          "redirect_url": "https://example.com/callback",
          "scopes": [
            "email",
            "profile",
            "openid"
          ]
        },
        "static": {
          "hint": true,
          "users": [
            {
              "authentication_context": {
                "property1": {},
                "property2": {}
              },
              "password": "secret",
              "username": "peter"
            }
          ]
        }
      }
    ]
  },
  "authorization_code_ttl": "10m0s",
  "cookie_max_age": "1h10m30s",
  "developer_policy_id": "string",
  "enable_dynamic_client_registration": false,
  "enforce_pkce": false,
  "grant_types": [
    "authorization_code",
    "implicit",
    "refresh_token",
    "client_credentials"
  ],
  "id": "935ab21c-b20a-11e9-a2a3-2a2ae2dbcce4",
  "id_token_ttl": "1h10m30s",
  "issuer_url": "http://example.com/default/default",
  "jwks": {
    "keys": []
  },
  "key_type": "rsa",
  "logo_uri": "string",
  "name": "Sample authorization server",
  "profiles": [
    "fapi_rw"
  ],
  "refresh_token_ttl": "720h0m0s",
  "rotated_secrets": [
    "jFpwIvuKJP46J71WqszPv1SrzoUr-cSILP9EPdlClB4"
  ],
  "secret": "hW5WhKX_7w7BLwUQ6mn7Cp70_OoKI_F1y1hLS5U8lIU",
  "system": false,
  "tenant_id": "string",
  "user_policy_id": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

fetch('https://localhost:8443/api/admin/{tid}/servers/{aid}',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.put 'https://localhost:8443/api/admin/{tid}/servers/{aid}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.put('https://localhost:8443/api/admin/{tid}/servers/{aid}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://localhost:8443/api/admin/{tid}/servers/{aid}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PUT");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {access-token}"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "https://localhost:8443/api/admin/{tid}/servers/{aid}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

PUT /api/admin/{tid}/servers/{aid}

Update authorization server

Body parameter

{
  "access_token_ttl": "1h10m30s",
  "authentications": {
    "methods": [
      {
        "attributes": [
          {
            "description": "string",
            "name": "string"
          }
        ],
        "azure": {
          "client_id": "client",
          "client_secret": "secret",
          "fetch_groups": true,
          "get_user": true,
          "group_name_format": "id",
          "only_security_groups": true,
          "redirect_url": "https://example.com/callback",
          "scopes": [
            "email",
            "profile",
            "openid"
          ],
          "tenant": "123-312-123"
        },
        "cognito": {
          "client_id": "client",
          "client_secret": "secret",
          "get_user_info": true,
          "pool_id": "us-east-1_Q8WSOH11B",
          "redirect_url": "https://example.com/callback",
          "region": "us-east-1",
          "scopes": [
            "email",
            "profile",
            "openid"
          ]
        },
        "custom": {
          "login_url": "https://example.com/login"
        },
        "disabled": false,
        "id": "oidc",
        "mappings": [
          {
            "source": "access_token",
            "target": "."
          }
        ],
        "method": "string",
        "name": "OIDC",
        "oidc": {
          "client_id": "client",
          "client_secret": "secret",
          "get_user_info": true,
          "issuer_url": "string",
          "redirect_url": "https://example.com/callback",
          "scopes": [
            "email",
            "profile",
            "openid"
          ]
        },
        "static": {
          "hint": true,
          "users": [
            {
              "authentication_context": {
                "property1": {},
                "property2": {}
              },
              "password": "secret",
              "username": "peter"
            }
          ]
        }
      }
    ]
  },
  "authorization_code_ttl": "10m0s",
  "cookie_max_age": "1h10m30s",
  "developer_policy_id": "string",
  "enable_dynamic_client_registration": false,
  "enforce_pkce": false,
  "grant_types": [
    "authorization_code",
    "implicit",
    "refresh_token",
    "client_credentials"
  ],
  "id": "935ab21c-b20a-11e9-a2a3-2a2ae2dbcce4",
  "id_token_ttl": "1h10m30s",
  "issuer_url": "http://example.com/default/default",
  "jwks": {
    "keys": []
  },
  "key_type": "rsa",
  "logo_uri": "string",
  "name": "Sample authorization server",
  "profiles": [
    "fapi_rw"
  ],
  "refresh_token_ttl": "720h0m0s",
  "rotated_secrets": [
    "jFpwIvuKJP46J71WqszPv1SrzoUr-cSILP9EPdlClB4"
  ],
  "secret": "hW5WhKX_7w7BLwUQ6mn7Cp70_OoKI_F1y1hLS5U8lIU",
  "system": false,
  "tenant_id": "string",
  "user_policy_id": "string"
}

Parameters

Name In Type Required Description
tid path string true Tenant id
aid path string true Authorization server id
body body Server false none

Example responses

200 Response

{
  "access_token_ttl": "1h10m30s",
  "authentications": {
    "methods": [
      {
        "attributes": [
          {
            "description": "string",
            "name": "string"
          }
        ],
        "azure": {
          "client_id": "client",
          "client_secret": "secret",
          "fetch_groups": true,
          "get_user": true,
          "group_name_format": "id",
          "only_security_groups": true,
          "redirect_url": "https://example.com/callback",
          "scopes": [
            "email",
            "profile",
            "openid"
          ],
          "tenant": "123-312-123"
        },
        "cognito": {
          "client_id": "client",
          "client_secret": "secret",
          "get_user_info": true,
          "pool_id": "us-east-1_Q8WSOH11B",
          "redirect_url": "https://example.com/callback",
          "region": "us-east-1",
          "scopes": [
            "email",
            "profile",
            "openid"
          ]
        },
        "custom": {
          "login_url": "https://example.com/login"
        },
        "disabled": false,
        "id": "oidc",
        "mappings": [
          {
            "source": "access_token",
            "target": "."
          }
        ],
        "method": "string",
        "name": "OIDC",
        "oidc": {
          "client_id": "client",
          "client_secret": "secret",
          "get_user_info": true,
          "issuer_url": "string",
          "redirect_url": "https://example.com/callback",
          "scopes": [
            "email",
            "profile",
            "openid"
          ]
        },
        "static": {
          "hint": true,
          "users": [
            {
              "authentication_context": {
                "property1": {},
                "property2": {}
              },
              "password": "secret",
              "username": "peter"
            }
          ]
        }
      }
    ]
  },
  "authorization_code_ttl": "10m0s",
  "cookie_max_age": "1h10m30s",
  "developer_policy_id": "string",
  "enable_dynamic_client_registration": false,
  "enforce_pkce": false,
  "grant_types": [
    "authorization_code",
    "implicit",
    "refresh_token",
    "client_credentials"
  ],
  "id": "935ab21c-b20a-11e9-a2a3-2a2ae2dbcce4",
  "id_token_ttl": "1h10m30s",
  "issuer_url": "http://example.com/default/default",
  "jwks": {
    "keys": []
  },
  "key_type": "rsa",
  "logo_uri": "string",
  "name": "Sample authorization server",
  "profiles": [
    "fapi_rw"
  ],
  "refresh_token_ttl": "720h0m0s",
  "rotated_secrets": [
    "jFpwIvuKJP46J71WqszPv1SrzoUr-cSILP9EPdlClB4"
  ],
  "secret": "hW5WhKX_7w7BLwUQ6mn7Cp70_OoKI_F1y1hLS5U8lIU",
  "system": false,
  "tenant_id": "string",
  "user_policy_id": "string"
}

Responses

Status Meaning Description Schema
200 OK

Server

Server
400 Bad Request

HttpError

Error
401 Unauthorized

HttpError

Error
403 Forbidden

HttpError

Error
404 Not Found

HttpError

Error
422 Unprocessable Entity

HttpError

Error

deleteAuthorizationServer

Code samples

# You can also use wget
curl -X DELETE https://localhost:8443/api/admin/{tid}/servers/{aid} \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

DELETE https://localhost:8443/api/admin/{tid}/servers/{aid} HTTP/1.1
Host: localhost:8443
Accept: application/json

var headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: 'https://localhost:8443/api/admin/{tid}/servers/{aid}',
  method: 'delete',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

fetch('https://localhost:8443/api/admin/{tid}/servers/{aid}',
{
  method: 'DELETE',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.delete 'https://localhost:8443/api/admin/{tid}/servers/{aid}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.delete('https://localhost:8443/api/admin/{tid}/servers/{aid}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://localhost:8443/api/admin/{tid}/servers/{aid}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("DELETE");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {access-token}"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "https://localhost:8443/api/admin/{tid}/servers/{aid}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

DELETE /api/admin/{tid}/servers/{aid}

Delete authorization server

Parameters

Name In Type Required Description
tid path string true Tenant id
aid path string true Authorization server id

Example responses

400 Response

{
  "details": {},
  "error": "string",
  "status_code": 0
}

Responses

Status Meaning Description Schema
204 No Content

Authorization server has been deleted

None
400 Bad Request

HttpError

Error
401 Unauthorized

HttpError

Error
403 Forbidden

HttpError

Error
404 Not Found

HttpError

Error

listAPIsByServer

Code samples

# You can also use wget
curl -X GET https://localhost:8443/api/admin/{tid}/servers/{aid}/apis \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://localhost:8443/api/admin/{tid}/servers/{aid}/apis HTTP/1.1
Host: localhost:8443
Accept: application/json

var headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: 'https://localhost:8443/api/admin/{tid}/servers/{aid}/apis',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

fetch('https://localhost:8443/api/admin/{tid}/servers/{aid}/apis',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.get 'https://localhost:8443/api/admin/{tid}/servers/{aid}/apis',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://localhost:8443/api/admin/{tid}/servers/{aid}/apis', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://localhost:8443/api/admin/{tid}/servers/{aid}/apis");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {access-token}"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://localhost:8443/api/admin/{tid}/servers/{aid}/apis", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /api/admin/{tid}/servers/{aid}/apis

List API

Parameters

Name In Type Required Description
tid path string true Tenant id
aid path string true Server id
without_data_classifications query boolean false List apis that have no data classifications
data_classification query array[string] false List apis that have given data classifications

Example responses

200 Response

{
  "apis_by_services": {
    "property1": [
      {
        "can_have_policy": true,
        "data_classifications": [
          "string"
        ],
        "id": "1",
        "method": "GET",
        "path": "/pets",
        "policy_id": "block",
        "position": 1,
        "server_id": "default",
        "service_id": "1",
        "tenant_id": "default"
      }
    ],
    "property2": [
      {
        "can_have_policy": true,
        "data_classifications": [
          "string"
        ],
        "id": "1",
        "method": "GET",
        "path": "/pets",
        "policy_id": "block",
        "position": 1,
        "server_id": "default",
        "service_id": "1",
        "tenant_id": "default"
      }
    ]
  }
}

Responses

Status Meaning Description Schema
200 OK

ServerAPIs

ServerAPIs
401 Unauthorized

HttpError

Error
403 Forbidden

HttpError

Error

updateAuthentications

Code samples

# You can also use wget
curl -X PUT https://localhost:8443/api/admin/{tid}/servers/{aid}/authentications \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

PUT https://localhost:8443/api/admin/{tid}/servers/{aid}/authentications HTTP/1.1
Host: localhost:8443
Content-Type: application/json
Accept: application/json

var headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: 'https://localhost:8443/api/admin/{tid}/servers/{aid}/authentications',
  method: 'put',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');
const inputBody = '{
  "methods": [
    {
      "attributes": [
        {
          "description": "string",
          "name": "string"
        }
      ],
      "azure": {
        "client_id": "client",
        "client_secret": "secret",
        "fetch_groups": true,
        "get_user": true,
        "group_name_format": "id",
        "only_security_groups": true,
        "redirect_url": "https://example.com/callback",
        "scopes": [
          "email",
          "profile",
          "openid"
        ],
        "tenant": "123-312-123"
      },
      "cognito": {
        "client_id": "client",
        "client_secret": "secret",
        "get_user_info": true,
        "pool_id": "us-east-1_Q8WSOH11B",
        "redirect_url": "https://example.com/callback",
        "region": "us-east-1",
        "scopes": [
          "email",
          "profile",
          "openid"
        ]
      },
      "custom": {
        "login_url": "https://example.com/login"
      },
      "disabled": false,
      "id": "oidc",
      "mappings": [
        {
          "source": "access_token",
          "target": "."
        }
      ],
      "method": "string",
      "name": "OIDC",
      "oidc": {
        "client_id": "client",
        "client_secret": "secret",
        "get_user_info": true,
        "issuer_url": "string",
        "redirect_url": "https://example.com/callback",
        "scopes": [
          "email",
          "profile",
          "openid"
        ]
      },
      "static": {
        "hint": true,
        "users": [
          {
            "authentication_context": {
              "property1": {},
              "property2": {}
            },
            "password": "secret",
            "username": "peter"
          }
        ]
      }
    }
  ]
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

fetch('https://localhost:8443/api/admin/{tid}/servers/{aid}/authentications',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.put 'https://localhost:8443/api/admin/{tid}/servers/{aid}/authentications',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.put('https://localhost:8443/api/admin/{tid}/servers/{aid}/authentications', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://localhost:8443/api/admin/{tid}/servers/{aid}/authentications");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PUT");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {access-token}"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "https://localhost:8443/api/admin/{tid}/servers/{aid}/authentications", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

PUT /api/admin/{tid}/servers/{aid}/authentications

Update authentications.

Multiple authentication methods can be set per authorization server. If more than one authentication method is defined, user will have an option to choose what method to use. In case of one authentication method, user will be redirected to login page automatically. See Authentication body parameter for more details.

Body parameter

{
  "methods": [
    {
      "attributes": [
        {
          "description": "string",
          "name": "string"
        }
      ],
      "azure": {
        "client_id": "client",
        "client_secret": "secret",
        "fetch_groups": true,
        "get_user": true,
        "group_name_format": "id",
        "only_security_groups": true,
        "redirect_url": "https://example.com/callback",
        "scopes": [
          "email",
          "profile",
          "openid"
        ],
        "tenant": "123-312-123"
      },
      "cognito": {
        "client_id": "client",
        "client_secret": "secret",
        "get_user_info": true,
        "pool_id": "us-east-1_Q8WSOH11B",
        "redirect_url": "https://example.com/callback",
        "region": "us-east-1",
        "scopes": [
          "email",
          "profile",
          "openid"
        ]
      },
      "custom": {
        "login_url": "https://example.com/login"
      },
      "disabled": false,
      "id": "oidc",
      "mappings": [
        {
          "source": "access_token",
          "target": "."
        }
      ],
      "method": "string",
      "name": "OIDC",
      "oidc": {
        "client_id": "client",
        "client_secret": "secret",
        "get_user_info": true,
        "issuer_url": "string",
        "redirect_url": "https://example.com/callback",
        "scopes": [
          "email",
          "profile",
          "openid"
        ]
      },
      "static": {
        "hint": true,
        "users": [
          {
            "authentication_context": {
              "property1": {},
              "property2": {}
            },
            "password": "secret",
            "username": "peter"
          }
        ]
      }
    }
  ]
}

Parameters

Name In Type Required Description
tid path string true Tenant id
aid path string true Authorization server id
body body Authentications false none

Example responses

200 Response

{
  "methods": [
    {
      "attributes": [
        {
          "description": "string",
          "name": "string"
        }
      ],
      "azure": {
        "client_id": "client",
        "client_secret": "secret",
        "fetch_groups": true,
        "get_user": true,
        "group_name_format": "id",
        "only_security_groups": true,
        "redirect_url": "https://example.com/callback",
        "scopes": [
          "email",
          "profile",
          "openid"
        ],
        "tenant": "123-312-123"
      },
      "cognito": {
        "client_id": "client",
        "client_secret": "secret",
        "get_user_info": true,
        "pool_id": "us-east-1_Q8WSOH11B",
        "redirect_url": "https://example.com/callback",
        "region": "us-east-1",
        "scopes": [
          "email",
          "profile",
          "openid"
        ]
      },
      "custom": {
        "login_url": "https://example.com/login"
      },
      "disabled": false,
      "id": "oidc",
      "mappings": [
        {
          "source": "access_token",
          "target": "."
        }
      ],
      "method": "string",
      "name": "OIDC",
      "oidc": {
        "client_id": "client",
        "client_secret": "secret",
        "get_user_info": true,
        "issuer_url": "string",
        "redirect_url": "https://example.com/callback",
        "scopes": [
          "email",
          "profile",
          "openid"
        ]
      },
      "static": {
        "hint": true,
        "users": [
          {
            "authentication_context": {
              "property1": {},
              "property2": {}
            },
            "password": "secret",
            "username": "peter"
          }
        ]
      }
    }
  ]
}

Responses

Status Meaning Description Schema
200 OK

Authentications

Authentications
400 Bad Request

HttpError

Error
401 Unauthorized

HttpError

Error
403 Forbidden

HttpError

Error
404 Not Found

HttpError

Error
422 Unprocessable Entity

HttpError

Error

listClaims

Code samples

# You can also use wget
curl -X GET https://localhost:8443/api/admin/{tid}/servers/{aid}/claims \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://localhost:8443/api/admin/{tid}/servers/{aid}/claims HTTP/1.1
Host: localhost:8443
Accept: application/json

var headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: 'https://localhost:8443/api/admin/{tid}/servers/{aid}/claims',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

fetch('https://localhost:8443/api/admin/{tid}/servers/{aid}/claims',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.get 'https://localhost:8443/api/admin/{tid}/servers/{aid}/claims',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://localhost:8443/api/admin/{tid}/servers/{aid}/claims', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://localhost:8443/api/admin/{tid}/servers/{aid}/claims");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {access-token}"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://localhost:8443/api/admin/{tid}/servers/{aid}/claims", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /api/admin/{tid}/servers/{aid}/claims

List claims

Parameters

Name In Type Required Description
tid path string true Tenant id
aid path string true Authorization server id

Example responses

200 Response

{
  "claims": [
    {
      "authorization_server_id": "default",
      "id": "1",
      "mapping": "email",
      "name": "email",
      "scopes": [
        "email",
        "email_verified"
      ],
      "tenant_id": "default",
      "type": "string"
    }
  ]
}

Responses

Status Meaning Description Schema
200 OK

Claims

Claims
401 Unauthorized

HttpError

Error
403 Forbidden

HttpError

Error

listClients

Code samples

# You can also use wget
curl -X GET https://localhost:8443/api/admin/{tid}/servers/{aid}/clients \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://localhost:8443/api/admin/{tid}/servers/{aid}/clients HTTP/1.1
Host: localhost:8443
Accept: application/json

var headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: 'https://localhost:8443/api/admin/{tid}/servers/{aid}/clients',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

fetch('https://localhost:8443/api/admin/{tid}/servers/{aid}/clients',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.get 'https://localhost:8443/api/admin/{tid}/servers/{aid}/clients',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://localhost:8443/api/admin/{tid}/servers/{aid}/clients', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://localhost:8443/api/admin/{tid}/servers/{aid}/clients");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {access-token}"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://localhost:8443/api/admin/{tid}/servers/{aid}/clients", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /api/admin/{tid}/servers/{aid}/clients

List clients

Returns clients created by admins and developers. If client has been created by a developer, client secret will be empty.

Parameters

Name In Type Required Description
tid path string true Tenant id
aid path string true Authorization server id

Example responses

200 Response

{
  "clients": [
    {
      "audience": [
        "string"
      ],
      "authorization_server_id": "default",
      "client_hashed_secret": "string",
      "client_id": "string",
      "client_id_issued_at": 0,
      "client_name": "My app",
      "client_secret": "string",
      "client_secret_expires_at": 0,
      "client_uri": "string",
      "description": "string",
      "developer_id": "string",
      "grant_types": [
        "password",
        "refresh_token",
        "client_credentials",
        "implicit",
        "authorization_code"
      ],
      "jwks": {
        "keys": []
      },
      "jwks_uri": "string",
      "logo_uri": "string",
      "policy_uri": "string",
      "privacy": {
        "scopes": {
          "property1": {
            "pii_categories": [
              {
                "name": "HIPAA"
              }
            ],
            "purpose": "string"
          },
          "property2": {
            "pii_categories": [
              {
                "name": "HIPAA"
              }
            ],
            "purpose": "string"
          }
        }
      },
      "public": true,
      "redirect_uris": [
        "https://example.com/callback"
      ],
      "request_object_signing_alg": "none",
      "request_uris": [
        "string"
      ],
      "response_types": [
        "token",
        "id_token",
        "code"
      ],
      "scope": "email offline_access openid",
      "scopes": [
        "email",
        "offline_access",
        "openid"
      ],
      "sector_identifier_uri": "https://api.jsonbin.io/b/5db6ef08688fed59d2841f1e",
      "system": false,
      "tenant_id": "string",
      "tls_client_auth_san_dns": "string",
      "tls_client_auth_san_email": "string",
      "tls_client_auth_san_ip": "string",
      "tls_client_auth_san_uri": "string",
      "tls_client_auth_subject_dn": "string",
      "tls_client_certificate_bound_access_tokens": true,
      "token_endpoint_auth_method": "client_secret_basic",
      "token_endpoint_signing_alg": "string",
      "tos_uri": "string",
      "trusted": true,
      "userinfo_signed_response_alg": "none"
    }
  ]
}

Responses

Status Meaning Description Schema
200 OK

Clients

Clients
401 Unauthorized

HttpError

Error
403 Forbidden

HttpError

Error
404 Not Found

HttpError

Error

listDashboards

Code samples

# You can also use wget
curl -X GET https://localhost:8443/api/admin/{tid}/servers/{aid}/dashboards \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://localhost:8443/api/admin/{tid}/servers/{aid}/dashboards HTTP/1.1
Host: localhost:8443
Accept: application/json

var headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: 'https://localhost:8443/api/admin/{tid}/servers/{aid}/dashboards',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

fetch('https://localhost:8443/api/admin/{tid}/servers/{aid}/dashboards',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.get 'https://localhost:8443/api/admin/{tid}/servers/{aid}/dashboards',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://localhost:8443/api/admin/{tid}/servers/{aid}/dashboards', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://localhost:8443/api/admin/{tid}/servers/{aid}/dashboards");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {access-token}"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://localhost:8443/api/admin/{tid}/servers/{aid}/dashboards", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /api/admin/{tid}/servers/{aid}/dashboards

List links to dashboards.

Parameters

Name In Type Required Description
tid path string true Tenant id
aid path string true Server id

Example responses

200 Response

{
  "enabled": true,
  "sample_business_url": "string",
  "sample_threat_url": "string",
  "tenant_business_url": "string",
  "tenant_threat_url": "string"
}

Responses

Status Meaning Description Schema
200 OK

Dashboards

Dashboards
400 Bad Request

HttpError

Error
401 Unauthorized

HttpError

Error
403 Forbidden

HttpError

Error
404 Not Found

HttpError

Error

listGateways

Code samples

# You can also use wget
curl -X GET https://localhost:8443/api/admin/{tid}/servers/{aid}/gateways \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://localhost:8443/api/admin/{tid}/servers/{aid}/gateways HTTP/1.1
Host: localhost:8443
Accept: application/json

var headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: 'https://localhost:8443/api/admin/{tid}/servers/{aid}/gateways',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

fetch('https://localhost:8443/api/admin/{tid}/servers/{aid}/gateways',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.get 'https://localhost:8443/api/admin/{tid}/servers/{aid}/gateways',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://localhost:8443/api/admin/{tid}/servers/{aid}/gateways', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://localhost:8443/api/admin/{tid}/servers/{aid}/gateways");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {access-token}"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://localhost:8443/api/admin/{tid}/servers/{aid}/gateways", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /api/admin/{tid}/servers/{aid}/gateways

List gateways

Parameters

Name In Type Required Description
tid path string true Tenant id
aid path string true Authorization server id

Example responses

200 Response

{
  "gateways": [
    {
      "authorization_server_id": "default",
      "client_id": "string",
      "description": "string",
      "id": "1",
      "last_active": "2020-05-14T07:47:23Z",
      "name": "Cloudentity Pyron",
      "tenant_id": "default",
      "type": "pyron"
    }
  ]
}

Responses

Status Meaning Description Schema
200 OK

Gateways

Gateways
401 Unauthorized

HttpError

Error
403 Forbidden

HttpError

Error

listScopes

Code samples

# You can also use wget
curl -X GET https://localhost:8443/api/admin/{tid}/servers/{aid}/scopes \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://localhost:8443/api/admin/{tid}/servers/{aid}/scopes HTTP/1.1
Host: localhost:8443
Accept: application/json

var headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: 'https://localhost:8443/api/admin/{tid}/servers/{aid}/scopes',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

fetch('https://localhost:8443/api/admin/{tid}/servers/{aid}/scopes',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.get 'https://localhost:8443/api/admin/{tid}/servers/{aid}/scopes',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://localhost:8443/api/admin/{tid}/servers/{aid}/scopes', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://localhost:8443/api/admin/{tid}/servers/{aid}/scopes");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {access-token}"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://localhost:8443/api/admin/{tid}/servers/{aid}/scopes", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /api/admin/{tid}/servers/{aid}/scopes

List scopes

Parameters

Name In Type Required Description
tid path string true Tenant id
aid path string true Authorization server id

Example responses

200 Response

{
  "scopes": [
    {
      "authorization_server_id": "default",
      "description": "This scope value requests offline access using refresh token",
      "developer_policy_id": "block",
      "display_name": "Offline Access",
      "id": "1",
      "name": "offline_access",
      "service": {
        "authorization_server_id": "default",
        "description": "Service description",
        "gateway_id": "string",
        "id": "1",
        "name": "Sample service",
        "tenant_id": "default",
        "with_specification": true
      },
      "tenant_id": "default",
      "user_policy_id": "block",
      "with_service": true
    }
  ]
}

Responses

Status Meaning Description Schema
200 OK

ScopesWithServices

ScopesWithServices
401 Unauthorized

HttpError

Error
403 Forbidden

HttpError

Error

listServices

Code samples

# You can also use wget
curl -X GET https://localhost:8443/api/admin/{tid}/servers/{aid}/services \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://localhost:8443/api/admin/{tid}/servers/{aid}/services HTTP/1.1
Host: localhost:8443
Accept: application/json

var headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: 'https://localhost:8443/api/admin/{tid}/servers/{aid}/services',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

fetch('https://localhost:8443/api/admin/{tid}/servers/{aid}/services',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.get 'https://localhost:8443/api/admin/{tid}/servers/{aid}/services',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://localhost:8443/api/admin/{tid}/servers/{aid}/services', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://localhost:8443/api/admin/{tid}/servers/{aid}/services");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {access-token}"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://localhost:8443/api/admin/{tid}/servers/{aid}/services", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /api/admin/{tid}/servers/{aid}/services

List services

Parameters

Name In Type Required Description
tid path string true Tenant id
aid path string true Authorization server id

Example responses

200 Response

{
  "services": [
    {
      "authorization_server_id": "default",
      "description": "Service description",
      "gateway_id": "string",
      "id": "1",
      "name": "Sample service",
      "protected_by_lambda_authorizer": true,
      "tenant_id": "default",
      "with_specification": true
    }
  ]
}

Responses

Status Meaning Description Schema
200 OK

ServicesResponse

ServicesResponse
401 Unauthorized

HttpError

Error
403 Forbidden

HttpError

Error
404 Not Found

HttpError

Error

createService

Code samples

# You can also use wget
curl -X POST https://localhost:8443/api/admin/{tid}/services \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

POST https://localhost:8443/api/admin/{tid}/services HTTP/1.1
Host: localhost:8443
Content-Type: application/json
Accept: application/json

var headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: 'https://localhost:8443/api/admin/{tid}/services',
  method: 'post',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');
const inputBody = '{
  "authorization_server_id": "default",
  "description": "Service description",
  "gateway_id": "string",
  "id": "1",
  "name": "Sample service",
  "tenant_id": "default",
  "with_specification": true
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

fetch('https://localhost:8443/api/admin/{tid}/services',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.post 'https://localhost:8443/api/admin/{tid}/services',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.post('https://localhost:8443/api/admin/{tid}/services', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://localhost:8443/api/admin/{tid}/services");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {access-token}"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://localhost:8443/api/admin/{tid}/services", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /api/admin/{tid}/services

Create service.

Service name is required. Service id will be generated if not provided.

Body parameter

{
  "authorization_server_id": "default",
  "description": "Service description",
  "gateway_id": "string",
  "id": "1",
  "name": "Sample service",
  "tenant_id": "default",
  "with_specification": true
}

Parameters

Name In Type Required Description
tid path string true Tenant id
body body Service false none

Example responses

201 Response

{
  "authorization_server_id": "default",
  "description": "Service description",
  "gateway_id": "string",
  "id": "1",
  "name": "Sample service",
  "tenant_id": "default",
  "with_specification": true
}

Responses

Status Meaning Description Schema
201 Created

Service

Service
400 Bad Request

HttpError

Error
401 Unauthorized

HttpError

Error
403 Forbidden

HttpError

Error
404 Not Found

HttpError

Error
409 Conflict

HttpError

Error
422 Unprocessable Entity

HttpError

Error

getService

Code samples

# You can also use wget
curl -X GET https://localhost:8443/api/admin/{tid}/services/{sid} \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://localhost:8443/api/admin/{tid}/services/{sid} HTTP/1.1
Host: localhost:8443
Accept: application/json

var headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: 'https://localhost:8443/api/admin/{tid}/services/{sid}',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

fetch('https://localhost:8443/api/admin/{tid}/services/{sid}',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.get 'https://localhost:8443/api/admin/{tid}/services/{sid}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://localhost:8443/api/admin/{tid}/services/{sid}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://localhost:8443/api/admin/{tid}/services/{sid}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {access-token}"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://localhost:8443/api/admin/{tid}/services/{sid}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /api/admin/{tid}/services/{sid}

Get service

Parameters

Name In Type Required Description
tid path string true Tenant id
sid path string true none

Example responses

200 Response

{
  "authorization_server_id": "default",
  "description": "Service description",
  "gateway_id": "string",
  "id": "1",
  "name": "Sample service",
  "protected_by_lambda_authorizer": true,
  "scopes": [
    {
      "authorization_server_id": "default",
      "description": "This scope value requests offline access using refresh token",
      "developer_policy_id": "block",
      "display_name": "Offline Access",
      "id": "1",
      "name": "offline_access",
      "tenant_id": "default",
      "user_policy_id": "block"
    }
  ],
  "tenant_id": "default",
  "with_specification": true
}

Responses

Status Meaning Description Schema
200 OK

ServiceWithScopesResponse

ServiceWithScopesResponse
401 Unauthorized

HttpError

Error
403 Forbidden

HttpError

Error
404 Not Found

HttpError

Error

updateService

Code samples

# You can also use wget
curl -X PUT https://localhost:8443/api/admin/{tid}/services/{sid} \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

PUT https://localhost:8443/api/admin/{tid}/services/{sid} HTTP/1.1
Host: localhost:8443
Content-Type: application/json
Accept: application/json

var headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: 'https://localhost:8443/api/admin/{tid}/services/{sid}',
  method: 'put',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');
const inputBody = '{
  "authorization_server_id": "default",
  "description": "Service description",
  "gateway_id": "string",
  "id": "1",
  "name": "Sample service",
  "tenant_id": "default",
  "with_specification": true
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

fetch('https://localhost:8443/api/admin/{tid}/services/{sid}',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.put 'https://localhost:8443/api/admin/{tid}/services/{sid}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.put('https://localhost:8443/api/admin/{tid}/services/{sid}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://localhost:8443/api/admin/{tid}/services/{sid}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PUT");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {access-token}"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "https://localhost:8443/api/admin/{tid}/services/{sid}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

PUT /api/admin/{tid}/services/{sid}

Update service

Body parameter

{
  "authorization_server_id": "default",
  "description": "Service description",
  "gateway_id": "string",
  "id": "1",
  "name": "Sample service",
  "tenant_id": "default",
  "with_specification": true
}

Parameters

Name In Type Required Description
tid path string true Tenant id
sid path string true none
body body Service false none

Example responses

200 Response

{
  "authorization_server_id": "default",
  "description": "Service description",
  "gateway_id": "string",
  "id": "1",
  "name": "Sample service",
  "tenant_id": "default",
  "with_specification": true
}

Responses

Status Meaning Description Schema
200 OK

Service

Service
400 Bad Request

HttpError

Error
401 Unauthorized

HttpError

Error
403 Forbidden

HttpError

Error
404 Not Found

HttpError

Error
422 Unprocessable Entity

HttpError

Error

deleteService

Code samples

# You can also use wget
curl -X DELETE https://localhost:8443/api/admin/{tid}/services/{sid} \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

DELETE https://localhost:8443/api/admin/{tid}/services/{sid} HTTP/1.1
Host: localhost:8443
Accept: application/json

var headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: 'https://localhost:8443/api/admin/{tid}/services/{sid}',
  method: 'delete',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

fetch('https://localhost:8443/api/admin/{tid}/services/{sid}',
{
  method: 'DELETE',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.delete 'https://localhost:8443/api/admin/{tid}/services/{sid}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.delete('https://localhost:8443/api/admin/{tid}/services/{sid}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://localhost:8443/api/admin/{tid}/services/{sid}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("DELETE");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {access-token}"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "https://localhost:8443/api/admin/{tid}/services/{sid}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

DELETE /api/admin/{tid}/services/{sid}

Delete service

Parameters

Name In Type Required Description
tid path string true Tenant id
sid path string true none

Example responses

400 Response

{
  "details": {},
  "error": "string",
  "status_code": 0
}

Responses

Status Meaning Description Schema
204 No Content

Service has been deleted

None
400 Bad Request

HttpError

Error
401 Unauthorized

HttpError

Error
403 Forbidden

HttpError

Error
404 Not Found

HttpError

Error

listAPIsByService

Code samples

# You can also use wget
curl -X GET https://localhost:8443/api/admin/{tid}/services/{sid}/apis \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://localhost:8443/api/admin/{tid}/services/{sid}/apis HTTP/1.1
Host: localhost:8443
Accept: application/json

var headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: 'https://localhost:8443/api/admin/{tid}/services/{sid}/apis',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

fetch('https://localhost:8443/api/admin/{tid}/services/{sid}/apis',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.get 'https://localhost:8443/api/admin/{tid}/services/{sid}/apis',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://localhost:8443/api/admin/{tid}/services/{sid}/apis', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://localhost:8443/api/admin/{tid}/services/{sid}/apis");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {access-token}"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://localhost:8443/api/admin/{tid}/services/{sid}/apis", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /api/admin/{tid}/services/{sid}/apis

List API

Parameters

Name In Type Required Description
tid path string true Tenant id
sid path string true Service id
without_data_classifications query boolean false List apis that have no data classifications
data_classification query array[string] false List apis that have given data classifications

Example responses

200 Response

{
  "apis": [
    {
      "can_have_policy": true,
      "data_classifications": [
        "string"
      ],
      "id": "1",
      "method": "GET",
      "path": "/pets",
      "policy_id": "block",
      "position": 1,
      "server_id": "default",
      "service_id": "1",
      "tenant_id": "default"
    }
  ]
}

Responses

Status Meaning Description Schema
200 OK

APIs

APIs
401 Unauthorized

HttpError

Error
403 Forbidden

HttpError

Error

removeSpecification

Code samples

# You can also use wget
curl -X DELETE https://localhost:8443/api/admin/{tid}/services/{sid}/apis \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

DELETE https://localhost:8443/api/admin/{tid}/services/{sid}/apis HTTP/1.1
Host: localhost:8443
Accept: application/json

var headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: 'https://localhost:8443/api/admin/{tid}/services/{sid}/apis',
  method: 'delete',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

fetch('https://localhost:8443/api/admin/{tid}/services/{sid}/apis',
{
  method: 'DELETE',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.delete 'https://localhost:8443/api/admin/{tid}/services/{sid}/apis',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.delete('https://localhost:8443/api/admin/{tid}/services/{sid}/apis', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://localhost:8443/api/admin/{tid}/services/{sid}/apis");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("DELETE");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {access-token}"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "https://localhost:8443/api/admin/{tid}/services/{sid}/apis", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

DELETE /api/admin/{tid}/services/{sid}/apis

Remove all apis and policies created during import for a service.

If policy is used by another service it will not be removed.

If service is connected to a gateway, it will be disconnected.

Parameters

Name In Type Required Description
tid path string true Tenant id
sid path string true none

Example responses

200 Response

{
  "not_removed_policies": [
    {
      "id": "1",
      "policy_name": "check_consent",
      "tenant_id": "default",
      "validators": [
        {
          "conf": {
            "property1": {},
            "property2": {}
          },
          "name": "identity-context",
          "recovery": [
            {
              "id": "string",
              "type": "string"
            }
          ]
        }
      ]
    }
  ],
  "removed_apis": [
    {
      "can_have_policy": true,
      "data_classifications": [
        "string"
      ],
      "id": "1",
      "method": "GET",
      "path": "/pets",
      "policy_id": "block",
      "position": 1,
      "server_id": "default",
      "service_id": "1",
      "tenant_id": "default"
    }
  ],
  "removed_policies": [
    {
      "id": "1",
      "policy_name": "check_consent",
      "tenant_id": "default",
      "validators": [
        {
          "conf": {
            "property1": {},
            "property2": {}
          },
          "name": "identity-context",
          "recovery": [
            {
              "id": "string",
              "type": "string"
            }
          ]
        }
      ]
    }
  ]
}

Responses

Status Meaning Description Schema
200 OK

RemoveServiceConfigurationResult

RemoveServiceConfigurationResult
400 Bad Request

HttpError

Error
401 Unauthorized

HttpError

Error
403 Forbidden

HttpError

Error
404 Not Found

HttpError

Error
409 Conflict

HttpError

Error
422 Unprocessable Entity

HttpError

Error

importSpecificationFromFile

Code samples

# You can also use wget
curl -X POST https://localhost:8443/api/admin/{tid}/services/{sid}/apis/import/file \
  -H 'Content-Type: multipart/form-data' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

POST https://localhost:8443/api/admin/{tid}/services/{sid}/apis/import/file HTTP/1.1
Host: localhost:8443
Content-Type: multipart/form-data
Accept: application/json

var headers = {
  'Content-Type':'multipart/form-data',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: 'https://localhost:8443/api/admin/{tid}/services/{sid}/apis/import/file',
  method: 'post',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');
const inputBody = '{
  "file": "string"
}';
const headers = {
  'Content-Type':'multipart/form-data',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

fetch('https://localhost:8443/api/admin/{tid}/services/{sid}/apis/import/file',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'multipart/form-data',
  'Accept' => 'application/json',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.post 'https://localhost:8443/api/admin/{tid}/services/{sid}/apis/import/file',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'multipart/form-data',
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.post('https://localhost:8443/api/admin/{tid}/services/{sid}/apis/import/file', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://localhost:8443/api/admin/{tid}/services/{sid}/apis/import/file");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"multipart/form-data"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {access-token}"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://localhost:8443/api/admin/{tid}/services/{sid}/apis/import/file", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /api/admin/{tid}/services/{sid}/apis/import/file

Import OpenAPI specification from file

It removes all apis before import.

Body parameter

file: string

Parameters

Name In Type Required Description
tid path string true Tenant id
sid path string true none
gateway_type query string false none
body body object false none
» file body string(binary) false none

Example responses

200 Response

{
  "created_apis": [
    {
      "can_have_policy": true,
      "data_classifications": [
        "string"
      ],
      "id": "1",
      "method": "GET",
      "path": "/pets",
      "policy_id": "block",
      "position": 1,
      "server_id": "default",
      "service_id": "1",
      "tenant_id": "default"
    }
  ],
  "created_policies": [
    {
      "id": "1",
      "policy_name": "check_consent",
      "tenant_id": "default",
      "validators": [
        {
          "conf": {
            "property1": {},
            "property2": {}
          },
          "name": "identity-context",
          "recovery": [
            {
              "id": "string",
              "type": "string"
            }
          ]
        }
      ]
    }
  ],
  "created_scopes": [
    {
      "authorization_server_id": "default",
      "description": "This scope value requests offline access using refresh token",
      "developer_policy_id": "block",
      "display_name": "Offline Access",
      "id": "1",
      "name": "offline_access",
      "tenant_id": "default",
      "user_policy_id": "block"
    }
  ],
  "ignored_apis": [
    {
      "can_have_policy": true,
      "data_classifications": [
        "string"
      ],
      "id": "1",
      "method": "GET",
      "path": "/pets",
      "policy_id": "block",
      "position": 1,
      "server_id": "default",
      "service_id": "1",
      "tenant_id": "default"
    }
  ],
  "ignored_policies": [
    {
      "id": "1",
      "policy_name": "check_consent",
      "tenant_id": "default",
      "validators": [
        {
          "conf": {
            "property1": {},
            "property2": {}
          },
          "name": "identity-context",
          "recovery": [
            {
              "id": "string",
              "type": "string"
            }
          ]
        }
      ]
    }
  ],
  "ignored_scopes": [
    {
      "authorization_server_id": "default",
      "description": "This scope value requests offline access using refresh token",
      "developer_policy_id": "block",
      "display_name": "Offline Access",
      "id": "1",
      "name": "offline_access",
      "tenant_id": "default",
      "user_policy_id": "block"
    }
  ],
  "not_removed_policies": [
    {
      "id": "1",
      "policy_name": "check_consent",
      "tenant_id": "default",
      "validators": [
        {
          "conf": {
            "property1": {},
            "property2": {}
          },
          "name": "identity-context",
          "recovery": [
            {
              "id": "string",
              "type": "string"
            }
          ]
        }
      ]
    }
  ],
  "removed_apis": [
    {
      "can_have_policy": true,
      "data_classifications": [
        "string"
      ],
      "id": "1",
      "method": "GET",
      "path": "/pets",
      "policy_id": "block",
      "position": 1,
      "server_id": "default",
      "service_id": "1",
      "tenant_id": "default"
    }
  ],
  "removed_policies": [
    {
      "id": "1",
      "policy_name": "check_consent",
      "tenant_id": "default",
      "validators": [
        {
          "conf": {
            "property1": {},
            "property2": {}
          },
          "name": "identity-context",
          "recovery": [
            {
              "id": "string",
              "type": "string"
            }
          ]
        }
      ]
    }
  ]
}

Responses

Status Meaning Description Schema
200 OK

ImportServiceConfigurationResult

ImportServiceConfigurationResult
400 Bad Request

HttpError

Error
401 Unauthorized

HttpError

Error
403 Forbidden

HttpError

Error
404 Not Found

HttpError

Error
409 Conflict

HttpError

Error
422 Unprocessable Entity

HttpError

Error

importSpecificationFromText

Code samples

# You can also use wget
curl -X POST https://localhost:8443/api/admin/{tid}/services/{sid}/apis/import/text \
  -H 'Content-Type: text/plain' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

POST https://localhost:8443/api/admin/{tid}/services/{sid}/apis/import/text HTTP/1.1
Host: localhost:8443
Content-Type: text/plain
Accept: application/json

var headers = {
  'Content-Type':'text/plain',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: 'https://localhost:8443/api/admin/{tid}/services/{sid}/apis/import/text',
  method: 'post',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');
const inputBody = 'string';
const headers = {
  'Content-Type':'text/plain',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

fetch('https://localhost:8443/api/admin/{tid}/services/{sid}/apis/import/text',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'text/plain',
  'Accept' => 'application/json',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.post 'https://localhost:8443/api/admin/{tid}/services/{sid}/apis/import/text',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'text/plain',
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.post('https://localhost:8443/api/admin/{tid}/services/{sid}/apis/import/text', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://localhost:8443/api/admin/{tid}/services/{sid}/apis/import/text");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"text/plain"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {access-token}"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://localhost:8443/api/admin/{tid}/services/{sid}/apis/import/text", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /api/admin/{tid}/services/{sid}/apis/import/text

Import OpenAPI specification from text

It removes all apis and policies (created by previous import) before import.

Body parameter

Parameters

Name In Type Required Description
tid path string true Tenant id
sid path string true none
gateway_type query string false none
body body string false none

Example responses

200 Response

{
  "created_apis": [
    {
      "can_have_policy": true,
      "data_classifications": [
        "string"
      ],
      "id": "1",
      "method": "GET",
      "path": "/pets",
      "policy_id": "block",
      "position": 1,
      "server_id": "default",
      "service_id": "1",
      "tenant_id": "default"
    }
  ],
  "created_policies": [
    {
      "id": "1",
      "policy_name": "check_consent",
      "tenant_id": "default",
      "validators": [
        {
          "conf": {
            "property1": {},
            "property2": {}
          },
          "name": "identity-context",
          "recovery": [
            {
              "id": "string",
              "type": "string"
            }
          ]
        }
      ]
    }
  ],
  "created_scopes": [
    {
      "authorization_server_id": "default",
      "description": "This scope value requests offline access using refresh token",
      "developer_policy_id": "block",
      "display_name": "Offline Access",
      "id": "1",
      "name": "offline_access",
      "tenant_id": "default",
      "user_policy_id": "block"
    }
  ],
  "ignored_apis": [
    {
      "can_have_policy": true,
      "data_classifications": [
        "string"
      ],
      "id": "1",
      "method": "GET",
      "path": "/pets",
      "policy_id": "block",
      "position": 1,
      "server_id": "default",
      "service_id": "1",
      "tenant_id": "default"
    }
  ],
  "ignored_policies": [
    {
      "id": "1",
      "policy_name": "check_consent",
      "tenant_id": "default",
      "validators": [
        {
          "conf": {
            "property1": {},
            "property2": {}
          },
          "name": "identity-context",
          "recovery": [
            {
              "id": "string",
              "type": "string"
            }
          ]
        }
      ]
    }
  ],
  "ignored_scopes": [
    {
      "authorization_server_id": "default",
      "description": "This scope value requests offline access using refresh token",
      "developer_policy_id": "block",
      "display_name": "Offline Access",
      "id": "1",
      "name": "offline_access",
      "tenant_id": "default",
      "user_policy_id": "block"
    }
  ],
  "not_removed_policies": [
    {
      "id": "1",
      "policy_name": "check_consent",
      "tenant_id": "default",
      "validators": [
        {
          "conf": {
            "property1": {},
            "property2": {}
          },
          "name": "identity-context",
          "recovery": [
            {
              "id": "string",
              "type": "string"
            }
          ]
        }
      ]
    }
  ],
  "removed_apis": [
    {
      "can_have_policy": true,
      "data_classifications": [
        "string"
      ],
      "id": "1",
      "method": "GET",
      "path": "/pets",
      "policy_id": "block",
      "position": 1,
      "server_id": "default",
      "service_id": "1",
      "tenant_id": "default"
    }
  ],
  "removed_policies": [
    {
      "id": "1",
      "policy_name": "check_consent",
      "tenant_id": "default",
      "validators": [
        {
          "conf": {
            "property1": {},
            "property2": {}
          },
          "name": "identity-context",
          "recovery": [
            {
              "id": "string",
              "type": "string"
            }
          ]
        }
      ]
    }
  ]
}

Responses

Status Meaning Description Schema
200 OK

ImportServiceConfigurationResult

ImportServiceConfigurationResult
400 Bad Request

HttpError

Error
401 Unauthorized

HttpError

Error
403 Forbidden

HttpError

Error
404 Not Found

HttpError

Error
409 Conflict

HttpError

Error
422 Unprocessable Entity

HttpError

Error

importSpecificationFromURL

Code samples

# You can also use wget
curl -X POST https://localhost:8443/api/admin/{tid}/services/{sid}/apis/import/url \
  -H 'Content-Type: multipart/form-data' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

POST https://localhost:8443/api/admin/{tid}/services/{sid}/apis/import/url HTTP/1.1
Host: localhost:8443
Content-Type: multipart/form-data
Accept: application/json

var headers = {
  'Content-Type':'multipart/form-data',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: 'https://localhost:8443/api/admin/{tid}/services/{sid}/apis/import/url',
  method: 'post',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');
const inputBody = '{
  "url": "string"
}';
const headers = {
  'Content-Type':'multipart/form-data',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

fetch('https://localhost:8443/api/admin/{tid}/services/{sid}/apis/import/url',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'multipart/form-data',
  'Accept' => 'application/json',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.post 'https://localhost:8443/api/admin/{tid}/services/{sid}/apis/import/url',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'multipart/form-data',
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.post('https://localhost:8443/api/admin/{tid}/services/{sid}/apis/import/url', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://localhost:8443/api/admin/{tid}/services/{sid}/apis/import/url");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"multipart/form-data"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {access-token}"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://localhost:8443/api/admin/{tid}/services/{sid}/apis/import/url", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /api/admin/{tid}/services/{sid}/apis/import/url

Import OpenAPI specification from url

It removes all apis before import.

Body parameter

url: string

Parameters

Name In Type Required Description
tid path string true Tenant id
sid path string true none
gateway_type query string false none
body body object false none
» url body string false none

Example responses

200 Response

{
  "created_apis": [
    {
      "can_have_policy": true,
      "data_classifications": [
        "string"
      ],
      "id": "1",
      "method": "GET",
      "path": "/pets",
      "policy_id": "block",
      "position": 1,
      "server_id": "default",
      "service_id": "1",
      "tenant_id": "default"
    }
  ],
  "created_policies": [
    {
      "id": "1",
      "policy_name": "check_consent",
      "tenant_id": "default",
      "validators": [
        {
          "conf": {
            "property1": {},
            "property2": {}
          },
          "name": "identity-context",
          "recovery": [
            {
              "id": "string",
              "type": "string"
            }
          ]
        }
      ]
    }
  ],
  "created_scopes": [
    {
      "authorization_server_id": "default",
      "description": "This scope value requests offline access using refresh token",
      "developer_policy_id": "block",
      "display_name": "Offline Access",
      "id": "1",
      "name": "offline_access",
      "tenant_id": "default",
      "user_policy_id": "block"
    }
  ],
  "ignored_apis": [
    {
      "can_have_policy": true,
      "data_classifications": [
        "string"
      ],
      "id": "1",
      "method": "GET",
      "path": "/pets",
      "policy_id": "block",
      "position": 1,
      "server_id": "default",
      "service_id": "1",
      "tenant_id": "default"
    }
  ],
  "ignored_policies": [
    {
      "id": "1",
      "policy_name": "check_consent",
      "tenant_id": "default",
      "validators": [
        {
          "conf": {
            "property1": {},
            "property2": {}
          },
          "name": "identity-context",
          "recovery": [
            {
              "id": "string",
              "type": "string"
            }
          ]
        }
      ]
    }
  ],
  "ignored_scopes": [
    {
      "authorization_server_id": "default",
      "description": "This scope value requests offline access using refresh token",
      "developer_policy_id": "block",
      "display_name": "Offline Access",
      "id": "1",
      "name": "offline_access",
      "tenant_id": "default",
      "user_policy_id": "block"
    }
  ],
  "not_removed_policies": [
    {
      "id": "1",
      "policy_name": "check_consent",
      "tenant_id": "default",
      "validators": [
        {
          "conf": {
            "property1": {},
            "property2": {}
          },
          "name": "identity-context",
          "recovery": [
            {
              "id": "string",
              "type": "string"
            }
          ]
        }
      ]
    }
  ],
  "removed_apis": [
    {
      "can_have_policy": true,
      "data_classifications": [
        "string"
      ],
      "id": "1",
      "method": "GET",
      "path": "/pets",
      "policy_id": "block",
      "position": 1,
      "server_id": "default",
      "service_id": "1",
      "tenant_id": "default"
    }
  ],
  "removed_policies": [
    {
      "id": "1",
      "policy_name": "check_consent",
      "tenant_id": "default",
      "validators": [
        {
          "conf": {
            "property1": {},
            "property2": {}
          },
          "name": "identity-context",
          "recovery": [
            {
              "id": "string",
              "type": "string"
            }
          ]
        }
      ]
    }
  ]
}

Responses

Status Meaning Description Schema
200 OK

ImportServiceConfigurationResult

ImportServiceConfigurationResult
400 Bad Request

HttpError

Error
401 Unauthorized

HttpError

Error
403 Forbidden

HttpError

Error
404 Not Found

HttpError

Error
409 Conflict

HttpError

Error
422 Unprocessable Entity

HttpError

Error

getAdminTenant

Code samples

# You can also use wget
curl -X GET https://localhost:8443/api/admin/{tid}/tenant \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://localhost:8443/api/admin/{tid}/tenant HTTP/1.1
Host: localhost:8443
Accept: application/json

var headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: 'https://localhost:8443/api/admin/{tid}/tenant',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

fetch('https://localhost:8443/api/admin/{tid}/tenant',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.get 'https://localhost:8443/api/admin/{tid}/tenant',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://localhost:8443/api/admin/{tid}/tenant', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://localhost:8443/api/admin/{tid}/tenant");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {access-token}"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://localhost:8443/api/admin/{tid}/tenant", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /api/admin/{tid}/tenant

Get admin tenant

Parameters

Name In Type Required Description
tid path string true Tenant id

Example responses

200 Response

{
  "authentication_context_settings": {
    "attributes": [
      {
        "description": "string",
        "name": "string"
      }
    ]
  },
  "id": "string",
  "jwks": {
    "keys": []
  },
  "name": "Default",
  "url": "https://example.com/default"
}

Responses

Status Meaning Description Schema
200 OK

Tenant

Tenant
401 Unauthorized

HttpError

Error
403 Forbidden

HttpError

Error
404 Not Found

HttpError

Error

updateAdminTenant

Code samples

# You can also use wget
curl -X PUT https://localhost:8443/api/admin/{tid}/tenant \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

PUT https://localhost:8443/api/admin/{tid}/tenant HTTP/1.1
Host: localhost:8443
Content-Type: application/json
Accept: application/json

var headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: 'https://localhost:8443/api/admin/{tid}/tenant',
  method: 'put',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');
const inputBody = '{
  "authentication_context_settings": {
    "attributes": [
      {
        "description": "string",
        "name": "string"
      }
    ]
  },
  "id": "string",
  "jwks": {
    "keys": []
  },
  "name": "Default",
  "url": "https://example.com/default"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

fetch('https://localhost:8443/api/admin/{tid}/tenant',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.put 'https://localhost:8443/api/admin/{tid}/tenant',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.put('https://localhost:8443/api/admin/{tid}/tenant', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://localhost:8443/api/admin/{tid}/tenant");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PUT");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {access-token}"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "https://localhost:8443/api/admin/{tid}/tenant", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

PUT /api/admin/{tid}/tenant

Update admin tenant

Body parameter

{
  "authentication_context_settings": {
    "attributes": [
      {
        "description": "string",
        "name": "string"
      }
    ]
  },
  "id": "string",
  "jwks": {
    "keys": []
  },
  "name": "Default",
  "url": "https://example.com/default"
}

Parameters

Name In Type Required Description
tid path string true Tenant id
body body Tenant false none

Example responses

200 Response

{
  "authentication_context_settings": {
    "attributes": [
      {
        "description": "string",
        "name": "string"
      }
    ]
  },
  "id": "string",
  "jwks": {
    "keys": []
  },
  "name": "Default",
  "url": "https://example.com/default"
}

Responses

Status Meaning Description Schema
200 OK

Tenant

Tenant
400 Bad Request

HttpError

Error
401 Unauthorized

HttpError

Error
403 Forbidden

HttpError

Error
404 Not Found

HttpError

Error
422 Unprocessable Entity

HttpError

Error

developer

listClientsForDeveloper

Code samples

# You can also use wget
curl -X GET https://localhost:8443/api/developer/{tid}/clients \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://localhost:8443/api/developer/{tid}/clients HTTP/1.1
Host: localhost:8443
Accept: application/json

var headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: 'https://localhost:8443/api/developer/{tid}/clients',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

fetch('https://localhost:8443/api/developer/{tid}/clients',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.get 'https://localhost:8443/api/developer/{tid}/clients',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://localhost:8443/api/developer/{tid}/clients', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://localhost:8443/api/developer/{tid}/clients");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {access-token}"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://localhost:8443/api/developer/{tid}/clients", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /api/developer/{tid}/clients

List clients

Parameters

Name In Type Required Description
tid path string true Tenant id

Example responses

200 Response

{
  "clients": [
    {
      "audience": [
        "string"
      ],
      "authorization_server_id": "default",
      "client_id": "string",
      "client_id_issued_at": 0,
      "client_name": "My app",
      "client_secret": "string",
      "client_secret_expires_at": 0,
      "client_uri": "string",
      "description": "string",
      "grant_types": [
        "password",
        "refresh_token",
        "client_credentials",
        "implicit",
        "authorization_code"
      ],
      "jwks": {
        "keys": []
      },
      "jwks_uri": "string",
      "logo_uri": "string",
      "policy_uri": "string",
      "privacy": {
        "scopes": {
          "property1": {
            "pii_categories": [
              {
                "name": "HIPAA"
              }
            ],
            "purpose": "string"
          },
          "property2": {
            "pii_categories": [
              {
                "name": "HIPAA"
              }
            ],
            "purpose": "string"
          }
        }
      },
      "public": true,
      "redirect_uris": [
        "https://example.com/callback"
      ],
      "request_object_signing_alg": "none",
      "request_uris": [
        "string"
      ],
      "response_types": [
        "token",
        "id_token",
        "code"
      ],
      "scope": "email offline_access openid",
      "scopes": [
        "email",
        "offline_access",
        "openid"
      ],
      "sector_identifier_uri": "https://api.jsonbin.io/b/5db6ef08688fed59d2841f1e",
      "tls_client_auth_san_dns": "string",
      "tls_client_auth_san_email": "string",
      "tls_client_auth_san_ip": "string",
      "tls_client_auth_san_uri": "string",
      "tls_client_auth_subject_dn": "string",
      "tls_client_certificate_bound_access_tokens": true,
      "token_endpoint_auth_method": "client_secret_basic",
      "token_endpoint_signing_alg": "string",
      "tos_uri": "string",
      "userinfo_signed_response_alg": "none"
    }
  ]
}

Responses

Status Meaning Description Schema
200 OK

DeveloperClients

DeveloperClients
401 Unauthorized

HttpError

Error
403 Forbidden

HttpError

Error
404 Not Found

HttpError

Error

createClientForDeveloper

Code samples

# You can also use wget
curl -X POST https://localhost:8443/api/developer/{tid}/clients \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

POST https://localhost:8443/api/developer/{tid}/clients HTTP/1.1
Host: localhost:8443
Content-Type: application/json
Accept: application/json

var headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: 'https://localhost:8443/api/developer/{tid}/clients',
  method: 'post',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');
const inputBody = '{
  "audience": [
    "string"
  ],
  "authorization_server_id": "default",
  "client_id_issued_at": 0,
  "client_name": "My app",
  "client_secret_expires_at": 0,
  "client_uri": "string",
  "description": "string",
  "grant_types": [
    "password",
    "refresh_token",
    "client_credentials",
    "implicit",
    "authorization_code"
  ],
  "jwks": {
    "keys": []
  },
  "jwks_uri": "string",
  "logo_uri": "string",
  "policy_uri": "string",
  "privacy": {
    "scopes": {
      "property1": {
        "pii_categories": [
          {
            "name": "HIPAA"
          }
        ],
        "purpose": "string"
      },
      "property2": {
        "pii_categories": [
          {
            "name": "HIPAA"
          }
        ],
        "purpose": "string"
      }
    }
  },
  "public": true,
  "redirect_uris": [
    "https://example.com/callback"
  ],
  "request_object_signing_alg": "none",
  "request_uris": [
    "string"
  ],
  "response_types": [
    "token",
    "id_token",
    "code"
  ],
  "scope": "email offline_access openid",
  "scopes": [
    "email",
    "offline_access",
    "openid"
  ],
  "sector_identifier_uri": "https://api.jsonbin.io/b/5db6ef08688fed59d2841f1e",
  "tls_client_auth_san_dns": "string",
  "tls_client_auth_san_email": "string",
  "tls_client_auth_san_ip": "string",
  "tls_client_auth_san_uri": "string",
  "tls_client_auth_subject_dn": "string",
  "tls_client_certificate_bound_access_tokens": true,
  "token_endpoint_auth_method": "client_secret_basic",
  "token_endpoint_signing_alg": "string",
  "tos_uri": "string",
  "userinfo_signed_response_alg": "none"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

fetch('https://localhost:8443/api/developer/{tid}/clients',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.post 'https://localhost:8443/api/developer/{tid}/clients',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.post('https://localhost:8443/api/developer/{tid}/clients', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://localhost:8443/api/developer/{tid}/clients");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {access-token}"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://localhost:8443/api/developer/{tid}/clients", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /api/developer/{tid}/clients

Create new OAuth client.

Client must be created under existing tenant and authorization server.

Authorization server id where client should be assigned must be provided in the request body.

Client can't be created in a system authorization server.

Client id and secret are generated upon creation.

If grant type is not set, client will get authorization code grant type assigned with code as response type.

Default token authentication method is client_secret_basic.

It might happen that it won't be possible to create a client with specified scopes. Scopes assignment can be protected by policies defined by administrator.

Body parameter

{
  "audience": [
    "string"
  ],
  "authorization_server_id": "default",
  "client_id_issued_at": 0,
  "client_name": "My app",
  "client_secret_expires_at": 0,
  "client_uri": "string",
  "description": "string",
  "grant_types": [
    "password",
    "refresh_token",
    "client_credentials",
    "implicit",
    "authorization_code"
  ],
  "jwks": {
    "keys": []
  },
  "jwks_uri": "string",
  "logo_uri": "string",
  "policy_uri": "string",
  "privacy": {
    "scopes": {
      "property1": {
        "pii_categories": [
          {
            "name": "HIPAA"
          }
        ],
        "purpose": "string"
      },
      "property2": {
        "pii_categories": [
          {
            "name": "HIPAA"
          }
        ],
        "purpose": "string"
      }
    }
  },
  "public": true,
  "redirect_uris": [
    "https://example.com/callback"
  ],
  "request_object_signing_alg": "none",
  "request_uris": [
    "string"
  ],
  "response_types": [
    "token",
    "id_token",
    "code"
  ],
  "scope": "email offline_access openid",
  "scopes": [
    "email",
    "offline_access",
    "openid"
  ],
  "sector_identifier_uri": "https://api.jsonbin.io/b/5db6ef08688fed59d2841f1e",
  "tls_client_auth_san_dns": "string",
  "tls_client_auth_san_email": "string",
  "tls_client_auth_san_ip": "string",
  "tls_client_auth_san_uri": "string",
  "tls_client_auth_subject_dn": "string",
  "tls_client_certificate_bound_access_tokens": true,
  "token_endpoint_auth_method": "client_secret_basic",
  "token_endpoint_signing_alg": "string",
  "tos_uri": "string",
  "userinfo_signed_response_alg": "none"
}

Parameters

Name In Type Required Description
tid path string true Tenant id
body body DeveloperCreateClientRequest false none

Example responses

201 Response

{
  "audience": [
    "string"
  ],
  "authorization_server_id": "default",
  "client_id": "string",
  "client_id_issued_at": 0,
  "client_name": "My app",
  "client_secret": "string",
  "client_secret_expires_at": 0,
  "client_uri": "string",
  "description": "string",
  "grant_types": [
    "password",
    "refresh_token",
    "client_credentials",
    "implicit",
    "authorization_code"
  ],
  "jwks": {
    "keys": []
  },
  "jwks_uri": "string",
  "logo_uri": "string",
  "policy_uri": "string",
  "privacy": {
    "scopes": {
      "property1": {
        "pii_categories": [
          {
            "name": "HIPAA"
          }
        ],
        "purpose": "string"
      },
      "property2": {
        "pii_categories": [
          {
            "name": "HIPAA"
          }
        ],
        "purpose": "string"
      }
    }
  },
  "public": true,
  "redirect_uris": [
    "https://example.com/callback"
  ],
  "request_object_signing_alg": "none",
  "request_uris": [
    "string"
  ],
  "response_types": [
    "token",
    "id_token",
    "code"
  ],
  "scope": "email offline_access openid",
  "scopes": [
    "email",
    "offline_access",
    "openid"
  ],
  "sector_identifier_uri": "https://api.jsonbin.io/b/5db6ef08688fed59d2841f1e",
  "tls_client_auth_san_dns": "string",
  "tls_client_auth_san_email": "string",
  "tls_client_auth_san_ip": "string",
  "tls_client_auth_san_uri": "string",
  "tls_client_auth_subject_dn": "string",
  "tls_client_certificate_bound_access_tokens": true,
  "token_endpoint_auth_method": "client_secret_basic",
  "token_endpoint_signing_alg": "string",
  "tos_uri": "string",
  "userinfo_signed_response_alg": "none"
}

Responses

Status Meaning Description Schema
201 Created

DeveloperClientResponse

DeveloperClientResponse
401 Unauthorized

HttpError

Error
403 Forbidden

HttpError

Error
404 Not Found

HttpError

Error
409 Conflict

HttpError

Error
422 Unprocessable Entity

HttpError

Error

getClientForDeveloper

Code samples

# You can also use wget
curl -X GET https://localhost:8443/api/developer/{tid}/clients/{cid} \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://localhost:8443/api/developer/{tid}/clients/{cid} HTTP/1.1
Host: localhost:8443
Accept: application/json

var headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: 'https://localhost:8443/api/developer/{tid}/clients/{cid}',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

fetch('https://localhost:8443/api/developer/{tid}/clients/{cid}',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.get 'https://localhost:8443/api/developer/{tid}/clients/{cid}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://localhost:8443/api/developer/{tid}/clients/{cid}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://localhost:8443/api/developer/{tid}/clients/{cid}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {access-token}"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://localhost:8443/api/developer/{tid}/clients/{cid}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /api/developer/{tid}/clients/{cid}

Get client

Parameters

Name In Type Required Description
tid path string true Tenant id
cid path string true Client id

Example responses

200 Response

{
  "audience": [
    "string"
  ],
  "authorization_server_id": "default",
  "client_id": "string",
  "client_id_issued_at": 0,
  "client_name": "My app",
  "client_secret": "string",
  "client_secret_expires_at": 0,
  "client_uri": "string",
  "description": "string",
  "grant_types": [
    "password",
    "refresh_token",
    "client_credentials",
    "implicit",
    "authorization_code"
  ],
  "jwks": {
    "keys": []
  },
  "jwks_uri": "string",
  "logo_uri": "string",
  "policy_uri": "string",
  "privacy": {
    "scopes": {
      "property1": {
        "pii_categories": [
          {
            "name": "HIPAA"
          }
        ],
        "purpose": "string"
      },
      "property2": {
        "pii_categories": [
          {
            "name": "HIPAA"
          }
        ],
        "purpose": "string"
      }
    }
  },
  "public": true,
  "redirect_uris": [
    "https://example.com/callback"
  ],
  "request_object_signing_alg": "none",
  "request_uris": [
    "string"
  ],
  "response_types": [
    "token",
    "id_token",
    "code"
  ],
  "scope": "email offline_access openid",
  "scopes": [
    "email",
    "offline_access",
    "openid"
  ],
  "sector_identifier_uri": "https://api.jsonbin.io/b/5db6ef08688fed59d2841f1e",
  "tls_client_auth_san_dns": "string",
  "tls_client_auth_san_email": "string",
  "tls_client_auth_san_ip": "string",
  "tls_client_auth_san_uri": "string",
  "tls_client_auth_subject_dn": "string",
  "tls_client_certificate_bound_access_tokens": true,
  "token_endpoint_auth_method": "client_secret_basic",
  "token_endpoint_signing_alg": "string",
  "tos_uri": "string",
  "userinfo_signed_response_alg": "none"
}

Responses

Status Meaning Description Schema
200 OK

DeveloperClientResponse

DeveloperClientResponse
401 Unauthorized

HttpError

Error
403 Forbidden

HttpError

Error
404 Not Found

HttpError

Error

updateClientForDeveloper

Code samples

# You can also use wget
curl -X PUT https://localhost:8443/api/developer/{tid}/clients/{cid} \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

PUT https://localhost:8443/api/developer/{tid}/clients/{cid} HTTP/1.1
Host: localhost:8443
Content-Type: application/json
Accept: application/json

var headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: 'https://localhost:8443/api/developer/{tid}/clients/{cid}',
  method: 'put',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');
const inputBody = '{
  "audience": [
    "string"
  ],
  "client_id_issued_at": 0,
  "client_name": "My app",
  "client_secret": "string",
  "client_secret_expires_at": 0,
  "client_uri": "string",
  "description": "string",
  "grant_types": [
    "password",
    "refresh_token",
    "client_credentials",
    "implicit",
    "authorization_code"
  ],
  "jwks": {
    "keys": []
  },
  "jwks_uri": "string",
  "logo_uri": "string",
  "policy_uri": "string",
  "privacy": {
    "scopes": {
      "property1": {
        "pii_categories": [
          {
            "name": "HIPAA"
          }
        ],
        "purpose": "string"
      },
      "property2": {
        "pii_categories": [
          {
            "name": "HIPAA"
          }
        ],
        "purpose": "string"
      }
    }
  },
  "public": true,
  "redirect_uris": [
    "https://example.com/callback"
  ],
  "request_object_signing_alg": "none",
  "request_uris": [
    "string"
  ],
  "response_types": [
    "token",
    "id_token",
    "code"
  ],
  "scope": "email offline_access openid",
  "scopes": [
    "email",
    "offline_access",
    "openid"
  ],
  "sector_identifier_uri": "https://api.jsonbin.io/b/5db6ef08688fed59d2841f1e",
  "tls_client_auth_san_dns": "string",
  "tls_client_auth_san_email": "string",
  "tls_client_auth_san_ip": "string",
  "tls_client_auth_san_uri": "string",
  "tls_client_auth_subject_dn": "string",
  "tls_client_certificate_bound_access_tokens": true,
  "token_endpoint_auth_method": "client_secret_basic",
  "token_endpoint_signing_alg": "string",
  "tos_uri": "string",
  "userinfo_signed_response_alg": "none"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

fetch('https://localhost:8443/api/developer/{tid}/clients/{cid}',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.put 'https://localhost:8443/api/developer/{tid}/clients/{cid}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.put('https://localhost:8443/api/developer/{tid}/clients/{cid}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://localhost:8443/api/developer/{tid}/clients/{cid}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PUT");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {access-token}"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "https://localhost:8443/api/developer/{tid}/clients/{cid}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

PUT /api/developer/{tid}/clients/{cid}

Update client

The entire client object must be send for update.

Body parameter

{
  "audience": [
    "string"
  ],
  "client_id_issued_at": 0,
  "client_name": "My app",
  "client_secret": "string",
  "client_secret_expires_at": 0,
  "client_uri": "string",
  "description": "string",
  "grant_types": [
    "password",
    "refresh_token",
    "client_credentials",
    "implicit",
    "authorization_code"
  ],
  "jwks": {
    "keys": []
  },
  "jwks_uri": "string",
  "logo_uri": "string",
  "policy_uri": "string",
  "privacy": {
    "scopes": {
      "property1": {
        "pii_categories": [
          {
            "name": "HIPAA"
          }
        ],
        "purpose": "string"
      },
      "property2": {
        "pii_categories": [
          {
            "name": "HIPAA"
          }
        ],
        "purpose": "string"
      }
    }
  },
  "public": true,
  "redirect_uris": [
    "https://example.com/callback"
  ],
  "request_object_signing_alg": "none",
  "request_uris": [
    "string"
  ],
  "response_types": [
    "token",
    "id_token",
    "code"
  ],
  "scope": "email offline_access openid",
  "scopes": [
    "email",
    "offline_access",
    "openid"
  ],
  "sector_identifier_uri": "https://api.jsonbin.io/b/5db6ef08688fed59d2841f1e",
  "tls_client_auth_san_dns": "string",
  "tls_client_auth_san_email": "string",
  "tls_client_auth_san_ip": "string",
  "tls_client_auth_san_uri": "string",
  "tls_client_auth_subject_dn": "string",
  "tls_client_certificate_bound_access_tokens": true,
  "token_endpoint_auth_method": "client_secret_basic",
  "token_endpoint_signing_alg": "string",
  "tos_uri": "string",
  "userinfo_signed_response_alg": "none"
}

Parameters

Name In Type Required Description
tid path string true Tenant id
cid path string true Client id
body body DeveloperUpdateClientRequest false none

Example responses

200 Response

{
  "audience": [
    "string"
  ],
  "authorization_server_id": "default",
  "client_id": "string",
  "client_id_issued_at": 0,
  "client_name": "My app",
  "client_secret": "string",
  "client_secret_expires_at": 0,
  "client_uri": "string",
  "description": "string",
  "grant_types": [
    "password",
    "refresh_token",
    "client_credentials",
    "implicit",
    "authorization_code"
  ],
  "jwks": {
    "keys": []
  },
  "jwks_uri": "string",
  "logo_uri": "string",
  "policy_uri": "string",
  "privacy": {
    "scopes": {
      "property1": {
        "pii_categories": [
          {
            "name": "HIPAA"
          }
        ],
        "purpose": "string"
      },
      "property2": {
        "pii_categories": [
          {
            "name": "HIPAA"
          }
        ],
        "purpose": "string"
      }
    }
  },
  "public": true,
  "redirect_uris": [
    "https://example.com/callback"
  ],
  "request_object_signing_alg": "none",
  "request_uris": [
    "string"
  ],
  "response_types": [
    "token",
    "id_token",
    "code"
  ],
  "scope": "email offline_access openid",
  "scopes": [
    "email",
    "offline_access",
    "openid"
  ],
  "sector_identifier_uri": "https://api.jsonbin.io/b/5db6ef08688fed59d2841f1e",
  "tls_client_auth_san_dns": "string",
  "tls_client_auth_san_email": "string",
  "tls_client_auth_san_ip": "string",
  "tls_client_auth_san_uri": "string",
  "tls_client_auth_subject_dn": "string",
  "tls_client_certificate_bound_access_tokens": true,
  "token_endpoint_auth_method": "client_secret_basic",
  "token_endpoint_signing_alg": "string",
  "tos_uri": "string",
  "userinfo_signed_response_alg": "none"
}

Responses

Status Meaning Description Schema
200 OK

DeveloperClientResponse

DeveloperClientResponse
400 Bad Request

HttpError

Error
401 Unauthorized

HttpError

Error
403 Forbidden

HttpError

Error
404 Not Found

HttpError

Error
422 Unprocessable Entity

HttpError

Error

deleteClientForDeveloper

Code samples

# You can also use wget
curl -X DELETE https://localhost:8443/api/developer/{tid}/clients/{cid} \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

DELETE https://localhost:8443/api/developer/{tid}/clients/{cid} HTTP/1.1
Host: localhost:8443
Accept: application/json

var headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: 'https://localhost:8443/api/developer/{tid}/clients/{cid}',
  method: 'delete',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

fetch('https://localhost:8443/api/developer/{tid}/clients/{cid}',
{
  method: 'DELETE',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.delete 'https://localhost:8443/api/developer/{tid}/clients/{cid}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.delete('https://localhost:8443/api/developer/{tid}/clients/{cid}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://localhost:8443/api/developer/{tid}/clients/{cid}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("DELETE");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {access-token}"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "https://localhost:8443/api/developer/{tid}/clients/{cid}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

DELETE /api/developer/{tid}/clients/{cid}

Delete client

Parameters

Name In Type Required Description
tid path string true Tenant id
cid path string true Client id

Example responses

400 Response

{
  "details": {},
  "error": "string",
  "status_code": 0
}

Responses

Status Meaning Description Schema
204 No Content

Client has been deleted

None
400 Bad Request

HttpError

Error
401 Unauthorized

HttpError

Error
403 Forbidden

HttpError

Error
404 Not Found

HttpError

Error

listServersForDeveloper

Code samples

# You can also use wget
curl -X GET https://localhost:8443/api/developer/{tid}/servers \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://localhost:8443/api/developer/{tid}/servers HTTP/1.1
Host: localhost:8443
Accept: application/json

var headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: 'https://localhost:8443/api/developer/{tid}/servers',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

fetch('https://localhost:8443/api/developer/{tid}/servers',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.get 'https://localhost:8443/api/developer/{tid}/servers',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://localhost:8443/api/developer/{tid}/servers', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://localhost:8443/api/developer/{tid}/servers");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {access-token}"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://localhost:8443/api/developer/{tid}/servers", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /api/developer/{tid}/servers

List authorization servers

Returns list of authorization severs.

Parameters

Name In Type Required Description
tid path string true Tenant id

Example responses

200 Response

{
  "servers": [
    {
      "grant_types": [
        "implicit",
        "authorization_code",
        "refresh_token"
      ],
      "id": "default",
      "issuer_url": "https://example.com/default/default",
      "name": "ACP"
    }
  ]
}

Responses

Status Meaning Description Schema
200 OK

ListServersDeveloperResponse

ListServersDeveloperResponse
401 Unauthorized

HttpError

Error
403 Forbidden

HttpError

Error
404 Not Found

HttpError

Error

getServerForDeveloper

Code samples

# You can also use wget
curl -X GET https://localhost:8443/api/developer/{tid}/servers/{aid} \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://localhost:8443/api/developer/{tid}/servers/{aid} HTTP/1.1
Host: localhost:8443
Accept: application/json

var headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: 'https://localhost:8443/api/developer/{tid}/servers/{aid}',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

fetch('https://localhost:8443/api/developer/{tid}/servers/{aid}',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.get 'https://localhost:8443/api/developer/{tid}/servers/{aid}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://localhost:8443/api/developer/{tid}/servers/{aid}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://localhost:8443/api/developer/{tid}/servers/{aid}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {access-token}"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://localhost:8443/api/developer/{tid}/servers/{aid}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /api/developer/{tid}/servers/{aid}

Get authorization server

Returns authorization server details with list of scopes.

Parameters

Name In Type Required Description
tid path string true Tenant id
aid path string true Authorization server id

Example responses

200 Response

{
  "grant_types": [
    "implicit",
    "authorization_code",
    "refresh_token"
  ],
  "id": "default",
  "issuer_url": "https://example.com/default/default",
  "name": "ACP",
  "scopes": [
    {
      "scope_description": "This scope value requests offline access using refresh token",
      "scope_display_name": "Offline access",
      "scope_id": "1",
      "scope_name": "offline_access",
      "service_description": "service description",
      "service_id": "1",
      "service_name": "service",
      "with_service": false
    }
  ]
}

Responses

Status Meaning Description Schema
200 OK

GetServerWithScopesDeveloperResponse

GetServerWithScopesDeveloperResponse
401 Unauthorized

HttpError

Error
403 Forbidden

HttpError

Error
404 Not Found

HttpError

Error

system

exportConfiguration

Code samples

# You can also use wget
curl -X GET https://localhost:8443/api/system/configuration \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://localhost:8443/api/system/configuration HTTP/1.1
Host: localhost:8443
Accept: application/json

var headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: 'https://localhost:8443/api/system/configuration',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'

};

fetch('https://localhost:8443/api/system/configuration',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.get 'https://localhost:8443/api/system/configuration',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://localhost:8443/api/system/configuration', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://localhost:8443/api/system/configuration");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {access-token}"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://localhost:8443/api/system/configuration", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /api/system/configuration

Export configuration

Parameters

Name In Type Required Description
tid query string false Tenant id

Example responses

200 Response

{
  "apis": [
    {
      "can_have_policy": true,
      "data_classifications": [
        "string"
      ],
      "id": "1",
      "method": "GET",
      "path": "/pets",
      "policy_id": "block",
      "position": 1,
      "server_id": "default",
      "service_id": "1",
      "tenant_id": "default"
    }
  ],
  "claims": [
    {
      "authorization_server_id": "default",
      "id": "1",
      "mapping": "email",
      "name": "email",
      "scopes": [
        "email",
        "email_verified"
      ],
      "tenant_id": "default",
      "type": "string"
    }
  ],
  "clients": [
    {
      "audience": [
        "string"
      ],
      "authorization_server_id": "default",
      "client_hashed_secret": "string",
      "client_id": "string",
      "client_id_issued_at": 0,
      "client_name": "My app",
      "client_secret": "string",
      "client_secret_expires_at": 0,
      "client_uri": "string",
      "description": "string",
      "developer_id": "string",
      "grant_types": [
        "password",
        "refresh_token",
        "client_credentials",
        "implicit",
        "authorization_code"
      ],
      "jwks": {
        "keys": []
      },
      "jwks_uri": "string",
      "logo_uri": "string",
      "policy_uri": "string",
      "privacy": {
        "scopes": {
          "property1": {
            "pii_categories": [
              {
                "name": "HIPAA"
              }
            ],
            "purpose": "string"
          },
          "property2": {
            "pii_categories": [
              {
                "name": "HIPAA"
              }
            ],
            "purpose": "string"
          }
        }
      },
      "public": true,
      "redirect_uris": [
        "https://example.com/callback"
      ],
      "request_object_signing_alg": "none",
      "request_uris": [
        "string"
      ],
      "response_types": [
        "token",
        "id_token",
        "code"
      ],
      "scope": "email offline_access openid",
      "scopes": [
        "email",
        "offline_access",
        "openid"
      ],
      "sector_identifier_uri": "https://api.jsonbin.io/b/5db6ef08688fed59d2841f1e",
      "system": false,
      "tenant_id": "string",
      "tls_client_auth_san_dns": "string",
      "tls_client_auth_san_email": "string",
      "tls_client_auth_san_ip": "string",
      "tls_client_auth_san_uri": "string",
      "tls_client_auth_subject_dn": "string",
      "tls_client_certificate_bound_access_tokens": true,
      "token_endpoint_auth_method": "client_secret_basic",
      "token_endpoint_signing_alg": "string",
      "tos_uri": "string",
      "trusted": true,
      "userinfo_signed_response_alg": "none"
    }
  ],
  "consent_actions": [
    {
      "consents": [
        {
          "can_be_withdrawn": false,
          "description": "End User License Agreement",
          "id": "1",
          "internal_services": [
            {
              "name": "string",
              "purposes": [
                {
                  "name": "Core Function",
                  "primary": true
                }
              ]
            }
          ],
          "name": "EULA",
          "pii_categories": [
            {
              "name": "HIPAA"
            }
          ],
          "required": false,
          "tenant_id": "default",
          "third_party_services": [
            {
              "name": "string",
              "purposes": [
                {
                  "name": "Core Function",
                  "primary": true
                }
              ]
            }
          ],
          "update_existing_grants": "explicitAll",
          "valid_from": "2019-12-11T13:44:28.772101Z",
          "version": 1
        }
      ],
      "description": "Consents required by application X",
      "id": "1",
      "name": "application_x",
      "tenant_id": "default"
    }
  ],
  "consents": [
    {
      "can_be_withdrawn": false,
      "description": "End User License Agreement",
      "id": "1",
      "internal_services": [
        {
          "name": "string",
          "purposes": [
            {
              "name": "Core Function",
              "primary": true
            }
          ]
        }
      ],
      "name": "EULA",
      "pii_categories": [
        {
          "name": "HIPAA"
        }
      ],
      "tenant_id": "default",
      "third_party_services": [
        {
          "name": "string",
          "purposes": [
            {
              "name": "Core Function",
              "primary": true
            }
          ]
        }
      ],
      "update_existing_grants": "explicitAll",
      "valid_from": "2019-12-11T13:44:28.772101Z",
      "version": 1
    }
  ],
  "policies": [
    {
      "id": "1",
      "policy_name": "check_consent",
      "tenant_id": "default",
      "validators": [
        {
          "conf": {
            "property1": {},
            "property2": {}
          },
          "name": "identity-context",
          "recovery": [
            {
              "id": "string",
              "type": "string"
            }
          ]
        }
      ]
    }
  ],
  "scopes_without_service": [
    {
      "authorization_server_id": "default",
      "description": "This scope value requests offline access using refresh token",
      "developer_policy_id": "block",
      "display_name": "Offline Access",
      "id": "1",
      "name": "offline_access",
      "tenant_id": "default",
      "user_policy_id": "block"
    }
  ],
  "servers": [
    {
      "access_token_ttl": "1h10m30s",
      "authentications": {
        "methods": [
          {
            "attributes": [
              {
                "description": "string",
                "name": "string"
              }
            ],
            "azure": {
              "client_id": "client",
              "client_secret": "secret",
              "fetch_groups": true,
              "get_user": true,
              "group_name_format": "id",
              "only_security_groups": true,
              "redirect_url": "https://example.com/callback",
              "scopes": [
                "email",
                "profile",
                "openid"
              ],
              "tenant": "123-312-123"
            },
            "cognito": {
              "client_id": "client",
              "client_secret": "secret",
              "get_user_info": true,
              "pool_id": "us-east-1_Q8WSOH11B",
              "redirect_url": "https://example.com/callback",
              "region": "us-east-1",
              "scopes": [
                "email",
                "profile",
                "openid"
              ]
            },
            "custom": {
              "login_url": "https://example.com/login"
            },
            "disabled": false,
            "id": "oidc",
            "mappings": [
              {
                "source": "access_token",
                "target": "."
              }
            ],
            "method": "string",
            "name": "OIDC",
            "oidc": {
              "client_id": "client",
              "client_secret": "secret",
              "get_user_info": true,
              "issuer_url": "string",
              "redirect_url": "https://example.com/callback",
              "scopes": [
                "email",
                "profile",
                "openid"
              ]
            },
            "static": {
              "hint": true,
              "users": [
                {
                  "authentication_context": {
                    "property1": {},
                    "property2": {}
                  },
                  "password": "secret",
                  "username": "peter"
                }
              ]
            }
          }
        ]
      },
      "authorization_code_ttl": "10m0s",
      "cookie_max_age": "1h10m30s",
      "developer_policy_id": "string",
      "enable_dynamic_client_registration": false,
      "enforce_pkce": false,
      "grant_types": [
        "authorization_code",
        "implicit",
        "refresh_token",
        "client_credentials"
      ],
      "id": "935ab21c-b20a-11e9-a2a3-2a2ae2dbcce4",
      "id_token_ttl": "1h10m30s",
      "issuer_url": "http://example.com/default/default",
      "jwks": {
        "keys": []
      },
      "key_type": "rsa",
      "logo_uri": "string",
      "name": "Sample authorization server",
      "profiles": [
        "fapi_rw"
      ],
      "refresh_token_ttl": "720h0m0s",
      "rotated_secrets": [
        "jFpwIvuKJP46J71WqszPv1SrzoUr-cSILP9EPdlClB4"
      ],
      "secret": "hW5WhKX_7w7BLwUQ6mn7Cp70_OoKI_F1y1hLS5U8lIU",
      "system": false,
      "tenant_id": "string",
      "user_policy_id": "string"
    }
  ],
  "services": [
    {
      "authorization_server_id": "default",
      "description": "Service description",
      "gateway_id": "string",
      "id": "1",
      "name": "Sample service",
      "scopes": [
        {
          "authorization_server_id": "default",
          "description": "This scope value requests offline access using refresh token",
          "developer_policy_id": "block",
          "display_name": "Offline Access",
          "id": "1",
          "name": "offline_access",
          "tenant_id": "default",
          "user_policy_id": "block"
        }
      ],
      "tenant_id": "default",
      "with_specification": true
    }
  ],
  "tenants": [
    {
      "authentication_context_settings": {
        "attributes": [
          {
            "description"