OpenAPI definition v0

info

You are viewing REST API documentation. This documentation is auto-generated from a swagger specification which itself is generated from annotations in the source code of the project. It is possible that this documentation includes bugs and that code samples are incomplete or wrong.

Authentication

• HTTP Authentication, scheme: bearer
• OAuth 2.0 Authorization.
  • Flow: clientCredentials
  • OAuth 2.0 Token URL = http://localhost:8080/security/oauth/token

Interaction

Retrieve an existing interaction by it's id

GET http://localhost:8080/rtc-api/interactions/{interactionId} HTTP/1.1
Host: localhost:8080
Accept: application/json

Parameters

Parameter	In	Type	Required	Description
interactionId	path	string	true	none

Responses

Overview

Status	Meaning	Description	Schema
200	OK	OK	Interaction
400	Bad Request	Bad Request	Inline

Response Schema

Status Code 400

Name	Type	Required	Restrictions	Description
» additionalProperties	string	false	none	none

Examples

200 Response

{
  "id": "string",
  "organizationId": "string",
  "createdBy": "string",
  "createdAt": "2019-08-24T14:15:22Z",
  "type": "string",
  "data": {
    "property1": {},
    "property2": {}
  },
  "version": 0
}

400 Response

caution

To perform this operation, you must be authenticated by means of one of the following methods: BearerToken, OAuth2ClientCredentials

Code samples

Shell

curl -X GET http://localhost:8080/rtc-api/interactions/{interactionId} \
  -H 'Accept: application/json' \  -H 'Authorization: Bearer {access-token}'

Go

package main

import (
    "bytes"
    "net/http"
)

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

    var body []byte
    // body = ...

    req, err := http.NewRequest("GET", "http://localhost:8080/rtc-api/interactions/{interactionId}", bytes.NewBuffer(body))
    req.Header = headers

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

Node

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

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

fetch('http://localhost:8080/rtc-api/interactions/{interactionId}', {
  method: 'GET',
  headers
})
.then(r => r.json())
.then((body) => {
    console.log(body)
})

Java

// This sample needs improvement.
URL obj = new URL("http://localhost:8080/rtc-api/interactions/{interactionId}");

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());

Python

import requests

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

r = requests.get(
  'http://localhost:8080/rtc-api/interactions/{interactionId}',
  params={},
  headers = headers)

print r.json()

Ruby

require 'rest-client'
require 'json'

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

result = RestClient.get 'http://localhost:8080/rtc-api/interactions/{interactionId}',
  params: {}, headers: headers

p JSON.parse(result)

Update an existing interaction

PUT http://localhost:8080/rtc-api/interactions/{interactionId} HTTP/1.1
Host: localhost:8080
Content-Type: application/json
Accept: */*

Request body

{
  "type": "string",
  "data": {
    "property1": {},
    "property2": {}
  },
  "version": 0
}

Parameters

Parameter	In	Type	Required	Description
interactionId	path	string	true	none
body	body	UpdateInteractionWebCommand	true	none

Responses

Overview

Status	Meaning	Description	Schema
204	No Content	Updated	None
400	Bad Request	Bad Request	Inline

Response Schema

Status Code 400

Name	Type	Required	Restrictions	Description
» additionalProperties	string	false	none	none

Examples

400 Response

caution

To perform this operation, you must be authenticated by means of one of the following methods: BearerToken, OAuth2ClientCredentials

Code samples

Shell

curl -X PUT http://localhost:8080/rtc-api/interactions/{interactionId} \
  -H 'Content-Type: application/json' \  -H 'Accept: */*' \  -H 'Authorization: Bearer {access-token}'

Go

package main

import (
    "bytes"
    "net/http"
)

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

    var body []byte
    // body = ...

    req, err := http.NewRequest("PUT", "http://localhost:8080/rtc-api/interactions/{interactionId}", bytes.NewBuffer(body))
    req.Header = headers

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

Node

const fetch = require('node-fetch');
const input = '{
  "type": "string",
  "data": {
    "property1": {},
    "property2": {}
  },
  "version": 0
}';
const headers = {
  'Content-Type': 'application/json',  'Accept': '*/*',  'Authorization': 'Bearer {access-token}'
}

fetch('http://localhost:8080/rtc-api/interactions/{interactionId}', {
  method: 'PUT',
  body: input,
  headers
})
.then(r => r.json())
.then((body) => {
    console.log(body)
})

Java

// This sample needs improvement.
URL obj = new URL("http://localhost:8080/rtc-api/interactions/{interactionId}");

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());

Python

import requests

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

r = requests.put(
  'http://localhost:8080/rtc-api/interactions/{interactionId}',
  params={},
  headers = headers)

print r.json()

Ruby

require 'rest-client'
require 'json'

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

result = RestClient.put 'http://localhost:8080/rtc-api/interactions/{interactionId}',
  params: {}, headers: headers

p JSON.parse(result)

Create a new contact (not actually)

POST http://localhost:8080/rtc-api/talkdesk-integration/create HTTP/1.1
Host: localhost:8080
Content-Type: application/json
Accept: application/json

Request body

{
  "data": {
    "contact_id": "string"
  }
}

Parameters

Parameter	In	Type	Required	Description
body	body	TalkdeskCreateTalkdeskRequest	true	none

Responses

Overview

Status	Meaning	Description	Schema
200	OK	OK	TalkdeskCreateTalkdeskResponse
400	Bad Request	Bad Request	Inline

Response Schema

Status Code 400

Name	Type	Required	Restrictions	Description
» additionalProperties	string	false	none	none

Examples

200 Response

{
  "message": "string",
  "contact_external_id": "string"
}

400 Response

caution

To perform this operation, you must be authenticated by means of one of the following methods: BearerToken, OAuth2ClientCredentials

Code samples

Shell

curl -X POST http://localhost:8080/rtc-api/talkdesk-integration/create \
  -H 'Content-Type: application/json' \  -H 'Accept: application/json' \  -H 'Authorization: Bearer {access-token}'

Go

package main

import (
    "bytes"
    "net/http"
)

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

    var body []byte
    // body = ...

    req, err := http.NewRequest("POST", "http://localhost:8080/rtc-api/talkdesk-integration/create", bytes.NewBuffer(body))
    req.Header = headers

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

Node

const fetch = require('node-fetch');
const input = '{
  "data": {
    "contact_id": "string"
  }
}';
const headers = {
  'Content-Type': 'application/json',  'Accept': 'application/json',  'Authorization': 'Bearer {access-token}'
}

fetch('http://localhost:8080/rtc-api/talkdesk-integration/create', {
  method: 'POST',
  body: input,
  headers
})
.then(r => r.json())
.then((body) => {
    console.log(body)
})

Java

// This sample needs improvement.
URL obj = new URL("http://localhost:8080/rtc-api/talkdesk-integration/create");

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());

Python

import requests

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

r = requests.post(
  'http://localhost:8080/rtc-api/talkdesk-integration/create',
  params={},
  headers = headers)

print r.json()

Ruby

require 'rest-client'
require 'json'

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

result = RestClient.post 'http://localhost:8080/rtc-api/talkdesk-integration/create',
  params: {}, headers: headers

p JSON.parse(result)

validate authorization

POST http://localhost:8080/rtc-api/talkdesk-integration/authorization-validator HTTP/1.1
Host: localhost:8080
Content-Type: application/json
Accept: application/json

Request body

{
  "property1": {},
  "property2": {}
}

Parameters

Parameter	In	Type	Required	Description
body	body	object	true	none
» additionalProperties	body	object	false	none

Responses

Overview

Status	Meaning	Description	Schema
200	OK	OK	Inline
400	Bad Request	Bad Request	Inline

Response Schema

Status Code 200

Name	Type	Required	Restrictions	Description
» additionalProperties	string	false	none	none

Status Code 400

Name	Type	Required	Restrictions	Description
» additionalProperties	string	false	none	none

Examples

200 Response

{
  "property1": "string",
  "property2": "string"
}

400 Response

caution

To perform this operation, you must be authenticated by means of one of the following methods: BearerToken, OAuth2ClientCredentials

Code samples

Shell

curl -X POST http://localhost:8080/rtc-api/talkdesk-integration/authorization-validator \
  -H 'Content-Type: application/json' \  -H 'Accept: application/json' \  -H 'Authorization: Bearer {access-token}'

Go

package main

import (
    "bytes"
    "net/http"
)

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

    var body []byte
    // body = ...

    req, err := http.NewRequest("POST", "http://localhost:8080/rtc-api/talkdesk-integration/authorization-validator", bytes.NewBuffer(body))
    req.Header = headers

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

Node

const fetch = require('node-fetch');
const input = '{
  "property1": {},
  "property2": {}
}';
const headers = {
  'Content-Type': 'application/json',  'Accept': 'application/json',  'Authorization': 'Bearer {access-token}'
}

fetch('http://localhost:8080/rtc-api/talkdesk-integration/authorization-validator', {
  method: 'POST',
  body: input,
  headers
})
.then(r => r.json())
.then((body) => {
    console.log(body)
})

Java

// This sample needs improvement.
URL obj = new URL("http://localhost:8080/rtc-api/talkdesk-integration/authorization-validator");

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());

Python

import requests

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

r = requests.post(
  'http://localhost:8080/rtc-api/talkdesk-integration/authorization-validator',
  params={},
  headers = headers)

print r.json()

Ruby

require 'rest-client'
require 'json'

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

result = RestClient.post 'http://localhost:8080/rtc-api/talkdesk-integration/authorization-validator',
  params: {}, headers: headers

p JSON.parse(result)

Return contact activity

POST http://localhost:8080/rtc-api/talkdesk-integration/activity HTTP/1.1
Host: localhost:8080
Content-Type: application/json
Accept: application/json
Host: string

Request body

{
  "meta": {
    "interaction_types": [
      "string"
    ]
  },
  "data": {
    "contact_id": "string"
  }
}

Parameters

Parameter	In	Type	Required	Description
Host	header	string	true	none
body	body	TalkdeskContactActivityRequest	true	none

Responses

Overview

Status	Meaning	Description	Schema
200	OK	OK	Inline
400	Bad Request	Bad Request	Inline

Response Schema

Status Code 200

Name	Type	Required	Restrictions	Description
anonymous	[TalkdeskContactActivityResponseItem]	false	none	none
» id	string	false	none	none
» subject	string	false	none	none
» description	string	false	none	none
» date	string	false	none	none
» url	string	false	none	none
» type	string	false	none	none
» priority	string	false	none	none
» status	string	false	none	none

Status Code 400

Name	Type	Required	Restrictions	Description
» additionalProperties	string	false	none	none

Examples

200 Response

[
  {
    "id": "string",
    "subject": "string",
    "description": "string",
    "date": "string",
    "url": "string",
    "type": "string",
    "priority": "string",
    "status": "string"
  }
]

400 Response

caution

To perform this operation, you must be authenticated by means of one of the following methods: BearerToken, OAuth2ClientCredentials

Code samples

Shell

curl -X POST http://localhost:8080/rtc-api/talkdesk-integration/activity \
  -H 'Content-Type: application/json' \  -H 'Accept: application/json' \  -H 'Host: string' \  -H 'Authorization: Bearer {access-token}'

Go

package main

import (
    "bytes"
    "net/http"
)

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

    var body []byte
    // body = ...

    req, err := http.NewRequest("POST", "http://localhost:8080/rtc-api/talkdesk-integration/activity", bytes.NewBuffer(body))
    req.Header = headers

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

Node

const fetch = require('node-fetch');
const input = '{
  "meta": {
    "interaction_types": [
      "string"
    ]
  },
  "data": {
    "contact_id": "string"
  }
}';
const headers = {
  'Content-Type': 'application/json',  'Accept': 'application/json',  'Host': 'string',  'Authorization': 'Bearer {access-token}'
}

fetch('http://localhost:8080/rtc-api/talkdesk-integration/activity', {
  method: 'POST',
  body: input,
  headers
})
.then(r => r.json())
.then((body) => {
    console.log(body)
})

Java

// This sample needs improvement.
URL obj = new URL("http://localhost:8080/rtc-api/talkdesk-integration/activity");

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());

Python

import requests

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

r = requests.post(
  'http://localhost:8080/rtc-api/talkdesk-integration/activity',
  params={},
  headers = headers)

print r.json()

Ruby

require 'rest-client'
require 'json'

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

result = RestClient.post 'http://localhost:8080/rtc-api/talkdesk-integration/activity',
  params: {}, headers: headers

p JSON.parse(result)

Retrieve interactions by date range

GET http://localhost:8080/rtc-api/interactions?pageable=page,0,size,1,sort,string&start=2019-08-24T14%3A15%3A22Z&end=2019-08-24T14%3A15%3A22Z&params=property1,string,property2,string HTTP/1.1
Host: localhost:8080
Accept: application/json

Parameters

Parameter	In	Type	Required	Description
pageable	query	Pageable	true	none
start	query	string(date-time)	true	none
end	query	string(date-time)	true	none
params	query	object	true	none

Responses

Overview

Status	Meaning	Description	Schema
200	OK	OK	PageInteraction
400	Bad Request	Bad Request	Inline

Response Schema

Status Code 400

Name	Type	Required	Restrictions	Description
» additionalProperties	string	false	none	none

Examples

200 Response

{
  "totalPages": 0,
  "totalElements": 0,
  "first": true,
  "last": true,
  "size": 0,
  "content": [
    {
      "id": "string",
      "organizationId": "string",
      "createdBy": "string",
      "createdAt": "2019-08-24T14:15:22Z",
      "type": "string",
      "data": {
        "property1": {},
        "property2": {}
      },
      "version": 0
    }
  ],
  "number": 0,
  "sort": [
    {
      "direction": "string",
      "nullHandling": "string",
      "ascending": true,
      "property": "string",
      "ignoreCase": true
    }
  ],
  "numberOfElements": 0,
  "pageable": {
    "offset": 0,
    "sort": [
      {
        "direction": "string",
        "nullHandling": "string",
        "ascending": true,
        "property": "string",
        "ignoreCase": true
      }
    ],
    "pageSize": 0,
    "paged": true,
    "pageNumber": 0,
    "unpaged": true
  },
  "empty": true
}

400 Response

caution

To perform this operation, you must be authenticated by means of one of the following methods: BearerToken, OAuth2ClientCredentials

Code samples

Shell

curl -X GET http://localhost:8080/rtc-api/interactions?pageable=page,0,size,1,sort,string&start=2019-08-24T14%3A15%3A22Z&end=2019-08-24T14%3A15%3A22Z&params=property1,string,property2,string \
  -H 'Accept: application/json' \  -H 'Authorization: Bearer {access-token}'

Go

package main

import (
    "bytes"
    "net/http"
)

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

    var body []byte
    // body = ...

    req, err := http.NewRequest("GET", "http://localhost:8080/rtc-api/interactions", bytes.NewBuffer(body))
    req.Header = headers

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

Node

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

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

fetch('http://localhost:8080/rtc-api/interactions?pageable=page,0,size,1,sort,string&start=2019-08-24T14%3A15%3A22Z&end=2019-08-24T14%3A15%3A22Z&params=property1,string,property2,string', {
  method: 'GET',
  headers
})
.then(r => r.json())
.then((body) => {
    console.log(body)
})

Java

// This sample needs improvement.
URL obj = new URL("http://localhost:8080/rtc-api/interactions?pageable=page,0,size,1,sort,string&start=2019-08-24T14%3A15%3A22Z&end=2019-08-24T14%3A15%3A22Z&params=property1,string,property2,string");

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());

Python

import requests

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

r = requests.get(
  'http://localhost:8080/rtc-api/interactions',
  params={
    'pageable': {
  "page": 0,
  "size": 1,
  "sort": [
    "string"
  ]
},
    'start': '2019-08-24T14:15:22Z',
    'end': '2019-08-24T14:15:22Z',
    'params': {
  "property1": "string",
  "property2": "string"
}},
  headers = headers)

print r.json()

Ruby

require 'rest-client'
require 'json'

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

result = RestClient.get 'http://localhost:8080/rtc-api/interactions',
  params: {
    'pageable' => '[Pageable](#schemapageable)',
    'start' => 'string(date-time)',
    'end' => 'string(date-time)',
    'params' => 'object'}, headers: headers

p JSON.parse(result)

Create a new interaction

POST http://localhost:8080/rtc-api/interactions HTTP/1.1
Host: localhost:8080
Content-Type: application/json
Accept: application/json

Request body

{
  "interactionId": "string",
  "type": "string",
  "data": {
    "property1": {},
    "property2": {}
  }
}

Parameters

Parameter	In	Type	Required	Description
body	body	CreateInteractionWebCommand	true	none

Responses

Overview

Status	Meaning	Description	Schema
200	OK	OK	CreateInteractionResponse
400	Bad Request	Bad Request	Inline

Response Schema

Status Code 400

Name	Type	Required	Restrictions	Description
» additionalProperties	string	false	none	none

Examples

200 Response

{
  "interactionId": "string",
  "version": 0
}

400 Response

caution

To perform this operation, you must be authenticated by means of one of the following methods: BearerToken, OAuth2ClientCredentials

Code samples

Shell

curl -X POST http://localhost:8080/rtc-api/interactions \
  -H 'Content-Type: application/json' \  -H 'Accept: application/json' \  -H 'Authorization: Bearer {access-token}'

Go

package main

import (
    "bytes"
    "net/http"
)

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

    var body []byte
    // body = ...

    req, err := http.NewRequest("POST", "http://localhost:8080/rtc-api/interactions", bytes.NewBuffer(body))
    req.Header = headers

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

Node

const fetch = require('node-fetch');
const input = '{
  "interactionId": "string",
  "type": "string",
  "data": {
    "property1": {},
    "property2": {}
  }
}';
const headers = {
  'Content-Type': 'application/json',  'Accept': 'application/json',  'Authorization': 'Bearer {access-token}'
}

fetch('http://localhost:8080/rtc-api/interactions', {
  method: 'POST',
  body: input,
  headers
})
.then(r => r.json())
.then((body) => {
    console.log(body)
})

Java

// This sample needs improvement.
URL obj = new URL("http://localhost:8080/rtc-api/interactions");

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());

Python

import requests

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

r = requests.post(
  'http://localhost:8080/rtc-api/interactions',
  params={},
  headers = headers)

print r.json()

Ruby

require 'rest-client'
require 'json'

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

result = RestClient.post 'http://localhost:8080/rtc-api/interactions',
  params: {}, headers: headers

p JSON.parse(result)

Registrations

Create a new user endpoint aka register a user

POST http://localhost:8080/rtc-api/users/endpoints HTTP/1.1
Host: localhost:8080
Content-Type: application/json
Accept: application/json

Request body

{
  "userEndpointId": "string",
  "keepAliveSeconds": 5,
  "serverKeepAliveReminderOn": true
}

Parameters

Parameter	In	Type	Required	Description
body	body	RegisterUserEndpointWebCommand	true	none

Responses

Overview

Status	Meaning	Description	Schema
200	OK	OK	string
400	Bad Request	Bad Request	Inline

Response Schema

Status Code 400

Name	Type	Required	Restrictions	Description
» additionalProperties	string	false	none	none

Examples

200 Response

"string"

400 Response

caution

To perform this operation, you must be authenticated by means of one of the following methods: BearerToken, OAuth2ClientCredentials

Code samples

Shell

curl -X POST http://localhost:8080/rtc-api/users/endpoints \
  -H 'Content-Type: application/json' \  -H 'Accept: application/json' \  -H 'Authorization: Bearer {access-token}'

Go

package main

import (
    "bytes"
    "net/http"
)

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

    var body []byte
    // body = ...

    req, err := http.NewRequest("POST", "http://localhost:8080/rtc-api/users/endpoints", bytes.NewBuffer(body))
    req.Header = headers

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

Node

const fetch = require('node-fetch');
const input = '{
  "userEndpointId": "string",
  "keepAliveSeconds": 5,
  "serverKeepAliveReminderOn": true
}';
const headers = {
  'Content-Type': 'application/json',  'Accept': 'application/json',  'Authorization': 'Bearer {access-token}'
}

fetch('http://localhost:8080/rtc-api/users/endpoints', {
  method: 'POST',
  body: input,
  headers
})
.then(r => r.json())
.then((body) => {
    console.log(body)
})

Java

// This sample needs improvement.
URL obj = new URL("http://localhost:8080/rtc-api/users/endpoints");

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());

Python

import requests

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

r = requests.post(
  'http://localhost:8080/rtc-api/users/endpoints',
  params={},
  headers = headers)

print r.json()

Ruby

require 'rest-client'
require 'json'

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

result = RestClient.post 'http://localhost:8080/rtc-api/users/endpoints',
  params: {}, headers: headers

p JSON.parse(result)

Destroy an existing user endpoint aka unregister a user

POST http://localhost:8080/rtc-api/users/endpoints/unregister HTTP/1.1
Host: localhost:8080
Content-Type: application/json
Accept: */*

Request body

{
  "userEndpointId": "string",
  "reason": "string"
}

Parameters

Parameter	In	Type	Required	Description
body	body	UnregisterUserEndpointWebCommand	true	none

Responses

Overview

Status	Meaning	Description	Schema
204	No Content	No Content	None
400	Bad Request	Bad Request	Inline

Response Schema

Status Code 400

Name	Type	Required	Restrictions	Description
» additionalProperties	string	false	none	none

Examples

400 Response

caution

To perform this operation, you must be authenticated by means of one of the following methods: BearerToken, OAuth2ClientCredentials

Code samples

Shell

curl -X POST http://localhost:8080/rtc-api/users/endpoints/unregister \
  -H 'Content-Type: application/json' \  -H 'Accept: */*' \  -H 'Authorization: Bearer {access-token}'

Go

package main

import (
    "bytes"
    "net/http"
)

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

    var body []byte
    // body = ...

    req, err := http.NewRequest("POST", "http://localhost:8080/rtc-api/users/endpoints/unregister", bytes.NewBuffer(body))
    req.Header = headers

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

Node

