Introduction

BYRD API provides a simple and consistent way that allows developers to build on top of BYRD via structured data and in predictable formats using RESTful endpoints.

We are continuously improving and adding new endpoints to the API. For any questions or feedback, please use this form.

Authentication

# You can also use wget
# This curl statement will return a REST Representation of
# the current data model
curl -X GET /v1/datamodel/current \
  --user username:password

# This statement will return a REST Representation of
# the current data model

GET /v1/datamodel/current HTTP/1.1

Authorization: username:password

// This code will return a REST Representation of
// the current data model

const headers = {
  'Authorization':'username:password'
};

fetch('/v1/datamodel/current',
{
  method: 'GET',
  headers: headers
})
.then(function(res) {
  return res.json();
}).then(function(body) {
  console.log(body);
});

# This code will return a REST Representation of
# the current data model

require 'rest-client'
require 'json'

headers = {
  'Authorization' => 'username:password'
}

result = RestClient.get '/v1/datamodel/current',
  params: {
  }, headers: headers

p JSON.parse(result)

# This code will return a REST Representation of
# the current data model

import requests
headers = {
  'Authorization': 'username:password'
}

r = requests.get('/v1/datamodel/current', headers = headers)

print(r.json())

<?php
// This code will return a REST Representation of
// the current data model

require 'vendor/autoload.php';

$headers = array(
    'Authorization' => 'username:password',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','/v1/datamodel/current', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

// This code will return a REST Representation of
// the current data model

URL obj = new URL("/v1/datamodel/current");
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());

// This code will return a REST Representation of
// the current data model

package main

import (
  "bytes"
  "net/http"
)

func main() {
  headers := map[string][]string{
      "Authorization": []string{"username:password"},
  }

  data := bytes.NewBuffer([]byte{jsonReq})
  req, err := http.NewRequest("GET", "/v1/datamodel/current", data)
  req.Header = headers

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

Most of the information can be obtained or sent to the system via simple HTTP GET and HTTP POST calls. The available endpoints are described in this documentation.

To obtain a connection to the system you need to pass your login credentials as Basic Authentication scheme in your Authorization Header.

Asset Folders

Documents, media files and folders management resource

convertToPublicAsset

# You can also use wget
curl -X PUT /v1/assetFolders/_convertToPublicAsset{path} \
  -H 'Content-Type: */*' \
  -H 'Accept: application/json; charset=UTF-8'

PUT /v1/assetFolders/_convertToPublicAsset{path} HTTP/1.1

Content-Type: */*
Accept: application/json; charset=UTF-8

const inputBody = '{
  "path": "string",
  "name": "string"
}';
const headers = {
  'Content-Type':'*/*',
  'Accept':'application/json; charset=UTF-8'
};

