Zextras Carbonio Workstream Collaboration Meeting Api v1.3.1

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

Zextras Carbonio Workstream Collaboration Meeting HTTP APIs definition.

Base URLs:

http://localhost:10000

Meetings

getMeetingPublic

Code samples

# You can also use wget
curl -X GET http://localhost:10000/public/meetings/{meetingId} \
  -H 'Accept: application/json'

GET http://localhost:10000/public/meetings/{meetingId} HTTP/1.1
Host: localhost:10000
Accept: application/json


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

fetch('http://localhost:10000/public/meetings/{meetingId}',
{
  method: 'GET',

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

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

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

fetch('http://localhost:10000/public/meetings/{meetingId}',
{
  method: 'GET',

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

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json'
}

result = RestClient.get 'http://localhost:10000/public/meetings/{meetingId}',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.get('http://localhost:10000/public/meetings/{meetingId}', headers = headers)

print(r.json())

URL obj = new URL("http://localhost:10000/public/meetings/{meetingId}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "http://localhost:10000/public/meetings/{meetingId}", data)
    req.Header = headers

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

 'application/json',
);

$client = new \GuzzleHttp\Client();

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

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

 // ...

GET /public/meetings/{meetingId}

Retrieves public data of the meeting

Parameters

Name	In	Type	Required	Description
meetingId	path	string(uuid)	true	meeting identifier

Example responses

200 Response

{
  "name": "string"
}

Responses

Status	Meaning	Description	Schema
200	OK	Gets the public data of a meeting	PublicMeeting

listMeeting

Code samples

# You can also use wget
curl -X GET http://localhost:10000/meetings \
  -H 'Accept: application/json'

GET http://localhost:10000/meetings HTTP/1.1
Host: localhost:10000
Accept: application/json


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

fetch('http://localhost:10000/meetings',
{
  method: 'GET',

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

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

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

fetch('http://localhost:10000/meetings',
{
  method: 'GET',

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

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json'
}

result = RestClient.get 'http://localhost:10000/meetings',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.get('http://localhost:10000/meetings', headers = headers)

print(r.json())

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

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
    }

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

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

 'application/json',
);

$client = new \GuzzleHttp\Client();

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

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

 // ...

GET /meetings

Retrieves a list of every meeting the user has access to

Example responses

200 Response

[
  {
    "id": "497f6eca-6276-4993-bfeb-53cbbbba6f08",
    "name": "string",
    "roomId": "c3631f02-ff67-42b8-8775-18c47f52a678",
    "active": true,
    "participants": [
      {
        "userId": "2c4a230c-5085-4924-a3e1-25fb4fc5965b",
        "userType": "moderator",
        "queueId": "string",
        "audioStreamEnabled": true,
        "videoStreamEnabled": true,
        "screenStreamEnabled": true,
        "joinedAt": "2019-08-24T14:15:22Z"
      }
    ],
    "createdAt": "2019-08-24T14:15:22Z",
    "startedAt": "2019-08-24T14:15:22Z",
    "meetingType": "permanent",
    "recStartedAt": "2019-08-24T14:15:22Z",
    "recUserId": "afe41963-8cfa-48e9-b5e3-94c589db1681"
  }
]

Responses

Status	Meaning	Description	Schema
200	OK	List of every meeting that the user has access to	Inline

Response Schema

Status Code 200

Name	Type	Required	Restrictions	Description
anonymous	[Meeting]	false	none	[Meeting data]
» id	string(uuid)	false	read-only	meeting identifier
» name	string	false	none	The meeting name
» roomId	string(uuid)	false	read-only	room identifier
» active	boolean	false	none	Indicates if the meeting is active
» participants	[allOf]	false	none	[Meeting participant data]

allOf

Name	Type	Required	Restrictions	Description
»» anonymous	MeetingUser	false	none	Defines a user in the access list of a meeting
»»» userId	string(uuid)	false	none	user identifier
»»» userType	MeetingUserType	false	none	none

and

Name	Type	Required	Restrictions	Description
»» anonymous	object	false	none	none
»»» queueId	string	false	read-only	Reference to the user queue of the user
»»» audioStreamEnabled	boolean	false	read-only	indicates the audio stream status
»»» videoStreamEnabled	boolean	false	read-only	indicates the video stream status
»»» screenStreamEnabled	boolean	false	read-only	indicates the screen share stream status
»»» joinedAt	string(date-time)	false	read-only	participant joining timestamp

continued

Name	Type	Required	Restrictions	Description
» createdAt	string(date-time)	false	read-only	entity creation date
» startedAt	string(date-time)	false	read-only	meeting starting time
» meetingType	MeetingType	false	none	Defines the type of meeting, if permanent it will never be automatically deleted, if scheduled it will be removed after the expiration is passed
» recStartedAt	string(date-time)	false	read-only	start recording timestamp
» recUserId	string(uuid)	false	read-only	user who started the recording

Enumerated Values

Property	Value
userType	moderator
userType	registered
meetingType	permanent
meetingType	scheduled

createMeeting

Code samples

# You can also use wget
curl -X POST http://localhost:10000/meetings \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json'

POST http://localhost:10000/meetings HTTP/1.1
Host: localhost:10000
Content-Type: application/json
Accept: application/json

const inputBody = '{
  "name": "string",
  "roomId": "c3631f02-ff67-42b8-8775-18c47f52a678",
  "meetingType": "permanent",
  "expiration": "2019-08-24T14:15:22Z"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json'
};

fetch('http://localhost:10000/meetings',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

const fetch = require('node-fetch');
const inputBody = {
  "name": "string",
  "roomId": "c3631f02-ff67-42b8-8775-18c47f52a678",
  "meetingType": "permanent",
  "expiration": "2019-08-24T14:15:22Z"
};
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json'
};

fetch('http://localhost:10000/meetings',
{
  method: 'POST',
  body: JSON.stringify(inputBody),
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json'
}

result = RestClient.post 'http://localhost:10000/meetings',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.post('http://localhost:10000/meetings', headers = headers)

print(r.json())

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

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

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

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

 'application/json',
    'Accept' => 'application/json',
);

$client = new \GuzzleHttp\Client();

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

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

 // ...

POST /meetings

Creates a new meeting

Body parameter

{
  "name": "string",
  "roomId": "c3631f02-ff67-42b8-8775-18c47f52a678",
  "meetingType": "permanent",
  "expiration": "2019-08-24T14:15:22Z"
}

Parameters

Name	In	Type	Required	Description
body	body	NewMeetingData	true	Data to create a new meeting

Example responses

200 Response

{
  "id": "497f6eca-6276-4993-bfeb-53cbbbba6f08",
  "name": "string",
  "roomId": "c3631f02-ff67-42b8-8775-18c47f52a678",
  "active": true,
  "participants": [
    {
      "userId": "2c4a230c-5085-4924-a3e1-25fb4fc5965b",
      "userType": "moderator",
      "queueId": "string",
      "audioStreamEnabled": true,
      "videoStreamEnabled": true,
      "screenStreamEnabled": true,
      "joinedAt": "2019-08-24T14:15:22Z"
    }
  ],
  "createdAt": "2019-08-24T14:15:22Z",
  "startedAt": "2019-08-24T14:15:22Z",
  "meetingType": "permanent",
  "recStartedAt": "2019-08-24T14:15:22Z",
  "recUserId": "afe41963-8cfa-48e9-b5e3-94c589db1681"
}

Responses

Status	Meaning	Description	Schema
200	OK	The meeting just created	Meeting

getMeeting

Code samples

# You can also use wget
curl -X GET http://localhost:10000/meetings/{meetingId} \
  -H 'Accept: application/json'

GET http://localhost:10000/meetings/{meetingId} HTTP/1.1
Host: localhost:10000
Accept: application/json


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

fetch('http://localhost:10000/meetings/{meetingId}',
{
  method: 'GET',

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

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

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

fetch('http://localhost:10000/meetings/{meetingId}',
{
  method: 'GET',

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

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json'
}

result = RestClient.get 'http://localhost:10000/meetings/{meetingId}',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.get('http://localhost:10000/meetings/{meetingId}', headers = headers)

print(r.json())

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

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
    }

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

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

 'application/json',
);

$client = new \GuzzleHttp\Client();

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

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

 // ...

GET /meetings/{meetingId}

Retrieves the requested meeting

Parameters

Name	In	Type	Required	Description
meetingId	path	string(uuid)	true	meeting identifier

Example responses

200 Response

{
  "id": "497f6eca-6276-4993-bfeb-53cbbbba6f08",
  "name": "string",
  "roomId": "c3631f02-ff67-42b8-8775-18c47f52a678",
  "active": true,
  "participants": [
    {
      "userId": "2c4a230c-5085-4924-a3e1-25fb4fc5965b",
      "userType": "moderator",
      "queueId": "string",
      "audioStreamEnabled": true,
      "videoStreamEnabled": true,
      "screenStreamEnabled": true,
      "joinedAt": "2019-08-24T14:15:22Z"
    }
  ],
  "createdAt": "2019-08-24T14:15:22Z",
  "startedAt": "2019-08-24T14:15:22Z",
  "meetingType": "permanent",
  "recStartedAt": "2019-08-24T14:15:22Z",
  "recUserId": "afe41963-8cfa-48e9-b5e3-94c589db1681"
}

Responses

Status	Meaning	Description	Schema
200	OK	Gets the requested meeting data	Meeting
401	Unauthorized	User not authorized	None
403	Forbidden	The requester could not access the resource	None
404	Not Found	The requested resource was not found	None

deleteMeeting

Code samples

# You can also use wget
curl -X DELETE http://localhost:10000/meetings/{meetingId}

DELETE http://localhost:10000/meetings/{meetingId} HTTP/1.1
Host: localhost:10000


fetch('http://localhost:10000/meetings/{meetingId}',
{
  method: 'DELETE'

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

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

fetch('http://localhost:10000/meetings/{meetingId}',
{
  method: 'DELETE'

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

require 'rest-client'
require 'json'

result = RestClient.delete 'http://localhost:10000/meetings/{meetingId}',
  params: {
  }

p JSON.parse(result)

import requests

r = requests.delete('http://localhost:10000/meetings/{meetingId}')

print(r.json())

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

package main

import (
       "bytes"
       "net/http"
)

func main() {

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "http://localhost:10000/meetings/{meetingId}", data)
    req.Header = headers

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

request('DELETE','http://localhost:10000/meetings/{meetingId}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

DELETE /meetings/{meetingId}

Deletes the requested meeting

Parameters

Name	In	Type	Required	Description
meetingId	path	string(uuid)	true	meeting identifier

Responses

Status	Meaning	Description	Schema
204	No Content	The meeting was deleted successfully	None
401	Unauthorized	User not authorized	None
403	Forbidden	The requester could not access the resource	None
404	Not Found	The requested resource was not found	None

startMeeting

Code samples

# You can also use wget
curl -X POST http://localhost:10000/meetings/{meetingId}/start \
  -H 'Accept: application/json'

POST http://localhost:10000/meetings/{meetingId}/start HTTP/1.1
Host: localhost:10000
Accept: application/json


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

fetch('http://localhost:10000/meetings/{meetingId}/start',
{
  method: 'POST',

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

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

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

fetch('http://localhost:10000/meetings/{meetingId}/start',
{
  method: 'POST',

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

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json'
}

result = RestClient.post 'http://localhost:10000/meetings/{meetingId}/start',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.post('http://localhost:10000/meetings/{meetingId}/start', headers = headers)

print(r.json())

URL obj = new URL("http://localhost:10000/meetings/{meetingId}/start");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "http://localhost:10000/meetings/{meetingId}/start", data)
    req.Header = headers

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

 'application/json',
);

$client = new \GuzzleHttp\Client();

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

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

 // ...

POST /meetings/{meetingId}/start

Starts the current meeting

Parameters

Name	In	Type	Required	Description
meetingId	path	string(uuid)	true	meeting identifier

Example responses

200 Response

{
  "id": "497f6eca-6276-4993-bfeb-53cbbbba6f08",
  "name": "string",
  "roomId": "c3631f02-ff67-42b8-8775-18c47f52a678",
  "active": true,
  "participants": [
    {
      "userId": "2c4a230c-5085-4924-a3e1-25fb4fc5965b",
      "userType": "moderator",
      "queueId": "string",
      "audioStreamEnabled": true,
      "videoStreamEnabled": true,
      "screenStreamEnabled": true,
      "joinedAt": "2019-08-24T14:15:22Z"
    }
  ],
  "createdAt": "2019-08-24T14:15:22Z",
  "startedAt": "2019-08-24T14:15:22Z",
  "meetingType": "permanent",
  "recStartedAt": "2019-08-24T14:15:22Z",
  "recUserId": "afe41963-8cfa-48e9-b5e3-94c589db1681"
}

Responses

Status	Meaning	Description	Schema
200	OK	The meeting was started successfully	Meeting
401	Unauthorized	User not authorized	None
403	Forbidden	The requester could not access the resource	None
404	Not Found	The requested resource was not found	None

stopMeeting

Code samples

# You can also use wget
curl -X POST http://localhost:10000/meetings/{meetingId}/stop \
  -H 'Accept: application/json'

POST http://localhost:10000/meetings/{meetingId}/stop HTTP/1.1
Host: localhost:10000
Accept: application/json


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

fetch('http://localhost:10000/meetings/{meetingId}/stop',
{
  method: 'POST',

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

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

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

fetch('http://localhost:10000/meetings/{meetingId}/stop',
{
  method: 'POST',

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

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json'
}

result = RestClient.post 'http://localhost:10000/meetings/{meetingId}/stop',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.post('http://localhost:10000/meetings/{meetingId}/stop', headers = headers)

print(r.json())

URL obj = new URL("http://localhost:10000/meetings/{meetingId}/stop");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "http://localhost:10000/meetings/{meetingId}/stop", data)
    req.Header = headers

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

 'application/json',
);

$client = new \GuzzleHttp\Client();

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

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

 // ...

POST /meetings/{meetingId}/stop

Stops the current meeting

Parameters

Name	In	Type	Required	Description
meetingId	path	string(uuid)	true	meeting identifier

Example responses

200 Response

{
  "id": "497f6eca-6276-4993-bfeb-53cbbbba6f08",
  "name": "string",
  "roomId": "c3631f02-ff67-42b8-8775-18c47f52a678",
  "active": true,
  "participants": [
    {
      "userId": "2c4a230c-5085-4924-a3e1-25fb4fc5965b",
      "userType": "moderator",
      "queueId": "string",
      "audioStreamEnabled": true,
      "videoStreamEnabled": true,
      "screenStreamEnabled": true,
      "joinedAt": "2019-08-24T14:15:22Z"
    }
  ],
  "createdAt": "2019-08-24T14:15:22Z",
  "startedAt": "2019-08-24T14:15:22Z",
  "meetingType": "permanent",
  "recStartedAt": "2019-08-24T14:15:22Z",
  "recUserId": "afe41963-8cfa-48e9-b5e3-94c589db1681"
}

Responses

Status	Meaning	Description	Schema
200	OK	The meeting was stopped successfully	Meeting
401	Unauthorized	User not authorized	None
403	Forbidden	The requester could not access the resource	None
404	Not Found	The requested resource was not found	None

joinMeeting

Code samples

# You can also use wget
curl -X POST http://localhost:10000/meetings/{meetingId}/join \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json'

POST http://localhost:10000/meetings/{meetingId}/join HTTP/1.1
Host: localhost:10000
Content-Type: application/json
Accept: application/json

const inputBody = '{
  "audioStreamEnabled": false,
  "videoStreamEnabled": false
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json'
};

fetch('http://localhost:10000/meetings/{meetingId}/join',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

const fetch = require('node-fetch');
const inputBody = {
  "audioStreamEnabled": false,
  "videoStreamEnabled": false
};
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json'
};

fetch('http://localhost:10000/meetings/{meetingId}/join',
{
  method: 'POST',
  body: JSON.stringify(inputBody),
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json'
}

result = RestClient.post 'http://localhost:10000/meetings/{meetingId}/join',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.post('http://localhost:10000/meetings/{meetingId}/join', headers = headers)

print(r.json())

URL obj = new URL("http://localhost:10000/meetings/{meetingId}/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());

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "http://localhost:10000/meetings/{meetingId}/join", data)
    req.Header = headers

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

 'application/json',
    'Accept' => 'application/json',
);

$client = new \GuzzleHttp\Client();

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

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

 // ...

POST /meetings/{meetingId}/join

Adds the current user to the specified meeting

Body parameter

{
  "audioStreamEnabled": false,
  "videoStreamEnabled": false
}

Parameters

Name	In	Type	Required	Description
meetingId	path	string(uuid)	true	meeting identifier
body	body	JoinSettings	true	user request containing its streams settings to join a meeting

Example responses

200 Response

{
  "status": "ACCEPTED"
}

Responses

Status	Meaning	Description	Schema
200	OK	The result of the join operation for the meeting	JoinMeetingResult
401	Unauthorized	User not authorized	None
403	Forbidden	The requester could not access the resource	None
404	Not Found	The requested resource was not found	None

leaveMeeting

Code samples

# You can also use wget
curl -X POST http://localhost:10000/meetings/{meetingId}/leave

POST http://localhost:10000/meetings/{meetingId}/leave HTTP/1.1
Host: localhost:10000


fetch('http://localhost:10000/meetings/{meetingId}/leave',
{
  method: 'POST'

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

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

fetch('http://localhost:10000/meetings/{meetingId}/leave',
{
  method: 'POST'

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

require 'rest-client'
require 'json'

result = RestClient.post 'http://localhost:10000/meetings/{meetingId}/leave',
  params: {
  }

p JSON.parse(result)

import requests

r = requests.post('http://localhost:10000/meetings/{meetingId}/leave')

print(r.json())

URL obj = new URL("http://localhost:10000/meetings/{meetingId}/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());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "http://localhost:10000/meetings/{meetingId}/leave", data)
    req.Header = headers

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

request('POST','http://localhost:10000/meetings/{meetingId}/leave', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

POST /meetings/{meetingId}/leave

Remove the current user to the specified meeting

Parameters

Name	In	Type	Required	Description
meetingId	path	string(uuid)	true	meeting identifier

Responses

Status	Meaning	Description	Schema
204	No Content	The user exited the meeting successfully	None
401	Unauthorized	User not authorized	None
403	Forbidden	The requester could not access the resource	None
404	Not Found	The requested resource was not found	None

getQueue

Code samples

# You can also use wget
curl -X GET http://localhost:10000/meetings/{meetingId}/queue \
  -H 'Accept: application/json'

GET http://localhost:10000/meetings/{meetingId}/queue HTTP/1.1
Host: localhost:10000
Accept: application/json


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

fetch('http://localhost:10000/meetings/{meetingId}/queue',
{
  method: 'GET',

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

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

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

fetch('http://localhost:10000/meetings/{meetingId}/queue',
{
  method: 'GET',

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

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json'
}

result = RestClient.get 'http://localhost:10000/meetings/{meetingId}/queue',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.get('http://localhost:10000/meetings/{meetingId}/queue', headers = headers)

print(r.json())

URL obj = new URL("http://localhost:10000/meetings/{meetingId}/queue");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "http://localhost:10000/meetings/{meetingId}/queue", data)
    req.Header = headers

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

 'application/json',
);

$client = new \GuzzleHttp\Client();

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

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

 // ...

GET /meetings/{meetingId}/queue

Retrieve the list of people in queue for the meeting

Parameters

Name	In	Type	Required	Description
meetingId	path	string(uuid)	true	meeting identifier

Example responses

200 Response

{
  "users": [
    "497f6eca-6276-4993-bfeb-53cbbbba6f08"
  ]
}

Responses

Status	Meaning	Description	Schema
200	OK	The list of queued users	QueuedUsers
401	Unauthorized	User not authorized	None
403	Forbidden	The requester could not access the resource	None
404	Not Found	The requested resource was not found	None

updateQueuedUser

Code samples

# You can also use wget
curl -X POST http://localhost:10000/meetings/{meetingId}/queue/{userId} \
  -H 'Content-Type: application/json'

POST http://localhost:10000/meetings/{meetingId}/queue/{userId} HTTP/1.1
Host: localhost:10000
Content-Type: application/json

const inputBody = '{
  "status": "ACCEPTED"
}';
const headers = {
  'Content-Type':'application/json'
};

fetch('http://localhost:10000/meetings/{meetingId}/queue/{userId}',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

const fetch = require('node-fetch');
const inputBody = {
  "status": "ACCEPTED"
};
const headers = {
  'Content-Type':'application/json'
};

fetch('http://localhost:10000/meetings/{meetingId}/queue/{userId}',
{
  method: 'POST',
  body: JSON.stringify(inputBody),
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json'
}

result = RestClient.post 'http://localhost:10000/meetings/{meetingId}/queue/{userId}',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.post('http://localhost:10000/meetings/{meetingId}/queue/{userId}', headers = headers)

print(r.json())

URL obj = new URL("http://localhost:10000/meetings/{meetingId}/queue/{userId}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "http://localhost:10000/meetings/{meetingId}/queue/{userId}", data)
    req.Header = headers

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

 'application/json',
);

$client = new \GuzzleHttp\Client();

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

try {
    $response = $client->request('POST','http://localhost:10000/meetings/{meetingId}/queue/{userId}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

POST /meetings/{meetingId}/queue/{userId}

Updates the status of a queued user

Body parameter

{
  "status": "ACCEPTED"
}

Parameters

Name	In	Type	Required	Description
meetingId	path	string(uuid)	true	meeting identifier
userId	path	string(uuid)	true	user identifier
body	body	QueuedUserUpdate	true	request to approve or reject a user inside a meeting

Responses

Status	Meaning	Description	Schema
204	No Content	The queued user was updated successfully	None
401	Unauthorized	User not authorized	None
403	Forbidden	The requester could not access the resource	None
404	Not Found	The requested resource was not found	None

updateMediaStream

Code samples

# You can also use wget
curl -X PUT http://localhost:10000/meetings/{meetingId}/media \
  -H 'Content-Type: application/json'

PUT http://localhost:10000/meetings/{meetingId}/media HTTP/1.1
Host: localhost:10000
Content-Type: application/json

const inputBody = '{
  "type": "video",
  "enabled": true,
  "sdp": "string"
}';
const headers = {
  'Content-Type':'application/json'
};

fetch('http://localhost:10000/meetings/{meetingId}/media',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

const fetch = require('node-fetch');
const inputBody = {
  "type": "video",
  "enabled": true,
  "sdp": "string"
};
const headers = {
  'Content-Type':'application/json'
};

fetch('http://localhost:10000/meetings/{meetingId}/media',
{
  method: 'PUT',
  body: JSON.stringify(inputBody),
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json'
}

result = RestClient.put 'http://localhost:10000/meetings/{meetingId}/media',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.put('http://localhost:10000/meetings/{meetingId}/media', headers = headers)

print(r.json())

URL obj = new URL("http://localhost:10000/meetings/{meetingId}/media");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PUT");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "http://localhost:10000/meetings/{meetingId}/media", data)
    req.Header = headers

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

 'application/json',
);

$client = new \GuzzleHttp\Client();

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

try {
    $response = $client->request('PUT','http://localhost:10000/meetings/{meetingId}/media', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

PUT /meetings/{meetingId}/media

Update media stream status for the current session

Body parameter

{
  "type": "video",
  "enabled": true,
  "sdp": "string"
}

Parameters

Name	In	Type	Required	Description
meetingId	path	string(uuid)	true	meeting identifier
body	body	MediaStreamSettings	true	user request to update a media stream status

Responses

Status	Meaning	Description	Schema
204	No Content	The status of media stream changed successfully	None
401	Unauthorized	User not authorized	None
403	Forbidden	The requester could not access the resource	None
404	Not Found	The requested resource was not found	None

answerRtcMediaStream

Code samples

# You can also use wget
curl -X PUT http://localhost:10000/meetings/{meetingId}/media/answer \
  -H 'Content-Type: application/json'

PUT http://localhost:10000/meetings/{meetingId}/media/answer HTTP/1.1
Host: localhost:10000
Content-Type: application/json

const inputBody = '{
  "sdp": "string"
}';
const headers = {
  'Content-Type':'application/json'
};

fetch('http://localhost:10000/meetings/{meetingId}/media/answer',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

const fetch = require('node-fetch');
const inputBody = {
  "sdp": "string"
};
const headers = {
  'Content-Type':'application/json'
};

fetch('http://localhost:10000/meetings/{meetingId}/media/answer',
{
  method: 'PUT',
  body: JSON.stringify(inputBody),
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json'
}

result = RestClient.put 'http://localhost:10000/meetings/{meetingId}/media/answer',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.put('http://localhost:10000/meetings/{meetingId}/media/answer', headers = headers)

print(r.json())

URL obj = new URL("http://localhost:10000/meetings/{meetingId}/media/answer");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PUT");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "http://localhost:10000/meetings/{meetingId}/media/answer", data)
    req.Header = headers

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

 'application/json',
);

$client = new \GuzzleHttp\Client();

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

try {
    $response = $client->request('PUT','http://localhost:10000/meetings/{meetingId}/media/answer', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

PUT /meetings/{meetingId}/media/answer

Complete WebRTC negotiation for media streams for the current session

Body parameter

{
  "sdp": "string"
}

Parameters

Name	In	Type	Required	Description
meetingId	path	string(uuid)	true	meeting identifier
body	body	SessionDescriptionProtocol	true	user request to send a rtc session description related to media stream for WebRTC negotiation

Responses

Status	Meaning	Description	Schema
204	No Content	The answer related to the media stream has been processed and sent successfully	None
401	Unauthorized	User not authorized	None
403	Forbidden	The requester could not access the resource	None
404	Not Found	The requested resource was not found	None

updateSubscriptionsMediaStream

Code samples

# You can also use wget
curl -X PUT http://localhost:10000/meetings/{meetingId}/media/subscribe \
  -H 'Content-Type: application/json'

PUT http://localhost:10000/meetings/{meetingId}/media/subscribe HTTP/1.1
Host: localhost:10000
Content-Type: application/json

const inputBody = '{
  "subscribe": [
    {
      "userId": "string",
      "type": "video"
    }
  ],
  "unsubscribe": [
    {
      "userId": "string",
      "type": "video"
    }
  ]
}';
const headers = {
  'Content-Type':'application/json'
};

fetch('http://localhost:10000/meetings/{meetingId}/media/subscribe',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

const fetch = require('node-fetch');
const inputBody = {
  "subscribe": [
    {
      "userId": "string",
      "type": "video"
    }
  ],
  "unsubscribe": [
    {
      "userId": "string",
      "type": "video"
    }
  ]
};
const headers = {
  'Content-Type':'application/json'
};

fetch('http://localhost:10000/meetings/{meetingId}/media/subscribe',
{
  method: 'PUT',
  body: JSON.stringify(inputBody),
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json'
}

result = RestClient.put 'http://localhost:10000/meetings/{meetingId}/media/subscribe',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.put('http://localhost:10000/meetings/{meetingId}/media/subscribe', headers = headers)

print(r.json())

URL obj = new URL("http://localhost:10000/meetings/{meetingId}/media/subscribe");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PUT");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "http://localhost:10000/meetings/{meetingId}/media/subscribe", data)
    req.Header = headers

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

 'application/json',
);

$client = new \GuzzleHttp\Client();

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

try {
    $response = $client->request('PUT','http://localhost:10000/meetings/{meetingId}/media/subscribe', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

PUT /meetings/{meetingId}/media/subscribe

Update subscriptions of the current session to the desired media streams

Body parameter

{
  "subscribe": [
    {
      "userId": "string",
      "type": "video"
    }
  ],
  "unsubscribe": [
    {
      "userId": "string",
      "type": "video"
    }
  ]
}

Parameters

Name	In	Type	Required	Description
meetingId	path	string(uuid)	true	meeting identifier
body	body	SubscriptionUpdates	true	user request to update subscriptions to the desired media stream

Responses

Status	Meaning	Description	Schema
204	No Content	The user subscribed to media streams successfully	None
401	Unauthorized	User not authorized	None
403	Forbidden	The requester could not access the resource	None
404	Not Found	The requested resource was not found	None

updateAudioStream

Code samples

# You can also use wget
curl -X PUT http://localhost:10000/meetings/{meetingId}/audio \
  -H 'Content-Type: application/json'

PUT http://localhost:10000/meetings/{meetingId}/audio HTTP/1.1
Host: localhost:10000
Content-Type: application/json

const inputBody = '{
  "enabled": true,
  "userToModerate": "string"
}';
const headers = {
  'Content-Type':'application/json'
};

fetch('http://localhost:10000/meetings/{meetingId}/audio',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

const fetch = require('node-fetch');
const inputBody = {
  "enabled": true,
  "userToModerate": "string"
};
const headers = {
  'Content-Type':'application/json'
};

fetch('http://localhost:10000/meetings/{meetingId}/audio',
{
  method: 'PUT',
  body: JSON.stringify(inputBody),
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json'
}

result = RestClient.put 'http://localhost:10000/meetings/{meetingId}/audio',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.put('http://localhost:10000/meetings/{meetingId}/audio', headers = headers)

print(r.json())

URL obj = new URL("http://localhost:10000/meetings/{meetingId}/audio");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PUT");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "http://localhost:10000/meetings/{meetingId}/audio", data)
    req.Header = headers

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

 'application/json',
);

$client = new \GuzzleHttp\Client();

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

try {
    $response = $client->request('PUT','http://localhost:10000/meetings/{meetingId}/audio', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

PUT /meetings/{meetingId}/audio

Update audio stream status for a user, a moderator can disable audio for another user

Body parameter

{
  "enabled": true,
  "userToModerate": "string"
}

Parameters

Name	In	Type	Required	Description
meetingId	path	string(uuid)	true	meeting identifier
body	body	AudioStreamSettings	true	user request to update a meeting stream status

Responses

Status	Meaning	Description	Schema
204	No Content	The status of audio stream changed successfully	None
401	Unauthorized	User not authorized	None
403	Forbidden	The requester could not access the resource	None
404	Not Found	The requested resource was not found	None

offerRtcAudioStream

Code samples

# You can also use wget
curl -X PUT http://localhost:10000/meetings/{meetingId}/audio/offer \
  -H 'Content-Type: application/json'

PUT http://localhost:10000/meetings/{meetingId}/audio/offer HTTP/1.1
Host: localhost:10000
Content-Type: application/json

const inputBody = '{
  "sdp": "string"
}';
const headers = {
  'Content-Type':'application/json'
};

fetch('http://localhost:10000/meetings/{meetingId}/audio/offer',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

const fetch = require('node-fetch');
const inputBody = {
  "sdp": "string"
};
const headers = {
  'Content-Type':'application/json'
};

fetch('http://localhost:10000/meetings/{meetingId}/audio/offer',
{
  method: 'PUT',
  body: JSON.stringify(inputBody),
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json'
}

result = RestClient.put 'http://localhost:10000/meetings/{meetingId}/audio/offer',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.put('http://localhost:10000/meetings/{meetingId}/audio/offer', headers = headers)

print(r.json())

URL obj = new URL("http://localhost:10000/meetings/{meetingId}/audio/offer");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PUT");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "http://localhost:10000/meetings/{meetingId}/audio/offer", data)
    req.Header = headers

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

 'application/json',
);

$client = new \GuzzleHttp\Client();

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

try {
    $response = $client->request('PUT','http://localhost:10000/meetings/{meetingId}/audio/offer', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

PUT /meetings/{meetingId}/audio/offer

Start WebRTC negotiation for audio stream for the current session

Body parameter

{
  "sdp": "string"
}

Parameters

Name	In	Type	Required	Description
meetingId	path	string(uuid)	true	meeting identifier
body	body	SessionDescriptionProtocol	true	user request to send a rtc session description related to media stream for WebRTC negotiation

Responses

Status	Meaning	Description	Schema
204	No Content	The offer related to the audio stream has been processed and sent successfully	None
401	Unauthorized	User not authorized	None
403	Forbidden	The requester could not access the resource	None
404	Not Found	The requested resource was not found	None

startRecording

Code samples

# You can also use wget
curl -X POST http://localhost:10000/meetings/{meetingId}/startRecording

POST http://localhost:10000/meetings/{meetingId}/startRecording HTTP/1.1
Host: localhost:10000


fetch('http://localhost:10000/meetings/{meetingId}/startRecording',
{
  method: 'POST'

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

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

fetch('http://localhost:10000/meetings/{meetingId}/startRecording',
{
  method: 'POST'

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

require 'rest-client'
require 'json'

result = RestClient.post 'http://localhost:10000/meetings/{meetingId}/startRecording',
  params: {
  }

p JSON.parse(result)

import requests

r = requests.post('http://localhost:10000/meetings/{meetingId}/startRecording')

print(r.json())

URL obj = new URL("http://localhost:10000/meetings/{meetingId}/startRecording");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "http://localhost:10000/meetings/{meetingId}/startRecording", data)
    req.Header = headers

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

request('POST','http://localhost:10000/meetings/{meetingId}/startRecording', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

POST /meetings/{meetingId}/startRecording

Start recording on the specified meeting

Parameters

Name	In	Type	Required	Description
meetingId	path	string(uuid)	true	meeting identifier

Responses

Status	Meaning	Description	Schema
204	No Content	The recording has been started successfully	None
401	Unauthorized	User not authorized	None
403	Forbidden	The requester could not access the resource	None
404	Not Found	The requested resource was not found	None

stopRecording

Code samples

# You can also use wget
curl -X POST http://localhost:10000/meetings/{meetingId}/stopRecording \
  -H 'Content-Type: application/json'

POST http://localhost:10000/meetings/{meetingId}/stopRecording HTTP/1.1
Host: localhost:10000
Content-Type: application/json

const inputBody = '{
  "name": "string",
  "folderId": "string"
}';
const headers = {
  'Content-Type':'application/json'
};

fetch('http://localhost:10000/meetings/{meetingId}/stopRecording',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

const fetch = require('node-fetch');
const inputBody = {
  "name": "string",
  "folderId": "string"
};
const headers = {
  'Content-Type':'application/json'
};

fetch('http://localhost:10000/meetings/{meetingId}/stopRecording',
{
  method: 'POST',
  body: JSON.stringify(inputBody),
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json'
}

result = RestClient.post 'http://localhost:10000/meetings/{meetingId}/stopRecording',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.post('http://localhost:10000/meetings/{meetingId}/stopRecording', headers = headers)

print(r.json())

URL obj = new URL("http://localhost:10000/meetings/{meetingId}/stopRecording");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "http://localhost:10000/meetings/{meetingId}/stopRecording", data)
    req.Header = headers

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

 'application/json',
);

$client = new \GuzzleHttp\Client();

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

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

 // ...

POST /meetings/{meetingId}/stopRecording

Stop recording on the specified meeting

Body parameter

{
  "name": "string",
  "folderId": "string"
}

Parameters

Name	In	Type	Required	Description
meetingId	path	string(uuid)	true	meeting identifier
body	body	RecordingFields	true	user request to stop recording on a specific meeting

Responses

Status	Meaning	Description	Schema
204	No Content	The recording has been stopped successfully	None
401	Unauthorized	User not authorized	None
403	Forbidden	The requester could not access the resource	None
404	Not Found	The requested resource was not found	None

Schemas

NewMeetingData

{
  "name": "string",
  "roomId": "c3631f02-ff67-42b8-8775-18c47f52a678",
  "meetingType": "permanent",
  "expiration": "2019-08-24T14:15:22Z"
}

Properties

Name	Type	Required	Restrictions	Description
name	string	true	none	none
roomId	string(uuid)	false	none	none
meetingType	MeetingType	true	none	Defines the type of meeting, if permanent it will never be automatically deleted, if scheduled it will be removed after the expiration is passed
expiration	string(date-time)	false	none	This field is only used for scheduled meetings to indicate when the meeting will no more be necessary

JoinMeetingResult

{
  "status": "ACCEPTED"
}

Properties

Name	Type	Required	Restrictions	Description
status	JoinStatus	false	none	none

QueuedUsers

{
  "users": [
    "497f6eca-6276-4993-bfeb-53cbbbba6f08"
  ]
}

Properties

Name	Type	Required	Restrictions	Description
users	[string]	false	none	none

MeetingUser

{
  "userId": "2c4a230c-5085-4924-a3e1-25fb4fc5965b",
  "userType": "moderator"
}

Defines a user in the access list of a meeting

Properties

Name	Type	Required	Restrictions	Description
userId	string(uuid)	false	none	user identifier
userType	MeetingUserType	false	none	none

MeetingType

"permanent"

Defines the type of meeting, if permanent it will never be automatically deleted, if scheduled it will be removed after the expiration is passed

Properties

Name	Type	Required	Restrictions	Description
anonymous	string	false	none	Defines the type of meeting, if permanent it will never be automatically deleted, if scheduled it will be removed after the expiration is passed

Enumerated Values

Property	Value
anonymous	permanent
anonymous	scheduled

MeetingUserType

"moderator"

Properties

Name	Type	Required	Restrictions	Description
anonymous	string	false	none	none

Enumerated Values

Property	Value
anonymous	moderator
anonymous	registered

QueueUpdateStatus

"ACCEPTED"

Properties

Name	Type	Required	Restrictions	Description
anonymous	string	false	none	none

Enumerated Values

Property	Value
anonymous	ACCEPTED
anonymous	REJECTED

JoinStatus

"ACCEPTED"

Properties

Name	Type	Required	Restrictions	Description
anonymous	string	false	none	none

Enumerated Values

Property	Value
anonymous	ACCEPTED
anonymous	WAITING

Participant

{
  "userId": "2c4a230c-5085-4924-a3e1-25fb4fc5965b",
  "userType": "moderator",
  "queueId": "string",
  "audioStreamEnabled": true,
  "videoStreamEnabled": true,
  "screenStreamEnabled": true,
  "joinedAt": "2019-08-24T14:15:22Z"
}

Meeting participant data

Properties

allOf

Name	Type	Required	Restrictions	Description
anonymous	MeetingUser	false	none	Defines a user in the access list of a meeting

and

Name	Type	Required	Restrictions	Description
anonymous	object	false	none	none
» queueId	string	false	read-only	Reference to the user queue of the user
» audioStreamEnabled	boolean	false	read-only	indicates the audio stream status
» videoStreamEnabled	boolean	false	read-only	indicates the video stream status
» screenStreamEnabled	boolean	false	read-only	indicates the screen share stream status
» joinedAt	string(date-time)	false	read-only	participant joining timestamp

Meeting

{
  "id": "497f6eca-6276-4993-bfeb-53cbbbba6f08",
  "name": "string",
  "roomId": "c3631f02-ff67-42b8-8775-18c47f52a678",
  "active": true,
  "participants": [
    {
      "userId": "2c4a230c-5085-4924-a3e1-25fb4fc5965b",
      "userType": "moderator",
      "queueId": "string",
      "audioStreamEnabled": true,
      "videoStreamEnabled": true,
      "screenStreamEnabled": true,
      "joinedAt": "2019-08-24T14:15:22Z"
    }
  ],
  "createdAt": "2019-08-24T14:15:22Z",
  "startedAt": "2019-08-24T14:15:22Z",
  "meetingType": "permanent",
  "recStartedAt": "2019-08-24T14:15:22Z",
  "recUserId": "afe41963-8cfa-48e9-b5e3-94c589db1681"
}

Meeting data

Properties

Name	Type	Required	Restrictions	Description
id	string(uuid)	false	read-only	meeting identifier
name	string	false	none	The meeting name
roomId	string(uuid)	false	read-only	room identifier
active	boolean	false	none	Indicates if the meeting is active
participants	[Participant]	false	none	[Meeting participant data]
createdAt	string(date-time)	false	read-only	entity creation date
startedAt	string(date-time)	false	read-only	meeting starting time
meetingType	MeetingType	false	none	Defines the type of meeting, if permanent it will never be automatically deleted, if scheduled it will be removed after the expiration is passed
recStartedAt	string(date-time)	false	read-only	start recording timestamp
recUserId	string(uuid)	false	read-only	user who started the recording

PublicMeeting

{
  "name": "string"
}

public Meeting data

Properties

Name	Type	Required	Restrictions	Description
name	string	false	none	the Meeting name

JoinSettings

{
  "audioStreamEnabled": false,
  "videoStreamEnabled": false
}

user's streams settings to join a meeting

Properties

Name	Type	Required	Restrictions	Description
audioStreamEnabled	boolean	true	none	indicates the audio stream status to join the meeting
videoStreamEnabled	boolean	true	none	indicates the video stream status to join the meeting

MediaStreamSettings

{
  "type": "video",
  "enabled": true,
  "sdp": "string"
}

settings to apply on user's media stream

Properties

Name	Type	Required	Restrictions	Description
type	string	true	none	indicates the media stream type
enabled	boolean	true	none	indicates the status to change the media stream to
sdp	string	false	none	indicates the descriptor of the session

Enumerated Values

Property	Value
type	video
type	screen

AudioStreamSettings

{
  "enabled": true,
  "userToModerate": "string"
}

settings to apply on user's audio stream

Properties

Name	Type	Required	Restrictions	Description
enabled	boolean	true	none	indicates the status to change the audio stream to
userToModerate	string	false	none	optional user to mute if i'm a moderator, only works if enabled is false

SessionDescriptionProtocol

{
  "sdp": "string"
}

contains sdp descriptor needed for a media stream to perform WebRTC negotiation

Properties

Name	Type	Required	Restrictions	Description
sdp	string	true	none	indicates the descriptor of the session

SubscriptionUpdates

{
  "subscribe": [
    {
      "userId": "string",
      "type": "video"
    }
  ],
  "unsubscribe": [
    {
      "userId": "string",
      "type": "video"
    }
  ]
}

subscriptions updates related to media streams

Properties

Name	Type	Required	Restrictions	Description
subscribe	[MediaStream]	true	none	indicates the media streams which user wants to subscribe to
unsubscribe	[MediaStream]	true	none	indicates the media streams which user wants to unsubscribe to

MediaStream

{
  "userId": "string",
  "type": "video"
}

representation of meeting media stream

Properties

Name	Type	Required	Restrictions	Description
userId	string	true	none	user identifier which owns the related media stream
type	string	true	none	indicates the media stream type

Enumerated Values

Property	Value
type	video
type	screen

QueuedUserUpdate

{
  "status": "ACCEPTED"
}

Queued user update data

Properties

Name	Type	Required	Restrictions	Description
status	QueueUpdateStatus	false	none	none

RecordingFields

{
  "name": "string",
  "folderId": "string"
}

Recording data used to upload it on Files service

Properties

Name	Type	Required	Restrictions	Description
name	string	true	none	recording name
folderId	string	true	none	folder id where the recording will be saved