const fetch = require('node-fetch');
const input = '{
  "userEndpointId": "string",
  "reason": "string"
}';
const headers = {
  'Content-Type': 'application/json',  'Accept': '*/*',  'Authorization': 'Bearer {access-token}'
}

fetch('http://localhost:8080/rtc-api/users/endpoints/unregister', {
  method: 'POST',
  body: input,
  headers
})
.then(r => r.json())
.then((body) => {
    console.log(body)
})

Java

// This sample needs improvement.
URL obj = new URL("http://localhost:8080/rtc-api/users/endpoints/unregister");

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());

Python

import requests

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

r = requests.post(
  'http://localhost:8080/rtc-api/users/endpoints/unregister',
  params={},
  headers = headers)

print r.json()

Ruby

require 'rest-client'
require 'json'

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

result = RestClient.post 'http://localhost:8080/rtc-api/users/endpoints/unregister',
  params: {}, headers: headers

p JSON.parse(result)

Sends event to all registered user endpoints

POST http://localhost:8080/rtc-api/users/endpoints/sendEvent HTTP/1.1
Host: localhost:8080
Content-Type: application/json
Accept: */*

Returns number of messages sent. Users with 'SERVICE' role need to supply organization id.

Request body

{
  "userId": "string",
  "organizationId": "string",
  "userEndpointId": "string",
  "event": {
    "property1": {},
    "property2": {}
  },
  "masks": [
    "string"
  ],
  "qos": 0
}

Parameters

Parameter	In	Type	Required	Description
body	body	SendEventToUserWebCommand	true	none

Responses

Overview

Status	Meaning	Description	Schema
200	OK	OK	integer
400	Bad Request	Bad Request	Inline

Response Schema

Status Code 400

Name	Type	Required	Restrictions	Description
» additionalProperties	string	false	none	none

Examples

200 Response

caution

To perform this operation, you must be authenticated by means of one of the following methods: BearerToken, OAuth2ClientCredentials

Code samples

Shell

curl -X POST http://localhost:8080/rtc-api/users/endpoints/sendEvent \
  -H 'Content-Type: application/json' \  -H 'Accept: */*' \  -H 'Authorization: Bearer {access-token}'

Go

package main

import (
    "bytes"
    "net/http"
)

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

    var body []byte
    // body = ...

    req, err := http.NewRequest("POST", "http://localhost:8080/rtc-api/users/endpoints/sendEvent", bytes.NewBuffer(body))
    req.Header = headers

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

Node

const fetch = require('node-fetch');
const input = '{
  "userId": "string",
  "organizationId": "string",
  "userEndpointId": "string",
  "event": {
    "property1": {},
    "property2": {}
  },
  "masks": [
    "string"
  ],
  "qos": 0
}';
const headers = {
  'Content-Type': 'application/json',  'Accept': '*/*',  'Authorization': 'Bearer {access-token}'
}

fetch('http://localhost:8080/rtc-api/users/endpoints/sendEvent', {
  method: 'POST',
  body: input,
  headers
})
.then(r => r.json())
.then((body) => {
    console.log(body)
})

Java

// This sample needs improvement.
URL obj = new URL("http://localhost:8080/rtc-api/users/endpoints/sendEvent");

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());

Python

import requests

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

r = requests.post(
  'http://localhost:8080/rtc-api/users/endpoints/sendEvent',
  params={},
  headers = headers)

print r.json()

Ruby

require 'rest-client'
require 'json'

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

result = RestClient.post 'http://localhost:8080/rtc-api/users/endpoints/sendEvent',
  params: {}, headers: headers

p JSON.parse(result)

Create a new user endpoint aka register a user - ios specific call

POST http://localhost:8080/rtc-api/users/endpoints/register HTTP/1.1
Host: localhost:8080
Content-Type: application/json
Accept: application/json

Request body

{
  "userEndpointId": "string",
  "keepAliveSeconds": 5,
  "serverKeepAliveReminderOn": true
}

Parameters

Parameter	In	Type	Required	Description
body	body	RegisterUserEndpointWebCommand	true	none

Responses

Overview

Status	Meaning	Description	Schema
200	OK	OK	RegisterResult
400	Bad Request	Bad Request	Inline

Response Schema

Status Code 400

Name	Type	Required	Restrictions	Description
» additionalProperties	string	false	none	none

Examples

200 Response

{
  "id": "string"
}

400 Response

caution

To perform this operation, you must be authenticated by means of one of the following methods: BearerToken, OAuth2ClientCredentials

Code samples

Shell

curl -X POST http://localhost:8080/rtc-api/users/endpoints/register \
  -H 'Content-Type: application/json' \  -H 'Accept: application/json' \  -H 'Authorization: Bearer {access-token}'

Go

package main

import (
    "bytes"
    "net/http"
)

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

    var body []byte
    // body = ...

    req, err := http.NewRequest("POST", "http://localhost:8080/rtc-api/users/endpoints/register", bytes.NewBuffer(body))
    req.Header = headers

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

Node

const fetch = require('node-fetch');
const input = '{
  "userEndpointId": "string",
  "keepAliveSeconds": 5,
  "serverKeepAliveReminderOn": true
}';
const headers = {
  'Content-Type': 'application/json',  'Accept': 'application/json',  'Authorization': 'Bearer {access-token}'
}

fetch('http://localhost:8080/rtc-api/users/endpoints/register', {
  method: 'POST',
  body: input,
  headers
})
.then(r => r.json())
.then((body) => {
    console.log(body)
})

Java

// This sample needs improvement.
URL obj = new URL("http://localhost:8080/rtc-api/users/endpoints/register");

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());

Python

import requests

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

r = requests.post(
  'http://localhost:8080/rtc-api/users/endpoints/register',
  params={},
  headers = headers)

print r.json()

Ruby

require 'rest-client'
require 'json'

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

result = RestClient.post 'http://localhost:8080/rtc-api/users/endpoints/register',
  params: {}, headers: headers

p JSON.parse(result)

Send keepalive for a user endpoint

POST http://localhost:8080/rtc-api/users/endpoints/keepalive HTTP/1.1
Host: localhost:8080
Content-Type: application/json
Accept: */*

Request body

{
  "userEndpointId": "string"
}

Parameters

Parameter	In	Type	Required	Description
body	body	KeepUserEndpointAliveWebCommand	true	none

Responses

Overview

Status	Meaning	Description	Schema
204	No Content	No Content	None
400	Bad Request	Bad Request	Inline

Response Schema

Status Code 400

Name	Type	Required	Restrictions	Description
» additionalProperties	string	false	none	none

Examples

400 Response

caution

To perform this operation, you must be authenticated by means of one of the following methods: BearerToken, OAuth2ClientCredentials

Code samples

Shell

curl -X POST http://localhost:8080/rtc-api/users/endpoints/keepalive \
  -H 'Content-Type: application/json' \  -H 'Accept: */*' \  -H 'Authorization: Bearer {access-token}'

Go

package main

import (
    "bytes"
    "net/http"
)

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

    var body []byte
    // body = ...

    req, err := http.NewRequest("POST", "http://localhost:8080/rtc-api/users/endpoints/keepalive", bytes.NewBuffer(body))
    req.Header = headers

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

Node

const fetch = require('node-fetch');
const input = '{
  "userEndpointId": "string"
}';
const headers = {
  'Content-Type': 'application/json',  'Accept': '*/*',  'Authorization': 'Bearer {access-token}'
}

fetch('http://localhost:8080/rtc-api/users/endpoints/keepalive', {
  method: 'POST',
  body: input,
  headers
})
.then(r => r.json())
.then((body) => {
    console.log(body)
})

Java

// This sample needs improvement.
URL obj = new URL("http://localhost:8080/rtc-api/users/endpoints/keepalive");

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());

Python

import requests

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

r = requests.post(
  'http://localhost:8080/rtc-api/users/endpoints/keepalive',
  params={},
  headers = headers)

print r.json()

Ruby

require 'rest-client'
require 'json'

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

result = RestClient.post 'http://localhost:8080/rtc-api/users/endpoints/keepalive',
  params: {}, headers: headers

p JSON.parse(result)

Snapshots

Upload a snapshot

POST http://localhost:8080/rtc-api/snapshots/upload HTTP/1.1
Host: localhost:8080
Content-Type: multipart/form-data
Accept: */*

Request body

relatedSnapshotId: string
applicationId: string
targetUserId: string
targetUserEndpointId: string
interactionId: string
userEndpointId: string
snapshotType: string
snapshotSuffix: string
snapshotMimeType: string
image: string

Parameters

Parameter	In	Type	Required	Description
body	body	object	true	none
» relatedSnapshotId	body	string	false	none
» applicationId	body	string	true	none
» targetUserId	body	string	true	none
» targetUserEndpointId	body	string	true	none
» interactionId	body	string	true	none
» userEndpointId	body	string	true	none
» snapshotType	body	string	true	none
» snapshotSuffix	body	string	true	none
» snapshotMimeType	body	string	true	none
» image	body	string(binary)	true	none

Responses

Overview

Status	Meaning	Description	Schema
204	No Content	No Content	SnapshotUploadResult
400	Bad Request	Bad Request	Inline

Response Schema

Status Code 400

Name	Type	Required	Restrictions	Description
» additionalProperties	string	false	none	none

Examples

204 Response

caution

To perform this operation, you must be authenticated by means of one of the following methods: BearerToken, OAuth2ClientCredentials

Code samples

Shell

curl -X POST http://localhost:8080/rtc-api/snapshots/upload \
  -H 'Content-Type: multipart/form-data' \  -H 'Accept: */*' \  -H 'Authorization: Bearer {access-token}'

Go

package main

import (
    "bytes"
    "net/http"
)

func main() {
    headers := map[string][]string{ 
        "Content-Type": []string{"multipart/form-data"},
        "Accept": []string{"*/*"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    var body []byte
    // body = ...

    req, err := http.NewRequest("POST", "http://localhost:8080/rtc-api/snapshots/upload", bytes.NewBuffer(body))
    req.Header = headers

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

Node

const fetch = require('node-fetch');
const input = '{
  "relatedSnapshotId": "string",
  "applicationId": "string",
  "targetUserId": "string",
  "targetUserEndpointId": "string",
  "interactionId": "string",
  "userEndpointId": "string",
  "snapshotType": "string",
  "snapshotSuffix": "string",
  "snapshotMimeType": "string",
  "image": "string"
}';
const headers = {
  'Content-Type': 'multipart/form-data',  'Accept': '*/*',  'Authorization': 'Bearer {access-token}'
}

fetch('http://localhost:8080/rtc-api/snapshots/upload', {
  method: 'POST',
  body: input,
  headers
})
.then(r => r.json())
.then((body) => {
    console.log(body)
})

Java

// This sample needs improvement.
URL obj = new URL("http://localhost:8080/rtc-api/snapshots/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());

Python

import requests

headers = {
  'Content-Type': 'multipart/form-data',
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.post(
  'http://localhost:8080/rtc-api/snapshots/upload',
  params={},
  headers = headers)

print r.json()

Ruby

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'multipart/form-data',
  'Accept' => '*/*',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.post 'http://localhost:8080/rtc-api/snapshots/upload',
  params: {}, headers: headers

p JSON.parse(result)

Create a signed url for a snapshot

POST http://localhost:8080/rtc-api/snapshots/signedUrl HTTP/1.1
Host: localhost:8080
Content-Type: application/json
Accept: application/json
Referer: string

Request body

{
  "snapshotId": "string",
  "createInternalSignedUrl": true
}

Parameters

Parameter	In	Type	Required	Description
Referer	header	string	true	none
body	body	CreateSnapshotSignedURLWebCommand	true	none

Responses

Overview

Status	Meaning	Description	Schema
200	OK	OK	SignedUrl
400	Bad Request	Bad Request	Inline

Response Schema

Status Code 400

Name	Type	Required	Restrictions	Description
» additionalProperties	string	false	none	none

Examples

200 Response

{
  "url": "string",
  "validUntil": "2019-08-24T14:15:22Z"
}

400 Response

caution

To perform this operation, you must be authenticated by means of one of the following methods: BearerToken, OAuth2ClientCredentials

Code samples

Shell

curl -X POST http://localhost:8080/rtc-api/snapshots/signedUrl \
  -H 'Content-Type: application/json' \  -H 'Accept: application/json' \  -H 'Referer: string' \  -H 'Authorization: Bearer {access-token}'

Go

package main

import (
    "bytes"
    "net/http"
)

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

    var body []byte
    // body = ...

    req, err := http.NewRequest("POST", "http://localhost:8080/rtc-api/snapshots/signedUrl", bytes.NewBuffer(body))
    req.Header = headers

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

Node

const fetch = require('node-fetch');
const input = '{
  "snapshotId": "string",
  "createInternalSignedUrl": true
}';
const headers = {
  'Content-Type': 'application/json',  'Accept': 'application/json',  'Referer': 'string',  'Authorization': 'Bearer {access-token}'
}

fetch('http://localhost:8080/rtc-api/snapshots/signedUrl', {
  method: 'POST',
  body: input,
  headers
})
.then(r => r.json())
.then((body) => {
    console.log(body)
})

Java

// This sample needs improvement.
URL obj = new URL("http://localhost:8080/rtc-api/snapshots/signedUrl");

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());

Python

import requests

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

r = requests.post(
  'http://localhost:8080/rtc-api/snapshots/signedUrl',
  params={},
  headers = headers)

print r.json()

Ruby

require 'rest-client'
require 'json'

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

result = RestClient.post 'http://localhost:8080/rtc-api/snapshots/signedUrl',
  params: {}, headers: headers

p JSON.parse(result)

Creates a new snapshot request

POST http://localhost:8080/rtc-api/snapshots/request HTTP/1.1
Host: localhost:8080
Content-Type: application/json
Accept: application/json

Request body

{
  "applicationId": "string",
  "userEndpointId": "string",
  "targetUserId": "string",
  "targetUserEndpointId": "string",
  "sessionType": "UNKNOWN",
  "sessionId": "string",
  "interactionId": "string",
  "snapshotType": "string"
}

Parameters

Parameter	In	Type	Required	Description
body	body	SnapshotRequestWebCommand	true	none

Responses

Overview

Status	Meaning	Description	Schema
200	OK	OK	SnapshotRequestResult
400	Bad Request	Bad Request	Inline

Response Schema

Status Code 400

Name	Type	Required	Restrictions	Description
» additionalProperties	string	false	none	none

Examples

200 Response

{
  "snapshotId": "string"
}

400 Response

caution

To perform this operation, you must be authenticated by means of one of the following methods: BearerToken, OAuth2ClientCredentials

Code samples

Shell

curl -X POST http://localhost:8080/rtc-api/snapshots/request \
  -H 'Content-Type: application/json' \  -H 'Accept: application/json' \  -H 'Authorization: Bearer {access-token}'

Go

package main

import (
    "bytes"
    "net/http"
)

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

    var body []byte
    // body = ...

    req, err := http.NewRequest("POST", "http://localhost:8080/rtc-api/snapshots/request", bytes.NewBuffer(body))
    req.Header = headers

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

Node

const fetch = require('node-fetch');
const input = '{
  "applicationId": "string",
  "userEndpointId": "string",
  "targetUserId": "string",
  "targetUserEndpointId": "string",
  "sessionType": "UNKNOWN",
  "sessionId": "string",
  "interactionId": "string",
  "snapshotType": "string"
}';
const headers = {
  'Content-Type': 'application/json',  'Accept': 'application/json',  'Authorization': 'Bearer {access-token}'
}

fetch('http://localhost:8080/rtc-api/snapshots/request', {
  method: 'POST',
  body: input,
  headers
})
.then(r => r.json())
.then((body) => {
    console.log(body)
})

Java

// This sample needs improvement.
URL obj = new URL("http://localhost:8080/rtc-api/snapshots/request");

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());

Python

import requests

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

r = requests.post(
  'http://localhost:8080/rtc-api/snapshots/request',
  params={},
  headers = headers)

print r.json()

Ruby

require 'rest-client'
require 'json'

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

result = RestClient.post 'http://localhost:8080/rtc-api/snapshots/request',
  params: {}, headers: headers

p JSON.parse(result)

Discard a snapshot

POST http://localhost:8080/rtc-api/snapshots/discard HTTP/1.1
Host: localhost:8080
Content-Type: application/json
Accept: */*

Request body

{
  "snapshotId": "string",
  "userEndpointId": "string"
}

Parameters

Parameter	In	Type	Required	Description
body	body	SnapshotDiscardWebCommand	true	none

Responses

Overview

Status	Meaning	Description	Schema
204	No Content	No Content	None
400	Bad Request	Bad Request	Inline

Response Schema

Status Code 400

Name	Type	Required	Restrictions	Description
» additionalProperties	string	false	none	none

Examples

400 Response

caution

To perform this operation, you must be authenticated by means of one of the following methods: BearerToken, OAuth2ClientCredentials

Code samples

Shell

curl -X POST http://localhost:8080/rtc-api/snapshots/discard \
  -H 'Content-Type: application/json' \  -H 'Accept: */*' \  -H 'Authorization: Bearer {access-token}'

Go

package main

import (
    "bytes"
    "net/http"
)

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

    var body []byte
    // body = ...

    req, err := http.NewRequest("POST", "http://localhost:8080/rtc-api/snapshots/discard", bytes.NewBuffer(body))
    req.Header = headers

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

Node

const fetch = require('node-fetch');
const input = '{
  "snapshotId": "string",
  "userEndpointId": "string"
}';
const headers = {
  'Content-Type': 'application/json',  'Accept': '*/*',  'Authorization': 'Bearer {access-token}'
}

fetch('http://localhost:8080/rtc-api/snapshots/discard', {
  method: 'POST',
  body: input,
  headers
})
.then(r => r.json())
.then((body) => {
    console.log(body)
})

Java

// This sample needs improvement.
URL obj = new URL("http://localhost:8080/rtc-api/snapshots/discard");

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());

Python

import requests

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

r = requests.post(
  'http://localhost:8080/rtc-api/snapshots/discard',
  params={},
  headers = headers)

print r.json()

Ruby

require 'rest-client'
require 'json'

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

result = RestClient.post 'http://localhost:8080/rtc-api/snapshots/discard',
  params: {}, headers: headers

p JSON.parse(result)

Creates a new camera request

POST http://localhost:8080/rtc-api/snapshots/cameraRequest HTTP/1.1
Host: localhost:8080
Content-Type: application/json
Accept: application/json

Request body

{
  "userEndpointId": "string",
  "targetUserId": "string",
  "targetUserEndpointId": "string",
  "sessionType": "UNKNOWN",
  "sessionId": "string",
  "cameraRequestType": "CAMERA_SWITCH"
}

Parameters

Parameter	In	Type	Required	Description
body	body	SnapshotCameraRequestWebCommand	true	none

Responses

Overview

Status	Meaning	Description	Schema
200	OK	OK	string
400	Bad Request	Bad Request	Inline

Response Schema

Status Code 400

Name	Type	Required	Restrictions	Description
» additionalProperties	string	false	none	none

Examples

200 Response

"string"

400 Response

caution

To perform this operation, you must be authenticated by means of one of the following methods: BearerToken, OAuth2ClientCredentials

Code samples

Shell

curl -X POST http://localhost:8080/rtc-api/snapshots/cameraRequest \
  -H 'Content-Type: application/json' \  -H 'Accept: application/json' \  -H 'Authorization: Bearer {access-token}'

Go

package main

import (
    "bytes"
    "net/http"
)

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

    var body []byte
    // body = ...

    req, err := http.NewRequest("POST", "http://localhost:8080/rtc-api/snapshots/cameraRequest", bytes.NewBuffer(body))
    req.Header = headers

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

Node

const fetch = require('node-fetch');
const input = '{
  "userEndpointId": "string",
  "targetUserId": "string",
  "targetUserEndpointId": "string",
  "sessionType": "UNKNOWN",
  "sessionId": "string",
  "cameraRequestType": "CAMERA_SWITCH"
}';
const headers = {
  'Content-Type': 'application/json',  'Accept': 'application/json',  'Authorization': 'Bearer {access-token}'
}

fetch('http://localhost:8080/rtc-api/snapshots/cameraRequest', {
  method: 'POST',
  body: input,
  headers
})
.then(r => r.json())
.then((body) => {
    console.log(body)
})

Java

// This sample needs improvement.
URL obj = new URL("http://localhost:8080/rtc-api/snapshots/cameraRequest");

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());

Python

import requests

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

r = requests.post(
  'http://localhost:8080/rtc-api/snapshots/cameraRequest',
  params={},
  headers = headers)

print r.json()

Ruby

require 'rest-client'
require 'json'

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

result = RestClient.post 'http://localhost:8080/rtc-api/snapshots/cameraRequest',
  params: {}, headers: headers

p JSON.parse(result)

Responds to a camera request

POST http://localhost:8080/rtc-api/snapshots/cameraRequestRespond HTTP/1.1
Host: localhost:8080
Content-Type: application/json
Accept: */*

Request body

{
  "snapshotCameraRequestId": "string",
  "userEndpointId": "string",
  "succeeded": true,
  "additionalInformation": "string"
}

Parameters

Parameter	In	Type	Required	Description
body	body	SnapshotCameraRequestRespondWebCommand	true	none

Responses

Overview

Status	Meaning	Description	Schema
204	No Content	No Content	None
400	Bad Request	Bad Request	Inline

Response Schema

Status Code 400

Name	Type	Required	Restrictions	Description
» additionalProperties	string	false	none	none

Examples

400 Response

caution

To perform this operation, you must be authenticated by means of one of the following methods: BearerToken, OAuth2ClientCredentials

Code samples

Shell

curl -X POST http://localhost:8080/rtc-api/snapshots/cameraRequestRespond \
  -H 'Content-Type: application/json' \  -H 'Accept: */*' \  -H 'Authorization: Bearer {access-token}'

Go

package main

import (
    "bytes"
    "net/http"
)

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

    var body []byte
    // body = ...

    req, err := http.NewRequest("POST", "http://localhost:8080/rtc-api/snapshots/cameraRequestRespond", bytes.NewBuffer(body))
    req.Header = headers

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

Node