fetch('/v1/assetFolders/_convertToPublicAsset{path}',
{
  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' => '*/*',
  'Accept' => 'application/json; charset=UTF-8'
}

result = RestClient.put '/v1/assetFolders/_convertToPublicAsset{path}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': '*/*',
  'Accept': 'application/json; charset=UTF-8'
}

r = requests.put('/v1/assetFolders/_convertToPublicAsset{path}', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Content-Type' => '*/*',
    'Accept' => 'application/json; charset=UTF-8',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('PUT','/v1/assetFolders/_convertToPublicAsset{path}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("/v1/assetFolders/_convertToPublicAsset{path}");
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{"*/*"},
        "Accept": []string{"application/json; charset=UTF-8"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "/v1/assetFolders/_convertToPublicAsset{path}", data)
    req.Header = headers

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

PUT /v1/assetFolders/_convertToPublicAsset{path}

Convert an asset to a public asset

Parameters

Name	In	Type	Required	Description
path	path	string	true	none
body	body	FolderPathName	false	none

Responses

Status	Meaning	Description	Schema
default	Default	default response	None

Response Schema

getFolderContent

# You can also use wget
curl -X GET /v1/assetFolders{path} \
  -H 'Accept: application/json' \
  -H 'If-None-Match: string'

GET /v1/assetFolders{path} HTTP/1.1

Accept: application/json
If-None-Match: string


const headers = {
  'Accept':'application/json',
  'If-None-Match':'string'
};

fetch('/v1/assetFolders{path}',
{
  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',
  'If-None-Match' => 'string'
}

result = RestClient.get '/v1/assetFolders{path}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'If-None-Match': 'string'
}

r = requests.get('/v1/assetFolders{path}', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
    'If-None-Match' => 'string',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','/v1/assetFolders{path}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("/v1/assetFolders{path}");
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"},
        "If-None-Match": []string{"string"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/v1/assetFolders{path}", data)
    req.Header = headers

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

GET /v1/assetFolders{path}

Get a folder content by its path

Parameters

Name	In	Type	Required	Description
If-None-Match	header	string	false	none
allowCaching	query	boolean	false	none
download	query	boolean	false	none
path	path	string	true	none

[
  {
    "name": "string",
    "linkType": "ASSET",
    "createdAt": "2019-08-24T14:15:22Z",
    "createdBy": "string",
    "changedAt": "2019-08-24T14:15:22Z",
    "changedBy": "string",
    "parentFolderId": 0
  }
]

Responses

Status	Meaning	Description	Schema
200	OK	none	Inline

Response Schema

Status Code 200

Name	Type	Required	Restrictions	Description
anonymous	[AssetFolderLink]	false	none	none
» name	string	false	none	none
» linkType	string	false	none	none
» createdAt	string(date-time)	false	none	none
» createdBy	string	false	none	none
» changedAt	string(date-time)	false	none	none
» changedBy	string	false	none	none
» parentFolderId	integer(int64)	false	none	none

Enumerated Values

Property	Value
linkType	ASSET
linkType	FOLDER

createFolder

# You can also use wget
curl -X POST /v1/assetFolders{path} \
  -H 'Content-Type: */*' \
  -H 'Accept: application/json; charset=UTF-8'

POST /v1/assetFolders{path} HTTP/1.1

Content-Type: */*
Accept: application/json; charset=UTF-8

const inputBody = '{
  "path": "string",
  "name": "string"
}';
const headers = {
  'Content-Type':'*/*',
  'Accept':'application/json; charset=UTF-8'
};

fetch('/v1/assetFolders{path}',
{
  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' => '*/*',
  'Accept' => 'application/json; charset=UTF-8'
}

result = RestClient.post '/v1/assetFolders{path}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': '*/*',
  'Accept': 'application/json; charset=UTF-8'
}

r = requests.post('/v1/assetFolders{path}', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Content-Type' => '*/*',
    'Accept' => 'application/json; charset=UTF-8',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('POST','/v1/assetFolders{path}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("/v1/assetFolders{path}");
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{"*/*"},
        "Accept": []string{"application/json; charset=UTF-8"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "/v1/assetFolders{path}", data)
    req.Header = headers

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

POST /v1/assetFolders{path}

Create a folder in the specified path

Parameters

Name	In	Type	Required	Description
path	path	string	true	none
body	body	FolderPathName	false	none

Responses

Status	Meaning	Description	Schema
default	Default	default response	None

Response Schema

deleteItem

# You can also use wget
curl -X DELETE /v1/assetFolders/_delete{path} \
  -H 'Accept: application/json; charset=UTF-8'

DELETE /v1/assetFolders/_delete{path} HTTP/1.1

Accept: application/json; charset=UTF-8


const headers = {
  'Accept':'application/json; charset=UTF-8'
};

fetch('/v1/assetFolders/_delete{path}',
{
  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; charset=UTF-8'
}

result = RestClient.delete '/v1/assetFolders/_delete{path}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json; charset=UTF-8'
}

r = requests.delete('/v1/assetFolders/_delete{path}', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json; charset=UTF-8',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('DELETE','/v1/assetFolders/_delete{path}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("/v1/assetFolders/_delete{path}");
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; charset=UTF-8"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "/v1/assetFolders/_delete{path}", data)
    req.Header = headers

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

DELETE /v1/assetFolders/_delete{path}

Delete asset/folder with the given path

Parameters

Name	In	Type	Required	Description
path	path	string	true	none

Responses

Status	Meaning	Description	Schema
default	Default	default response	None

Response Schema

deleteItems

# You can also use wget
curl -X DELETE /v1/assetFolders/_deleteItems \
  -H 'Content-Type: */*' \
  -H 'Accept: application/json; charset=UTF-8'

DELETE /v1/assetFolders/_deleteItems HTTP/1.1

Content-Type: */*
Accept: application/json; charset=UTF-8

const inputBody = '{}';
const headers = {
  'Content-Type':'*/*',
  'Accept':'application/json; charset=UTF-8'
};

fetch('/v1/assetFolders/_deleteItems',
{
  method: 'DELETE',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => '*/*',
  'Accept' => 'application/json; charset=UTF-8'
}

result = RestClient.delete '/v1/assetFolders/_deleteItems',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': '*/*',
  'Accept': 'application/json; charset=UTF-8'
}

r = requests.delete('/v1/assetFolders/_deleteItems', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Content-Type' => '*/*',
    'Accept' => 'application/json; charset=UTF-8',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('DELETE','/v1/assetFolders/_deleteItems', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("/v1/assetFolders/_deleteItems");
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{
        "Content-Type": []string{"*/*"},
        "Accept": []string{"application/json; charset=UTF-8"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "/v1/assetFolders/_deleteItems", data)
    req.Header = headers

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

DELETE /v1/assetFolders/_deleteItems

Delete assets/folders with the given paths

Parameters

Name	In	Type	Required	Description
body	body	object	false	none

Responses

Status	Meaning	Description	Schema
default	Default	default response	None

Response Schema

getDetailsOfAnAssetFolderLink

# You can also use wget
curl -X GET /v1/assetFolders/_getDetails{path} \
  -H 'Accept: application/json'

GET /v1/assetFolders/_getDetails{path} HTTP/1.1

Accept: application/json


const headers = {
  'Accept':'application/json'
};

fetch('/v1/assetFolders/_getDetails{path}',
{
  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'
}

result = RestClient.get '/v1/assetFolders/_getDetails{path}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json'
}

r = requests.get('/v1/assetFolders/_getDetails{path}', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','/v1/assetFolders/_getDetails{path}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("/v1/assetFolders/_getDetails{path}");
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"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/v1/assetFolders/_getDetails{path}", data)
    req.Header = headers

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

GET /v1/assetFolders/_getDetails{path}

Get folder details by its path

Parameters

Name	In	Type	Required	Description
path	path	string	true	none

{
  "name": "string",
  "linkType": "ASSET",
  "createdAt": "2019-08-24T14:15:22Z",
  "createdBy": "string",
  "changedAt": "2019-08-24T14:15:22Z",
  "changedBy": "string",
  "parentFolderId": 0
}

Responses

Status	Meaning	Description	Schema
200	OK	none	AssetFolderLink

moveAsset

# You can also use wget
curl -X PUT /v1/assetFolders/_moveAsset{path} \
  -H 'Content-Type: */*' \
  -H 'Accept: application/json; charset=UTF-8'

PUT /v1/assetFolders/_moveAsset{path} HTTP/1.1

Content-Type: */*
Accept: application/json; charset=UTF-8

const inputBody = '{
  "path": "string",
  "name": "string"
}';
const headers = {
  'Content-Type':'*/*',
  'Accept':'application/json; charset=UTF-8'
};

fetch('/v1/assetFolders/_moveAsset{path}',
{
  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' => '*/*',
  'Accept' => 'application/json; charset=UTF-8'
}

result = RestClient.put '/v1/assetFolders/_moveAsset{path}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': '*/*',
  'Accept': 'application/json; charset=UTF-8'
}

r = requests.put('/v1/assetFolders/_moveAsset{path}', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Content-Type' => '*/*',
    'Accept' => 'application/json; charset=UTF-8',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('PUT','/v1/assetFolders/_moveAsset{path}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("/v1/assetFolders/_moveAsset{path}");
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{"*/*"},
        "Accept": []string{"application/json; charset=UTF-8"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "/v1/assetFolders/_moveAsset{path}", data)
    req.Header = headers

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

PUT /v1/assetFolders/_moveAsset{path}

Move asset to the given path

Parameters

Name	In	Type	Required	Description
path	path	string	true	none
body	body	FolderPathName	false	none

Responses

Status	Meaning	Description	Schema
default	Default	default response	None

Response Schema

moveFolder

# You can also use wget
curl -X PUT /v1/assetFolders/_moveFolder{path} \
  -H 'Content-Type: */*' \
  -H 'Accept: application/json; charset=UTF-8'

PUT /v1/assetFolders/_moveFolder{path} HTTP/1.1

Content-Type: */*
Accept: application/json; charset=UTF-8

const inputBody = '{
  "path": "string",
  "name": "string"
}';
const headers = {
  'Content-Type':'*/*',
  'Accept':'application/json; charset=UTF-8'
};

fetch('/v1/assetFolders/_moveFolder{path}',
{
  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' => '*/*',
  'Accept' => 'application/json; charset=UTF-8'
}

result = RestClient.put '/v1/assetFolders/_moveFolder{path}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': '*/*',
  'Accept': 'application/json; charset=UTF-8'
}

r = requests.put('/v1/assetFolders/_moveFolder{path}', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Content-Type' => '*/*',
    'Accept' => 'application/json; charset=UTF-8',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('PUT','/v1/assetFolders/_moveFolder{path}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("/v1/assetFolders/_moveFolder{path}");
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{"*/*"},
        "Accept": []string{"application/json; charset=UTF-8"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "/v1/assetFolders/_moveFolder{path}", data)
    req.Header = headers

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

PUT /v1/assetFolders/_moveFolder{path}

Move folder to the given path

Parameters

Name	In	Type	Required	Description
path	path	string	true	none
body	body	FolderPathName	false	none

Responses

Status	Meaning	Description	Schema
default	Default	default response	None

Response Schema

renameAsset

# You can also use wget
curl -X PUT /v1/assetFolders/_renameAsset{path} \
  -H 'Content-Type: */*' \
  -H 'Accept: application/json; charset=UTF-8'

PUT /v1/assetFolders/_renameAsset{path} HTTP/1.1

Content-Type: */*
Accept: application/json; charset=UTF-8

const inputBody = '{
  "path": "string",
  "name": "string"
}';
const headers = {
  'Content-Type':'*/*',
  'Accept':'application/json; charset=UTF-8'
};

fetch('/v1/assetFolders/_renameAsset{path}',
{
  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' => '*/*',
  'Accept' => 'application/json; charset=UTF-8'
}

result = RestClient.put '/v1/assetFolders/_renameAsset{path}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': '*/*',
  'Accept': 'application/json; charset=UTF-8'
}

r = requests.put('/v1/assetFolders/_renameAsset{path}', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Content-Type' => '*/*',
    'Accept' => 'application/json; charset=UTF-8',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('PUT','/v1/assetFolders/_renameAsset{path}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("/v1/assetFolders/_renameAsset{path}");
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{"*/*"},
        "Accept": []string{"application/json; charset=UTF-8"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "/v1/assetFolders/_renameAsset{path}", data)
    req.Header = headers

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

PUT /v1/assetFolders/_renameAsset{path}

Rename asset to the given name

Parameters

Name	In	Type	Required	Description
path	path	string	true	none
body	body	FolderPathName	false	none

Responses

Status	Meaning	Description	Schema
default	Default	default response	None

Response Schema

renameFolder

# You can also use wget
curl -X PUT /v1/assetFolders/_renameFolder{path} \
  -H 'Content-Type: */*' \
  -H 'Accept: application/json; charset=UTF-8'

PUT /v1/assetFolders/_renameFolder{path} HTTP/1.1

Content-Type: */*
Accept: application/json; charset=UTF-8

const inputBody = '{
  "path": "string",
  "name": "string"
}';
const headers = {
  'Content-Type':'*/*',
  'Accept':'application/json; charset=UTF-8'
};

fetch('/v1/assetFolders/_renameFolder{path}',
{
  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' => '*/*',
  'Accept' => 'application/json; charset=UTF-8'
}

result = RestClient.put '/v1/assetFolders/_renameFolder{path}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': '*/*',
  'Accept': 'application/json; charset=UTF-8'
}

r = requests.put('/v1/assetFolders/_renameFolder{path}', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Content-Type' => '*/*',
    'Accept' => 'application/json; charset=UTF-8',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('PUT','/v1/assetFolders/_renameFolder{path}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("/v1/assetFolders/_renameFolder{path}");
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{"*/*"},
        "Accept": []string{"application/json; charset=UTF-8"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "/v1/assetFolders/_renameFolder{path}", data)
    req.Header = headers

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

PUT /v1/assetFolders/_renameFolder{path}

Rename folder to the given name

Parameters

Name	In	Type	Required	Description
path	path	string	true	none
body	body	FolderPathName	false	none

Responses

Status	Meaning	Description	Schema
default	Default	default response	None

Response Schema

uploadArchive

# You can also use wget
curl -X POST /v1/assetFolders/_uploadArchive{path} \
  -H 'Accept: application/json; charset=UTF-8'

POST /v1/assetFolders/_uploadArchive{path} HTTP/1.1

Accept: application/json; charset=UTF-8


const headers = {
  'Accept':'application/json; charset=UTF-8'
};

fetch('/v1/assetFolders/_uploadArchive{path}',
{
  method: 'POST',

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

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json; charset=UTF-8'
}

result = RestClient.post '/v1/assetFolders/_uploadArchive{path}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json; charset=UTF-8'
}

r = requests.post('/v1/assetFolders/_uploadArchive{path}', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json; charset=UTF-8',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('POST','/v1/assetFolders/_uploadArchive{path}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("/v1/assetFolders/_uploadArchive{path}");
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{
        "Accept": []string{"application/json; charset=UTF-8"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "/v1/assetFolders/_uploadArchive{path}", data)
    req.Header = headers

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

POST /v1/assetFolders/_uploadArchive{path}

Upload an archive file and uncompress it to the given folder path

Parameters

Name	In	Type	Required	Description
path	path	string	true	none

Responses

Status	Meaning	Description	Schema
default	Default	default response	None

Response Schema

uploadFile

# You can also use wget
curl -X POST /v1/assetFolders/_uploadFile{path} \
  -H 'Accept: application/json; charset=UTF-8'

POST /v1/assetFolders/_uploadFile{path} HTTP/1.1

Accept: application/json; charset=UTF-8


const headers = {
  'Accept':'application/json; charset=UTF-8'
};

fetch('/v1/assetFolders/_uploadFile{path}',
{
  method: 'POST',

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

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json; charset=UTF-8'
}

result = RestClient.post '/v1/assetFolders/_uploadFile{path}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json; charset=UTF-8'
}

r = requests.post('/v1/assetFolders/_uploadFile{path}', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json; charset=UTF-8',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('POST','/v1/assetFolders/_uploadFile{path}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("/v1/assetFolders/_uploadFile{path}");
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{
        "Accept": []string{"application/json; charset=UTF-8"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "/v1/assetFolders/_uploadFile{path}", data)
    req.Header = headers

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

POST /v1/assetFolders/_uploadFile{path}

Upload a file to the given folder path

Parameters

Name	In	Type	Required	Description
path	path	string	true	none

Responses

Status	Meaning	Description	Schema
default	Default	default response	None

Response Schema

Bulk subscriptions

A bulk subscription is used to retrieve a bulk of items based on a set of criteria. The bulk subscription entries are used to define such criteria. Each entry is a tuple of attributes and their values.

getBulkSubscriptionEntriesForId

# You can also use wget
curl -X GET /v1/bulkSubscription/{id}/entries \
  -H 'x-cursor: string'

GET /v1/bulkSubscription/{id}/entries HTTP/1.1

x-cursor: string


const headers = {
  'x-cursor':'string'
};

fetch('/v1/bulkSubscription/{id}/entries',
{
  method: 'GET',

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

require 'rest-client'
require 'json'

headers = {
  'x-cursor' => 'string'
}

result = RestClient.get '/v1/bulkSubscription/{id}/entries',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'x-cursor': 'string'
}

r = requests.get('/v1/bulkSubscription/{id}/entries', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'x-cursor' => 'string',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','/v1/bulkSubscription/{id}/entries', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("/v1/bulkSubscription/{id}/entries");
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{
        "x-cursor": []string{"string"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/v1/bulkSubscription/{id}/entries", data)
    req.Header = headers

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

GET /v1/bulkSubscription/{id}/entries

Retrieve bulk subscription entries for a bulk subscription

Retrieves a list of bulk subscription entries based on the provided parameters. Pagination is supported through the use of ‘limit’ query parameter with either ‘cursor’ header or the ‘offset’ query parameter.

Parameters

Name	In	Type	Required	Description
id	path	string	true	The id of the bulk subscription to retrieve entries for
keywords	query	string	false	Specifies the keywords or query string to search bulk subscription entries for
limit	query	integer(int32)	false	Maximum number of bulk subscription entries to return in the page
offset	query	integer(int32)	false	Offset of the first bulk subscription entry to return in the page
x-cursor	header	string	false	Cursor to use for pagination

Responses

Status	Meaning	Description	Schema
404	Not Found	No bulk subscription found for the provided id	None

addBulkSubscriptionEntriesForId

# You can also use wget
curl -X POST /v1/bulkSubscription/{id}/entries \
  -H 'Content-Type: application/json'

POST /v1/bulkSubscription/{id}/entries HTTP/1.1

Content-Type: application/json

const inputBody = '[
    {
        "attribute1": "<val_A>"
        "attribute2": "<val_2>"
    }    {
        "attribute1": "<val_A>"
        "attribute2": "<val_3>"
    }    {
        "attribute1": "<val_C>"
        "attribute2": "<val_1>"
    }]';
const headers = {
  'Content-Type':'application/json'
};

fetch('/v1/bulkSubscription/{id}/entries',
{
  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'
}

result = RestClient.post '/v1/bulkSubscription/{id}/entries',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json'
}

r = requests.post('/v1/bulkSubscription/{id}/entries', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Content-Type' => 'application/json',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('POST','/v1/bulkSubscription/{id}/entries', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("/v1/bulkSubscription/{id}/entries");
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"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "/v1/bulkSubscription/{id}/entries", data)
    req.Header = headers

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

POST /v1/bulkSubscription/{id}/entries

Add bulk subscription entries for a bulk subscription

"[\n    {\n        \"attribute1\": \"<val_A>\"\n        \"attribute2\": \"<val_2>\"\n    }    {\n        \"attribute1\": \"<val_A>\"\n        \"attribute2\": \"<val_3>\"\n    }    {\n        \"attribute1\": \"<val_C>\"\n        \"attribute2\": \"<val_1>\"\n    }]"

Parameters

Name	In	Type	Required	Description
id	path	string	true	The id of the bulk subscription to add entries for
synchronously	query	boolean	false	Determines whether the operation should be performed synchronously

Responses

Status	Meaning	Description	Schema
404	Not Found	No bulk subscription found for the provided id	None

removeBulkSubscriptionEntriesForId

# You can also use wget
curl -X DELETE /v1/bulkSubscription/{id}/entries \
  -H 'Content-Type: application/json'

DELETE /v1/bulkSubscription/{id}/entries HTTP/1.1

Content-Type: application/json

const inputBody = '[
    {
        "attribute1": "<val_A>"
        "attribute2": "<val_2>"
    }    {
        "attribute1": "<val_A>"
        "attribute2": "<val_3>"
    }    {
        "attribute1": "<val_C>"
        "attribute2": "<val_1>"
    }]';
const headers = {
  'Content-Type':'application/json'
};

fetch('/v1/bulkSubscription/{id}/entries',
{
  method: 'DELETE',
  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'
}

result = RestClient.delete '/v1/bulkSubscription/{id}/entries',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json'
}

r = requests.delete('/v1/bulkSubscription/{id}/entries', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Content-Type' => 'application/json',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('DELETE','/v1/bulkSubscription/{id}/entries', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("/v1/bulkSubscription/{id}/entries");
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{
        "Content-Type": []string{"application/json"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "/v1/bulkSubscription/{id}/entries", data)
    req.Header = headers

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

DELETE /v1/bulkSubscription/{id}/entries

Remove bulk subscription entries for a bulk subscription

"[\n    {\n        \"attribute1\": \"<val_A>\"\n        \"attribute2\": \"<val_2>\"\n    }    {\n        \"attribute1\": \"<val_A>\"\n        \"attribute2\": \"<val_3>\"\n    }    {\n        \"attribute1\": \"<val_C>\"\n        \"attribute2\": \"<val_1>\"\n    }]"

Parameters

Name	In	Type	Required	Description
id	path	string	true	The id of the bulk subscription to remove entries for
synchronously	query	boolean	false	Determines whether the operation should be performed synchronously

Responses

Status	Meaning	Description	Schema
404	Not Found	No bulk subscription found for the provided id	None

getBulkSubscriptionEntriesForName

# You can also use wget
curl -X GET /v1/bulkSubscription/{name}/entries \
  -H 'x-cursor: string'

GET /v1/bulkSubscription/{name}/entries HTTP/1.1

x-cursor: string


const headers = {
  'x-cursor':'string'
};

fetch('/v1/bulkSubscription/{name}/entries',
{
  method: 'GET',

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

require 'rest-client'
require 'json'

headers = {
  'x-cursor' => 'string'
}

result = RestClient.get '/v1/bulkSubscription/{name}/entries',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'x-cursor': 'string'
}

r = requests.get('/v1/bulkSubscription/{name}/entries', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'x-cursor' => 'string',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','/v1/bulkSubscription/{name}/entries', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("/v1/bulkSubscription/{name}/entries");
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{
        "x-cursor": []string{"string"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/v1/bulkSubscription/{name}/entries", data)
    req.Header = headers

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

GET /v1/bulkSubscription/{name}/entries

Retrieve bulk subscription entries for a bulk subscription

Parameters

Name	In	Type	Required	Description
name	path	string	true	The name of the bulk subscription to retrieve entries for
keywords	query	string	false	Specifies the keywords or query string to search bulk subscription entries for
limit	query	integer(int32)	false	Maximum number of bulk subscription entries to return in the page
offset	query	integer(int32)	false	Offset of the first bulk subscription entry to return in the page
x-cursor	header	string	false	Cursor to use for pagination

Responses

Status	Meaning	Description	Schema
404	Not Found	No bulk subscription found for the provided name	None

addBulkSubscriptionEntriesForName

# You can also use wget
curl -X POST /v1/bulkSubscription/{name}/entries \
  -H 'Content-Type: application/json'

POST /v1/bulkSubscription/{name}/entries HTTP/1.1

Content-Type: application/json

const inputBody = '[
    {
        "attribute1": "<val_A>"
        "attribute2": "<val_2>"
    }    {
        "attribute1": "<val_A>"
        "attribute2": "<val_3>"
    }    {
        "attribute1": "<val_C>"
        "attribute2": "<val_1>"
    }]';
const headers = {
  'Content-Type':'application/json'
};

fetch('/v1/bulkSubscription/{name}/entries',
{
  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'
}

result = RestClient.post '/v1/bulkSubscription/{name}/entries',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json'
}

r = requests.post('/v1/bulkSubscription/{name}/entries', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Content-Type' => 'application/json',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('POST','/v1/bulkSubscription/{name}/entries', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("/v1/bulkSubscription/{name}/entries");
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"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "/v1/bulkSubscription/{name}/entries", data)
    req.Header = headers

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

POST /v1/bulkSubscription/{name}/entries

Add bulk subscription entries for a bulk subscription

"[\n    {\n        \"attribute1\": \"<val_A>\"\n        \"attribute2\": \"<val_2>\"\n    }    {\n        \"attribute1\": \"<val_A>\"\n        \"attribute2\": \"<val_3>\"\n    }    {\n        \"attribute1\": \"<val_C>\"\n        \"attribute2\": \"<val_1>\"\n    }]"

Parameters

Name	In	Type	Required	Description
name	path	string	true	The name of the bulk subscription to add entries for
synchronously	query	boolean	false	Determines whether the operation should be performed synchronously

Responses

Status	Meaning	Description	Schema
404	Not Found	No bulk subscription found for the provided name	None

removeBulkSubscriptionEntriesForName

# You can also use wget
curl -X DELETE /v1/bulkSubscription/{name}/entries \
  -H 'Content-Type: application/json'

DELETE /v1/bulkSubscription/{name}/entries HTTP/1.1

Content-Type: application/json

const inputBody = '[
    {
        "attribute1": "<val_A>"
        "attribute2": "<val_2>"
    }    {
        "attribute1": "<val_A>"
        "attribute2": "<val_3>"
    }    {
        "attribute1": "<val_C>"
        "attribute2": "<val_1>"
    }]';
const headers = {
  'Content-Type':'application/json'
};

fetch('/v1/bulkSubscription/{name}/entries',
{
  method: 'DELETE',
  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'
}

result = RestClient.delete '/v1/bulkSubscription/{name}/entries',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json'
}

r = requests.delete('/v1/bulkSubscription/{name}/entries', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Content-Type' => 'application/json',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('DELETE','/v1/bulkSubscription/{name}/entries', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("/v1/bulkSubscription/{name}/entries");
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{
        "Content-Type": []string{"application/json"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "/v1/bulkSubscription/{name}/entries", data)
    req.Header = headers

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

DELETE /v1/bulkSubscription/{name}/entries

Remove bulk subscription entries for a bulk subscription

"[\n    {\n        \"attribute1\": \"<val_A>\"\n        \"attribute2\": \"<val_2>\"\n    }    {\n        \"attribute1\": \"<val_A>\"\n        \"attribute2\": \"<val_3>\"\n    }    {\n        \"attribute1\": \"<val_C>\"\n        \"attribute2\": \"<val_1>\"\n    }]"

Parameters

Name	In	Type	Required	Description
name	path	string	true	The name of the bulk subscription to remove entries for
synchronously	query	boolean	false	Determines whether the operation should be performed synchronously

Responses

Status	Meaning	Description	Schema
404	Not Found	No bulk subscription found for the provided name	None

getBulkSubscriptions

# You can also use wget
curl -X GET /v1/bulkSubscription \
  -H 'Accept: application/json; charset=UTF-8' \
  -H 'x-cursor: string'

GET /v1/bulkSubscription HTTP/1.1

Accept: application/json; charset=UTF-8
x-cursor: string


const headers = {
  'Accept':'application/json; charset=UTF-8',
  'x-cursor':'string'
};

fetch('/v1/bulkSubscription',
{
  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; charset=UTF-8',
  'x-cursor' => 'string'
}

result = RestClient.get '/v1/bulkSubscription',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json; charset=UTF-8',
  'x-cursor': 'string'
}

r = requests.get('/v1/bulkSubscription', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json; charset=UTF-8',
    'x-cursor' => 'string',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','/v1/bulkSubscription', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("/v1/bulkSubscription");
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; charset=UTF-8"},
        "x-cursor": []string{"string"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/v1/bulkSubscription", data)
    req.Header = headers

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

GET /v1/bulkSubscription

Retrieve bulk subscriptions

Retrieves a list of bulk subscriptions based on the provided parameters, ordered by the last updated date. Pagination is supported through the use of ‘limit’ query parameter with either ‘cursor’ header or the ‘offset’ query parameter.

Parameters

Name	In	Type	Required	Description
keywords	query	string	false	Specifies the keywords or query string to search bulk subscriptions for
limit	query	integer(int32)	false	Maximum number of bulk subscriptions to return in the page
offset	query	integer(int32)	false	Offset of the first bulk subscription to return in the page
x-cursor	header	string	false	Cursor to use for pagination

Responses

Status	Meaning	Description	Schema
default	Default	default response	None

Response Schema

createBulkSubscription

# You can also use wget
curl -X POST /v1/bulkSubscription \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json; charset=UTF-8'

POST /v1/bulkSubscription HTTP/1.1

Content-Type: application/json
Accept: application/json; charset=UTF-8

const inputBody = '{
  "name": "<BULK_SUBSCRIPTION_NAME>",
  "label": "<BULK_SUBSCRIPTION_LABEL>",
  "attributes": [
    "attribute1",
    "attribute2"
  ]
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json; charset=UTF-8'
};

fetch('/v1/bulkSubscription',
{
  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; charset=UTF-8'
}

result = RestClient.post '/v1/bulkSubscription',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json; charset=UTF-8'
}

r = requests.post('/v1/bulkSubscription', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Content-Type' => 'application/json',
    'Accept' => 'application/json; charset=UTF-8',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('POST','/v1/bulkSubscription', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("/v1/bulkSubscription");
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; charset=UTF-8"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "/v1/bulkSubscription", data)
    req.Header = headers

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

POST /v1/bulkSubscription

Create a bulk subscription

{
  "name": "<BULK_SUBSCRIPTION_NAME>",
  "label": "<BULK_SUBSCRIPTION_LABEL>",
  "attributes": [
    "attribute1",
    "attribute2"
  ]
}

Parameters

Name	In	Type	Required	Description
synchronously	query	boolean	false	Determines whether the operation should be performed synchronously

Responses

Status	Meaning	Description	Schema
default	Default	default response	None

Response Schema

getBulkSubscription

# You can also use wget
curl -X GET /v1/bulkSubscription/{name}

GET /v1/bulkSubscription/{name} HTTP/1.1


fetch('/v1/bulkSubscription/{name}',
{
  method: 'GET'

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

require 'rest-client'
require 'json'

result = RestClient.get '/v1/bulkSubscription/{name}',
  params: {
  }

p JSON.parse(result)

import requests

r = requests.get('/v1/bulkSubscription/{name}')

print(r.json())

<?php

require 'vendor/autoload.php';

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','/v1/bulkSubscription/{name}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("/v1/bulkSubscription/{name}");
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() {

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/v1/bulkSubscription/{name}", data)
    req.Header = headers

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

GET /v1/bulkSubscription/{name}

Retrieve a bulk subscription

Parameters

Name	In	Type	Required	Description
name	path	string	true	The name of the bulk subscription to retrieve

Responses

Status	Meaning	Description	Schema
404	Not Found	No bulk subscription found for the provided name	None

updateBulkSubscription

# You can also use wget
curl -X PUT /v1/bulkSubscription/{name} \
  -H 'Content-Type: application/json'

PUT /v1/bulkSubscription/{name} HTTP/1.1

Content-Type: application/json

const inputBody = '{
  "name": "<BULK_SUBSCRIPTION_NAME>",
  "label": "<BULK_SUBSCRIPTION_LABEL>",
  "attributes": [
    "attribute1",
    "attribute2"
  ]
}';
const headers = {
  'Content-Type':'application/json'
};

fetch('/v1/bulkSubscription/{name}',
{
  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'
}

result = RestClient.put '/v1/bulkSubscription/{name}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json'
}

r = requests.put('/v1/bulkSubscription/{name}', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Content-Type' => 'application/json',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('PUT','/v1/bulkSubscription/{name}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("/v1/bulkSubscription/{name}");
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"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "/v1/bulkSubscription/{name}", data)
    req.Header = headers

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

PUT /v1/bulkSubscription/{name}

Update bulk subscription

{
  "name": "<BULK_SUBSCRIPTION_NAME>",
  "label": "<BULK_SUBSCRIPTION_LABEL>",
  "attributes": [
    "attribute1",
    "attribute2"
  ]
}

Parameters

Name	In	Type	Required	Description
name	path	string	true	The name of the bulk subscription to update
synchronously	query	boolean	false	Determines whether the operation should be performed synchronously

Responses

Status	Meaning	Description	Schema
404	Not Found	No bulk subscription found for the provided name	None

deleteBulkSubscription

# You can also use wget
curl -X DELETE /v1/bulkSubscription/{name}

DELETE /v1/bulkSubscription/{name} HTTP/1.1


fetch('/v1/bulkSubscription/{name}',
{
  method: 'DELETE'

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

require 'rest-client'
require 'json'

result = RestClient.delete '/v1/bulkSubscription/{name}',
  params: {
  }

p JSON.parse(result)

import requests

r = requests.delete('/v1/bulkSubscription/{name}')

print(r.json())

<?php

require 'vendor/autoload.php';

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('DELETE','/v1/bulkSubscription/{name}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("/v1/bulkSubscription/{name}");
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() {

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "/v1/bulkSubscription/{name}", data)
    req.Header = headers

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

DELETE /v1/bulkSubscription/{name}

Delete bulk subscription

Parameters

Name	In	Type	Required	Description
name	path	string	true	The name of the bulk subscription to delete
synchronously	query	string	false	Specify whether to to delete synchronously or not
force	query	string	false	Enforces deletion even bulk subscription is in wrong state

Responses

Status	Meaning	Description	Schema
404	Not Found	No bulk subscription found for the provided name	None

getBulkSubscription_1

# You can also use wget
curl -X GET /v1/bulkSubscription/{id}

GET /v1/bulkSubscription/{id} HTTP/1.1


fetch('/v1/bulkSubscription/{id}',
{
  method: 'GET'

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

require 'rest-client'
require 'json'

result = RestClient.get '/v1/bulkSubscription/{id}',
  params: {
  }

p JSON.parse(result)

import requests

r = requests.get('/v1/bulkSubscription/{id}')

print(r.json())

<?php

require 'vendor/autoload.php';

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','/v1/bulkSubscription/{id}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("/v1/bulkSubscription/{id}");
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() {

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/v1/bulkSubscription/{id}", data)
    req.Header = headers

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

GET /v1/bulkSubscription/{id}

Retrieve a bulk subscription

Parameters

Name	In	Type	Required	Description
id	path	string	true	The id of the bulk subscription to retrieve

Responses

Status	Meaning	Description	Schema
404	Not Found	No bulk subscription found for the provided id	None

updateBulkSubscription_1

# You can also use wget
curl -X PUT /v1/bulkSubscription/{id} \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json; charset=UTF-8'

PUT /v1/bulkSubscription/{id} HTTP/1.1

Content-Type: application/json
Accept: application/json; charset=UTF-8

const inputBody = '{
  "id": "<BULK_SUBSCRIPTION_ID>",
  "label": "<BULK_SUBSCRIPTION_LABEL>",
  "attributes": [
    "attribute1",
    "attribute2"
  ]
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json; charset=UTF-8'
};

fetch('/v1/bulkSubscription/{id}',
{
  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; charset=UTF-8'
}

result = RestClient.put '/v1/bulkSubscription/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json; charset=UTF-8'
}

r = requests.put('/v1/bulkSubscription/{id}', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Content-Type' => 'application/json',
    'Accept' => 'application/json; charset=UTF-8',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('PUT','/v1/bulkSubscription/{id}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("/v1/bulkSubscription/{id}");
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; charset=UTF-8"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "/v1/bulkSubscription/{id}", data)
    req.Header = headers

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

PUT /v1/bulkSubscription/{id}

Update bulk subscription

{
  "id": "<BULK_SUBSCRIPTION_ID>",
  "label": "<BULK_SUBSCRIPTION_LABEL>",
  "attributes": [
    "attribute1",
    "attribute2"
  ]
}

Parameters

Name	In	Type	Required	Description
id	path	string	true	The id of the bulk subscription to update
synchronously	query	boolean	false	Determines whether the operation should be performed synchronously

Responses

Status	Meaning	Description	Schema
default	Default	default response	None

Response Schema

deleteBulkSubscription_1

# You can also use wget
curl -X DELETE /v1/bulkSubscription/{id}

DELETE /v1/bulkSubscription/{id} HTTP/1.1


fetch('/v1/bulkSubscription/{id}',
{
  method: 'DELETE'

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

require 'rest-client'
require 'json'

result = RestClient.delete '/v1/bulkSubscription/{id}',
  params: {
  }

p JSON.parse(result)

import requests

r = requests.delete('/v1/bulkSubscription/{id}')

print(r.json())

<?php

require 'vendor/autoload.php';

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('DELETE','/v1/bulkSubscription/{id}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("/v1/bulkSubscription/{id}");
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() {

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "/v1/bulkSubscription/{id}", data)
    req.Header = headers

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

DELETE /v1/bulkSubscription/{id}

Delete bulk subscription

Parameters

Name	In	Type	Required	Description
name	path	string	true	The name of the bulk subscription to delete
synchronously	query	string	false	Specify whether to to delete synchronously or not
force	query	string	false	Enforces deletion even bulk subscription is in wrong state
id	path	integer(int64)	true	none

Responses

Status	Meaning	Description	Schema
404	Not Found	No bulk subscription found for the provided id	None

getBulkSubscriptionId

# You can also use wget
curl -X GET /v1/bulkSubscription/{name}/id

GET /v1/bulkSubscription/{name}/id HTTP/1.1


fetch('/v1/bulkSubscription/{name}/id',
{
  method: 'GET'

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

require 'rest-client'
require 'json'

result = RestClient.get '/v1/bulkSubscription/{name}/id',
  params: {
  }

p JSON.parse(result)

import requests

r = requests.get('/v1/bulkSubscription/{name}/id')

print(r.json())

<?php

require 'vendor/autoload.php';

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','/v1/bulkSubscription/{name}/id', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("/v1/bulkSubscription/{name}/id");
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() {

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/v1/bulkSubscription/{name}/id", data)
    req.Header = headers

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

GET /v1/bulkSubscription/{name}/id

Retrieve the id associated with a bulk subscription

Parameters

Name	In	Type	Required	Description
name	path	string	true	The name of the bulk subscription

Responses

Status	Meaning	Description	Schema
404	Not Found	No bulk subscription found for the provided name	None

getBulkSubscriptionImportsForId

# You can also use wget
curl -X GET /v1/bulkSubscription/{id}/imports \
  -H 'x-cursor: string'

GET /v1/bulkSubscription/{id}/imports HTTP/1.1

x-cursor: string


const headers = {
  'x-cursor':'string'
};

fetch('/v1/bulkSubscription/{id}/imports',
{
  method: 'GET',

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

require 'rest-client'
require 'json'

headers = {
  'x-cursor' => 'string'
}

result = RestClient.get '/v1/bulkSubscription/{id}/imports',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'x-cursor': 'string'
}

r = requests.get('/v1/bulkSubscription/{id}/imports', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'x-cursor' => 'string',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','/v1/bulkSubscription/{id}/imports', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("/v1/bulkSubscription/{id}/imports");
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{
        "x-cursor": []string{"string"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/v1/bulkSubscription/{id}/imports", data)
    req.Header = headers

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

GET /v1/bulkSubscription/{id}/imports

Retrieve bulk subscription imports for a bulk subscription

Retrieves a list of bulk subscription imports based on the provided parameters. Pagination is supported through the use of ‘limit’ query parameter with either ‘cursor’ header or the ‘offset’ query parameter.

Parameters

Name	In	Type	Required	Description
id	path	string	true	The id of the bulk subscription to retrieve imports for
offset	query	integer(int32)	false	Offset of the first bulk subscription import to return in the page
limit	query	integer(int32)	false	Maximum number of bulk subscription imports to return in the page
x-cursor	header	string	false	Cursor to use for pagination

Responses

Status	Meaning	Description	Schema
404	Not Found	No bulk subscription found for the provided id	None

getBulkSubscriptionImportsForName

# You can also use wget
curl -X GET /v1/bulkSubscription/{name}/imports \
  -H 'x-cursor: string'

GET /v1/bulkSubscription/{name}/imports HTTP/1.1

x-cursor: string


const headers = {
  'x-cursor':'string'
};

fetch('/v1/bulkSubscription/{name}/imports',
{
  method: 'GET',

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

require 'rest-client'
require 'json'

headers = {
  'x-cursor' => 'string'
}

result = RestClient.get '/v1/bulkSubscription/{name}/imports',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'x-cursor': 'string'
}

r = requests.get('/v1/bulkSubscription/{name}/imports', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'x-cursor' => 'string',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','/v1/bulkSubscription/{name}/imports', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("/v1/bulkSubscription/{name}/imports");
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{
        "x-cursor": []string{"string"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/v1/bulkSubscription/{name}/imports", data)
    req.Header = headers

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

GET /v1/bulkSubscription/{name}/imports

Retrieve bulk subscription imports for a bulk subscription

Parameters

Name	In	Type	Required	Description
name	path	string	true	The name of the bulk subscription to retrieve imports for
offset	query	integer(int32)	false	Offset of the first bulk subscription import to return in the page
limit	query	integer(int32)	false	Maximum number of bulk subscription imports to return in the page
x-cursor	header	string	false	Cursor to use for pagination

Responses

Status	Meaning	Description	Schema
404	Not Found	No bulk subscription found for the provided name	None

getBulkSubscriptionName

# You can also use wget
curl -X GET /v1/bulkSubscription/{id}/name

GET /v1/bulkSubscription/{id}/name HTTP/1.1


fetch('/v1/bulkSubscription/{id}/name',
{
  method: 'GET'

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

require 'rest-client'
require 'json'

result = RestClient.get '/v1/bulkSubscription/{id}/name',
  params: {
  }

p JSON.parse(result)

import requests

r = requests.get('/v1/bulkSubscription/{id}/name')

print(r.json())

<?php

require 'vendor/autoload.php';

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','/v1/bulkSubscription/{id}/name', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("/v1/bulkSubscription/{id}/name");
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() {

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/v1/bulkSubscription/{id}/name", data)
    req.Header = headers

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

GET /v1/bulkSubscription/{id}/name

Retrieve the name associated with a bulk subscription

Parameters

Name	In	Type	Required	Description
id	path	string	true	The id of the bulk subscription

Responses

Status	Meaning	Description	Schema
404	Not Found	No bulk subscription found for the provided id	None

uploadBulkSubscriptionEntriesForId

# You can also use wget
curl -X POST /v1/bulkSubscription/{id}/_upload \
  -H 'Content-Type: multipart/form-data'

POST /v1/bulkSubscription/{id}/_upload HTTP/1.1

Content-Type: multipart/form-data

const inputBody = '[
    {
        "attribute1": "<val_A>"
        "attribute2": "<val_2>"
    }    {
        "attribute1": "<val_A>"
        "attribute2": "<val_3>"
    }    {
        "attribute1": "<val_C>"
        "attribute2": "<val_1>"
    }]';
const headers = {
  'Content-Type':'multipart/form-data'
};

fetch('/v1/bulkSubscription/{id}/_upload',
{
  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'
}

result = RestClient.post '/v1/bulkSubscription/{id}/_upload',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'multipart/form-data'
}

r = requests.post('/v1/bulkSubscription/{id}/_upload', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Content-Type' => 'multipart/form-data',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('POST','/v1/bulkSubscription/{id}/_upload', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("/v1/bulkSubscription/{id}/_upload");
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"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "/v1/bulkSubscription/{id}/_upload", data)
    req.Header = headers

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

POST /v1/bulkSubscription/{id}/_upload

Upload bulk subscription entries for a bulk subscription

|-
[
    {
        "attribute1": "<val_A>"
        "attribute2": "<val_2>"
    }    {
        "attribute1": "<val_A>"
        "attribute2": "<val_3>"
    }    {
        "attribute1": "<val_C>"
        "attribute2": "<val_1>"
    }]

Parameters

Name	In	Type	Required	Description
id	path	string	true	The id of the bulk subscription to upload entries for
action	query	string	false	The action to perform on the uploaded entries. Valid values are: ADD_ENTRIES, DELETE_ENTRIES

Responses

Status	Meaning	Description	Schema
400	Bad Request	No file found in the request	None
404	Not Found	No bulk subscription found for the provided id	None

uploadBulkSubscriptionForName

# You can also use wget
curl -X POST /v1/bulkSubscription/{name}/_upload \
  -H 'Content-Type: multipart/form-data'

POST /v1/bulkSubscription/{name}/_upload HTTP/1.1

Content-Type: multipart/form-data

const inputBody = '[
    {
        "attribute1": "<val_A>"
        "attribute2": "<val_2>"
    }    {
        "attribute1": "<val_A>"
        "attribute2": "<val_3>"
    }    {
        "attribute1": "<val_C>"
        "attribute2": "<val_1>"
    }]';
const headers = {
  'Content-Type':'multipart/form-data'
};

fetch('/v1/bulkSubscription/{name}/_upload',
{
  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'
}

result = RestClient.post '/v1/bulkSubscription/{name}/_upload',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'multipart/form-data'
}

r = requests.post('/v1/bulkSubscription/{name}/_upload', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Content-Type' => 'multipart/form-data',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('POST','/v1/bulkSubscription/{name}/_upload', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("/v1/bulkSubscription/{name}/_upload");
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"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "/v1/bulkSubscription/{name}/_upload", data)
    req.Header = headers

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

POST /v1/bulkSubscription/{name}/_upload

Upload bulk subscription entries for a bulk subscription

|-
[
    {
        "attribute1": "<val_A>"
        "attribute2": "<val_2>"
    }    {
        "attribute1": "<val_A>"
        "attribute2": "<val_3>"
    }    {
        "attribute1": "<val_C>"
        "attribute2": "<val_1>"
    }]

Parameters

Name	In	Type	Required	Description
name	path	string	true	The name of the bulk subscription to upload entries for
action	query	string	false	The action to perform on the uploaded entries. Valid values are: ADD_ENTRIES, DELETE_ENTRIES

Responses

Status	Meaning	Description	Schema
400	Bad Request	No file found in the request	None
404	Not Found	No bulk subscription found for the provided name	None

Data Model

Data Model Resource - provides information about data models

findByTranslation

# You can also use wget
curl -X GET /v1/datamodel/retrieval/{kind}

GET /v1/datamodel/retrieval/{kind} HTTP/1.1


fetch('/v1/datamodel/retrieval/{kind}',
{
  method: 'GET'

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

require 'rest-client'
require 'json'

result = RestClient.get '/v1/datamodel/retrieval/{kind}',
  params: {
  }

p JSON.parse(result)

import requests

r = requests.get('/v1/datamodel/retrieval/{kind}')

print(r.json())

<?php

require 'vendor/autoload.php';

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','/v1/datamodel/retrieval/{kind}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("/v1/datamodel/retrieval/{kind}");
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() {

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/v1/datamodel/retrieval/{kind}", data)
    req.Header = headers

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

GET /v1/datamodel/retrieval/{kind}

Retrieve definitions of the data model that match a given query

Returns keys of categories, attributes, or enum codes

Parameters

Name	In	Type	Required	Description
kind	path	string	true	none
q	query	string	false	none
dataModel	query	string	false	none
extension	query	string	false	none
leaf	query	boolean	false	none
parent	query	array[string]	false	none
name	query	array[string]	false	none
code	query	array[string]	false	none
limit	query	integer(int32)	false	none

Responses

Status	Meaning	Description	Schema
200	OK	OK	None
403	Forbidden	Sign-in required	None

getDataModel

# You can also use wget
curl -X GET /v1/datamodel/current \
  -H 'If-None-Match: string'

GET /v1/datamodel/current HTTP/1.1

If-None-Match: string


const headers = {
  'If-None-Match':'string'
};

fetch('/v1/datamodel/current',
{
  method: 'GET',

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

require 'rest-client'
require 'json'

headers = {
  'If-None-Match' => 'string'
}

result = RestClient.get '/v1/datamodel/current',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'If-None-Match': 'string'
}

r = requests.get('/v1/datamodel/current', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'If-None-Match' => 'string',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','/v1/datamodel/current', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("/v1/datamodel/current");
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{
        "If-None-Match": []string{"string"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/v1/datamodel/current", data)
    req.Header = headers

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

GET /v1/datamodel/current

Retrieve the current data model

The result contains classes, attributes, layouts, etc.

Parameters

Name	In	Type	Required	Description
If-None-Match	header	string	false	none
allowCaching	query	boolean	false	none

Responses

Status	Meaning	Description	Schema
200	OK	OK	None
403	Forbidden	Sign-in required	None

getDefaultItem

# You can also use wget
curl -X GET /v1/datamodel/defaultItem/{category}

GET /v1/datamodel/defaultItem/{category} HTTP/1.1


fetch('/v1/datamodel/defaultItem/{category}',
{
  method: 'GET'

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

require 'rest-client'
require 'json'

result = RestClient.get '/v1/datamodel/defaultItem/{category}',
  params: {
  }

p JSON.parse(result)

import requests

r = requests.get('/v1/datamodel/defaultItem/{category}')

print(r.json())

<?php

require 'vendor/autoload.php';

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','/v1/datamodel/defaultItem/{category}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("/v1/datamodel/defaultItem/{category}");
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() {

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/v1/datamodel/defaultItem/{category}", data)
    req.Header = headers

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

GET /v1/datamodel/defaultItem/{category}

Get an item with pre-populated default values for a category

Returns default values as specified by the current data model

Parameters

Name	In	Type	Required	Description
category	path	string	true	none

Responses

Status	Meaning	Description	Schema
200	OK	OK	None
403	Forbidden	Sign-in required	None
404	Not Found	Category not found	None

getExportFormats

# You can also use wget
curl -X GET /v1/datamodel/exportFormats

GET /v1/datamodel/exportFormats HTTP/1.1


fetch('/v1/datamodel/exportFormats',
{
  method: 'GET'

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

require 'rest-client'
require 'json'

result = RestClient.get '/v1/datamodel/exportFormats',
  params: {
  }

p JSON.parse(result)

import requests

r = requests.get('/v1/datamodel/exportFormats')

print(r.json())

<?php

require 'vendor/autoload.php';

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','/v1/datamodel/exportFormats', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("/v1/datamodel/exportFormats");
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() {

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/v1/datamodel/exportFormats", data)
    req.Header = headers

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

GET /v1/datamodel/exportFormats

Retrieve all available Export Formats defined either by the system or the current data model

The result contains all formats defined in the system or the headers of the outbound transformation script or the export script

Parameters

Name	In	Type	Required	Description
includeExportMappings	query	boolean	false	none
returnKeyValueFormat	query	boolean	false	none

Responses

Status	Meaning	Description	Schema
200	OK	OK	None
403	Forbidden	Sign-in required	None

Items

The items resource is used to retrieve and manipulate items

addToFavorites

# You can also use wget
curl -X POST /v1/items/favorites/{primaryKey}

POST /v1/items/favorites/{primaryKey} HTTP/1.1


fetch('/v1/items/favorites/{primaryKey}',
{
  method: 'POST'

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

require 'rest-client'
require 'json'

result = RestClient.post '/v1/items/favorites/{primaryKey}',
  params: {
  }

p JSON.parse(result)

import requests

r = requests.post('/v1/items/favorites/{primaryKey}')

print(r.json())

<?php

require 'vendor/autoload.php';

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('POST','/v1/items/favorites/{primaryKey}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("/v1/items/favorites/{primaryKey}");
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() {

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "/v1/items/favorites/{primaryKey}", data)
    req.Header = headers

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

POST /v1/items/favorites/{primaryKey}

Adds an item to the favorite list

The item itself doesn’t change

Parameters

Name	In	Type	Required	Description
primaryKey	path	string	true	none

Responses

Status	Meaning	Description	Schema
403	Forbidden	Sign-in required	None

removeFromFavorites

# You can also use wget
curl -X DELETE /v1/items/favorites/{primaryKey}

DELETE /v1/items/favorites/{primaryKey} HTTP/1.1


fetch('/v1/items/favorites/{primaryKey}',
{
  method: 'DELETE'

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

require 'rest-client'
require 'json'

result = RestClient.delete '/v1/items/favorites/{primaryKey}',
  params: {
  }

p JSON.parse(result)

import requests

r = requests.delete('/v1/items/favorites/{primaryKey}')

print(r.json())

<?php

require 'vendor/autoload.php';

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('DELETE','/v1/items/favorites/{primaryKey}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("/v1/items/favorites/{primaryKey}");
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() {

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "/v1/items/favorites/{primaryKey}", data)
    req.Header = headers

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

DELETE /v1/items/favorites/{primaryKey}

Removes an item from the favorite list

The item itself doesn’t change

Parameters

Name	In	Type	Required	Description
primaryKey	path	string	true	none

Responses

Status	Meaning	Description	Schema
403	Forbidden	Sign-in required	None

auditItem

# You can also use wget
curl -X POST /v1/items/{primaryKey}/audit

POST /v1/items/{primaryKey}/audit HTTP/1.1


fetch('/v1/items/{primaryKey}/audit',
{
  method: 'POST'

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

require 'rest-client'
require 'json'

result = RestClient.post '/v1/items/{primaryKey}/audit',
  params: {
  }

p JSON.parse(result)

import requests

r = requests.post('/v1/items/{primaryKey}/audit')

print(r.json())

<?php

require 'vendor/autoload.php';

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('POST','/v1/items/{primaryKey}/audit', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("/v1/items/{primaryKey}/audit");
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() {

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "/v1/items/{primaryKey}/audit", data)
    req.Header = headers

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

POST /v1/items/{primaryKey}/audit

Audit/Unaudit an item

Parameters

Name	In	Type	Required	Description
primaryKey	path	string	true	none
status	query	boolean	false	none

Responses

Status	Meaning	Description	Schema
400	Bad Request	Invalid primary key	None
404	Not Found	Item not found	None

copyItem

# You can also use wget
curl -X GET /v1/items/{primaryKey}/copy

GET /v1/items/{primaryKey}/copy HTTP/1.1


fetch('/v1/items/{primaryKey}/copy',
{
  method: 'GET'

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

require 'rest-client'
require 'json'

result = RestClient.get '/v1/items/{primaryKey}/copy',
  params: {
  }

p JSON.parse(result)

import requests

r = requests.get('/v1/items/{primaryKey}/copy')

print(r.json())

<?php

require 'vendor/autoload.php';

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','/v1/items/{primaryKey}/copy', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("/v1/items/{primaryKey}/copy");
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() {

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/v1/items/{primaryKey}/copy", data)
    req.Header = headers

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

GET /v1/items/{primaryKey}/copy

Get a copy of an item

Parameters

Name	In	Type	Required	Description
primaryKey	path	string	true	none
validate	query	boolean	false	none

Responses

Status	Meaning	Description	Schema
400	Bad Request	Invalid primary key	None
404	Not Found	Item not found	None

getFavorites

# You can also use wget
curl -X GET /v1/items/favorites

GET /v1/items/favorites HTTP/1.1


fetch('/v1/items/favorites',
{
  method: 'GET'

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

require 'rest-client'
require 'json'

result = RestClient.get '/v1/items/favorites',
  params: {
  }

p JSON.parse(result)

import requests

r = requests.get('/v1/items/favorites')

print(r.json())

<?php

require 'vendor/autoload.php';

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','/v1/items/favorites', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("/v1/items/favorites");
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() {

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/v1/items/favorites", data)
    req.Header = headers

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

GET /v1/items/favorites

Fetch the favorite items

Items from the user`s favorite list

Responses

Status	Meaning	Description	Schema
403	Forbidden	Sign-in required	None

getItemByKey

# You can also use wget
curl -X GET /v1/items/{primaryKey}

GET /v1/items/{primaryKey} HTTP/1.1


fetch('/v1/items/{primaryKey}',
{
  method: 'GET'

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

require 'rest-client'
require 'json'

result = RestClient.get '/v1/items/{primaryKey}',
  params: {
  }

p JSON.parse(result)

import requests

r = requests.get('/v1/items/{primaryKey}')

print(r.json())

<?php

require 'vendor/autoload.php';

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','/v1/items/{primaryKey}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("/v1/items/{primaryKey}");
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() {

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/v1/items/{primaryKey}", data)
    req.Header = headers

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

GET /v1/items/{primaryKey}

Find an item by its primary key

To get item by its primary key

Parameters

Name	In	Type	Required	Description
primaryKey	path	string	true	the item`s primary key
checksum	query	string	false	none
validate	query	boolean	false	none
forceRevalidation	query	boolean	false	none

Responses

Status	Meaning	Description	Schema
400	Bad Request	Invalid primary key	None
403	Forbidden	Sign-in required	None
404	Not Found	Item not found	None

getItemEventHistory

# You can also use wget
curl -X GET /v1/items/{primaryKey}/eventHistory \
  -H 'x-cursor: string'

GET /v1/items/{primaryKey}/eventHistory HTTP/1.1

x-cursor: string


const headers = {
  'x-cursor':'string'
};

fetch('/v1/items/{primaryKey}/eventHistory',
{
  method: 'GET',

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

require 'rest-client'
require 'json'

headers = {
  'x-cursor' => 'string'
}

result = RestClient.get '/v1/items/{primaryKey}/eventHistory',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'x-cursor': 'string'
}

r = requests.get('/v1/items/{primaryKey}/eventHistory', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'x-cursor' => 'string',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','/v1/items/{primaryKey}/eventHistory', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("/v1/items/{primaryKey}/eventHistory");
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{
        "x-cursor": []string{"string"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/v1/items/{primaryKey}/eventHistory", data)
    req.Header = headers

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

GET /v1/items/{primaryKey}/eventHistory

Get the event history of an item

Parameters

Name	In	Type	Required	Description
primaryKey	path	string	true	none
newestFirst	query	boolean	false	none
offset	query	integer(int32)	false	none
limit	query	integer(int32)	false	none
x-cursor	header	string	false	none

Responses

Status	Meaning	Description	Schema
400	Bad Request	Invalid primary key	None
404	Not Found	Item not found	None

getItemHierarchies

# You can also use wget
curl -X GET /v1/items/{primaryKey}/hierarchies

GET /v1/items/{primaryKey}/hierarchies HTTP/1.1


fetch('/v1/items/{primaryKey}/hierarchies',
{
  method: 'GET'

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

require 'rest-client'
require 'json'

result = RestClient.get '/v1/items/{primaryKey}/hierarchies',
  params: {
  }

p JSON.parse(result)

import requests

r = requests.get('/v1/items/{primaryKey}/hierarchies')

print(r.json())

<?php

require 'vendor/autoload.php';

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','/v1/items/{primaryKey}/hierarchies', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("/v1/items/{primaryKey}/hierarchies");
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() {

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/v1/items/{primaryKey}/hierarchies", data)
    req.Header = headers

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

GET /v1/items/{primaryKey}/hierarchies

Get the hierarchy of an item, given a primary key in the path

Parameters

Name	In	Type	Required	Description
primaryKey	path	string	true	none
hierarchyName	query	string	false	none

Responses

Status	Meaning	Description	Schema
404	Not Found	Item not found	None

getItemHistory

# You can also use wget
curl -X GET /v1/items/{primaryKey}/history

GET /v1/items/{primaryKey}/history HTTP/1.1


fetch('/v1/items/{primaryKey}/history',
{
  method: 'GET'

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

require 'rest-client'
require 'json'

result = RestClient.get '/v1/items/{primaryKey}/history',
  params: {
  }

p JSON.parse(result)

import requests

r = requests.get('/v1/items/{primaryKey}/history')

print(r.json())

<?php

require 'vendor/autoload.php';

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','/v1/items/{primaryKey}/history', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("/v1/items/{primaryKey}/history");
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() {

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/v1/items/{primaryKey}/history", data)
    req.Header = headers

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

GET /v1/items/{primaryKey}/history

Get the change history of an item

Parameters

Name	In	Type	Required	Description
primaryKey	path	string	true	none
historyId	query	integer(int64)	false	none

Responses

Status	Meaning	Description	Schema
400	Bad Request	Invalid primary key	None
404	Not Found	Item not found	None

getItemPublications

# You can also use wget
curl -X GET /v1/items/{primaryKey}/publications

GET /v1/items/{primaryKey}/publications HTTP/1.1


fetch('/v1/items/{primaryKey}/publications',
{
  method: 'GET'

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

require 'rest-client'
require 'json'

result = RestClient.get '/v1/items/{primaryKey}/publications',
  params: {
  }

p JSON.parse(result)

import requests

r = requests.get('/v1/items/{primaryKey}/publications')

print(r.json())

<?php

require 'vendor/autoload.php';

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','/v1/items/{primaryKey}/publications', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("/v1/items/{primaryKey}/publications");
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() {

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/v1/items/{primaryKey}/publications", data)
    req.Header = headers

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

GET /v1/items/{primaryKey}/publications

Get the current publications of an item

Parameters

Name	In	Type	Required	Description
primaryKey	path	string	true	none

Responses

Status	Meaning	Description	Schema
400	Bad Request	Invalid primary key	None
404	Not Found	Item not found	None

getItemTags

# You can also use wget
curl -X GET /v1/items/{primaryKey}/tags \
  -H 'x-cursor: string'

GET /v1/items/{primaryKey}/tags HTTP/1.1

x-cursor: string


const headers = {
  'x-cursor':'string'
};

fetch('/v1/items/{primaryKey}/tags',
{
  method: 'GET',

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

require 'rest-client'
require 'json'

headers = {
  'x-cursor' => 'string'
}

result = RestClient.get '/v1/items/{primaryKey}/tags',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'x-cursor': 'string'
}

r = requests.get('/v1/items/{primaryKey}/tags', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'x-cursor' => 'string',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','/v1/items/{primaryKey}/tags', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("/v1/items/{primaryKey}/tags");
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{
        "x-cursor": []string{"string"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/v1/items/{primaryKey}/tags", data)
    req.Header = headers

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

GET /v1/items/{primaryKey}/tags

Get the stored tags of an item

This will only return any ‘recently’ stored tags

Parameters

Name	In	Type	Required	Description
primaryKey	path	string	true	none
newestFirst	query	boolean	false	none
baseTag	query	string	false	none
offset	query	integer(int32)	false	none
limit	query	integer(int32)	false	none
x-cursor	header	string	false	none

Responses

Status	Meaning	Description	Schema
400	Bad Request	Invalid primary key	None
404	Not Found	Item not found	None

getItemValidationResult

# You can also use wget
curl -X GET /v1/items/{primaryKey}/validationResult

GET /v1/items/{primaryKey}/validationResult HTTP/1.1


fetch('/v1/items/{primaryKey}/validationResult',
{
  method: 'GET'

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

require 'rest-client'
require 'json'

result = RestClient.get '/v1/items/{primaryKey}/validationResult',
  params: {
  }

p JSON.parse(result)

import requests

r = requests.get('/v1/items/{primaryKey}/validationResult')

print(r.json())

<?php

require 'vendor/autoload.php';

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','/v1/items/{primaryKey}/validationResult', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("/v1/items/{primaryKey}/validationResult");
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() {

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/v1/items/{primaryKey}/validationResult", data)
    req.Header = headers

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

GET /v1/items/{primaryKey}/validationResult

Find the latest validation result for an item

This will return the result of the latest validation for the specified item. It includes the validation error and warning messages as well as the attribute status. Note that the existance of the item is not checked, so the returned value can simply be null or empty.

Parameters

Name	In	Type	Required	Description
primaryKey	path	string	true	none

Responses

Status	Meaning	Description	Schema
400	Bad Request	Invalid primary key	None
403	Forbidden	Sign-in required	None

getItems

# You can also use wget
curl -X GET /v1/items \
  -H 'x-item-cursor: string'

GET /v1/items HTTP/1.1

x-item-cursor: string


const headers = {
  'x-item-cursor':'string'
};

fetch('/v1/items',
{
  method: 'GET',

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

require 'rest-client'
require 'json'

headers = {
  'x-item-cursor' => 'string'
}

result = RestClient.get '/v1/items',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'x-item-cursor': 'string'
}

r = requests.get('/v1/items', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'x-item-cursor' => 'string',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','/v1/items', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("/v1/items");
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{
        "x-item-cursor": []string{"string"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/v1/items", data)
    req.Header = headers

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

GET /v1/items

Retrieve items

Several parameters can be used to filter the result list

Parameters

Name	In	Type	Required	Description
selectionId	query	string	false	Specifies the id of a stored selection to query the items with.
items	query	array[string]	false	none
keyword	query	string	false	Specifies the keywords or query string to search items for.
category	query	string	false	none
tags	query	string	false	none
compliant	query	boolean	false	none
errorKey	query	string	false	none
warningKey	query	string	false	none
reviewErrorKey	query	string	false	none
reviewWarningKey	query	string	false	none
publicationDestination	query	string	false	none
publicationTaskId	query	integer(int64)	false	none
withPublicationTaskChecksums	query	boolean	false	none
recipientKey	query	string	false	none
reviewer	query	string	false	none
reviewStatus	query	string	false	none
taskId	query	integer(int64)	false	none
exactSearchAttributeName	query	string	false	none
exactSearchValues	query	array[string]	false	none
disableAdditionalAttributes	query	string	false	none
simpleQuery	query	boolean	false	Set to true to enforce a direct database query instead of a full text query.
primaryKey	query	array[string]	false	Specify one or more item primary keys to restrict the query for.
newestFirst	query	boolean	false	Set to true to sort the result by the updatedAt__ system property in DECENDING order, set to false to sort the result by the updatedAt__ system property in ASCENDING order or not set it at all to sort by primaryKey__.
updatedAfter	query	string(date-time)	false	Retrieves only items which were updated after the specified date.
updatedBefore	query	string(date-time)	false	Retrieves only items which were updated before the specified date.
page	query	integer(int32)	false	none
sort	query	array[string]	false	Specifies one or multiple attributes to sort the result by.
direction	query	array[string]	false	Specifies the sort direction per attribute defined in the sort parameter
bulkSubscriptionName	query	string	false	Specifies the name of a bulk subscription to query the items belonging to the bulk subscription.
bulkSubscriptionId	query	integer(int32)	false	Specifies the id of a bulk subscription to query the items belonging to the bulk subscription.
count	query	integer(int32)	false	Determines the maximum number of items to return
format	query	string	false	none
download	query	boolean	false	none
fields	query	array[string]	false	none
layout	query	string	false	none
x-item-cursor	header	string	false	none

Detailed descriptions

selectionId: Specifies the id of a stored selection to query the items with.

This parameter will force using the full text index. See also the simpleQuery parameter.

keyword: Specifies the keywords or query string to search items for.

This parameter will force using the full text index. See also the simpleQuery parameter.

simpleQuery: Set to true to enforce a direct database query instead of a full text query.

This is only necessary, if you do not specify any of the following parameters:

primaryKey
newestFirst
updatedAfter
updatedBefore