Zextras Carbonio Workstream Collaboration CE Meeting Api v0.7.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 CE Meeting HTTP APIs definition.

Base URLs:

• http://localhost:10000

Meetings

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"
  }
]

Responses

Response Schema

Status Code 200

allOf

and

continued

Enumerated Values

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

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"
}

Responses

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

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"
}

Responses

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

Responses

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

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"
}

Responses

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

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"
}

Responses

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

Example responses

200 Response

{
  "status": "ACCEPTED"
}

Responses

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

Responses

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

Responses

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

Responses

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

Responses

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

Responses

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

Responses

Schemas

NewMeetingData

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

Properties

JoinMeetingResult

{
  "status": "ACCEPTED"
}

Properties

Room

{
  "id": "497f6eca-6276-4993-bfeb-53cbbbba6f08",
  "type": null,
  "name": "string",
  "description": "string"
}

Room data for a meeting

Properties

MeetingUser

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

Defines a user in the access list of a meeting

Properties

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

Enumerated Values

MeetingUserType

"moderator"

Properties

Enumerated Values

JoinStatus

"ACCEPTED"

Properties

Enumerated Values

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

and

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"
}

Meeting data

Properties

JoinSettings

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

user's streams settings to join a meeting

Properties

MediaStreamSettings

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

settings to apply on user's media stream

Properties

Enumerated Values

AudioStreamSettings

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

settings to apply on user's audio stream

Properties

SessionDescriptionProtocol

{
  "sdp": "string"
}

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

Properties

SubscriptionUpdates

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

subscriptions updates related to media streams

Properties

MediaStream

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

representation of meeting media stream

Properties

Enumerated Values