const fetch = require('node-fetch');
const input = '{
  "snapshotCameraRequestId": "string",
  "userEndpointId": "string",
  "succeeded": true,
  "additionalInformation": "string"
}';
const headers = {
  'Content-Type': 'application/json',  'Accept': '*/*',  'Authorization': 'Bearer {access-token}'
}

fetch('http://localhost:8080/rtc-api/snapshots/cameraRequestRespond', {
  method: 'POST',
  body: input,
  headers
})
.then(r => r.json())
.then((body) => {
    console.log(body)
})

Java

// This sample needs improvement.
URL obj = new URL("http://localhost:8080/rtc-api/snapshots/cameraRequestRespond");

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());

Python

import requests

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

r = requests.post(
  'http://localhost:8080/rtc-api/snapshots/cameraRequestRespond',
  params={},
  headers = headers)

print r.json()

Ruby

require 'rest-client'
require 'json'

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

result = RestClient.post 'http://localhost:8080/rtc-api/snapshots/cameraRequestRespond',
  params: {}, headers: headers

p JSON.parse(result)

Approve a snapshot

POST http://localhost:8080/rtc-api/snapshots/approve HTTP/1.1
Host: localhost:8080
Content-Type: application/json
Accept: */*

Request body

{
  "snapshotId": "string",
  "userEndpointId": "string",
  "snapshotType": "string"
}

Parameters

Parameter	In	Type	Required	Description
body	body	SnapshotApproveWebCommand	true	none

Responses

Overview

Status	Meaning	Description	Schema
204	No Content	No Content	None
400	Bad Request	Bad Request	Inline

Response Schema

Status Code 400

Name	Type	Required	Restrictions	Description
» additionalProperties	string	false	none	none

Examples

400 Response

caution

To perform this operation, you must be authenticated by means of one of the following methods: BearerToken, OAuth2ClientCredentials

Code samples

Shell

curl -X POST http://localhost:8080/rtc-api/snapshots/approve \
  -H 'Content-Type: application/json' \  -H 'Accept: */*' \  -H 'Authorization: Bearer {access-token}'

Go

package main

import (
    "bytes"
    "net/http"
)

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

    var body []byte
    // body = ...

    req, err := http.NewRequest("POST", "http://localhost:8080/rtc-api/snapshots/approve", bytes.NewBuffer(body))
    req.Header = headers

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

Node

const fetch = require('node-fetch');
const input = '{
  "snapshotId": "string",
  "userEndpointId": "string",
  "snapshotType": "string"
}';
const headers = {
  'Content-Type': 'application/json',  'Accept': '*/*',  'Authorization': 'Bearer {access-token}'
}

fetch('http://localhost:8080/rtc-api/snapshots/approve', {
  method: 'POST',
  body: input,
  headers
})
.then(r => r.json())
.then((body) => {
    console.log(body)
})

Java

// This sample needs improvement.
URL obj = new URL("http://localhost:8080/rtc-api/snapshots/approve");

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());

Python

import requests

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

r = requests.post(
  'http://localhost:8080/rtc-api/snapshots/approve',
  params={},
  headers = headers)

print r.json()

Ruby

require 'rest-client'
require 'json'

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

result = RestClient.post 'http://localhost:8080/rtc-api/snapshots/approve',
  params: {}, headers: headers

p JSON.parse(result)

Acquire a snapshot

POST http://localhost:8080/rtc-api/snapshots/acquire HTTP/1.1
Host: localhost:8080
Content-Type: multipart/form-data
Accept: */*

Request body

snapshotId: string
userEndpointId: string
snapshotType: string
snapshotSuffix: string
snapshotMimeType: string
image: string

Parameters

Parameter	In	Type	Required	Description
body	body	object	true	none
» snapshotId	body	string	true	none
» userEndpointId	body	string	true	none
» snapshotType	body	string	true	none
» snapshotSuffix	body	string	true	none
» snapshotMimeType	body	string	true	none
» image	body	string(binary)	true	none

Responses

Overview

Status	Meaning	Description	Schema
204	No Content	No Content	None
400	Bad Request	Bad Request	Inline

Response Schema

Status Code 400

Name	Type	Required	Restrictions	Description
» additionalProperties	string	false	none	none

Examples

400 Response

caution

To perform this operation, you must be authenticated by means of one of the following methods: BearerToken, OAuth2ClientCredentials

Code samples

Shell

curl -X POST http://localhost:8080/rtc-api/snapshots/acquire \
  -H 'Content-Type: multipart/form-data' \  -H 'Accept: */*' \  -H 'Authorization: Bearer {access-token}'

Go

package main

import (
    "bytes"
    "net/http"
)

