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:
getMeetingPublic
Code samples
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();
$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 ) {
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
This operation does not require authentication
listMeeting
Code samples
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();
$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 ) {
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
This operation does not require authentication
createMeeting
Code samples
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();
$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 ) {
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
This operation does not require authentication
getMeeting
Code samples
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();
$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 ) {
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
This operation does not require authentication
deleteMeeting
Code samples
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 ) {
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
This operation does not require authentication
startMeeting
Code samples
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();
$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 ) {
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
This operation does not require authentication
stopMeeting
Code samples
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();
$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 ) {
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
This operation does not require authentication
joinMeeting
Code samples
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();
$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 ) {
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
This operation does not require authentication
leaveMeeting
Code samples
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 ) {
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
This operation does not require authentication
getQueue
Code samples
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();
$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 ) {
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
This operation does not require authentication
updateQueuedUser
Code samples
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();
$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 ) {
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
This operation does not require authentication
Code samples
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();
$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 ) {
print_r($e ->getMessage());
}
PUT /meetings/{meetingId}/media
Update media stream status for the current session
Body parameter
{
"type" : "video" ,
"enabled" : true ,
"sdp" : "string"
}
Name
In
Type
Required
Description
meetingId
path
string(uuid)
true
meeting identifier
body
body
MediaStreamSettings
true
user request to update a media stream status
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
This operation does not require authentication
Code samples
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();
$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 ) {
print_r($e ->getMessage());
}
PUT /meetings/{meetingId}/media/answer
Complete WebRTC negotiation for media streams for the current session
Body parameter
{
"sdp" : "string"
}
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
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
This operation does not require authentication
Code samples
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();
$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 ) {
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"
}
]
}
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
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
This operation does not require authentication
updateAudioStream
Code samples
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();
$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 ) {
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
This operation does not require authentication
offerRtcAudioStream
Code samples
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();
$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 ) {
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
This operation does not require authentication
startRecording
Code samples
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 ) {
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
This operation does not require authentication
stopRecording
Code samples
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();
$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 ) {
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
This operation does not require authentication
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
{
"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
{
"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
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