func main() {
    headers := map[string][]string{ 
        "Content-Type": []string{"multipart/form-data"},
        "Accept": []string{"*/*"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    var body []byte
    // body = ...

    req, err := http.NewRequest("POST", "http://localhost:8080/rtc-api/snapshots/acquire", bytes.NewBuffer(body))
    req.Header = headers

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

Node

const fetch = require('node-fetch');
const input = '{
  "snapshotId": "string",
  "userEndpointId": "string",
  "snapshotType": "string",
  "snapshotSuffix": "string",
  "snapshotMimeType": "string",
  "image": "string"
}';
const headers = {
  'Content-Type': 'multipart/form-data',  'Accept': '*/*',  'Authorization': 'Bearer {access-token}'
}

fetch('http://localhost:8080/rtc-api/snapshots/acquire', {
  method: 'POST',
  body: input,
  headers
})
.then(r => r.json())
.then((body) => {
    console.log(body)
})

Java

// This sample needs improvement.
URL obj = new URL("http://localhost:8080/rtc-api/snapshots/acquire");

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());

Python

import requests

headers = {
  'Content-Type': 'multipart/form-data',
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.post(
  'http://localhost:8080/rtc-api/snapshots/acquire',
  params={},
  headers = headers)

print r.json()

Ruby

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'multipart/form-data',
  'Accept' => '*/*',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.post 'http://localhost:8080/rtc-api/snapshots/acquire',
  params: {}, headers: headers

p JSON.parse(result)

retrieve snapshots

GET http://localhost:8080/rtc-api/snapshots?interactionId=string HTTP/1.1
Host: localhost:8080
Accept: */*

Parameters

Parameter	In	Type	Required	Description
interactionId	query	string	true	none

Responses

Overview

Status	Meaning	Description	Schema
200	OK	OK	Inline
400	Bad Request	Bad Request	Inline

Response Schema

Status Code 400

Name	Type	Required	Restrictions	Description
» additionalProperties	string	false	none	none

Examples

200 Response

caution

To perform this operation, you must be authenticated by means of one of the following methods: BearerToken, OAuth2ClientCredentials

Code samples

Shell

curl -X GET http://localhost:8080/rtc-api/snapshots?interactionId=string \
  -H 'Accept: */*' \  -H 'Authorization: Bearer {access-token}'

Go

package main

import (
    "bytes"
    "net/http"
)

func main() {
    headers := map[string][]string{ 
        "Accept": []string{"*/*"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    var body []byte
    // body = ...

    req, err := http.NewRequest("GET", "http://localhost:8080/rtc-api/snapshots", bytes.NewBuffer(body))
    req.Header = headers

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

Node

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

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

fetch('http://localhost:8080/rtc-api/snapshots?interactionId=string', {
  method: 'GET',
  headers
})
.then(r => r.json())
.then((body) => {
    console.log(body)
})

Java

// This sample needs improvement.
URL obj = new URL("http://localhost:8080/rtc-api/snapshots?interactionId=string");

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());

Python

import requests

headers = {
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get(
  'http://localhost:8080/rtc-api/snapshots',
  params={
    'interactionId': 'string'},
  headers = headers)

print r.json()

Ruby

require 'rest-client'
require 'json'

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

result = RestClient.get 'http://localhost:8080/rtc-api/snapshots',
  params: {
    'interactionId' => 'string'}, headers: headers

p JSON.parse(result)

retrieve specific snapshot

GET http://localhost:8080/rtc-api/snapshots/{snapshotId} HTTP/1.1
Host: localhost:8080
Accept: */*

Parameters

Parameter	In	Type	Required	Description
snapshotId	path	string	true	none

Responses

Overview

Status	Meaning	Description	Schema
200	OK	OK	Snapshot
400	Bad Request	Bad Request	Inline

Response Schema

Status Code 400

Name	Type	Required	Restrictions	Description
» additionalProperties	string	false	none	none

Examples

200 Response

caution

To perform this operation, you must be authenticated by means of one of the following methods: BearerToken, OAuth2ClientCredentials

Code samples

Shell

curl -X GET http://localhost:8080/rtc-api/snapshots/{snapshotId} \
  -H 'Accept: */*' \  -H 'Authorization: Bearer {access-token}'

Go

package main

import (
    "bytes"
    "net/http"
)

func main() {
    headers := map[string][]string{ 
        "Accept": []string{"*/*"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    var body []byte
    // body = ...

    req, err := http.NewRequest("GET", "http://localhost:8080/rtc-api/snapshots/{snapshotId}", bytes.NewBuffer(body))
    req.Header = headers

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

Node

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

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

fetch('http://localhost:8080/rtc-api/snapshots/{snapshotId}', {
  method: 'GET',
  headers
})
.then(r => r.json())
.then((body) => {
    console.log(body)
})

Java

// This sample needs improvement.
URL obj = new URL("http://localhost:8080/rtc-api/snapshots/{snapshotId}");

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());

Python

import requests

headers = {
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get(
  'http://localhost:8080/rtc-api/snapshots/{snapshotId}',
  params={},
  headers = headers)

print r.json()

Ruby

require 'rest-client'
require 'json'

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

result = RestClient.get 'http://localhost:8080/rtc-api/snapshots/{snapshotId}',
  params: {}, headers: headers

p JSON.parse(result)

get a builtin signed url

GET http://localhost:8080/rtc-api/snapshots/signed/{snapshotId}/{expiration}?signature=string HTTP/1.1
Host: localhost:8080
Accept: */*

Parameters

Parameter	In	Type	Required	Description
snapshotId	path	string	true	none
expiration	path	integer(int64)	true	none
signature	query	string	true	none

Responses

Overview

Status	Meaning	Description	Schema
200	OK	OK	string
400	Bad Request	Bad Request	Inline

Response Schema

Status Code 400

Name	Type	Required	Restrictions	Description
» additionalProperties	string	false	none	none

Examples

200 Response

caution

To perform this operation, you must be authenticated by means of one of the following methods: BearerToken, OAuth2ClientCredentials

Code samples

Shell

curl -X GET http://localhost:8080/rtc-api/snapshots/signed/{snapshotId}/{expiration}?signature=string \
  -H 'Accept: */*' \  -H 'Authorization: Bearer {access-token}'

Go

package main

import (
    "bytes"
    "net/http"
)

func main() {
    headers := map[string][]string{ 
        "Accept": []string{"*/*"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    var body []byte
    // body = ...

    req, err := http.NewRequest("GET", "http://localhost:8080/rtc-api/snapshots/signed/{snapshotId}/{expiration}", bytes.NewBuffer(body))
    req.Header = headers

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

Node

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

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

fetch('http://localhost:8080/rtc-api/snapshots/signed/{snapshotId}/{expiration}?signature=string', {
  method: 'GET',
  headers
})
.then(r => r.json())
.then((body) => {
    console.log(body)
})

Java

// This sample needs improvement.
URL obj = new URL("http://localhost:8080/rtc-api/snapshots/signed/{snapshotId}/{expiration}?signature=string");

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());

Python

import requests

headers = {
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get(
  'http://localhost:8080/rtc-api/snapshots/signed/{snapshotId}/{expiration}',
  params={
    'signature': 'string'},
  headers = headers)

print r.json()

Ruby

require 'rest-client'
require 'json'

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

result = RestClient.get 'http://localhost:8080/rtc-api/snapshots/signed/{snapshotId}/{expiration}',
  params: {
    'signature' => 'string'}, headers: headers

p JSON.parse(result)

Ratings

Create a new rating

POST http://localhost:8080/rtc-api/ratings HTTP/1.1
Host: localhost:8080
Content-Type: application/json
Accept: application/json

Request body

{
  "userEndpointId": "string",
  "sessionType": "UNKNOWN",
  "sessionId": "string",
  "rating": 0,
  "comment": "string",
  "interactionId": "string"
}

Parameters

Parameter	In	Type	Required	Description
body	body	CreateRatingWebCommand	true	none

Responses

Overview

Status	Meaning	Description	Schema
200	OK	OK	CreatingRatingWebResponse
400	Bad Request	Bad Request	Inline

Response Schema

Status Code 400

Name	Type	Required	Restrictions	Description
» additionalProperties	string	false	none	none

Examples

200 Response

{
  "id": "string"
}

400 Response

caution

To perform this operation, you must be authenticated by means of one of the following methods: BearerToken, OAuth2ClientCredentials

Code samples

Shell

curl -X POST http://localhost:8080/rtc-api/ratings \
  -H 'Content-Type: application/json' \  -H 'Accept: application/json' \  -H 'Authorization: Bearer {access-token}'

Go

package main

import (
    "bytes"
    "net/http"
)

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

    var body []byte
    // body = ...

    req, err := http.NewRequest("POST", "http://localhost:8080/rtc-api/ratings", bytes.NewBuffer(body))
    req.Header = headers

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

Node

const fetch = require('node-fetch');
const input = '{
  "userEndpointId": "string",
  "sessionType": "UNKNOWN",
  "sessionId": "string",
  "rating": 0,
  "comment": "string",
  "interactionId": "string"
}';
const headers = {
  'Content-Type': 'application/json',  'Accept': 'application/json',  'Authorization': 'Bearer {access-token}'
}

fetch('http://localhost:8080/rtc-api/ratings', {
  method: 'POST',
  body: input,
  headers
})
.then(r => r.json())
.then((body) => {
    console.log(body)
})

Java

// This sample needs improvement.
URL obj = new URL("http://localhost:8080/rtc-api/ratings");

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());

Python

import requests

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

r = requests.post(
  'http://localhost:8080/rtc-api/ratings',
  params={},
  headers = headers)

print r.json()

Ruby

require 'rest-client'
require 'json'

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

result = RestClient.post 'http://localhost:8080/rtc-api/ratings',
  params: {}, headers: headers

p JSON.parse(result)

Find ratings by interaction id

GET http://localhost:8080/rtc-api/ratings/interactions/{interactionId} HTTP/1.1
Host: localhost:8080
Accept: application/json

Parameters

Parameter	In	Type	Required	Description
interactionId	path	string	true	none

Responses

Overview

Status	Meaning	Description	Schema
200	OK	OK	Inline
400	Bad Request	Bad Request	Inline

Response Schema

Status Code 200

Name	Type	Required	Restrictions	Description
anonymous	[Rating]	false	none	none
» id	string	false	none	rating id
» userId	string	false	none	the user who created this rating
» userEndpointId	string	false	none	the user endpoint from which the user created this rating
» organizationId	string	false	none	related organization id
» interactionId	string	false	none	related interaction id
» sessionType	string	false	none	kind of session, CALL or CONFERENCE
» sessionId	string	false	none	the call or conference id related with this rating
» score	integer(int32)	false	none	the rating the user gave, scale is 1-5, 1 meaning bad and 5 perfect
» comment	string	false	none	any comment the user gave
» createdAt	string(date-time)	false	none	none

Enumerated Values

Property	Value
sessionType	UNKNOWN
sessionType	CALL
sessionType	CONFERENCE

Status Code 400

Name	Type	Required	Restrictions	Description
» additionalProperties	string	false	none	none

Examples

200 Response

[
  {
    "id": "string",
    "userId": "string",
    "userEndpointId": "string",
    "organizationId": "string",
    "interactionId": "string",
    "sessionType": "UNKNOWN",
    "sessionId": "string",
    "score": 0,
    "comment": "string",
    "createdAt": "2019-08-24T14:15:22Z"
  }
]

400 Response

caution

To perform this operation, you must be authenticated by means of one of the following methods: BearerToken, OAuth2ClientCredentials

Code samples

Shell

curl -X GET http://localhost:8080/rtc-api/ratings/interactions/{interactionId} \
  -H 'Accept: application/json' \  -H 'Authorization: Bearer {access-token}'

Go

package main

import (
    "bytes"
    "net/http"
)

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

    var body []byte
    // body = ...

    req, err := http.NewRequest("GET", "http://localhost:8080/rtc-api/ratings/interactions/{interactionId}", bytes.NewBuffer(body))
    req.Header = headers

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

Node

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

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

fetch('http://localhost:8080/rtc-api/ratings/interactions/{interactionId}', {
  method: 'GET',
  headers
})
.then(r => r.json())
.then((body) => {
    console.log(body)
})

Java

// This sample needs improvement.
URL obj = new URL("http://localhost:8080/rtc-api/ratings/interactions/{interactionId}");

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());

Python

import requests

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

r = requests.get(
  'http://localhost:8080/rtc-api/ratings/interactions/{interactionId}',
  params={},
  headers = headers)

print r.json()

Ruby

require 'rest-client'
require 'json'

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

result = RestClient.get 'http://localhost:8080/rtc-api/ratings/interactions/{interactionId}',
  params: {}, headers: headers

p JSON.parse(result)

Find ratings by conference id

GET http://localhost:8080/rtc-api/ratings/conferences/{conferenceId} HTTP/1.1
Host: localhost:8080
Accept: application/json

Parameters

Parameter	In	Type	Required	Description
conferenceId	path	string	true	none

Responses

Overview

Status	Meaning	Description	Schema
200	OK	OK	Inline
400	Bad Request	Bad Request	Inline

Response Schema

Status Code 200

Name	Type	Required	Restrictions	Description
anonymous	[Rating]	false	none	none
» id	string	false	none	rating id
» userId	string	false	none	the user who created this rating
» userEndpointId	string	false	none	the user endpoint from which the user created this rating
» organizationId	string	false	none	related organization id
» interactionId	string	false	none	related interaction id
» sessionType	string	false	none	kind of session, CALL or CONFERENCE
» sessionId	string	false	none	the call or conference id related with this rating
» score	integer(int32)	false	none	the rating the user gave, scale is 1-5, 1 meaning bad and 5 perfect
» comment	string	false	none	any comment the user gave
» createdAt	string(date-time)	false	none	none

Enumerated Values

Property	Value
sessionType	UNKNOWN
sessionType	CALL
sessionType	CONFERENCE

Status Code 400

Name	Type	Required	Restrictions	Description
» additionalProperties	string	false	none	none

Examples

200 Response

[
  {
    "id": "string",
    "userId": "string",
    "userEndpointId": "string",
    "organizationId": "string",
    "interactionId": "string",
    "sessionType": "UNKNOWN",
    "sessionId": "string",
    "score": 0,
    "comment": "string",
    "createdAt": "2019-08-24T14:15:22Z"
  }
]

400 Response

caution

To perform this operation, you must be authenticated by means of one of the following methods: BearerToken, OAuth2ClientCredentials

Code samples

Shell

curl -X GET http://localhost:8080/rtc-api/ratings/conferences/{conferenceId} \
  -H 'Accept: application/json' \  -H 'Authorization: Bearer {access-token}'

Go

package main

import (
    "bytes"
    "net/http"
)

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

    var body []byte
    // body = ...

    req, err := http.NewRequest("GET", "http://localhost:8080/rtc-api/ratings/conferences/{conferenceId}", bytes.NewBuffer(body))
    req.Header = headers

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

Node

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

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

fetch('http://localhost:8080/rtc-api/ratings/conferences/{conferenceId}', {
  method: 'GET',
  headers
})
.then(r => r.json())
.then((body) => {
    console.log(body)
})

Java

// This sample needs improvement.
URL obj = new URL("http://localhost:8080/rtc-api/ratings/conferences/{conferenceId}");

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());

Python

import requests

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

r = requests.get(
  'http://localhost:8080/rtc-api/ratings/conferences/{conferenceId}',
  params={},
  headers = headers)

print r.json()

Ruby

require 'rest-client'
require 'json'

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

result = RestClient.get 'http://localhost:8080/rtc-api/ratings/conferences/{conferenceId}',
  params: {}, headers: headers

p JSON.parse(result)

File Transfers

Find file transfers

GET http://localhost:8080/rtc-api/filetransfers HTTP/1.1
Host: localhost:8080
Accept: application/json

Parameters

Parameter	In	Type	Required	Description
interactionId	query	string	false	find by interactionId, mutually exclusive with conferenceId
conferenceId	query	string	false	find by conferenceId, mutually exclusive with interactionId
all	query	boolean	false	if provided and true, all file transfers will be received, not just the ones sent or received by user calling which is the default behavior

Responses

Overview

Status	Meaning	Description	Schema
200	OK	OK	Inline
400	Bad Request	Bad Request	Inline

Response Schema

Status Code 400

Name	Type	Required	Restrictions	Description
» additionalProperties	string	false	none	none

Examples

200 Response

{}

400 Response

caution

To perform this operation, you must be authenticated by means of one of the following methods: BearerToken, OAuth2ClientCredentials

Code samples

Shell

curl -X GET http://localhost:8080/rtc-api/filetransfers \
  -H 'Accept: application/json' \  -H 'Authorization: Bearer {access-token}'

Go

package main

import (
    "bytes"
    "net/http"
)

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

    var body []byte
    // body = ...

    req, err := http.NewRequest("GET", "http://localhost:8080/rtc-api/filetransfers", bytes.NewBuffer(body))
    req.Header = headers

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

Node

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

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

fetch('http://localhost:8080/rtc-api/filetransfers', {
  method: 'GET',
  headers
})
.then(r => r.json())
.then((body) => {
    console.log(body)
})

Java

// This sample needs improvement.
URL obj = new URL("http://localhost:8080/rtc-api/filetransfers");

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());

Python

import requests

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

r = requests.get(
  'http://localhost:8080/rtc-api/filetransfers',
  params={},
  headers = headers)

print r.json()

Ruby

require 'rest-client'
require 'json'

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

result = RestClient.get 'http://localhost:8080/rtc-api/filetransfers',
  params: {}, headers: headers

p JSON.parse(result)

Transfer a file

POST http://localhost:8080/rtc-api/filetransfers?targetType=user HTTP/1.1
Host: localhost:8080
Content-Type: multipart/form-data
Accept: */*
X-Auvious-TransactionId: string

Request body

userEndpointId: string
applicationId: string
interactionId: string
conferenceId: string
targetId: string
file: string

Parameters

Parameter	In	Type	Required	Description
X-Auvious-TransactionId	header	string	false	used for detecting retries of the same request
targetType	query	string	true	target type e.g. USER, affects which users will receive the FileTransferEvent message
body	body	object	true	none
» userEndpointId	body	string	false	which userEndpoint id to link to
» applicationId	body	string	true	which application id to use, must match user organization
» interactionId	body	string	false	which integration id to link this transfer to, optional
» conferenceId	body	string	false	which conference id to link this transfer to, optional
» targetId	body	string	true	target id e.g. a user id, will be used to send the FileTransferEvent to all user endpoints of user
» file	body	string(binary)	true	the actual file

Enumerated Values

Parameter	Value
targetType	user

Responses

Overview

Status	Meaning	Description	Schema
200	OK	OK	FileTransferResult
400	Bad Request	Bad Request	Inline

Response Schema

Status Code 400

Name	Type	Required	Restrictions	Description
» additionalProperties	string	false	none	none

Examples

200 Response

caution

To perform this operation, you must be authenticated by means of one of the following methods: BearerToken, OAuth2ClientCredentials

Code samples

Shell

curl -X POST http://localhost:8080/rtc-api/filetransfers?targetType=user \
  -H 'Content-Type: multipart/form-data' \  -H 'Accept: */*' \  -H 'X-Auvious-TransactionId: string' \  -H 'Authorization: Bearer {access-token}'

Go

package main

import (
    "bytes"
    "net/http"
)

func main() {
    headers := map[string][]string{ 
        "Content-Type": []string{"multipart/form-data"},
        "Accept": []string{"*/*"},
        "X-Auvious-TransactionId": []string{"string"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    var body []byte
    // body = ...

    req, err := http.NewRequest("POST", "http://localhost:8080/rtc-api/filetransfers", bytes.NewBuffer(body))
    req.Header = headers

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

Node

const fetch = require('node-fetch');
const input = '{
  "userEndpointId": "string",
  "applicationId": "string",
  "interactionId": "string",
  "conferenceId": "string",
  "targetId": "string",
  "file": "string"
}';
const headers = {
  'Content-Type': 'multipart/form-data',  'Accept': '*/*',  'X-Auvious-TransactionId': 'string',  'Authorization': 'Bearer {access-token}'
}

fetch('http://localhost:8080/rtc-api/filetransfers?targetType=user', {
  method: 'POST',
  body: input,
  headers
})
.then(r => r.json())
.then((body) => {
    console.log(body)
})

Java

// This sample needs improvement.
URL obj = new URL("http://localhost:8080/rtc-api/filetransfers?targetType=user");

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());

Python

import requests

headers = {
  'Content-Type': 'multipart/form-data',
  'Accept': '*/*',
  'X-Auvious-TransactionId': 'string',
  'Authorization': 'Bearer {access-token}'
}

r = requests.post(
  'http://localhost:8080/rtc-api/filetransfers',
  params={
    'targetType': 'user'},
  headers = headers)

print r.json()

Ruby

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'multipart/form-data',
  'Accept' => '*/*',
  'X-Auvious-TransactionId' => 'string',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.post 'http://localhost:8080/rtc-api/filetransfers',
  params: {
    'targetType' => 'string'}, headers: headers

p JSON.parse(result)

create a signed url

POST http://localhost:8080/rtc-api/filetransfers/{fileTransferId}/signedUrl HTTP/1.1
Host: localhost:8080
Accept: application/json
Referer: string

Parameters

Parameter	In	Type	Required	Description
fileTransferId	path	string	true	none
Referer	header	string	true	none

Responses

Overview

Status	Meaning	Description	Schema
200	OK	OK	SignedUrl
400	Bad Request	Bad Request	Inline

Response Schema

Status Code 400

Name	Type	Required	Restrictions	Description
» additionalProperties	string	false	none	none

Examples

200 Response

{
  "url": "string",
  "validUntil": "2019-08-24T14:15:22Z"
}

400 Response

caution

To perform this operation, you must be authenticated by means of one of the following methods: BearerToken, OAuth2ClientCredentials

Code samples

Shell

curl -X POST http://localhost:8080/rtc-api/filetransfers/{fileTransferId}/signedUrl \
  -H 'Accept: application/json' \  -H 'Referer: string' \  -H 'Authorization: Bearer {access-token}'

Go

package main

import (
    "bytes"
    "net/http"
)

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

    var body []byte
    // body = ...

    req, err := http.NewRequest("POST", "http://localhost:8080/rtc-api/filetransfers/{fileTransferId}/signedUrl", bytes.NewBuffer(body))
    req.Header = headers

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

Node

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

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

fetch('http://localhost:8080/rtc-api/filetransfers/{fileTransferId}/signedUrl', {
  method: 'POST',
  headers
})
.then(r => r.json())
.then((body) => {
    console.log(body)
})

Java

// This sample needs improvement.
URL obj = new URL("http://localhost:8080/rtc-api/filetransfers/{fileTransferId}/signedUrl");

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());

Python

import requests

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

r = requests.post(
  'http://localhost:8080/rtc-api/filetransfers/{fileTransferId}/signedUrl',
  params={},
  headers = headers)

print r.json()

Ruby

require 'rest-client'
require 'json'

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

result = RestClient.post 'http://localhost:8080/rtc-api/filetransfers/{fileTransferId}/signedUrl',
  params: {}, headers: headers

p JSON.parse(result)

get a builtin signed url

GET http://localhost:8080/rtc-api/filetransfers/signed/{fileTransferId}/{expiration}?signature=string HTTP/1.1
Host: localhost:8080
Accept: */*

Parameters

Parameter	In	Type	Required	Description
fileTransferId	path	string	true	none
expiration	path	integer(int64)	true	none
signature	query	string	true	none

Responses

Overview

Status	Meaning	Description	Schema
200	OK	OK	string
400	Bad Request	Bad Request	Inline

Response Schema

Status Code 400

Name	Type	Required	Restrictions	Description
» additionalProperties	string	false	none	none

Examples

200 Response

caution

To perform this operation, you must be authenticated by means of one of the following methods: BearerToken, OAuth2ClientCredentials

Code samples

Shell

curl -X GET http://localhost:8080/rtc-api/filetransfers/signed/{fileTransferId}/{expiration}?signature=string \
  -H 'Accept: */*' \  -H 'Authorization: Bearer {access-token}'

Go

package main

import (
    "bytes"
    "net/http"
)

func main() {
    headers := map[string][]string{ 
        "Accept": []string{"*/*"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    var body []byte
    // body = ...

    req, err := http.NewRequest("GET", "http://localhost:8080/rtc-api/filetransfers/signed/{fileTransferId}/{expiration}", bytes.NewBuffer(body))
    req.Header = headers

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

Node

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

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

fetch('http://localhost:8080/rtc-api/filetransfers/signed/{fileTransferId}/{expiration}?signature=string', {
  method: 'GET',
  headers
})
.then(r => r.json())
.then((body) => {
    console.log(body)
})

Java

// This sample needs improvement.
URL obj = new URL("http://localhost:8080/rtc-api/filetransfers/signed/{fileTransferId}/{expiration}?signature=string");

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());

Python

import requests

headers = {
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get(
  'http://localhost:8080/rtc-api/filetransfers/signed/{fileTransferId}/{expiration}',
  params={
    'signature': 'string'},
  headers = headers)

print r.json()

Ruby

require 'rest-client'
require 'json'

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

result = RestClient.get 'http://localhost:8080/rtc-api/filetransfers/signed/{fileTransferId}/{expiration}',
  params: {
    'signature' => 'string'}, headers: headers

p JSON.parse(result)

Conferences

View request, when a user receives ConferenceStreamPublishedEvent, the next logical thing to is to view the stream, and to view a stream one needs to start with this request.

POST http://localhost:8080/rtc-api/conferences/viewStream HTTP/1.1
Host: localhost:8080
Content-Type: application/json
Accept: application/json

Request body

{
  "conferenceId": "string",
  "userEndpointId": "string",
  "streamId": "string",
  "sdpOffer": "string",
  "viewerId": "string",
  "metadata": {
    "property1": "string",
    "property2": "string"
  }
}

Parameters

Parameter	In	Type	Required	Description
body	body	ConferenceViewStreamWebCommand	true	none

Responses

Overview

Status	Meaning	Description	Schema
200	OK	OK	ConferenceStreamViewResult
400	Bad Request	Bad Request	Inline

Response Schema

Status Code 400

Name	Type	Required	Restrictions	Description
» additionalProperties	string	false	none	none

Examples

200 Response

{
  "viewerId": "string",
  "sdpAnswer": "string"
}

400 Response

caution

To perform this operation, you must be authenticated by means of one of the following methods: BearerToken, OAuth2ClientCredentials

Code samples

Shell

curl -X POST http://localhost:8080/rtc-api/conferences/viewStream \
  -H 'Content-Type: application/json' \  -H 'Accept: application/json' \  -H 'Authorization: Bearer {access-token}'

Go

package main

import (
    "bytes"
    "net/http"
)

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

    var body []byte
    // body = ...

    req, err := http.NewRequest("POST", "http://localhost:8080/rtc-api/conferences/viewStream", bytes.NewBuffer(body))
    req.Header = headers

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

Node

const fetch = require('node-fetch');
const input = '{
  "conferenceId": "string",
  "userEndpointId": "string",
  "streamId": "string",
  "sdpOffer": "string",
  "viewerId": "string",
  "metadata": {
    "property1": "string",
    "property2": "string"
  }
}';
const headers = {
  'Content-Type': 'application/json',  'Accept': 'application/json',  'Authorization': 'Bearer {access-token}'
}

fetch('http://localhost:8080/rtc-api/conferences/viewStream', {
  method: 'POST',
  body: input,
  headers
})
.then(r => r.json())
.then((body) => {
    console.log(body)
})

Java

// This sample needs improvement.
URL obj = new URL("http://localhost:8080/rtc-api/conferences/viewStream");

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());

Python

import requests

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

r = requests.post(
  'http://localhost:8080/rtc-api/conferences/viewStream',
  params={},
  headers = headers)

print r.json()

Ruby

require 'rest-client'
require 'json'

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

result = RestClient.post 'http://localhost:8080/rtc-api/conferences/viewStream',
  params: {}, headers: headers

p JSON.parse(result)

Updates conference stream metadata

POST http://localhost:8080/rtc-api/conferences/updateStreamMetadata HTTP/1.1
Host: localhost:8080
Content-Type: application/json
Accept: */*

Request body

{
  "conferenceId": "string",
  "userEndpointId": "string",
  "streamId": "string",
  "newMetadata": {
    "property1": {},
    "property2": {}
  }
}

Parameters

Parameter	In	Type	Required	Description
body	body	UpdateConferenceStreamMetadataWebCommand	true	none

Responses

Overview

Status	Meaning	Description	Schema
204	No Content	No Content	None
400	Bad Request	Bad Request	Inline

Response Schema

Status Code 400

Name	Type	Required	Restrictions	Description
» additionalProperties	string	false	none	none

Examples

400 Response

caution

To perform this operation, you must be authenticated by means of one of the following methods: BearerToken, OAuth2ClientCredentials

Code samples

Shell

curl -X POST http://localhost:8080/rtc-api/conferences/updateStreamMetadata \
  -H 'Content-Type: application/json' \  -H 'Accept: */*' \  -H 'Authorization: Bearer {access-token}'

Go

package main

import (
    "bytes"
    "net/http"
)

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

    var body []byte
    // body = ...

    req, err := http.NewRequest("POST", "http://localhost:8080/rtc-api/conferences/updateStreamMetadata", bytes.NewBuffer(body))
    req.Header = headers

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

Node

const fetch = require('node-fetch');
const input = '{
  "conferenceId": "string",
  "userEndpointId": "string",
  "streamId": "string",
  "newMetadata": {
    "property1": {},
    "property2": {}
  }
}';
const headers = {
  'Content-Type': 'application/json',  'Accept': '*/*',  'Authorization': 'Bearer {access-token}'
}

fetch('http://localhost:8080/rtc-api/conferences/updateStreamMetadata', {
  method: 'POST',
  body: input,
  headers
})
.then(r => r.json())
.then((body) => {
    console.log(body)
})

Java

// This sample needs improvement.
URL obj = new URL("http://localhost:8080/rtc-api/conferences/updateStreamMetadata");

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());

Python

import requests

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

r = requests.post(
  'http://localhost:8080/rtc-api/conferences/updateStreamMetadata',
  params={},
  headers = headers)

print r.json()

Ruby

require 'rest-client'
require 'json'

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

result = RestClient.post 'http://localhost:8080/rtc-api/conferences/updateStreamMetadata',
  params: {}, headers: headers

p JSON.parse(result)

Update the bitrate of a conference stream.

POST http://localhost:8080/rtc-api/conferences/updatePublishedStreamBitrate HTTP/1.1
Host: localhost:8080
Content-Type: application/json
Accept: */*

Request body

{
  "conferenceId": "string",
  "userEndpointId": "string",
  "streamId": "string",
  "videoBitrate": 30000
}

Parameters

Parameter	In	Type	Required	Description
body	body	ConferenceUpdatePublishedStreamBitrateWebCommand	true	none

Responses

Overview

Status	Meaning	Description	Schema
204	No Content	No Content	None
400	Bad Request	Bad Request	Inline
404	Not Found	Not Found	None

Response Schema

Status Code 400

Name	Type	Required	Restrictions	Description
» additionalProperties	string	false	none	none

Examples

400 Response

caution

To perform this operation, you must be authenticated by means of one of the following methods: BearerToken, OAuth2ClientCredentials

Code samples

Shell

curl -X POST http://localhost:8080/rtc-api/conferences/updatePublishedStreamBitrate \
  -H 'Content-Type: application/json' \  -H 'Accept: */*' \  -H 'Authorization: Bearer {access-token}'

Go

package main

import (
    "bytes"
    "net/http"
)

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

    var body []byte
    // body = ...

    req, err := http.NewRequest("POST", "http://localhost:8080/rtc-api/conferences/updatePublishedStreamBitrate", bytes.NewBuffer(body))
    req.Header = headers

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

Node

const fetch = require('node-fetch');
const input = '{
  "conferenceId": "string",
  "userEndpointId": "string",
  "streamId": "string",
  "videoBitrate": 30000
}';
const headers = {
  'Content-Type': 'application/json',  'Accept': '*/*',  'Authorization': 'Bearer {access-token}'
}

fetch('http://localhost:8080/rtc-api/conferences/updatePublishedStreamBitrate', {
  method: 'POST',
  body: input,
  headers
})
.then(r => r.json())
.then((body) => {
    console.log(body)
})

Java

// This sample needs improvement.
URL obj = new URL("http://localhost:8080/rtc-api/conferences/updatePublishedStreamBitrate");

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());

Python

import requests

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

r = requests.post(
  'http://localhost:8080/rtc-api/conferences/updatePublishedStreamBitrate',
  params={},
  headers = headers)

print r.json()

Ruby

require 'rest-client'
require 'json'

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

result = RestClient.post 'http://localhost:8080/rtc-api/conferences/updatePublishedStreamBitrate',
  params: {}, headers: headers

p JSON.parse(result)

Updates conference participant metadata

POST http://localhost:8080/rtc-api/conferences/updateParticipantMetadata HTTP/1.1
Host: localhost:8080
Content-Type: application/json
Accept: */*

Request body

{
  "conferenceId": "string",
  "userEndpointId": "string",
  "newMetadata": {
    "property1": {},
    "property2": {}
  }
}

Parameters

Parameter	In	Type	Required	Description
body	body	UpdateConferenceParticipantMetadataWebCommand	true	none

Responses

Overview

Status	Meaning	Description	Schema
204	No Content	No Content	None
400	Bad Request	Bad Request	Inline

Response Schema

Status Code 400

Name	Type	Required	Restrictions	Description
» additionalProperties	string	false	none	none

Examples

400 Response

caution

To perform this operation, you must be authenticated by means of one of the following methods: BearerToken, OAuth2ClientCredentials

Code samples

Shell

curl -X POST http://localhost:8080/rtc-api/conferences/updateParticipantMetadata \
  -H 'Content-Type: application/json' \  -H 'Accept: */*' \  -H 'Authorization: Bearer {access-token}'

Go

package main

import (
    "bytes"
    "net/http"
)

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

    var body []byte
    // body = ...

    req, err := http.NewRequest("POST", "http://localhost:8080/rtc-api/conferences/updateParticipantMetadata", bytes.NewBuffer(body))
    req.Header = headers

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

Node

const fetch = require('node-fetch');
const input = '{
  "conferenceId": "string",
  "userEndpointId": "string",
  "newMetadata": {
    "property1": {},
    "property2": {}
  }
}';
const headers = {
  'Content-Type': 'application/json',  'Accept': '*/*',  'Authorization': 'Bearer {access-token}'
}

fetch('http://localhost:8080/rtc-api/conferences/updateParticipantMetadata', {
  method: 'POST',
  body: input,
  headers
})
.then(r => r.json())
.then((body) => {
    console.log(body)
})

Java

// This sample needs improvement.
URL obj = new URL("http://localhost:8080/rtc-api/conferences/updateParticipantMetadata");

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());

Python

import requests

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

r = requests.post(
  'http://localhost:8080/rtc-api/conferences/updateParticipantMetadata',
  params={},
  headers = headers)

print r.json()

Ruby

require 'rest-client'
require 'json'

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

result = RestClient.post 'http://localhost:8080/rtc-api/conferences/updateParticipantMetadata',
  params: {}, headers: headers

p JSON.parse(result)

Updates conference metadata

POST http://localhost:8080/rtc-api/conferences/updateMetadata HTTP/1.1
Host: localhost:8080
Content-Type: application/json
Accept: */*

Request body

{
  "conferenceId": "string",
  "userEndpointId": "string",
  "operation": "SET",
  "key": "string",
  "value": "string"
}

Parameters

Parameter	In	Type	Required	Description
body	body	UpdateConferenceMetadataWebCommand	true	none

Responses

Overview

Status	Meaning	Description	Schema
204	No Content	No Content	None
400	Bad Request	Bad Request	Inline

Response Schema

Status Code 400

Name	Type	Required	Restrictions	Description
» additionalProperties	string	false	none	none

Examples

400 Response

caution

To perform this operation, you must be authenticated by means of one of the following methods: BearerToken, OAuth2ClientCredentials

Code samples

Shell

curl -X POST http://localhost:8080/rtc-api/conferences/updateMetadata \
  -H 'Content-Type: application/json' \  -H 'Accept: */*' \  -H 'Authorization: Bearer {access-token}'

Go

package main

import (
    "bytes"
    "net/http"
)

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

    var body []byte
    // body = ...

    req, err := http.NewRequest("POST", "http://localhost:8080/rtc-api/conferences/updateMetadata", bytes.NewBuffer(body))
    req.Header = headers

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

Node

const fetch = require('node-fetch');
const input = '{
  "conferenceId": "string",
  "userEndpointId": "string",
  "operation": "SET",
  "key": "string",
  "value": "string"
}';
const headers = {
  'Content-Type': 'application/json',  'Accept': '*/*',  'Authorization': 'Bearer {access-token}'
}

fetch('http://localhost:8080/rtc-api/conferences/updateMetadata', {
  method: 'POST',
  body: input,
  headers
})
.then(r => r.json())
.then((body) => {
    console.log(body)
})

Java

// This sample needs improvement.
URL obj = new URL("http://localhost:8080/rtc-api/conferences/updateMetadata");

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());

Python

import requests

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

r = requests.post(
  'http://localhost:8080/rtc-api/conferences/updateMetadata',
  params={},
  headers = headers)

print r.json()

Ruby

require 'rest-client'
require 'json'

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

result = RestClient.post 'http://localhost:8080/rtc-api/conferences/updateMetadata',
  params: {}, headers: headers

p JSON.parse(result)

Unpublish a stream from the conference.

POST http://localhost:8080/rtc-api/conferences/unpublishStream HTTP/1.1
Host: localhost:8080
Content-Type: application/json
Accept: */*

Request body

{
  "conferenceId": "string",
  "userEndpointId": "string",
  "streamId": "string"
}

Parameters

Parameter	In	Type	Required	Description
body	body	ConferenceUnpublishStreamWebCommand	true	none

Responses

Overview

Status	Meaning	Description	Schema
204	No Content	No Content	None
400	Bad Request	Bad Request	Inline

Response Schema

Status Code 400

Name	Type	Required	Restrictions	Description
» additionalProperties	string	false	none	none

Examples

400 Response

caution

To perform this operation, you must be authenticated by means of one of the following methods: BearerToken, OAuth2ClientCredentials

Code samples

Shell

curl -X POST http://localhost:8080/rtc-api/conferences/unpublishStream \
  -H 'Content-Type: application/json' \  -H 'Accept: */*' \  -H 'Authorization: Bearer {access-token}'

Go

package main

import (
    "bytes"
    "net/http"
)

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

    var body []byte
    // body = ...

    req, err := http.NewRequest("POST", "http://localhost:8080/rtc-api/conferences/unpublishStream", bytes.NewBuffer(body))
    req.Header = headers

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

Node

const fetch = require('node-fetch');
const input = '{
  "conferenceId": "string",
  "userEndpointId": "string",
  "streamId": "string"
}';
const headers = {
  'Content-Type': 'application/json',  'Accept': '*/*',  'Authorization': 'Bearer {access-token}'
}

fetch('http://localhost:8080/rtc-api/conferences/unpublishStream', {
  method: 'POST',
  body: input,
  headers
})
.then(r => r.json())
.then((body) => {
    console.log(body)
})

Java

// This sample needs improvement.
URL obj = new URL("http://localhost:8080/rtc-api/conferences/unpublishStream");

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());

Python

import requests

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

r = requests.post(
  'http://localhost:8080/rtc-api/conferences/unpublishStream',
  params={},
  headers = headers)

print r.json()

Ruby

require 'rest-client'
require 'json'

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

result = RestClient.post 'http://localhost:8080/rtc-api/conferences/unpublishStream',
  params: {}, headers: headers

p JSON.parse(result)

Request to stop viewing a stream. Should be called when leaving, or when ConferenceStreamUnpublishedEvent is received

POST http://localhost:8080/rtc-api/conferences/stopViewStream HTTP/1.1
Host: localhost:8080
Content-Type: application/json
Accept: */*

Request body

{
  "conferenceId": "string",
  "userEndpointId": "string",
  "streamId": "string",
  "viewerId": "string"
}

Parameters

Parameter	In	Type	Required	Description
body	body	ConferenceStopViewStreamWebCommand	true	none

Responses

Overview

Status	Meaning	Description	Schema
204	No Content	No Content	None
400	Bad Request	Bad Request	Inline

Response Schema

Status Code 400

Name	Type	Required	Restrictions	Description
» additionalProperties	string	false	none	none

Examples

400 Response

caution

To perform this operation, you must be authenticated by means of one of the following methods: BearerToken, OAuth2ClientCredentials

Code samples

Shell

curl -X POST http://localhost:8080/rtc-api/conferences/stopViewStream \
  -H 'Content-Type: application/json' \  -H 'Accept: */*' \  -H 'Authorization: Bearer {access-token}'

Go

package main

import (
    "bytes"
    "net/http"
)

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

    var body []byte
    // body = ...

    req, err := http.NewRequest("POST", "http://localhost:8080/rtc-api/conferences/stopViewStream", bytes.NewBuffer(body))
    req.Header = headers

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

Node

const fetch = require('node-fetch');
const input = '{
  "conferenceId": "string",
  "userEndpointId": "string",
  "streamId": "string",
  "viewerId": "string"
}';
const headers = {
  'Content-Type': 'application/json',  'Accept': '*/*',  'Authorization': 'Bearer {access-token}'
}

fetch('http://localhost:8080/rtc-api/conferences/stopViewStream', {
  method: 'POST',
  body: input,
  headers
})
.then(r => r.json())
.then((body) => {
    console.log(body)
})

Java

// This sample needs improvement.
URL obj = new URL("http://localhost:8080/rtc-api/conferences/stopViewStream");

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());

Python

import requests

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

r = requests.post(
  'http://localhost:8080/rtc-api/conferences/stopViewStream',
  params={},
  headers = headers)

print r.json()

Ruby

require 'rest-client'
require 'json'

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

result = RestClient.post 'http://localhost:8080/rtc-api/conferences/stopViewStream',
  params: {}, headers: headers

p JSON.parse(result)

Sends event to all user endpoints that are currently joined on conference defined by conferenceId

POST http://localhost:8080/rtc-api/conferences/sendEvent HTTP/1.1
Host: localhost:8080
Content-Type: application/json
Accept: */*

Returns number of messages sent. Only users with 'SERVICE' role allowed

Request body

{
  "conferenceId": "string",
  "qos": "BEST_EFFORT",
  "event": {
    "property1": {},
    "property2": {}
  },
  "masks": [
    "string"
  ]
}

Parameters

Parameter	In	Type	Required	Description
body	body	SendEventToConferenceWebCommand	true	none

Responses

Overview

Status	Meaning	Description	Schema
200	OK	OK	SendEventResponse
400	Bad Request	Bad Request	Inline

Response Schema

Status Code 400

Name	Type	Required	Restrictions	Description
» additionalProperties	string	false	none	none

Examples

200 Response

caution

To perform this operation, you must be authenticated by means of one of the following methods: BearerToken, OAuth2ClientCredentials

Code samples

Shell

curl -X POST http://localhost:8080/rtc-api/conferences/sendEvent \
  -H 'Content-Type: application/json' \  -H 'Accept: */*' \  -H 'Authorization: Bearer {access-token}'

Go

package main

import (
    "bytes"
    "net/http"
)

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

    var body []byte
    // body = ...

    req, err := http.NewRequest("POST", "http://localhost:8080/rtc-api/conferences/sendEvent", bytes.NewBuffer(body))
    req.Header = headers

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

Node

const fetch = require('node-fetch');
const input = '{
  "conferenceId": "string",
  "qos": "BEST_EFFORT",
  "event": {
    "property1": {},
    "property2": {}
  },
  "masks": [
    "string"
  ]
}';
const headers = {
  'Content-Type': 'application/json',  'Accept': '*/*',  'Authorization': 'Bearer {access-token}'
}

fetch('http://localhost:8080/rtc-api/conferences/sendEvent', {
  method: 'POST',
  body: input,
  headers
})
.then(r => r.json())
.then((body) => {
    console.log(body)
})

Java

// This sample needs improvement.
URL obj = new URL("http://localhost:8080/rtc-api/conferences/sendEvent");

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());

Python

import requests

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

r = requests.post(
  'http://localhost:8080/rtc-api/conferences/sendEvent',
  params={},
  headers = headers)

print r.json()

Ruby

require 'rest-client'
require 'json'

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

result = RestClient.post 'http://localhost:8080/rtc-api/conferences/sendEvent',
  params: {}, headers: headers

p JSON.parse(result)

Publish a stream to the conference.

POST http://localhost:8080/rtc-api/conferences/publishStream HTTP/1.1
Host: localhost:8080
Content-Type: application/json
Accept: application/json

Request body

{
  "conferenceId": "string",
  "userEndpointId": "string",
  "streamId": "string",
  "conferenceStreamType": "MIC",
  "sdpOffer": "string",
  "metadata": {
    "property1": {},
    "property2": {}
  },
  "videoBitrate": 30000
}

Parameters

Parameter	In	Type	Required	Description
body	body	ConferencePublishStreamWebCommand	true	none

Responses

Overview

Status	Meaning	Description	Schema
200	OK	OK	ConferencePublishResult
400	Bad Request	Bad Request	Inline

Response Schema

Status Code 400

Name	Type	Required	Restrictions	Description
» additionalProperties	string	false	none	none

Examples

200 Response

{
  "streamId": "string",
  "sdpAnswer": "string"
}

400 Response

caution

To perform this operation, you must be authenticated by means of one of the following methods: BearerToken, OAuth2ClientCredentials

Code samples

Shell

curl -X POST http://localhost:8080/rtc-api/conferences/publishStream \
  -H 'Content-Type: application/json' \  -H 'Accept: application/json' \  -H 'Authorization: Bearer {access-token}'

Go

package main

import (
    "bytes"
    "net/http"
)

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

    var body []byte
    // body = ...

    req, err := http.NewRequest("POST", "http://localhost:8080/rtc-api/conferences/publishStream", bytes.NewBuffer(body))
    req.Header = headers

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

Node

const fetch = require('node-fetch');
const input = '{
  "conferenceId": "string",
  "userEndpointId": "string",
  "streamId": "string",
  "conferenceStreamType": "MIC",
  "sdpOffer": "string",
  "metadata": {
    "property1": {},
    "property2": {}
  },
  "videoBitrate": 30000
}';
const headers = {
  'Content-Type': 'application/json',  'Accept': 'application/json',  'Authorization': 'Bearer {access-token}'
}

fetch('http://localhost:8080/rtc-api/conferences/publishStream', {
  method: 'POST',
  body: input,
  headers
})
.then(r => r.json())
.then((body) => {
    console.log(body)
})

Java

// This sample needs improvement.
URL obj = new URL("http://localhost:8080/rtc-api/conferences/publishStream");

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());

Python

import requests

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

r = requests.post(
  'http://localhost:8080/rtc-api/conferences/publishStream',
  params={},
  headers = headers)

print r.json()

Ruby

require 'rest-client'
require 'json'

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

result = RestClient.post 'http://localhost:8080/rtc-api/conferences/publishStream',
  params: {}, headers: headers

p JSON.parse(result)

Leaves a conference.

POST http://localhost:8080/rtc-api/conferences/leave HTTP/1.1
Host: localhost:8080
Content-Type: application/json
Accept: */*

Request body

{
  "conferenceId": "string",
  "userEndpointId": "string",
  "reason": "string"
}

Parameters

Parameter	In	Type	Required	Description
body	body	LeaveConferenceWebCommand	true	none

Responses

Overview

Status	Meaning	Description	Schema
204	No Content	No Content	None
400	Bad Request	Bad Request	Inline

Response Schema

Status Code 400

Name	Type	Required	Restrictions	Description
» additionalProperties	string	false	none	none

Examples

400 Response

caution

To perform this operation, you must be authenticated by means of one of the following methods: BearerToken, OAuth2ClientCredentials

Code samples

Shell

curl -X POST http://localhost:8080/rtc-api/conferences/leave \
  -H 'Content-Type: application/json' \  -H 'Accept: */*' \  -H 'Authorization: Bearer {access-token}'

Go

package main

import (
    "bytes"
    "net/http"
)

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

    var body []byte
    // body = ...

    req, err := http.NewRequest("POST", "http://localhost:8080/rtc-api/conferences/leave", bytes.NewBuffer(body))
    req.Header = headers

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

Node

const fetch = require('node-fetch');
const input = '{
  "conferenceId": "string",
  "userEndpointId": "string",
  "reason": "string"
}';
const headers = {
  'Content-Type': 'application/json',  'Accept': '*/*',  'Authorization': 'Bearer {access-token}'
}

fetch('http://localhost:8080/rtc-api/conferences/leave', {
  method: 'POST',
  body: input,
  headers
})
.then(r => r.json())
.then((body) => {
    console.log(body)
})

Java

// This sample needs improvement.
URL obj = new URL("http://localhost:8080/rtc-api/conferences/leave");

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());

Python

import requests

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

r = requests.post(
  'http://localhost:8080/rtc-api/conferences/leave',
  params={},
  headers = headers)

print r.json()

Ruby

require 'rest-client'
require 'json'

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

result = RestClient.post 'http://localhost:8080/rtc-api/conferences/leave',
  params: {}, headers: headers

p JSON.parse(result)

Joins a conference

POST http://localhost:8080/rtc-api/conferences/join HTTP/1.1
Host: localhost:8080
Content-Type: application/json
Accept: application/json

Request body

{
  "conferenceId": "string",
  "userEndpointId": "string",
  "metadata": {
    "property1": {},
    "property2": {}
  }
}

Parameters

Parameter	In	Type	Required	Description
body	body	JoinConferenceWebCommand	true	none

Responses

Overview

Status	Meaning	Description	Schema
200	OK	OK	ConferenceSummary
400	Bad Request	Bad Request	AnotherErrorResponse
401	Unauthorized	Unauthorized	Inline
403	Forbidden	Forbidden	Inline
404	Not Found	Not Found	Inline
422	Unprocessable Entity	Conference Already Joined from same user and endpoint	Inline

Response Schema

Examples

200 Response

{
  "id": "string",
  "version": 0,
  "mode": "P2P"
}

caution

To perform this operation, you must be authenticated by means of one of the following methods: BearerToken, OAuth2ClientCredentials

Code samples

Shell

curl -X POST http://localhost:8080/rtc-api/conferences/join \
  -H 'Content-Type: application/json' \  -H 'Accept: application/json' \  -H 'Authorization: Bearer {access-token}'

Go

package main

import (
    "bytes"
    "net/http"
)

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

    var body []byte
    // body = ...

    req, err := http.NewRequest("POST", "http://localhost:8080/rtc-api/conferences/join", bytes.NewBuffer(body))
    req.Header = headers

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

Node

const fetch = require('node-fetch');
const input = '{
  "conferenceId": "string",
  "userEndpointId": "string",
  "metadata": {
    "property1": {},
    "property2": {}
  }
}';
const headers = {
  'Content-Type': 'application/json',  'Accept': 'application/json',  'Authorization': 'Bearer {access-token}'
}

fetch('http://localhost:8080/rtc-api/conferences/join', {
  method: 'POST',
  body: input,
  headers
})
.then(r => r.json())
.then((body) => {
    console.log(body)
})

Java

// This sample needs improvement.
URL obj = new URL("http://localhost:8080/rtc-api/conferences/join");

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());

Python

import requests

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

r = requests.post(
  'http://localhost:8080/rtc-api/conferences/join',
  params={},
  headers = headers)

print r.json()

Ruby

require 'rest-client'
require 'json'

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

result = RestClient.post 'http://localhost:8080/rtc-api/conferences/join',
  params: {}, headers: headers

p JSON.parse(result)

Sets the interaction id which this conference is related to.

POST http://localhost:8080/rtc-api/conferences/interaction HTTP/1.1
Host: localhost:8080
Content-Type: application/json
Accept: */*

Request body

{
  "conferenceId": "string",
  "interactionId": "string",
  "userEndpointId": "string"
}

Parameters

Parameter	In	Type	Required	Description
body	body	SetInteractionIdWebCommand	true	none

Responses

Overview

Status	Meaning	Description	Schema
204	No Content	No Content	None
400	Bad Request	Bad Request	Inline

Response Schema

Status Code 400

Name	Type	Required	Restrictions	Description
» additionalProperties	string	false	none	none

Examples

400 Response

caution

To perform this operation, you must be authenticated by means of one of the following methods: BearerToken, OAuth2ClientCredentials

Code samples

Shell

curl -X POST http://localhost:8080/rtc-api/conferences/interaction \
  -H 'Content-Type: application/json' \  -H 'Accept: */*' \  -H 'Authorization: Bearer {access-token}'

Go

package main

import (
    "bytes"
    "net/http"
)

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

    var body []byte
    // body = ...

    req, err := http.NewRequest("POST", "http://localhost:8080/rtc-api/conferences/interaction", bytes.NewBuffer(body))
    req.Header = headers

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

Node

const fetch = require('node-fetch');
const input = '{
  "conferenceId": "string",
  "interactionId": "string",
  "userEndpointId": "string"
}';
const headers = {
  'Content-Type': 'application/json',  'Accept': '*/*',  'Authorization': 'Bearer {access-token}'
}

fetch('http://localhost:8080/rtc-api/conferences/interaction', {
  method: 'POST',
  body: input,
  headers
})
.then(r => r.json())
.then((body) => {
    console.log(body)
})

Java

// This sample needs improvement.
URL obj = new URL("http://localhost:8080/rtc-api/conferences/interaction");

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());

Python

import requests

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

r = requests.post(
  'http://localhost:8080/rtc-api/conferences/interaction',
  params={},
  headers = headers)

print r.json()

Ruby

require 'rest-client'
require 'json'

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

result = RestClient.post 'http://localhost:8080/rtc-api/conferences/interaction',
  params: {}, headers: headers

p JSON.parse(result)

Ends a conference.

POST http://localhost:8080/rtc-api/conferences/end HTTP/1.1
Host: localhost:8080
Content-Type: application/json
Accept: */*

Request body

{
  "conferenceId": "string",
  "userEndpointId": "string",
  "reason": "string"
}

Parameters

Parameter	In	Type	Required	Description
body	body	EndConferenceWebCommand	true	none

Responses

Overview

Status	Meaning	Description	Schema
204	No Content	No Content	None
400	Bad Request	Bad Request	Inline

Response Schema

Status Code 400

Name	Type	Required	Restrictions	Description
» additionalProperties	string	false	none	none

Examples

400 Response

caution

To perform this operation, you must be authenticated by means of one of the following methods: BearerToken, OAuth2ClientCredentials

Code samples

Shell

curl -X POST http://localhost:8080/rtc-api/conferences/end \
  -H 'Content-Type: application/json' \  -H 'Accept: */*' \  -H 'Authorization: Bearer {access-token}'

Go

package main

import (
    "bytes"
    "net/http"
)

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

    var body []byte
    // body = ...

    req, err := http.NewRequest("POST", "http://localhost:8080/rtc-api/conferences/end", bytes.NewBuffer(body))
    req.Header = headers

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

Node

const fetch = require('node-fetch');
const input = '{
  "conferenceId": "string",
  "userEndpointId": "string",
  "reason": "string"
}';
const headers = {
  'Content-Type': 'application/json',  'Accept': '*/*',  'Authorization': 'Bearer {access-token}'
}

fetch('http://localhost:8080/rtc-api/conferences/end', {
  method: 'POST',
  body: input,
  headers
})
.then(r => r.json())
.then((body) => {
    console.log(body)
})

Java

// This sample needs improvement.
URL obj = new URL("http://localhost:8080/rtc-api/conferences/end");

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());

Python

import requests

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

r = requests.post(
  'http://localhost:8080/rtc-api/conferences/end',
  params={},
  headers = headers)

print r.json()

Ruby

require 'rest-client'
require 'json'

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

result = RestClient.post 'http://localhost:8080/rtc-api/conferences/end',
  params: {}, headers: headers

p JSON.parse(result)

Creates a conference.

POST http://localhost:8080/rtc-api/conferences/create HTTP/1.1
Host: localhost:8080
Content-Type: application/json
Accept: application/json

Request body

{
  "conferenceId": "string",
  "mode": "P2P",
  "organizationId": "string",
  "creatorEndpoint": "string",
  "interactionId": "string",
  "metadata": {
    "property1": "string",
    "property2": "string"
  }
}

Parameters

Parameter	In	Type	Required	Description
body	body	CreateConferenceWebCommand	true	none

Responses

Overview

Status	Meaning	Description	Schema
200	OK	OK	ConferenceSummary
400	Bad Request	Bad Request	Inline

Response Schema

Status Code 400

Name	Type	Required	Restrictions	Description
» additionalProperties	string	false	none	none

Examples

200 Response

{
  "id": "string",
  "version": 0,
  "mode": "P2P"
}

400 Response

caution

To perform this operation, you must be authenticated by means of one of the following methods: BearerToken, OAuth2ClientCredentials

Code samples

Shell

curl -X POST http://localhost:8080/rtc-api/conferences/create \
  -H 'Content-Type: application/json' \  -H 'Accept: application/json' \  -H 'Authorization: Bearer {access-token}'

Go

package main

import (
    "bytes"
    "net/http"
)

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

    var body []byte
    // body = ...

    req, err := http.NewRequest("POST", "http://localhost:8080/rtc-api/conferences/create", bytes.NewBuffer(body))
    req.Header = headers

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

Node

const fetch = require('node-fetch');
const input = '{
  "conferenceId": "string",
  "mode": "P2P",
  "organizationId": "string",
  "creatorEndpoint": "string",
  "interactionId": "string",
  "metadata": {
    "property1": "string",
    "property2": "string"
  }
}';
const headers = {
  'Content-Type': 'application/json',  'Accept': 'application/json',  'Authorization': 'Bearer {access-token}'
}

fetch('http://localhost:8080/rtc-api/conferences/create', {
  method: 'POST',
  body: input,
  headers
})
.then(r => r.json())
.then((body) => {
    console.log(body)
})

Java

// This sample needs improvement.
URL obj = new URL("http://localhost:8080/rtc-api/conferences/create");

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());

Python

import requests

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

r = requests.post(
  'http://localhost:8080/rtc-api/conferences/create',
  params={},
  headers = headers)

print r.json()

Ruby

require 'rest-client'
require 'json'

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

result = RestClient.post 'http://localhost:8080/rtc-api/conferences/create',
  params: {}, headers: headers

p JSON.parse(result)

Adds ice candidates for a view stream request.

POST http://localhost:8080/rtc-api/conferences/addViewStreamIceCandidates HTTP/1.1
Host: localhost:8080
Content-Type: application/json
Accept: */*

Request body

{
  "conferenceId": "string",
  "userEndpointId": "string",
  "streamId": "string",
  "viewerId": "string",
  "iceCandidates": [
    {
      "candidate": "string",
      "sdpMid": "string",
      "sdpMLineIndex": 0
    }
  ]
}

Parameters

Parameter	In	Type	Required	Description
body	body	ConferenceViewStreamIceCandidatesWebCommand	true	none

Responses

Overview

Status	Meaning	Description	Schema
204	No Content	No Content	None
400	Bad Request	Bad Request	Inline

Response Schema

Status Code 400

Name	Type	Required	Restrictions	Description
» additionalProperties	string	false	none	none

Examples

400 Response

caution

To perform this operation, you must be authenticated by means of one of the following methods: BearerToken, OAuth2ClientCredentials

Code samples

Shell

curl -X POST http://localhost:8080/rtc-api/conferences/addViewStreamIceCandidates \
  -H 'Content-Type: application/json' \  -H 'Accept: */*' \  -H 'Authorization: Bearer {access-token}'

Go

package main

import (
    "bytes"
    "net/http"
)

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

    var body []byte
    // body = ...

    req, err := http.NewRequest("POST", "http://localhost:8080/rtc-api/conferences/addViewStreamIceCandidates", bytes.NewBuffer(body))
    req.Header = headers

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

Node

const fetch = require('node-fetch');
const input = '{
  "conferenceId": "string",
  "userEndpointId": "string",
  "streamId": "string",
  "viewerId": "string",
  "iceCandidates": [
    {
      "candidate": "string",
      "sdpMid": "string",
      "sdpMLineIndex": 0
    }
  ]
}';
const headers = {
  'Content-Type': 'application/json',  'Accept': '*/*',  'Authorization': 'Bearer {access-token}'
}

fetch('http://localhost:8080/rtc-api/conferences/addViewStreamIceCandidates', {
  method: 'POST',
  body: input,
  headers
})
.then(r => r.json())
.then((body) => {
    console.log(body)
})

Java

// This sample needs improvement.
URL obj = new URL("http://localhost:8080/rtc-api/conferences/addViewStreamIceCandidates");

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());

Python

import requests

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

r = requests.post(
  'http://localhost:8080/rtc-api/conferences/addViewStreamIceCandidates',
  params={},
  headers = headers)

print r.json()

Ruby

require 'rest-client'
require 'json'

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

result = RestClient.post 'http://localhost:8080/rtc-api/conferences/addViewStreamIceCandidates',
  params: {}, headers: headers

p JSON.parse(result)

Adds ice candidates for a published stream. Must be called after publishStream request.

POST http://localhost:8080/rtc-api/conferences/addPublishStreamIceCandidates HTTP/1.1
Host: localhost:8080
Content-Type: application/json
Accept: */*

Request body

{
  "conferenceId": "string",
  "userEndpointId": "string",
  "streamId": "string",
  "iceCandidates": [
    {
      "candidate": "string",
      "sdpMid": "string",
      "sdpMLineIndex": 0
    }
  ]
}

Parameters

Parameter	In	Type	Required	Description
body	body	ConferencePublishStreamIceCandidatesWebCommand	true	none

Responses

Overview

Status	Meaning	Description	Schema
204	No Content	No Content	None
400	Bad Request	Bad Request	Inline

Response Schema

Status Code 400

Name	Type	Required	Restrictions	Description
» additionalProperties	string	false	none	none

Examples

400 Response

caution

To perform this operation, you must be authenticated by means of one of the following methods: BearerToken, OAuth2ClientCredentials

Code samples

Shell

curl -X POST http://localhost:8080/rtc-api/conferences/addPublishStreamIceCandidates \
  -H 'Content-Type: application/json' \  -H 'Accept: */*' \  -H 'Authorization: Bearer {access-token}'

Go

package main

import (
    "bytes"
    "net/http"
)

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

    var body []byte
    // body = ...

    req, err := http.NewRequest("POST", "http://localhost:8080/rtc-api/conferences/addPublishStreamIceCandidates", bytes.NewBuffer(body))
    req.Header = headers

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

Node

const fetch = require('node-fetch');
const input = '{
  "conferenceId": "string",
  "userEndpointId": "string",
  "streamId": "string",
  "iceCandidates": [
    {
      "candidate": "string",
      "sdpMid": "string",
      "sdpMLineIndex": 0
    }
  ]
}';
const headers = {
  'Content-Type': 'application/json',  'Accept': '*/*',  'Authorization': 'Bearer {access-token}'
}

fetch('http://localhost:8080/rtc-api/conferences/addPublishStreamIceCandidates', {
  method: 'POST',
  body: input,
  headers
})
.then(r => r.json())
.then((body) => {
    console.log(body)
})

Java

// This sample needs improvement.
URL obj = new URL("http://localhost:8080/rtc-api/conferences/addPublishStreamIceCandidates");

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());

Python

import requests

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

r = requests.post(
  'http://localhost:8080/rtc-api/conferences/addPublishStreamIceCandidates',
  params={},
  headers = headers)

print r.json()

Ruby

require 'rest-client'
require 'json'

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

result = RestClient.post 'http://localhost:8080/rtc-api/conferences/addPublishStreamIceCandidates',
  params: {}, headers: headers

p JSON.parse(result)

Get conference aggregate.

GET http://localhost:8080/rtc-api/conferences/{id} HTTP/1.1
Host: localhost:8080
Accept: application/json

Parameters

Parameter	In	Type	Required	Description
id	path	string	true	none

Responses

Overview

Status	Meaning	Description	Schema
200	OK	OK	Conference
400	Bad Request	Bad Request	Inline

Response Schema

Status Code 400

Name	Type	Required	Restrictions	Description
» additionalProperties	string	false	none	none

Examples

200 Response

{
  "id": "string",
  "mode": "P2P",
  "organizationId": "string",
  "interactionId": "string",
  "creator": "string",
  "creatorEndpoint": "string",
  "participants": [
    {
      "id": "string",
      "userId": "string",
      "state": "HEALTHY",
      "streams": [
        {
          "id": "string",
          "type": "MIC",
          "metadata": {
            "property1": {},
            "property2": {}
          },
          "videoBitrate": 0
        }
      ],
      "metadata": {
        "property1": {},
        "property2": {}
      }
    }
  ],
  "metadata": {
    "property1": {
      "value": "string",
      "userId": "string",
      "userEndpointId": "string",
      "lastModified": "2019-08-24T14:15:22Z"
    },
    "property2": {
      "value": "string",
      "userId": "string",
      "userEndpointId": "string",
      "lastModified": "2019-08-24T14:15:22Z"
    }
  },
  "version": 0,
  "empty": true
}

400 Response

caution

To perform this operation, you must be authenticated by means of one of the following methods: BearerToken, OAuth2ClientCredentials

Code samples

Shell

curl -X GET http://localhost:8080/rtc-api/conferences/{id} \
  -H 'Accept: application/json' \  -H 'Authorization: Bearer {access-token}'

Go

package main

import (
    "bytes"
    "net/http"
)

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

    var body []byte
    // body = ...

    req, err := http.NewRequest("GET", "http://localhost:8080/rtc-api/conferences/{id}", bytes.NewBuffer(body))
    req.Header = headers

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

Node

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

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

fetch('http://localhost:8080/rtc-api/conferences/{id}', {
  method: 'GET',
  headers
})
.then(r => r.json())
.then((body) => {
    console.log(body)
})

Java

// This sample needs improvement.
URL obj = new URL("http://localhost:8080/rtc-api/conferences/{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());

Python

import requests

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

r = requests.get(
  'http://localhost:8080/rtc-api/conferences/{id}',
  params={},
  headers = headers)

print r.json()

Ruby

require 'rest-client'
require 'json'

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

result = RestClient.get 'http://localhost:8080/rtc-api/conferences/{id}',
  params: {}, headers: headers

p JSON.parse(result)

Get a simple view of a conference, similar to full details but more convenient for some ui clients

GET http://localhost:8080/rtc-api/conferences/{id}/simpleView HTTP/1.1
Host: localhost:8080
Accept: application/json

Parameters

Parameter	In	Type	Required	Description
id	path	string	true	none

Responses

Overview

Status	Meaning	Description	Schema
200	OK	OK	ConferenceSimpleView
400	Bad Request	Bad Request	Inline

Response Schema

Status Code 400

Name	Type	Required	Restrictions	Description
» additionalProperties	string	false	none	none

Examples

200 Response

{
  "id": "string",
  "mode": "string",
  "metadata": {
    "property1": {
      "value": "string",
      "userId": "string",
      "userEndpointId": "string",
      "lastModified": "2019-08-24T14:15:22Z"
    },
    "property2": {
      "value": "string",
      "userId": "string",
      "userEndpointId": "string",
      "lastModified": "2019-08-24T14:15:22Z"
    }
  },
  "participants": [
    {
      "id": "string",
      "endpoints": [
        {
          "id": "string",
          "state": "HEALTHY",
          "streams": [
            {
              "id": "string",
              "type": "string",
              "metadata": {
                "property1": {},
                "property2": {}
              }
            }
          ],
          "metadata": {
            "property1": {},
            "property2": {}
          }
        }
      ]
    }
  ],
  "version": 0
}

400 Response

caution

To perform this operation, you must be authenticated by means of one of the following methods: BearerToken, OAuth2ClientCredentials

Code samples

Shell

curl -X GET http://localhost:8080/rtc-api/conferences/{id}/simpleView \
  -H 'Accept: application/json' \  -H 'Authorization: Bearer {access-token}'

Go

package main

import (
    "bytes"
    "net/http"
)

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

    var body []byte
    // body = ...

    req, err := http.NewRequest("GET", "http://localhost:8080/rtc-api/conferences/{id}/simpleView", bytes.NewBuffer(body))
    req.Header = headers

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

Node

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

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

fetch('http://localhost:8080/rtc-api/conferences/{id}/simpleView', {
  method: 'GET',
  headers
})
.then(r => r.json())
.then((body) => {
    console.log(body)
})

Java

// This sample needs improvement.
URL obj = new URL("http://localhost:8080/rtc-api/conferences/{id}/simpleView");

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());

Python

import requests

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

r = requests.get(
  'http://localhost:8080/rtc-api/conferences/{id}/simpleView',
  params={},
  headers = headers)

print r.json()

Ruby

require 'rest-client'
require 'json'

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

result = RestClient.get 'http://localhost:8080/rtc-api/conferences/{id}/simpleView',
  params: {}, headers: headers

p JSON.parse(result)

Get a list of all events of a conference, optionally since version v(query param). Blocks for a few seconds if no event is available at the time

GET http://localhost:8080/rtc-api/conferences/{id}/events?v=0 HTTP/1.1
Host: localhost:8080
Accept: application/json

Parameters

Parameter	In	Type	Required	Description
id	path	string	true	none
v	query	integer(int64)	true	none

Responses

Overview

Status	Meaning	Description	Schema
200	OK	OK	Inline
400	Bad Request	Bad Request	Inline

Response Schema

Status Code 200

Name	Type	Required	Restrictions	Description
anonymous	[ConferenceEvent]	false	none	none
» id	string	false	none	event unique id
» type	string	false	none	event type
» timestamp	string(date-time)	false	none	event time, format is "yyyy-MM-dd'T'HH:mm:ss.SSS'Z'"
» conferenceId	string	false	none	the conference which this event belongs to
» organizationId	string	false	none	the organizationId
» conferenceVersion	integer(int64)	false	none	the conference version this event was produced- can be used for ordering and or deduplication. It contains the version of the conference when the event was generated or null for creation events

Status Code 400

Name	Type	Required	Restrictions	Description
» additionalProperties	string	false	none	none

Examples

200 Response

[
  {
    "id": "string",
    "type": "string",
    "timestamp": "2019-08-24T14:15:22Z",
    "conferenceId": "string",
    "organizationId": "string",
    "conferenceVersion": 0
  }
]

400 Response

caution

To perform this operation, you must be authenticated by means of one of the following methods: BearerToken, OAuth2ClientCredentials

Code samples

Shell

curl -X GET http://localhost:8080/rtc-api/conferences/{id}/events?v=0 \
  -H 'Accept: application/json' \  -H 'Authorization: Bearer {access-token}'

Go

package main

import (
    "bytes"
    "net/http"
)

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

    var body []byte
    // body = ...

    req, err := http.NewRequest("GET", "http://localhost:8080/rtc-api/conferences/{id}/events", bytes.NewBuffer(body))
    req.Header = headers

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

Node

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

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

fetch('http://localhost:8080/rtc-api/conferences/{id}/events?v=0', {
  method: 'GET',
  headers
})
.then(r => r.json())
.then((body) => {
    console.log(body)
})

Java

// This sample needs improvement.
URL obj = new URL("http://localhost:8080/rtc-api/conferences/{id}/events?v=0");

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());

Python

import requests

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

r = requests.get(
  'http://localhost:8080/rtc-api/conferences/{id}/events',
  params={
    'v': '0'},
  headers = headers)

print r.json()

Ruby

require 'rest-client'
require 'json'

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

result = RestClient.get 'http://localhost:8080/rtc-api/conferences/{id}/events',
  params: {
    'v' => 'integer(int64)'}, headers: headers

p JSON.parse(result)

Gets a list of active conferences of the user organization

GET http://localhost:8080/rtc-api/conferences/active HTTP/1.1
Host: localhost:8080
Accept: application/json

Responses

Overview

Status	Meaning	Description	Schema
200	OK	OK	Inline
400	Bad Request	Bad Request	Inline

Response Schema

Status Code 200

Name	Type	Required	Restrictions	Description
anonymous	[Conference]	false	none	none
» id	string	false	none	none
» mode	string	false	none	none
» organizationId	string	false	none	none
» interactionId	string	false	none	none
» creator	string	false	none	none
» creatorEndpoint	string	false	none	none
» participants	[ConferenceParticipant]	false	none	none
»» id	string	false	none	none
»» userId	string	false	none	none
»» state	string	false	none	none
»» streams	[ConferenceStream]	false	none	none
»»» id	string	false	none	none
»»» type	string	false	none	none
»»» metadata	object	false	none	none
»»»» additionalProperties	object	false	none	none
»»» videoBitrate	integer(int32)	false	none	none
»» metadata	object	false	none	none
»»» additionalProperties	object	false	none	none
» metadata	object	false	none	none
»» additionalProperties	Metadata	false	none	none
»»» value	string	false	none	none
»»» userId	string	false	none	none
»»» userEndpointId	string	false	none	none
»»» lastModified	string(date-time)	false	none	none
» version	integer(int64)	false	none	none
» empty	boolean	false	none	none

Enumerated Values

Property	Value
mode	P2P
mode	ROUTER
mode	UNKNOWN
state	HEALTHY
state	SICK
state	UNKNOWN
type	MIC
type	CAM
type	SCREEN
type	MIC_AND_CAM
type	UNKNOWN

Status Code 400

Name	Type	Required	Restrictions	Description
» additionalProperties	string	false	none	none

Examples

200 Response

[
  {
    "id": "string",
    "mode": "P2P",
    "organizationId": "string",
    "interactionId": "string",
    "creator": "string",
    "creatorEndpoint": "string",
    "participants": [
      {
        "id": "string",
        "userId": "string",
        "state": "HEALTHY",
        "streams": [
          {
            "id": "string",
            "type": "MIC",
            "metadata": {
              "property1": {},
              "property2": {}
            },
            "videoBitrate": 0
          }
        ],
        "metadata": {
          "property1": {},
          "property2": {}
        }
      }
    ],
    "metadata": {
      "property1": {
        "value": "string",
        "userId": "string",
        "userEndpointId": "string",
        "lastModified": "2019-08-24T14:15:22Z"
      },
      "property2": {
        "value": "string",
        "userId": "string",
        "userEndpointId": "string",
        "lastModified": "2019-08-24T14:15:22Z"
      }
    },
    "version": 0,
    "empty": true
  }
]

400 Response

caution

To perform this operation, you must be authenticated by means of one of the following methods: BearerToken, OAuth2ClientCredentials

Code samples

Shell

curl -X GET http://localhost:8080/rtc-api/conferences/active \
  -H 'Accept: application/json' \  -H 'Authorization: Bearer {access-token}'

Go

package main

import (
    "bytes"
    "net/http"
)

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

    var body []byte
    // body = ...

    req, err := http.NewRequest("GET", "http://localhost:8080/rtc-api/conferences/active", bytes.NewBuffer(body))
    req.Header = headers

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

Node

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

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

fetch('http://localhost:8080/rtc-api/conferences/active', {
  method: 'GET',
  headers
})
.then(r => r.json())
.then((body) => {
    console.log(body)
})

Java

// This sample needs improvement.
URL obj = new URL("http://localhost:8080/rtc-api/conferences/active");

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());

Python

import requests

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

r = requests.get(
  'http://localhost:8080/rtc-api/conferences/active',
  params={},
  headers = headers)

print r.json()

Ruby

require 'rest-client'
require 'json'

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

result = RestClient.get 'http://localhost:8080/rtc-api/conferences/active',
  params: {}, headers: headers

p JSON.parse(result)

Assets

Upload an asset

POST http://localhost:8080/rtc-api/assets/{assetId} HTTP/1.1
Host: localhost:8080
Content-Type: multipart/form-data
Accept: */*
X-Auvious-TransactionId: string

Request body

applicationId: string
category: string
filename: string
rolesAllowedAccess: string
file: string

Parameters

Parameter	In	Type	Required	Description
assetId	path	string	true	none
X-Auvious-TransactionId	header	string	false	used for detecting retries of the same request
body	body	object	true	none
» applicationId	body	string	true	none
» category	body	string	true	none
» filename	body	string	false	none
» rolesAllowedAccess	body	string	true	comma separated list of roles allowed to access the asset, e.g.: admin,customer
» file	body	string(binary)	true	none

Responses

Overview

Status	Meaning	Description	Schema
204	No Content	No Content	None
400	Bad Request	Bad Request	Inline

Response Schema

Status Code 400

Name	Type	Required	Restrictions	Description
» additionalProperties	string	false	none	none

Examples

400 Response

caution

To perform this operation, you must be authenticated by means of one of the following methods: BearerToken, OAuth2ClientCredentials

Code samples

Shell

curl -X POST http://localhost:8080/rtc-api/assets/{assetId} \
  -H 'Content-Type: multipart/form-data' \  -H 'Accept: */*' \  -H 'X-Auvious-TransactionId: string' \  -H 'Authorization: Bearer {access-token}'

Go

package main

import (
    "bytes"
    "net/http"
)

func main() {
    headers := map[string][]string{ 
        "Content-Type": []string{"multipart/form-data"},
        "Accept": []string{"*/*"},
        "X-Auvious-TransactionId": []string{"string"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    var body []byte
    // body = ...

    req, err := http.NewRequest("POST", "http://localhost:8080/rtc-api/assets/{assetId}", bytes.NewBuffer(body))
    req.Header = headers

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

Node

const fetch = require('node-fetch');
const input = '{
  "applicationId": "string",
  "category": "string",
  "filename": "string",
  "rolesAllowedAccess": "string",
  "file": "string"
}';
const headers = {
  'Content-Type': 'multipart/form-data',  'Accept': '*/*',  'X-Auvious-TransactionId': 'string',  'Authorization': 'Bearer {access-token}'
}

fetch('http://localhost:8080/rtc-api/assets/{assetId}', {
  method: 'POST',
  body: input,
  headers
})
.then(r => r.json())
.then((body) => {
    console.log(body)
})

Java

// This sample needs improvement.
URL obj = new URL("http://localhost:8080/rtc-api/assets/{assetId}");

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());

Python

import requests

headers = {
  'Content-Type': 'multipart/form-data',
  'Accept': '*/*',
  'X-Auvious-TransactionId': 'string',
  'Authorization': 'Bearer {access-token}'
}

r = requests.post(
  'http://localhost:8080/rtc-api/assets/{assetId}',
  params={},
  headers = headers)

print r.json()

Ruby

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'multipart/form-data',
  'Accept' => '*/*',
  'X-Auvious-TransactionId' => 'string',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.post 'http://localhost:8080/rtc-api/assets/{assetId}',
  params: {}, headers: headers

p JSON.parse(result)

Delete an asset

DELETE http://localhost:8080/rtc-api/assets/{assetId} HTTP/1.1
Host: localhost:8080
Accept: */*
X-Auvious-TransactionId: string

Parameters

Parameter	In	Type	Required	Description
assetId	path	string	true	id of asset to delete
X-Auvious-TransactionId	header	string	false	Optional header used for detecting retries of the same request

Responses

Overview

Status	Meaning	Description	Schema
204	No Content	No Content	None
400	Bad Request	Bad Request	Inline

Response Schema

Status Code 400

Name	Type	Required	Restrictions	Description
» additionalProperties	string	false	none	none

Examples

400 Response

caution

To perform this operation, you must be authenticated by means of one of the following methods: BearerToken, OAuth2ClientCredentials

Code samples

Shell

curl -X DELETE http://localhost:8080/rtc-api/assets/{assetId} \
  -H 'Accept: */*' \  -H 'X-Auvious-TransactionId: string' \  -H 'Authorization: Bearer {access-token}'

Go

package main

import (
    "bytes"
    "net/http"
)

func main() {
    headers := map[string][]string{ 
        "Accept": []string{"*/*"},
        "X-Auvious-TransactionId": []string{"string"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    var body []byte
    // body = ...

    req, err := http.NewRequest("DELETE", "http://localhost:8080/rtc-api/assets/{assetId}", bytes.NewBuffer(body))
    req.Header = headers

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

Node

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

const headers = {
  'Accept': '*/*',  'X-Auvious-TransactionId': 'string',  'Authorization': 'Bearer {access-token}'
}

fetch('http://localhost:8080/rtc-api/assets/{assetId}', {
  method: 'DELETE',
  headers
})
.then(r => r.json())
.then((body) => {
    console.log(body)
})

Java

// This sample needs improvement.
URL obj = new URL("http://localhost:8080/rtc-api/assets/{assetId}");

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());

Python

import requests

headers = {
  'Accept': '*/*',
  'X-Auvious-TransactionId': 'string',
  'Authorization': 'Bearer {access-token}'
}

r = requests.delete(
  'http://localhost:8080/rtc-api/assets/{assetId}',
  params={},
  headers = headers)

print r.json()

Ruby

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*',
  'X-Auvious-TransactionId' => 'string',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.delete 'http://localhost:8080/rtc-api/assets/{assetId}',
  params: {}, headers: headers

p JSON.parse(result)

signedUrl_1

POST http://localhost:8080/rtc-api/assets/{assetId}/signedUrl HTTP/1.1
Host: localhost:8080
Accept: application/json
X-Auvious-CreateInternalSignedUrl: true
Referer: string

create a signed url

Parameters

Parameter	In	Type	Required	Description
assetId	path	string	true	none
X-Auvious-CreateInternalSignedUrl	header	boolean	false	none
Referer	header	string	true	none

Responses

Overview

Status	Meaning	Description	Schema
200	OK	OK	SignedUrl
400	Bad Request	Bad Request	Inline

Response Schema

Status Code 400

Name	Type	Required	Restrictions	Description
» additionalProperties	string	false	none	none

Examples

200 Response

{
  "url": "string",
  "validUntil": "2019-08-24T14:15:22Z"
}

400 Response

caution

To perform this operation, you must be authenticated by means of one of the following methods: BearerToken, OAuth2ClientCredentials

Code samples

Shell

curl -X POST http://localhost:8080/rtc-api/assets/{assetId}/signedUrl \
  -H 'Accept: application/json' \  -H 'X-Auvious-CreateInternalSignedUrl: true' \  -H 'Referer: string' \  -H 'Authorization: Bearer {access-token}'

Go

package main

import (
    "bytes"
    "net/http"
)

func main() {
    headers := map[string][]string{ 
        "Accept": []string{"application/json"},
        "X-Auvious-CreateInternalSignedUrl": []string{"true"},
        "Referer": []string{"string"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    var body []byte
    // body = ...

    req, err := http.NewRequest("POST", "http://localhost:8080/rtc-api/assets/{assetId}/signedUrl", bytes.NewBuffer(body))
    req.Header = headers

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

Node

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

const headers = {
  'Accept': 'application/json',  'X-Auvious-CreateInternalSignedUrl': 'true',  'Referer': 'string',  'Authorization': 'Bearer {access-token}'
}

fetch('http://localhost:8080/rtc-api/assets/{assetId}/signedUrl', {
  method: 'POST',
  headers
})
.then(r => r.json())
.then((body) => {
    console.log(body)
})

Java

// This sample needs improvement.
URL obj = new URL("http://localhost:8080/rtc-api/assets/{assetId}/signedUrl");

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());

Python

import requests

headers = {
  'Accept': 'application/json',
  'X-Auvious-CreateInternalSignedUrl': 'true',
  'Referer': 'string',
  'Authorization': 'Bearer {access-token}'
}

r = requests.post(
  'http://localhost:8080/rtc-api/assets/{assetId}/signedUrl',
  params={},
  headers = headers)

print r.json()

Ruby

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-Auvious-CreateInternalSignedUrl' => 'true',
  'Referer' => 'string',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.post 'http://localhost:8080/rtc-api/assets/{assetId}/signedUrl',
  params: {}, headers: headers

p JSON.parse(result)

Find assets by application id

GET http://localhost:8080/rtc-api/assets?applicationId=string HTTP/1.1
Host: localhost:8080
Accept: application/json

Parameters

Parameter	In	Type	Required	Description
applicationId	query	string	true	none

Responses

Overview

Status	Meaning	Description	Schema
200	OK	OK	Inline
400	Bad Request	Bad Request	Inline

Response Schema

Status Code 400

Name	Type	Required	Restrictions	Description
» additionalProperties	string	false	none	none

Examples

200 Response

{}

400 Response

caution

To perform this operation, you must be authenticated by means of one of the following methods: BearerToken, OAuth2ClientCredentials

Code samples

Shell

curl -X GET http://localhost:8080/rtc-api/assets?applicationId=string \
  -H 'Accept: application/json' \  -H 'Authorization: Bearer {access-token}'

Go

package main

import (
    "bytes"
    "net/http"
)

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

    var body []byte
    // body = ...

    req, err := http.NewRequest("GET", "http://localhost:8080/rtc-api/assets", bytes.NewBuffer(body))
    req.Header = headers

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

Node

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

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

fetch('http://localhost:8080/rtc-api/assets?applicationId=string', {
  method: 'GET',
  headers
})
.then(r => r.json())
.then((body) => {
    console.log(body)
})

Java

// This sample needs improvement.
URL obj = new URL("http://localhost:8080/rtc-api/assets?applicationId=string");

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());

Python

import requests

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

r = requests.get(
  'http://localhost:8080/rtc-api/assets',
  params={
    'applicationId': 'string'},
  headers = headers)

print r.json()

Ruby

require 'rest-client'
require 'json'

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

result = RestClient.get 'http://localhost:8080/rtc-api/assets',
  params: {
    'applicationId' => 'string'}, headers: headers

p JSON.parse(result)

get a builtin signed url

GET http://localhost:8080/rtc-api/assets/signed/{assetId}/{expiration}?signature=string HTTP/1.1
Host: localhost:8080
Accept: */*

Parameters

Parameter	In	Type	Required	Description
assetId	path	string	true	none
expiration	path	integer(int64)	true	none
signature	query	string	true	none

Responses

Overview

Status	Meaning	Description	Schema
200	OK	OK	Inline
400	Bad Request	Bad Request	Inline

Response Schema

Status Code 400

Name	Type	Required	Restrictions	Description
» additionalProperties	string	false	none	none

Examples

200 Response

caution

To perform this operation, you must be authenticated by means of one of the following methods: BearerToken, OAuth2ClientCredentials

Code samples

Shell

curl -X GET http://localhost:8080/rtc-api/assets/signed/{assetId}/{expiration}?signature=string \
  -H 'Accept: */*' \  -H 'Authorization: Bearer {access-token}'

Go

package main

import (
    "bytes"
    "net/http"
)

func main() {
    headers := map[string][]string{ 
        "Accept": []string{"*/*"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    var body []byte
    // body = ...

    req, err := http.NewRequest("GET", "http://localhost:8080/rtc-api/assets/signed/{assetId}/{expiration}", bytes.NewBuffer(body))
    req.Header = headers

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

Node

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

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

fetch('http://localhost:8080/rtc-api/assets/signed/{assetId}/{expiration}?signature=string', {
  method: 'GET',
  headers
})
.then(r => r.json())
.then((body) => {
    console.log(body)
})

Java

// This sample needs improvement.
URL obj = new URL("http://localhost:8080/rtc-api/assets/signed/{assetId}/{expiration}?signature=string");

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());

Python

import requests

headers = {
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get(
  'http://localhost:8080/rtc-api/assets/signed/{assetId}/{expiration}',
  params={
    'signature': 'string'},
  headers = headers)

print r.json()

Ruby

require 'rest-client'
require 'json'

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

result = RestClient.get 'http://localhost:8080/rtc-api/assets/signed/{assetId}/{expiration}',
  params: {
    'signature' => 'string'}, headers: headers

p JSON.parse(result)

IceSupport

Obtains iceServers for use by WebRTC peers

GET http://localhost:8080/rtc-api/iceServers HTTP/1.1
Host: localhost:8080
Accept: application/json

Responses

Overview

Status	Meaning	Description	Schema
200	OK	OK	IceServersResult
400	Bad Request	Bad Request	Inline

Response Schema

Status Code 400

Name	Type	Required	Restrictions	Description
» additionalProperties	string	false	none	none

Examples

200 Response

{
  "iceServers": [
    {
      "urls": [
        "string"
      ],
      "username": "string",
      "credential": "string"
    }
  ],
  "ttl": 0
}

400 Response

caution

To perform this operation, you must be authenticated by means of one of the following methods: BearerToken, OAuth2ClientCredentials

Code samples

Shell

curl -X GET http://localhost:8080/rtc-api/iceServers \
  -H 'Accept: application/json' \  -H 'Authorization: Bearer {access-token}'

Go

package main

import (
    "bytes"
    "net/http"
)

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

    var body []byte
    // body = ...

    req, err := http.NewRequest("GET", "http://localhost:8080/rtc-api/iceServers", bytes.NewBuffer(body))
    req.Header = headers

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

Node

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

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

fetch('http://localhost:8080/rtc-api/iceServers', {
  method: 'GET',
  headers
})
.then(r => r.json())
.then((body) => {
    console.log(body)
})

Java

// This sample needs improvement.
URL obj = new URL("http://localhost:8080/rtc-api/iceServers");

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());

Python

import requests

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

r = requests.get(
  'http://localhost:8080/rtc-api/iceServers',
  params={},
  headers = headers)

print r.json()

Ruby

require 'rest-client'
require 'json'

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

result = RestClient.get 'http://localhost:8080/rtc-api/iceServers',
  params: {}, headers: headers

p JSON.parse(result)

iceServersV2

GET http://localhost:8080/rtc-api/iceServers/v2 HTTP/1.1
Host: localhost:8080
Accept: application/json

Obtains iceServers for use by WebRTC peers

Responses

Overview

Status	Meaning	Description	Schema
200	OK	OK	IceServersResultV2
400	Bad Request	Bad Request	Inline

Response Schema

Status Code 400

Name	Type	Required	Restrictions	Description
» additionalProperties	string	false	none	none

Examples

200 Response

{
  "stun": "string",
  "turn": "string",
  "turnUsername": "string",
  "turnPassword": "string",
  "ttl": 0
}

400 Response

caution

To perform this operation, you must be authenticated by means of one of the following methods: BearerToken, OAuth2ClientCredentials

Code samples

Shell

curl -X GET http://localhost:8080/rtc-api/iceServers/v2 \
  -H 'Accept: application/json' \  -H 'Authorization: Bearer {access-token}'

Go

package main

import (
    "bytes"
    "net/http"
)

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

    var body []byte
    // body = ...

    req, err := http.NewRequest("GET", "http://localhost:8080/rtc-api/iceServers/v2", bytes.NewBuffer(body))
    req.Header = headers

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

Node

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

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

fetch('http://localhost:8080/rtc-api/iceServers/v2', {
  method: 'GET',
  headers
})
.then(r => r.json())
.then((body) => {
    console.log(body)
})

Java

// This sample needs improvement.
URL obj = new URL("http://localhost:8080/rtc-api/iceServers/v2");

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());

Python

import requests

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

r = requests.get(
  'http://localhost:8080/rtc-api/iceServers/v2',
  params={},
  headers = headers)

print r.json()

Ruby

require 'rest-client'
require 'json'

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

result = RestClient.get 'http://localhost:8080/rtc-api/iceServers/v2',
  params: {}, headers: headers

p JSON.parse(result)

Schemas

UpdateInteractionWebCommand

{
  "type": "string",
  "data": {
    "property1": {},
    "property2": {}
  },
  "version": 0
}

Properties

Name	Type	Required	Restrictions	Description
type	string	false	none	type of interaction, e.g. video call if omitted it wont be updated
data	object	false	none	interaction data, this is the place to store arbitrary data that might be needed later, if omitted it won't be updated. Careful with this, when supplied it all data will be replaced
» additionalProperties	object	false	none	interaction data, this is the place to store arbitrary data that might be needed later, if omitted it won't be updated. Careful with this, when supplied it all data will be replaced
version	integer(int64)	false	none	version of the interaction, used for optimistic locking, optional, if not provided it will be ignored

RegisterUserEndpointWebCommand

{
  "userEndpointId": "string",
  "keepAliveSeconds": 5,
  "serverKeepAliveReminderOn": true
}

Properties

Name	Type	Required	Restrictions	Description
userEndpointId	string	false	none	Supply the userEndpointId. Take care so this value is unique, otherwise better leave this empty and let the server produce one. Optional.
keepAliveSeconds	integer(int32)	true	none	how long before this endpoint expires if no keepalive request is sent. Mandatory.
serverKeepAliveReminderOn	boolean	false	none	if true, then an Event will be sent to the userEndpoint topic, to remind the client to makea keepalive request. Default is false.

UnregisterUserEndpointWebCommand

{
  "userEndpointId": "string",
  "reason": "string"
}

Properties

Name	Type	Required	Restrictions	Description
userEndpointId	string	true	none	none
reason	string	false	none	none

SendEventToUserWebCommand

{
  "userId": "string",
  "organizationId": "string",
  "userEndpointId": "string",
  "event": {
    "property1": {},
    "property2": {}
  },
  "masks": [
    "string"
  ],
  "qos": 0
}

Properties

Name	Type	Required	Restrictions	Description
userId	string	true	none	userId of user that will receive the message
organizationId	string	true	none	Organization id of user that sends and must match the user's org who will receive the message. Only applicable to internal services, for normal users their jwt organization_id claim will be used, since theycan only send events to users of their own organization
userEndpointId	string	false	none	userEndpointId of user that will receive the message, if not supplied it will be sent to all user endpoints of user with the specified userId.
event	object	true	none	event attributes, at least type and timestamp must be supplied with correct format. Format for type should begin with capital, end with Event, and use came case of at least a noun and a verb denoting what happened on what. Format for timestamp is ISO-8601 instant format e.g. '2011-12-03T10:15:30Z
» additionalProperties	object	false	none	event attributes, at least type and timestamp must be supplied with correct format. Format for type should begin with capital, end with Event, and use came case of at least a noun and a verb denoting what happened on what. Format for timestamp is ISO-8601 instant format e.g. '2011-12-03T10:15:30Z
masks	[string]	false	none	masks to apply, each item denotes a json path (https://github.com/json-path/JsonPath) syntax which will be applied on the event when stored or logged. By default no masks are applied. The masked fields must be of type string, and it will be replaced by a string of same length but with strings.
qos	integer(int32)	false	none	qos level 0 = best effort, 1 = at least once, other values best effort. Defaults to 0 (best effort)

RegisterResult

{
  "id": "string"
}

Properties

Name	Type	Required	Restrictions	Description
id	string	false	none	user endpoint id

KeepUserEndpointAliveWebCommand

{
  "userEndpointId": "string"
}

Properties

Name	Type	Required	Restrictions	Description
userEndpointId	string	true	none	none

RequestData

{
  "contact_id": "string"
}

Properties

Name	Type	Required	Restrictions	Description
contact_id	string	false	none	none

TalkdeskCreateTalkdeskRequest

{
  "data": {
    "contact_id": "string"
  }
}

Properties

Name	Type	Required	Restrictions	Description
data	RequestData	false	none	none

TalkdeskCreateTalkdeskResponse

{
  "message": "string",
  "contact_external_id": "string"
}

Properties

Name	Type	Required	Restrictions	Description
message	string	false	none	none
contact_external_id	string	false	none	none

Meta

{
  "interaction_types": [
    "string"
  ]
}

Properties

Name	Type	Required	Restrictions	Description
interaction_types	[string]	false	none	none

TalkdeskContactActivityRequest

{
  "meta": {
    "interaction_types": [
      "string"
    ]
  },
  "data": {
    "contact_id": "string"
  }
}

Properties

Name	Type	Required	Restrictions	Description
meta	Meta	false	none	none
data	RequestData	false	none	none

TalkdeskContactActivityResponseItem

{
  "id": "string",
  "subject": "string",
  "description": "string",
  "date": "string",
  "url": "string",
  "type": "string",
  "priority": "string",
  "status": "string"
}

Properties

Name	Type	Required	Restrictions	Description
id	string	false	none	none
subject	string	false	none	none
description	string	false	none	none
date	string	false	none	none
url	string	false	none	none
type	string	false	none	none
priority	string	false	none	none
status	string	false	none	none

SnapshotUploadResult

{
  "snapshotId": "string"
}

Properties

Name	Type	Required	Restrictions	Description
snapshotId	string	false	none	none

CreateSnapshotSignedURLWebCommand

{
  "snapshotId": "string",
  "createInternalSignedUrl": true
}

Properties

Name	Type	Required	Restrictions	Description
snapshotId	string	true	none	none
createInternalSignedUrl	boolean	false	none	none

SignedUrl

{
  "url": "string",
  "validUntil": "2019-08-24T14:15:22Z"
}

Properties

Name	Type	Required	Restrictions	Description
url	string(url)	false	none	none
validUntil	string(date-time)	false	none	none

SnapshotRequestWebCommand

{
  "applicationId": "string",
  "userEndpointId": "string",
  "targetUserId": "string",
  "targetUserEndpointId": "string",
  "sessionType": "UNKNOWN",
  "sessionId": "string",
  "interactionId": "string",
  "snapshotType": "string"
}

Properties

Name	Type	Required	Restrictions	Description
applicationId	string	true	none	the application to use
userEndpointId	string	true	none	the requester's userEndpointId
targetUserId	string	true	none	the request's target userId
targetUserEndpointId	string	true	none	the request's target userEndpointId
sessionType	string	false	none	session type, one of CONFERENCE
sessionId	string	false	none	session id, e.g. conference id for conference
interactionId	string	false	none	interaction id, e.g. if provided snapshot will be stored under interactions/{interaction-id} folder in storage
snapshotType	string	false	none	the snapshot's type

Enumerated Values

Property	Value
sessionType	UNKNOWN
sessionType	CALL
sessionType	CONFERENCE

SnapshotRequestResult

{
  "snapshotId": "string"
}

Properties

Name	Type	Required	Restrictions	Description
snapshotId	string	false	none	none

SnapshotDiscardWebCommand

{
  "snapshotId": "string",
  "userEndpointId": "string"
}

Properties

Name	Type	Required	Restrictions	Description
snapshotId	string	true	none	the snapshot id
userEndpointId	string	true	none	the discarder's userEndpointId

SnapshotCameraRequestWebCommand

{
  "userEndpointId": "string",
  "targetUserId": "string",
  "targetUserEndpointId": "string",
  "sessionType": "UNKNOWN",
  "sessionId": "string",
  "cameraRequestType": "CAMERA_SWITCH"
}

Properties

Name	Type	Required	Restrictions	Description
userEndpointId	string	true	none	the requester's userEndpointId
targetUserId	string	true	none	the request's target userId
targetUserEndpointId	string	true	none	the request's target userEndpointId
sessionType	string	false	none	session type, one of CONFERENCE
sessionId	string	false	none	session id, e.g. conference id for conference
cameraRequestType	string	true	none	the request type, feel free to enter what suits you

Enumerated Values

Property	Value
sessionType	UNKNOWN
sessionType	CALL
sessionType	CONFERENCE
cameraRequestType	CAMERA_SWITCH
cameraRequestType	FLASH_ON
cameraRequestType	FLASH_OFF

SnapshotCameraRequestRespondWebCommand

{
  "snapshotCameraRequestId": "string",
  "userEndpointId": "string",
  "succeeded": true,
  "additionalInformation": "string"
}

Properties

Name	Type	Required	Restrictions	Description
snapshotCameraRequestId	string	true	none	the request id
userEndpointId	string	true	none	the responder's userEndpointId
succeeded	boolean	true	none	indicates if the request succeeded
additionalInformation	string	false	none	additional information about the request success or failure

SnapshotApproveWebCommand

{
  "snapshotId": "string",
  "userEndpointId": "string",
  "snapshotType": "string"
}

Properties

Name	Type	Required	Restrictions	Description
snapshotId	string	true	none	the snapshot id
userEndpointId	string	true	none	the requester's userEndpointId
snapshotType	string	false	none	the snapshot type (override request snapshot type)

CreateRatingWebCommand

{
  "userEndpointId": "string",
  "sessionType": "UNKNOWN",
  "sessionId": "string",
  "rating": 0,
  "comment": "string",
  "interactionId": "string"
}

Properties

Name	Type	Required	Restrictions	Description
userEndpointId	string	false	none	user endpoint id, optional
sessionType	string	true	none	type of session, CALL or CONFERENCE
sessionId	string	true	none	the call or conference id related with this rating
rating	integer(int32)	true	none	the rating the user gave, scale is 1-5, 1 meaning bad and 5 perfect
comment	string	false	none	any comment the user gave
interactionId	string	false	none	related interaction id

Enumerated Values

Property	Value
sessionType	UNKNOWN
sessionType	CALL
sessionType	CONFERENCE

CreatingRatingWebResponse

{
  "id": "string"
}

Properties

Name	Type	Required	Restrictions	Description
id	string	false	none	none

CreateInteractionWebCommand

{
  "interactionId": "string",
  "type": "string",
  "data": {
    "property1": {},
    "property2": {}
  }
}

Properties

Name	Type	Required	Restrictions	Description
interactionId	string	false	none	interaction id, can be supplied to match integration party e.g. Genesys Cloud interaction/conversation id
type	string	false	none	type of interaction, e.g. video call
data	object	false	none	interaction data, this is the place to store arbitrary data that might be needed later
» additionalProperties	object	false	none	interaction data, this is the place to store arbitrary data that might be needed later

CreateInteractionResponse

{
  "interactionId": "string",
  "version": 0
}

Properties

Name	Type	Required	Restrictions	Description
interactionId	string	false	none	none
version	integer(int64)	false	none	none

FileTransferResult

{
  "fileTransferId": "string"
}

Properties

Name	Type	Required	Restrictions	Description
fileTransferId	string	false	none	none

ConferenceViewStreamWebCommand

{
  "conferenceId": "string",
  "userEndpointId": "string",
  "streamId": "string",
  "sdpOffer": "string",
  "viewerId": "string",
  "metadata": {
    "property1": "string",
    "property2": "string"
  }
}

Properties

Name	Type	Required	Restrictions	Description
conferenceId	string	true	none	Supply the conferenceId. Mandatory.
userEndpointId	string	true	none	Supply the user endpoint id of the viewer. Mandatory.
streamId	string	true	none	Supply the stream id to view. Mandatory.
sdpOffer	string	true	none	Supply the sdp offer. Mandatory.
viewerId	string	false	none	Supply the viewerId. Optional.
metadata	object	false	none	Stream metadata. Optional.
» additionalProperties	string	false	none	Stream metadata. Optional.

ConferenceStreamViewResult

{
  "viewerId": "string",
  "sdpAnswer": "string"
}

Properties

Name	Type	Required	Restrictions	Description
viewerId	string	false	none	none
sdpAnswer	string	false	none	none

UpdateConferenceStreamMetadataWebCommand

{
  "conferenceId": "string",
  "userEndpointId": "string",
  "streamId": "string",
  "newMetadata": {
    "property1": {},
    "property2": {}
  }
}

Properties

Name	Type	Required	Restrictions	Description
conferenceId	string	true	none	Supply the conferenceId. Mandatory.
userEndpointId	string	true	none	Supply the user endpoint id. Mandatory.
streamId	string	true	none	Supply the streamId. Optional.
newMetadata	object	false	none	Supply the metadata of the stream.
» additionalProperties	object	false	none	Supply the metadata of the stream.

ConferenceUpdatePublishedStreamBitrateWebCommand

{
  "conferenceId": "string",
  "userEndpointId": "string",
  "streamId": "string",
  "videoBitrate": 30000
}

Properties

Name	Type	Required	Restrictions	Description
conferenceId	string	true	none	Supply the conferenceId. Mandatory.
userEndpointId	string	true	none	Supply the user endpoint id. Mandatory.
streamId	string	false	none	Supply the streamId. Optional.
videoBitrate	integer(int32)	true	none	Stream video bitrate. Optional

UpdateConferenceParticipantMetadataWebCommand

{
  "conferenceId": "string",
  "userEndpointId": "string",
  "newMetadata": {
    "property1": {},
    "property2": {}
  }
}

Properties

Name	Type	Required	Restrictions	Description
conferenceId	string	true	none	Supply the conferenceId. Mandatory.
userEndpointId	string	true	none	Supply the user endpoint id. Mandatory.
newMetadata	object	true	none	Supply the metadata of the user.
» additionalProperties	object	false	none	Supply the metadata of the user.

UpdateConferenceMetadataWebCommand

{
  "conferenceId": "string",
  "userEndpointId": "string",
  "operation": "SET",
  "key": "string",
  "value": "string"
}

Properties

Name	Type	Required	Restrictions	Description
conferenceId	string	true	none	Supply the conferenceId. Mandatory.
userEndpointId	string	true	none	Supply the user endpoint id. Mandatory.
operation	string	true	none	Supply the operation, SET or REMOVE. Mandatory.
key	string	true	none	Supply the key. Mandatory
value	string	false	none	Supply the value, if the operation is SET. Ignored if operation is REMOVE

Enumerated Values

Property	Value
operation	SET
operation	REMOVE
operation	UNKNOWN

ConferenceUnpublishStreamWebCommand

{
  "conferenceId": "string",
  "userEndpointId": "string",
  "streamId": "string"
}

Properties

Name	Type	Required	Restrictions	Description
conferenceId	string	true	none	Supply the conferenceId. Mandatory.
userEndpointId	string	true	none	Supply the user endpoint id. Mandatory.
streamId	string	true	none	Supply the stream id to unpublish. Mandatory.

ConferenceStopViewStreamWebCommand

{
  "conferenceId": "string",
  "userEndpointId": "string",
  "streamId": "string",
  "viewerId": "string"
}

Properties

Name	Type	Required	Restrictions	Description
conferenceId	string	true	none	Supply the conferenceId. Mandatory.
userEndpointId	string	true	none	Supply the user endpoint id. Mandatory.
streamId	string	true	none	Supply the stream id. Mandatory.
viewerId	string	true	none	Supply the viewer id. Mandatory.

SendEventToConferenceWebCommand

{
  "conferenceId": "string",
  "qos": "BEST_EFFORT",
  "event": {
    "property1": {},
    "property2": {}
  },
  "masks": [
    "string"
  ]
}

Properties

Name	Type	Required	Restrictions	Description
conferenceId	string	true	none	conference id the members of which will receive the message
qos	string	true	none	define qos(optional), default is best effort
event	object	true	none	event attributes, at least type and timestamp must be supplied with correct format. Format for type should begin with capital, end with Event, and use came case of at least a noun and a verb denoting what happened on what. Format for timestamp is ISO-8601 instant format e.g. '2011-12-03T10:15:30Z
» additionalProperties	object	false	none	event attributes, at least type and timestamp must be supplied with correct format. Format for type should begin with capital, end with Event, and use came case of at least a noun and a verb denoting what happened on what. Format for timestamp is ISO-8601 instant format e.g. '2011-12-03T10:15:30Z
masks	[string]	false	none	masks to apply, each item denotes a json path (https://github.com/json-path/JsonPath) syntax which will be applied on the event when stored or logged. By default no masks are applied. The masked fields must be of type string, and it will be replaced by a string of same length but with strings.

Enumerated Values

Property	Value
qos	BEST_EFFORT
qos	AT_LEAST_ONCE

SendEventResponse

{
  "eventsSent": 0
}

Properties

Name	Type	Required	Restrictions	Description
eventsSent	integer(int32)	false	none	none

ConferencePublishStreamWebCommand

{
  "conferenceId": "string",
  "userEndpointId": "string",
  "streamId": "string",
  "conferenceStreamType": "MIC",
  "sdpOffer": "string",
  "metadata": {
    "property1": {},
    "property2": {}
  },
  "videoBitrate": 30000
}

Properties

Name	Type	Required	Restrictions	Description
conferenceId	string	true	none	Supply the conferenceId. Mandatory.
userEndpointId	string	true	none	Supply the user endpoint id. Mandatory.
streamId	string	false	none	Supply the streamId. Optional.
conferenceStreamType	string	true	none	Supply the stream type. One of MIC, CAM, SCREEN or MIC_AND_CAM. Mandatory.
sdpOffer	string	false	none	Supply the sdpOffer. Mandatory.
metadata	object	false	none	Stream metadata. Optional
» additionalProperties	object	false	none	Stream metadata. Optional
videoBitrate	integer(int32)	false	none	Stream video bitrate. Optional

Enumerated Values

Property	Value
conferenceStreamType	MIC
conferenceStreamType	CAM
conferenceStreamType	SCREEN
conferenceStreamType	MIC_AND_CAM
conferenceStreamType	UNKNOWN

ConferencePublishResult

{
  "streamId": "string",
  "sdpAnswer": "string"
}

Properties

Name	Type	Required	Restrictions	Description
streamId	string	false	none	none
sdpAnswer	string	false	none	none

LeaveConferenceWebCommand

{
  "conferenceId": "string",
  "userEndpointId": "string",
  "reason": "string"
}

Properties

Name	Type	Required	Restrictions	Description
conferenceId	string	true	none	Supply the conferenceId. Mandatory.
userEndpointId	string	true	none	Supply the user endpoint id. Mandatory.
reason	string	false	none	Supply a reason for leaving. Optional.

JoinConferenceWebCommand

{
  "conferenceId": "string",
  "userEndpointId": "string",
  "metadata": {
    "property1": {},
    "property2": {}
  }
}

Properties

Name	Type	Required	Restrictions	Description
conferenceId	string	true	none	Supply the conferenceId to join. Mandatory.
userEndpointId	string	true	none	Supply the userEndpointId of the user that wants to join. Mandatory.
metadata	object	false	none	Supply the metadata of the user.
» additionalProperties	object	false	none	Supply the metadata of the user.

ConferenceSummary

{
  "id": "string",
  "version": 0,
  "mode": "P2P"
}

Properties

Name	Type	Required	Restrictions	Description
id	string	false	none	none
version	integer(int64)	false	none	none
mode	string	false	none	none

Enumerated Values

Property	Value
mode	P2P
mode	ROUTER
mode	UNKNOWN

AnotherErrorResponse

{
  "error": "string",
  "error_description": "string"
}

Properties

Name	Type	Required	Restrictions	Description
error	string	false	none	none
error_description	string	false	none	none

SetInteractionIdWebCommand

{
  "conferenceId": "string",
  "interactionId": "string",
  "userEndpointId": "string"
}

Properties

Name	Type	Required	Restrictions	Description
conferenceId	string	true	none	none
interactionId	string	true	none	none
userEndpointId	string	false	none	none

EndConferenceWebCommand

{
  "conferenceId": "string",
  "userEndpointId": "string",
  "reason": "string"
}

Properties

Name	Type	Required	Restrictions	Description
conferenceId	string	true	none	Supply the conferenceId. Mandatory.
userEndpointId	string	true	none	Supply the user endpoint id. Mandatory.
reason	string	false	none	Supply a reason for leaving. Optional.

CreateConferenceWebCommand

{
  "conferenceId": "string",
  "mode": "P2P",
  "organizationId": "string",
  "creatorEndpoint": "string",
  "interactionId": "string",
  "metadata": {
    "property1": "string",
    "property2": "string"
  }
}

Properties

Name	Type	Required	Restrictions	Description
conferenceId	string	false	none	Supply the conferenceId. Take care so this value is unique, otherwise better leave this empty and let the server produce one. Optional.
mode	string	false	none	Supply the conference mode. Currently only ROUTER is supported. Optional.
organizationId	string	false	none	organization id, for internal use only
creatorEndpoint	string	false	none	Supply the creator user endpoint id. Optional.
interactionId	string	false	none	Interaction id related to this conference
metadata	object	false	none	Supply conference metadata. Optional.
» additionalProperties	string	false	none	Supply conference metadata. Optional.

Enumerated Values

Property	Value
mode	P2P
mode	ROUTER
mode	UNKNOWN

ConferenceViewStreamIceCandidatesWebCommand

{
  "conferenceId": "string",
  "userEndpointId": "string",
  "streamId": "string",
  "viewerId": "string",
  "iceCandidates": [
    {
      "candidate": "string",
      "sdpMid": "string",
      "sdpMLineIndex": 0
    }
  ]
}

Properties

Name	Type	Required	Restrictions	Description
conferenceId	string	true	none	Supply the conferenceId. Mandatory.
userEndpointId	string	true	none	Supply the user endpoint id. Mandatory.
streamId	string	true	none	Supply the viewing stream id. Mandatory.
viewerId	string	true	none	Supply the viewer id. Mandatory.
iceCandidates	[IceCandidate]	true	none	Supply the ice candidates found so far. Mandatory.

IceCandidate

{
  "candidate": "string",
  "sdpMid": "string",
  "sdpMLineIndex": 0
}

Supply the ice candidates found so far. Mandatory.

Properties

Name	Type	Required	Restrictions	Description
candidate	string	false	none	none
sdpMid	string	false	none	none
sdpMLineIndex	integer(int32)	false	none	none

ConferencePublishStreamIceCandidatesWebCommand

{
  "conferenceId": "string",
  "userEndpointId": "string",
  "streamId": "string",
  "iceCandidates": [
    {
      "candidate": "string",
      "sdpMid": "string",
      "sdpMLineIndex": 0
    }
  ]
}

Properties

Name	Type	Required	Restrictions	Description
conferenceId	string	true	none	Supply the conferenceId. Mandatory.
userEndpointId	string	true	none	Supply the user endpoint id. Mandatory.
streamId	string	true	none	Supply the published stream id. Mandatory.
iceCandidates	[IceCandidate]	true	none	Supply the ice candidates found so far. Mandatory.

Snapshot

{
  "id": "string",
  "relatedSnapshotId": "string",
  "organizationId": "string",
  "applicationId": "string",
  "requesterUserId": "string",
  "requesterUserEndpointId": "string",
  "userId": "string",
  "userEndpointId": "string",
  "sessionType": "UNKNOWN",
  "sessionId": "string",
  "timestamp": "2019-08-24T14:15:22Z",
  "interactionId": "string",
  "type": "string",
  "path": "string",
  "state": "UPLOADED",
  "requestProcessingResult": {
    "snapshotId": "string"
  },
  "approvalProcessingResult": {
    "succeeded": true,
    "additionalInformation": "string"
  },
  "suffix": "string",
  "mimeType": "string",
  "createdAt": "2019-08-24T14:15:22Z",
  "version": 0,
  "approved": true
}

Properties

Name	Type	Required	Restrictions	Description
id	string	false	none	none
relatedSnapshotId	string	false	none	none
organizationId	string	false	none	none
applicationId	string	false	none	none
requesterUserId	string	false	none	none
requesterUserEndpointId	string	false	none	none
userId	string	false	none	none
userEndpointId	string	false	none	none
sessionType	string	false	none	none
sessionId	string	false	none	none
timestamp	string(date-time)	false	none	none
interactionId	string	false	none	none
type	string	false	none	none
path	string	false	none	none
state	string	false	none	none
requestProcessingResult	SnapshotRequestResult	false	none	none
approvalProcessingResult	SnapshotApprovalProcessingResult	false	none	none
suffix	string	false	none	none
mimeType	string	false	none	none
createdAt	string(date-time)	false	none	none
version	integer(int64)	false	none	none
approved	boolean	false	none	none

Enumerated Values

Property	Value
sessionType	UNKNOWN
sessionType	CALL
sessionType	CONFERENCE
state	UPLOADED
state	APPROVED
state	DISCARDED

SnapshotApprovalProcessingResult

{
  "succeeded": true,
  "additionalInformation": "string"
}

Properties

Name	Type	Required	Restrictions	Description
succeeded	boolean	false	none	none
additionalInformation	string	false	none	none

Rating

{
  "id": "string",
  "userId": "string",
  "userEndpointId": "string",
  "organizationId": "string",
  "interactionId": "string",
  "sessionType": "UNKNOWN",
  "sessionId": "string",
  "score": 0,
  "comment": "string",
  "createdAt": "2019-08-24T14:15:22Z"
}

Properties

Name	Type	Required	Restrictions	Description
id	string	false	none	rating id
userId	string	false	none	the user who created this rating
userEndpointId	string	false	none	the user endpoint from which the user created this rating
organizationId	string	false	none	related organization id
interactionId	string	false	none	related interaction id
sessionType	string	false	none	kind of session, CALL or CONFERENCE
sessionId	string	false	none	the call or conference id related with this rating
score	integer(int32)	false	none	the rating the user gave, scale is 1-5, 1 meaning bad and 5 perfect
comment	string	false	none	any comment the user gave
createdAt	string(date-time)	false	none	none

Enumerated Values

Property	Value
sessionType	UNKNOWN
sessionType	CALL
sessionType	CONFERENCE

Pageable

{
  "page": 0,
  "size": 1,
  "sort": [
    "string"
  ]
}

Properties

Name	Type	Required	Restrictions	Description
page	integer(int32)	false	none	none
size	integer(int32)	false	none	none
sort	[string]	false	none	none

Interaction

{
  "id": "string",
  "organizationId": "string",
  "createdBy": "string",
  "createdAt": "2019-08-24T14:15:22Z",
  "type": "string",
  "data": {
    "property1": {},
    "property2": {}
  },
  "version": 0
}

Properties

Name	Type	Required	Restrictions	Description
id	string	false	none	none
organizationId	string	false	none	none
createdBy	string	false	none	none
createdAt	string(date-time)	false	none	none
type	string	false	none	none
data	object	false	none	none
» interaction data	object	false	none	none
version	integer(int64)	false	none	none

PageInteraction

{
  "totalPages": 0,
  "totalElements": 0,
  "first": true,
  "last": true,
  "size": 0,
  "content": [
    {
      "id": "string",
      "organizationId": "string",
      "createdBy": "string",
      "createdAt": "2019-08-24T14:15:22Z",
      "type": "string",
      "data": {
        "property1": {},
        "property2": {}
      },
      "version": 0
    }
  ],
  "number": 0,
  "sort": [
    {
      "direction": "string",
      "nullHandling": "string",
      "ascending": true,
      "property": "string",
      "ignoreCase": true
    }
  ],
  "numberOfElements": 0,
  "pageable": {
    "offset": 0,
    "sort": [
      {
        "direction": "string",
        "nullHandling": "string",
        "ascending": true,
        "property": "string",
        "ignoreCase": true
      }
    ],
    "pageSize": 0,
    "paged": true,
    "pageNumber": 0,
    "unpaged": true
  },
  "empty": true
}

Properties

Name	Type	Required	Restrictions	Description
totalPages	integer(int32)	false	none	none
totalElements	integer(int64)	false	none	none
first	boolean	false	none	none
last	boolean	false	none	none
size	integer(int32)	false	none	none
content	[Interaction]	false	none	none
number	integer(int32)	false	none	none
sort	[SortObject]	false	none	none
numberOfElements	integer(int32)	false	none	none
pageable	PageableObject	false	none	none
empty	boolean	false	none	none

PageableObject

{
  "offset": 0,
  "sort": [
    {
      "direction": "string",
      "nullHandling": "string",
      "ascending": true,
      "property": "string",
      "ignoreCase": true
    }
  ],
  "pageSize": 0,
  "paged": true,
  "pageNumber": 0,
  "unpaged": true
}

Properties

Name	Type	Required	Restrictions	Description
offset	integer(int64)	false	none	none
sort	[SortObject]	false	none	none
pageSize	integer(int32)	false	none	none
paged	boolean	false	none	none
pageNumber	integer(int32)	false	none	none
unpaged	boolean	false	none	none

SortObject

{
  "direction": "string",
  "nullHandling": "string",
  "ascending": true,
  "property": "string",
  "ignoreCase": true
}

Properties

Name	Type	Required	Restrictions	Description
direction	string	false	none	none
nullHandling	string	false	none	none
ascending	boolean	false	none	none
property	string	false	none	none
ignoreCase	boolean	false	none	none

IceServer

{
  "urls": [
    "string"
  ],
  "username": "string",
  "credential": "string"
}

Properties

Name	Type	Required	Restrictions	Description
urls	[string]	false	none	none
username	string	false	none	none
credential	string	false	none	none

IceServersResult

{
  "iceServers": [
    {
      "urls": [
        "string"
      ],
      "username": "string",
      "credential": "string"
    }
  ],
  "ttl": 0
}

Properties

Name	Type	Required	Restrictions	Description
iceServers	[IceServer]	false	none	none
ttl	integer(int32)	false	none	none

IceServersResultV2

{
  "stun": "string",
  "turn": "string",
  "turnUsername": "string",
  "turnPassword": "string",
  "ttl": 0
}

Properties

Name	Type	Required	Restrictions	Description
stun	string	false	none	none
turn	string	false	none	none
turnUsername	string	false	none	none
turnPassword	string	false	none	none
ttl	integer(int32)	false	none	none

Conference

{
  "id": "string",
  "mode": "P2P",
  "organizationId": "string",
  "interactionId": "string",
  "creator": "string",
  "creatorEndpoint": "string",
  "participants": [
    {
      "id": "string",
      "userId": "string",
      "state": "HEALTHY",
      "streams": [
        {
          "id": "string",
          "type": "MIC",
          "metadata": {
            "property1": {},
            "property2": {}
          },
          "videoBitrate": 0
        }
      ],
      "metadata": {
        "property1": {},
        "property2": {}
      }
    }
  ],
  "metadata": {
    "property1": {
      "value": "string",
      "userId": "string",
      "userEndpointId": "string",
      "lastModified": "2019-08-24T14:15:22Z"
    },
    "property2": {
      "value": "string",
      "userId": "string",
      "userEndpointId": "string",
      "lastModified": "2019-08-24T14:15:22Z"
    }
  },
  "version": 0,
  "empty": true
}

Properties

Name	Type	Required	Restrictions	Description
id	string	false	none	none
mode	string	false	none	none
organizationId	string	false	none	none
interactionId	string	false	none	none
creator	string	false	none	none
creatorEndpoint	string	false	none	none
participants	[ConferenceParticipant]	false	none	none
metadata	object	false	none	none
» additionalProperties	Metadata	false	none	none
version	integer(int64)	false	none	none
empty	boolean	false	none	none

Enumerated Values

Property	Value
mode	P2P
mode	ROUTER
mode	UNKNOWN

ConferenceParticipant

{
  "id": "string",
  "userId": "string",
  "state": "HEALTHY",
  "streams": [
    {
      "id": "string",
      "type": "MIC",
      "metadata": {
        "property1": {},
        "property2": {}
      },
      "videoBitrate": 0
    }
  ],
  "metadata": {
    "property1": {},
    "property2": {}
  }
}

Properties

Name	Type	Required	Restrictions	Description
id	string	false	none	none
userId	string	false	none	none
state	string	false	none	none
streams	[ConferenceStream]	false	none	none
metadata	object	false	none	none
» additionalProperties	object	false	none	none

Enumerated Values

Property	Value
state	HEALTHY
state	SICK
state	UNKNOWN

ConferenceStream

{
  "id": "string",
  "type": "MIC",
  "metadata": {
    "property1": {},
    "property2": {}
  },
  "videoBitrate": 0
}

Properties

Name	Type	Required	Restrictions	Description
id	string	false	none	none
type	string	false	none	none
metadata	object	false	none	none
» additionalProperties	object	false	none	none
videoBitrate	integer(int32)	false	none	none

Enumerated Values

Property	Value
type	MIC
type	CAM
type	SCREEN
type	MIC_AND_CAM
type	UNKNOWN

Metadata

{
  "value": "string",
  "userId": "string",
  "userEndpointId": "string",
  "lastModified": "2019-08-24T14:15:22Z"
}

Properties

Name	Type	Required	Restrictions	Description
value	string	false	none	none
userId	string	false	none	none
userEndpointId	string	false	none	none
lastModified	string(date-time)	false	none	none

ConferenceSimpleView

{
  "id": "string",
  "mode": "string",
  "metadata": {
    "property1": {
      "value": "string",
      "userId": "string",
      "userEndpointId": "string",
      "lastModified": "2019-08-24T14:15:22Z"
    },
    "property2": {
      "value": "string",
      "userId": "string",
      "userEndpointId": "string",
      "lastModified": "2019-08-24T14:15:22Z"
    }
  },
  "participants": [
    {
      "id": "string",
      "endpoints": [
        {
          "id": "string",
          "state": "HEALTHY",
          "streams": [
            {
              "id": "string",
              "type": "string",
              "metadata": {
                "property1": {},
                "property2": {}
              }
            }
          ],
          "metadata": {
            "property1": {},
            "property2": {}
          }
        }
      ]
    }
  ],
  "version": 0
}

Properties

Name	Type	Required	Restrictions	Description
id	string	false	none	none
mode	string	false	none	none
metadata	object	false	none	none
» additionalProperties	Metadata	false	none	none
participants	[ConferenceSimpleViewParticipant]	false	none	none
version	integer(int64)	false	none	none

ConferenceSimpleViewParticipant

{
  "id": "string",
  "endpoints": [
    {
      "id": "string",
      "state": "HEALTHY",
      "streams": [
        {
          "id": "string",
          "type": "string",
          "metadata": {
            "property1": {},
            "property2": {}
          }
        }
      ],
      "metadata": {
        "property1": {},
        "property2": {}
      }
    }
  ]
}

Properties

Name	Type	Required	Restrictions	Description
id	string	false	none	none
endpoints	[ConferenceSimpleViewParticipantEndpoint]	false	none	none

ConferenceSimpleViewParticipantEndpoint

{
  "id": "string",
  "state": "HEALTHY",
  "streams": [
    {
      "id": "string",
      "type": "string",
      "metadata": {
        "property1": {},
        "property2": {}
      }
    }
  ],
  "metadata": {
    "property1": {},
    "property2": {}
  }
}

Properties

Name	Type	Required	Restrictions	Description
id	string	false	none	none
state	string	false	none	none
streams	[ConferenceSimpleViewParticipantEndpointStream]	false	none	none
metadata	object	false	none	none
» additionalProperties	object	false	none	none

Enumerated Values

Property	Value
state	HEALTHY
state	SICK
state	UNKNOWN

ConferenceSimpleViewParticipantEndpointStream

{
  "id": "string",
  "type": "string",
  "metadata": {
    "property1": {},
    "property2": {}
  }
}

Properties

Name	Type	Required	Restrictions	Description
id	string	false	none	none
type	string	false	none	none
metadata	object	false	none	none
» additionalProperties	object	false	none	none

ConferenceEvent

{
  "id": "string",
  "type": "string",
  "timestamp": "2019-08-24T14:15:22Z",
  "conferenceId": "string",
  "organizationId": "string",
  "conferenceVersion": 0
}

Properties

Name	Type	Required	Restrictions	Description
id	string	false	none	event unique id
type	string	false	none	event type
timestamp	string(date-time)	false	none	event time, format is "yyyy-MM-dd'T'HH:mm:ss.SSS'Z'"
conferenceId	string	false	none	the conference which this event belongs to
organizationId	string	false	none	the organizationId
conferenceVersion	integer(int64)	false	none	the conference version this event was produced- can be used for ordering and or deduplication. It contains the version of the conference when the event was generated or null for creation events