Introduction
Since the latest Meedio API update, we present the new API version (v3) documentation.
The Meedio API is organized around REST. Our API has predictable resource-oriented URLs, accepts JSON-encoded request bodies, returns JSON-encoded responses, and uses standard HTTP response codes, authentication, and verbs.
We have language bindings in Shell, Ruby, Python, and JavaScript! You can view code examples in the dark area to the right, and you can switch the programming language of the examples with the tabs in the top right
Authentication
Example of the authorized request:
require "uri"
require "net/http"
url = URI("https://api.meedio.me/api/v3/example-route")
https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true
request = Net::HTTP::Get.new(url)
request["API_SECRET"] = "meedio_secret"
request["API_KEY"] = "meedio_key"
response = https.request(request)
puts response.read_body
import requests
url = "https://api.meedio.me/api/v3/example-route"
payload={}
headers = {
'API_SECRET': 'meedio_secret',
'API_KEY': 'meedio_key'
}
response = requests.request("GET", url, headers=headers, data=payload)
print(response.text)
# With shell, you can just pass the correct header with each request
curl --location --request GET 'https://api.meedio.me/api/v3/example-route' \
--header 'API_KEY: meedio_key' \
--header 'API_SECRET: meedio_secret'
var axios = require('axios');
var config = {
method: 'get',
url: 'https://api.meedio.me/api/v3/example-route',
headers: {
'API_SECRET': 'meedio_secret',
'API_KEY': 'meedio_key'
}
};
axios(config)
.then(function (response) {
console.log(JSON.stringify(response.data));
})
.catch(function (error) {
console.log(error);
});
<?php
require_once 'HTTP/Request2.php';
$request = new HTTP_Request2();
$request->setUrl('https://api.meedio.me/api/v3/example-route');
$request->setMethod(HTTP_Request2::METHOD_GET);
$request->setConfig(array(
'follow_redirects' => TRUE
));
$request->setHeader(array(
'API_SECRET' => 'meedio_secret',
'API_KEY' => 'meedio_key'
));
try {
$response = $request->send();
if ($response->getStatus() == 200) {
echo $response->getBody();
}
else {
echo 'Unexpected HTTP status: ' . $response->getStatus() . ' ' .
$response->getReasonPhrase();
}
}
catch(HTTP_Request2_Exception $e) {
echo 'Error: ' . $e->getMessage();
}
package main
import (
"fmt"
"net/http"
"io/ioutil"
)
func main() {
url := "https://api.meedio.me/api/v3/example-route"
method := "GET"
client := &http.Client {
}
req, err := http.NewRequest(method, url, nil)
if err != nil {
fmt.Println(err)
return
}
req.Header.Add("API_SECRET", "meedio_secret")
req.Header.Add("API_KEY", "meedio_key")
res, err := client.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer res.Body.Close()
body, err := ioutil.ReadAll(res.Body)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(string(body))
}
Make sure to replace
meedio_key
with your API key andmeedio_secret
with your API secret.
The Meedio API uses API keys to authenticate requests. You can view and manage your API keys in the Meedio Dashboard.
Your API keys carry many privileges, so be sure to keep them secure! Do not share your secret API keys in publicly accessible areas such as GitHub, client-side code, and so forth. Your API keys consists of two different keys - public key and secret. The secret key will be revealed only once after it was created and be sure to write it down or you will have to revoke this key.
Once you create the API keys, they will have the expiration date that was selected before creating the keys. We suggest to select "no expire" time when creating unless you have a requirement to rotate your API keys time-by-time.
Authentication to the API is performed via HTTP Headers. Provide your API key as the API_KEY
value and API secret as the API_SECRET
value.
API keys
Meedio authenticates your API requests using your account’s API keys. If you don’t include your key when making an API request, or use an incorrect or outdated one, Meedio returns a 401 - Unauthorised
HTTP response code.
Key examples and description
Key name | Example | Description |
---|---|---|
API_KEY | 41394730-be53-4e6c-aab7-e38242cad81b | This is the main key to access Meedio public API. Making requests with this key will decrease your daily and hourly limits of total issued API requests limit for your account. |
API_SECRET | cbT75ovrVxVBzweSI7Pll0wbM23yZ4RW | This is the authentication key to make your requests to Meedio public API. Meedio does not store this value in the database and encrypts it before issuing it to the developer. After making the request Meedio will compare your sent value with the encrypted one which is stored in our database. |
API limits
Meedio have a rate limiter for API requests. Every API access is being limited by specific amount of requests per minute. Once you reach the limit, Meedio returns a 429 - Too Many Requests
HTTP response code.
We suggest you to calculate how many requests you are going to use and contact Meedio support if there is a problem with that.
Value | Limit |
---|---|
Minute | 1000 |
Organization
Endpoints
GET /v3/organizations
An organization object is created once you make an agreement with Meedio. This is something that can't be modified by anyone else except Meedio yet. An organization object contains a very few details about organization and its members so far. We are planning to expand it with the statistics about the meetings and more within the end of the year 2022.
The organization object
The organization object
{
"name": "Organization name",
"users": [
{
"id": "e91254af-e761-4fdb-abe8-b4b1f7f02415",
"fullName": "John Meedio",
"email": "john@meedio.me",
"organizationRole": "USER"
}
]
}
name
- name of the organization (string)users
- an array of all users (can be empty) who belong to the organizationid
- version 4 UUID generated once the user was added to the organization (string)fullName
- organization user's name (string)email
- organization user's email (string)organizationRole
- organization user's role (USER or ADMIN)
Get the organization
GET /v3/organizations
import requests
url = "https://api.meedio.me/api/v3/organizations"
payload={}
headers = {
'API_SECRET': 'meedio_secret',
'API_KEY': 'meedio_key'
}
response = requests.request("GET", url, headers=headers, data=payload)
print(response.text)
require "uri"
require "net/http"
url = URI("https://api.meedio.me/api/v3/organizations")
https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true
request = Net::HTTP::Get.new(url)
request["API_SECRET"] = "meedio_secret"
request["API_KEY"] = "meedio_key"
response = https.request(request)
puts response.read_body
package main
import (
"fmt"
"net/http"
"io/ioutil"
)
func main() {
url := "https://api.meedio.me/api/v3/organizations"
method := "GET"
client := &http.Client {
}
req, err := http.NewRequest(method, url, nil)
if err != nil {
fmt.Println(err)
return
}
req.Header.Add("API_SECRET", "meedio_secret")
req.Header.Add("API_KEY", "meedio_key")
res, err := client.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer res.Body.Close()
body, err := ioutil.ReadAll(res.Body)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(string(body))
}
<?php
require_once 'HTTP/Request2.php';
$request = new HTTP_Request2();
$request->setUrl('https://api.meedio.me/api/v3/organizations');
$request->setMethod(HTTP_Request2::METHOD_GET);
$request->setConfig(array(
'follow_redirects' => TRUE
));
$request->setHeader(array(
'API_SECRET' => 'meedio_secret',
'API_KEY' => 'meedio_key'
));
try {
$response = $request->send();
if ($response->getStatus() == 200) {
echo $response->getBody();
}
else {
echo 'Unexpected HTTP status: ' . $response->getStatus() . ' ' .
$response->getReasonPhrase();
}
}
catch(HTTP_Request2_Exception $e) {
echo 'Error: ' . $e->getMessage();
}
var axios = require('axios');
var config = {
method: 'get',
url: 'https://api.meedio.me/api/v3/organizations',
headers: {
'API_SECRET': 'meedio_secret',
'API_KEY': 'meedio_key'
}
};
axios(config)
.then(function (response) {
console.log(JSON.stringify(response.data));
})
.catch(function (error) {
console.log(error);
});
curl --location --request GET 'https://api.meedio.me/api/v3/organizations' \
--header 'API_KEY: meedio_key' \
--header 'API_SECRET: meedio_secret'
Gets the details of the organization you belong to.
Parameters
No parameters.
Returns
Returns the organization object if a valid request was made, and returns an error otherwise.
Meeting
Endpoints
GET /v3/meeting/:id
POST /v3/meeting
Any member of the organization can create a meeting using the Meedio dashboard or the Public API. When creating a meeting via the Public API, a redirect URL is provided for the participants to meet.
Meeting closing logic
If no participant joins the meeting within 15 minutes of its creation, the meeting will close. However, if at least one participant joins, the meeting will remain open for 15 minutes after the last participant leaves.
Starting with version 3, meetings of type MEETING
can be made long-lasting. This means they will remain permanently accessible to the user.
Meeting object (response)
MEETING
type object
MEETING
type object
{
"id": "e91254af-e761-4fdb-abe8-b4b1f7f02415",
"isInfinite": true,
"redirectUrl": "https://p2p.meedio.me/meetings/e91254af-e761-4fdb-abe8-b4b1f7f02415"
}
id
- version 4 UUID generated once the meeting was created (string)isInfinite
- value that determines if the meeting is long-lasting (boolean)redirectUrl
- meeting redirect url (string)
Other types meeting object
CONSULTATION
type object
{
"id": "e91254af-e761-4fdb-abe8-b4b1f7f02415",
"redirectUrl": "https://p2p.meedio.me/meetings/e91254af-e761-4fdb-abe8-b4b1f7f02415"
}
id
- version 4 UUID generated once the meeting was created (string)redirectUrl
- meeting redirect url (string)
Create meeting
POST /v3/meeting
curl --location --request POST 'https://api.meedio.me/api/v3/meeting' \
--header 'API_KEY: meedio_key' \
--header 'API_SECRET: meedio_secret' \
--header 'Content-Type: application/json' \
--data-raw '{"ownerEmail":"john@meedio.me"}'
require "uri"
require "net/http"
url = URI("https://api.meedio.me/api/v3/meeting")
https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true
request = Net::HTTP::Post.new(url)
request["API_SECRET"] = "meedio_secret"
request["API_KEY"] = "meedio_key"
request["Content-Type"] = "application/json"
request.body = JSON.dump({
"ownerEmail" => "john@meedio.me"
})
response = https.request(request)
puts response.read_body
import requests
url = "https://api.meedio.me/api/v3/meeting"
payload = json.dumps({
"ownerEmail": "john@meedio.me"
})
headers = {
'API_SECRET': 'meedio_secret',
'API_KEY': 'meedio_key',
'Content-Type': 'application/json'
}
response = requests.request("POST", url, headers=headers, data=payload)
print(response.text)
var axios = require('axios');
var qs = require('qs');
var data = {
'ownerEmail': 'john@meedio.me'
};
var config = {
method: 'post',
url: 'https://api.meedio.me/api/v3/meeting',
headers: {
'API_SECRET': 'meedio_secret',
'API_KEY': 'meedio_key',
'Content-Type': 'application/json'
},
data : data
};
axios(config)
.then(function (response) {
console.log(JSON.stringify(response.data));
})
.catch(function (error) {
console.log(error);
});
<?php
require_once 'HTTP/Request2.php';
$request = new HTTP_Request2();
$request->setUrl('https://api.meedio.me/api/v3/meeting');
$request->setMethod(HTTP_Request2::METHOD_POST);
$request->setConfig(array(
'follow_redirects' => TRUE
));
$request->setHeader(array(
'API_SECRET' => 'meedio_secret',
'API_KEY' => 'meedio_key',
'Content-Type' => 'application/json'
));
$request->setBody(json_encode(array(
'ownerEmail' => 'john@meedio.me'
)));
try {
$response = $request->send();
if ($response->getStatus() == 200) {
echo $response->getBody();
}
else {
echo 'Unexpected HTTP status: ' . $response->getStatus() . ' ' .
$response->getReasonPhrase();
}
}
catch(HTTP_Request2_Exception $e) {
echo 'Error: ' . $e->getMessage();
}
package main
import (
"fmt"
"strings"
"net/http"
"io/ioutil"
)
func main() {
url := "https://api.meedio.me/api/v3/meeting"
method := "POST"
payload := bytes.NewBuffer([]byte(`{"ownerEmail":"john@meedio.me"}`))
client := &http.Client {
}
req, err := http.NewRequest(method, url, payload)
if err != nil {
fmt.Println(err)
return
}
req.Header.Add("API_SECRET", "meedio_secret")
req.Header.Add("API_KEY", "meedio_key")
req.Header.Add("Content-Type", "application/json")
res, err := client.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer res.Body.Close()
body, err := ioutil.ReadAll(res.Body)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(string(body))
}
To attend a meeting or get information about the meeting it needs to be created first. You need to fetch the organization you belong to first if you want to create a meeting. Pass the organization user email as an argument who is going to be an admin of the meeting after you fetch the organization details.
Please note that you cannot create a CONSULTATION
type long-lasting meeting, which means that passing isInfinite
param when creating a CONSULTATION
type meeting will result in an error.
Parameters
Medical organization
Key | Type | Description |
---|---|---|
ownerEmail |
required (String) | a valid value of organization member email. The member must belong to the same organization as you. |
type |
optional (MEETING or CONSULTATION) | a type of meeting. Not providing this field defaults to MEETING meeting. |
isInfinite |
optional (Boolean) | a boolean value if the meeting should be long-lasting or not. |
meetingId |
optional (String) | a valid UUID v4 value, that will be used as a meeting identifier. Not providing it generates a random UUID v4 identifier. |
Basic organization
Key | Type | Description |
---|---|---|
ownerEmail |
optional (String) | a valid value of organization member email. The member must belong to the same organization as you. |
type |
optional (MEETING or CONSULTATION) | a type of meeting. Not providing this field defaults to MEETING type. |
isInfinite |
optional (Boolean) | a boolean value if the meeting should be long-lasting or not. |
meetingId |
optional (String) | a valid UUID v4 value, that will be used as a meeting identifier. Not providing it generates a random UUID v4 identifier. |
Returns
Returns the meeting object if a valid request was made, and returns an error otherwise.
Get meeting
GET /v3/meeting
import requests
url = "https://api.meedio.me/api/v3/meeting/e91254af-e761-4fdb-abe8-b4b1f7f02415"
payload={}
headers = {
'API_SECRET': 'meedio_secret',
'API_KEY': 'meedio_key'
}
response = requests.request("GET", url, headers=headers, data=payload)
print(response.text)
require "uri"
require "net/http"
url = URI("https://api.meedio.me/api/v3/meeting/e91254af-e761-4fdb-abe8-b4b1f7f02415")
https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true
request = Net::HTTP::Get.new(url)
request["API_SECRET"] = "meedio_secret"
request["API_KEY"] = "meedio_key"
response = https.request(request)
puts response.read_body
package main
import (
"fmt"
"net/http"
"io/ioutil"
)
func main() {
url := "https://api.meedio.me/api/v3/meeting/e91254af-e761-4fdb-abe8-b4b1f7f02415"
method := "GET"
client := &http.Client {
}
req, err := http.NewRequest(method, url, nil)
if err != nil {
fmt.Println(err)
return
}
req.Header.Add("API_SECRET", "meedio_secret")
req.Header.Add("API_KEY", "meedio_key")
res, err := client.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer res.Body.Close()
body, err := ioutil.ReadAll(res.Body)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(string(body))
}
<?php
require_once 'HTTP/Request2.php';
$request = new HTTP_Request2();
$request->setUrl('https://api.meedio.me/api/v3/meeting/e91254af-e761-4fdb-abe8-b4b1f7f02415');
$request->setMethod(HTTP_Request2::METHOD_GET);
$request->setConfig(array(
'follow_redirects' => TRUE
));
$request->setHeader(array(
'API_SECRET' => 'meedio_secret',
'API_KEY' => 'meedio_key'
));
try {
$response = $request->send();
if ($response->getStatus() == 200) {
echo $response->getBody();
}
else {
echo 'Unexpected HTTP status: ' . $response->getStatus() . ' ' .
$response->getReasonPhrase();
}
}
catch(HTTP_Request2_Exception $e) {
echo 'Error: ' . $e->getMessage();
}
var axios = require('axios');
var config = {
method: 'get',
url: 'https://api.meedio.me/api/v3/meeting/e91254af-e761-4fdb-abe8-b4b1f7f02415',
headers: {
'API_SECRET': 'meedio_secret',
'API_KEY': 'meedio_key'
}
};
axios(config)
.then(function (response) {
console.log(JSON.stringify(response.data));
})
.catch(function (error) {
console.log(error);
});
curl --location --request GET 'https://api.meedio.me/api/v3/meeting/e91254af-e761-4fdb-abe8-b4b1f7f02415' \
--header 'API_KEY: meedio_key' \
--header 'API_SECRET: meedio_secret'
Gets the meeting information.
Parameters
No parameters.
Returns
Returns the meeting object if a valid identifier was provided, and returns an error otherwise.
Meeting types
- Valid meeting types are
MEETING
andCONSULTATION
. They are case insensitive when providing in request. Server will send error in response if any other type is provided.
Delete meeting
DELETE /v3/meeting
import requests
url = "https://api.meedio.me/api/v3/meeting/e91254af-e761-4fdb-abe8-b4b1f7f02415"
payload={}
headers = {
'API_SECRET': 'meedio_secret',
'API_KEY': 'meedio_key'
}
response = requests.request("DELETE", url, headers=headers, data=payload)
print(response.text)
require "uri"
require "net/http"
url = URI("https://api.meedio.me/api/v3/meeting/e91254af-e761-4fdb-abe8-b4b1f7f02415")
https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true
request = Net::HTTP::Delete.new(url)
request["API_SECRET"] = "meedio_secret"
request["API_KEY"] = "meedio_key"
response = https.request(request)
puts response.read_body
package main
import (
"fmt"
"net/http"
"io/ioutil"
)
func main() {
url := "https://api.meedio.me/api/v3/meeting/e91254af-e761-4fdb-abe8-b4b1f7f02415"
method := "DELETE"
client := &http.Client {
}
req, err := http.NewRequest(method, url, nil)
if err != nil {
fmt.Println(err)
return
}
req.Header.Add("API_SECRET", "meedio_secret")
req.Header.Add("API_KEY", "meedio_key")
res, err := client.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer res.Body.Close()
body, err := ioutil.ReadAll(res.Body)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(string(body))
}
<?php
require_once 'HTTP/Request2.php';
$request = new HTTP_Request2();
$request->setUrl('https://api.meedio.me/api/v3/meeting/e91254af-e761-4fdb-abe8-b4b1f7f02415');
$request->setMethod(HTTP_Request2::METHOD_GET);
$request->setConfig(array(
'follow_redirects' => TRUE
));
$request->setHeader(array(
'API_SECRET' => 'meedio_secret',
'API_KEY' => 'meedio_key'
));
try {
$response = $request->send();
if ($response->getStatus() == 200) {
echo $response->getBody();
}
else {
echo 'Unexpected HTTP status: ' . $response->getStatus() . ' ' .
$response->getReasonPhrase();
}
}
catch(HTTP_Request2_Exception $e) {
echo 'Error: ' . $e->getMessage();
}
var axios = require('axios');
var config = {
method: 'delete',
url: 'https://api.meedio.me/api/v3/meeting/e91254af-e761-4fdb-abe8-b4b1f7f02415',
headers: {
'API_SECRET': 'meedio_secret',
'API_KEY': 'meedio_key'
}
};
axios(config)
.then(function (response) {
console.log(JSON.stringify(response.data));
})
.catch(function (error) {
console.log(error);
});
curl --location --request DELETE 'https://api.meedio.me/api/v3/meeting/e91254af-e761-4fdb-abe8-b4b1f7f02415' \
--header 'API_KEY: meedio_key' \
--header 'API_SECRET: meedio_secret'
Deletes the given meeting. If the meeting has been created as long-lasting, it will be terminated as well. Please note, that all active participants in the given meeting will be kicked out.
Meeting deletion only works on meetings of type MEETING
.
Parameters
No parameters.
Returns
Returns the meeting object with a timestamp of the deletion time if a valid identifier was provided, and returns an error otherwise.
Rooms
Endpoints
GET /v3/room/:slug
POST /v3/room
A room could be created by any organization member using Meedio dashboard or Public API. Once you create a room it will be open as long as there will be at least one person online or 15 minutes after the last person leaves. When you create room via Public API you will be provided by the redirect URL.
Room object
Room object
{
"title": "title-example",
"slug": "room-slug-example",
"organizationSlug": "organization-slug-example",
"redirectUrl": "https://p2p.meedio.me/room-slug-example"
}
title
- room title (string)slug
- A URL slug refers to the end part of a URL after the backslash (“/”)organizationSlug
- organization slug (string)redirectUrl
- room redirect url (string)
Create Room
POST /v3/room
import requests
url = "https://api.meedio.me/api/v3/room"
payload='title=title-example&slug=room-slug-example'
headers = {
'API_SECRET': 'meedio_secret',
'API_KEY': 'meedio_key',
'Content-Type': 'application/json'
}
response = requests.request("POST", url, headers=headers, data=payload)
print(response.text)
require "uri"
require "json"
require "net/http"
url = URI("https://api.meedio.me/api/v3/room")
http = Net::HTTP.new(url.host, url.port);
request = Net::HTTP::Post.new(url)
request["API_KEY"] = 'meedio_key'
request["API_SECRET"] = 'meedio_secret'
request["Content-Type"] = "application/json"
request.body = "title=title-example&slug=room-slug-example"
response = http.request(request)
puts response.read_body
package main
import (
"fmt"
"strings"
"net/http"
"io/ioutil"
)
func main() {
url := "https://api.meedio.me/api/v3/room"
method := "POST"
payload := strings.NewReader(`{
"title": "title-example",
"slug": "room-slug-example"
}`)
client := &http.Client {
}
req, err := http.NewRequest(method, url, payload)
if err != nil {
fmt.Println(err)
return
}
req.Header.Add("API_KEY", 'meedio_key')
req.Header.Add("API_SECRET", 'meedio_secret')
req.Header.Add("Content-Type", "application/json")
res, err := client.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer res.Body.Close()
body, err := ioutil.ReadAll(res.Body)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(string(body))
}
<?php
require_once 'HTTP/Request2.php';
$request = new HTTP_Request2();
$request->setUrl('https://api.meedio.me/api/v3/room');
$request->setMethod(HTTP_Request2::METHOD_POST);
$request->setConfig(array(
'follow_redirects' => TRUE
));
$request->setHeader(array(
'API_KEY' => 'meedio_key',
'API_SECRET' => 'meedio_secret',
'Content-Type' => 'application/json'
));
$request->setBody('{\n "title": "title-example",\n "slug": "room-slug-example",\n}');
try {
$response = $request->send();
if ($response->getStatus() == 200) {
echo $response->getBody();
}
else {
echo 'Unexpected HTTP status: ' . $response->getStatus() . ' ' .
$response->getReasonPhrase();
}
}
catch(HTTP_Request2_Exception $e) {
echo 'Error: ' . $e->getMessage();
}
var axios = require('axios');
var qs = require('qs');
var data = qs.stringify({
'title': 'title-example',
'slug': 'room-slug-example'
});
var config = {
method: 'post',
url: 'https://api.meedio.me/api/v3/room',
headers: {
'API_SECRET': 'meedio_secret',
'API_KEY': 'meedio_key',
'Content-Type': 'application/json'
},
data : data
};
axios(config)
.then(function (response) {
console.log(JSON.stringify(response.data));
})
.catch(function (error) {
console.log(error);
});
curl --location --request POST 'https://api.meedio.me/api/v3/room' \
--header 'API_KEY: meedio_key' \
--header 'API_SECRET: meedio_secret' \
--header 'Content-Type: application/json' \
--data '{
"title": "title-example",
"slug": "room-slug-example"
}'
To attend a room or get information about the room it needs to be created first. Pass the slug and title(optional) as an argument.
Parameters
Key | Type | Description |
---|---|---|
slug |
required (String) | a valid room slug ("room-slug-example"). |
title |
optional (String) | a valid room title ("title-example"). |
Returns
Returns the room object if a valid request was made, and returns an error otherwise. If the title field isn't passed as an argument, the room object is returned without it.
Get Room
GET /v3/room
import requests
url = "https://api.meedio.me/api/v3/room/room-slug-example"
payload = {}
headers = {
'API_KEY': 'meedio_key',
'API_SECRET': 'meedio_secret'
}
response = requests.request("GET", url, headers=headers, data=payload)
print(response.text)
require "uri"
require "net/http"
url = URI("https://api.meedio.me/api/v3/room/room-slug-example")
http = Net::HTTP.new(url.host, url.port);
request = Net::HTTP::Get.new(url)
request["API_KEY"] = "meedio_key"
request["API_SECRET"] = "meedio_secret"
response = http.request(request)
puts response.read_body
package main
import (
"fmt"
"strings"
"net/http"
"io/ioutil"
)
func main() {
url := "https://api.meedio.me/api/v3/room/room-slug-example"
method := "GET"
payload := strings.NewReader(``)
client := &http.Client {
}
req, err := http.NewRequest(method, url, payload)
if err != nil {
fmt.Println(err)
return
}
req.Header.Add("API_KEY", "meedio_key")
req.Header.Add("API_SECRET", "meedio_secret")
res, err := client.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer res.Body.Close()
body, err := ioutil.ReadAll(res.Body)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(string(body))
}
<?php
require_once 'HTTP/Request2.php';
$request = new HTTP_Request2();
$request->setUrl('https://api.meedio.me/api/v3/room/room-slug-example');
$request->setMethod(HTTP_Request2::METHOD_GET);
$request->setConfig(array(
'follow_redirects' => TRUE
));
$request->setHeader(array(
'API_KEY' => 'meedio_key',
'API_SECRET' => 'meedio_secret'
));
$request->setBody('');
try {
$response = $request->send();
if ($response->getStatus() == 200) {
echo $response->getBody();
}
else {
echo 'Unexpected HTTP status: ' . $response->getStatus() . ' ' .
$response->getReasonPhrase();
}
}
catch(HTTP_Request2_Exception $e) {
echo 'Error: ' . $e->getMessage();
}
var axios = require('axios');
var config = {
method: 'get',
url: 'https://api.meedio.me/api/v3/room/room-slug-example',
headers: {
'API_SECRET': 'meedio_secret',
'API_KEY': 'meedio_key'
}
};
axios(config)
.then(function (response) {
console.log(JSON.stringify(response.data));
})
.catch(function (error) {
console.log(error);
});
curl --location --request GET 'https://api.meedio.me/api/v3/room/room-slug-example' \
--header 'API_KEY: meedio_key' \
--header 'API_SECRET: meedio_secret'
Searches for room by a slug.
Parameters
No parameters.
Returns
Returns the room object if a valid request was made, and returns an error otherwise. If the room doesn't have a title, the room object is returned without it.
Queue
Endpoints
POST /v3/queue
GET /v3/queue/:id
POST /v3/queue/:id
DELETE v3/queue/:id
A queue could be created by any organization member using Meedio dashboard or Public API. Once you create a queue, it will be open for members and clients to join.
When you create a queue via Public API you will be provided with the redirect URL where the two parties should meet. Clients join a live queue, while specialists accept those client from queue and have a meeting, after which the meeting is moved on to the next client.
Queue object
Queue object
{
id: "63da43d5928cb848430b8da5",
name: "example-name",
slug: "example-slug",
isActive: false,
organizationId: "cb386a76-448d-47b0-a19a-607c5ae68f93",
closingMessage: "example-closing-message",
type: "WAITING_ROOM",
members: [
{
userId: "00d247fb-5d4d-4c73-a5a0-20b3f895ca72",
fullName: "example-full-name",
isActive: false,
isAutoAccepting: false
joinedCallAt: null
}
]
}
id
- MongoDB ObjectID generated once the queue was created (string)name
- queue name (string)slug
- slug name (string)isActive
- queue status (boolean)organizationId
- version 4 UUID of the organization that the queue belongs to (string)closingMessage
- message displayed when the queue is not active (string)type
- type of queue (BOARD or WAITING_ROOM)members
- an array of members (doctors or specialists) that belong to the queueuserId
- version 4 UUID of the member (string)fullName
- full name of the member (string)isActive
- member status (boolean)isAutoAccepting
- a status that defines if the member is automatically accepting clients to a call (boolean)joinedCallAt
- timestamp of the moment that a member joins a call (Date)
Create queue
POST /v3/rooms/queue
curl --location --request POST 'https://api.meedio.me/api/v3/rooms/queue' \
--header 'API_KEY: meedio_key' \
--header 'API_SECRET: meedio_secret' \
--header 'Content-Type: application/json' \
--data-raw '{
"name": "meedio_name",
"slug": "meedio_slug",
"type": "WAITING_ROOM"
}'
require "uri"
require "json"
require "net/http"
url = URI("https://api.meedio.me/api/v3/rooms/queue")
http = Net::HTTP.new(url.host, url.port);
request = Net::HTTP::Post.new(url)
request["API_SECRET"] = "meedio_secret"
request["API_KEY"] = "meedio_key"
request["Content-Type"] = "application/json"
request.body = JSON.dump({
"name": "meedio_name",
"slug": "meedio_slug",
"type": "WAITING_ROOM"
})
response = http.request(request)
puts response.read_body
import requests
import json
url = "https://api.meedio.me/api/v3/rooms/queue"
payload = json.dumps({
"name": "meedio_name",
"slug": "meedio_slug",
"type": "WAITING_ROOM"
})
headers = {
'API_SECRET': 'meedio_secret',
'API_KEY': 'meedio_key',
'Content-Type': 'application/json',
}
response = requests.request("POST", url, headers=headers, data=payload)
print(response.text)
var axios = require('axios');
var data = JSON.stringify({
"name": "meedio_name",
"slug": "meedio_slug",
"type": "WAITING_ROOM"
});
var config = {
method: 'post',
url: 'https://api.meedio.me/api/v3/rooms/queue',
headers: {
'API_SECRET': 'meedio_secret',
'API_KEY': 'meedio_key',
'Content-Type': 'application/json',
},
data : data
};
axios(config)
.then(function (response) {
console.log(JSON.stringify(response.data));
})
.catch(function (error) {
console.log(error);
});
<?php
require_once 'HTTP/Request2.php';
$request = new HTTP_Request2();
$request->setUrl('https://api.meedio.me/api/v3/rooms/queue');
$request->setMethod(HTTP_Request2::METHOD_POST);
$request->setConfig(array(
'follow_redirects' => TRUE
));
$request->setHeader(array(
'API_SECRET' => 'meedio_secret',
'API_KEY' => 'meedio_key',
'Content-Type' => 'application/json',
));
$request->setBody('{\n "name": "meedio_name",\n "slug": "meedio_slug",\n "type": "WAITING_ROOM"\n}');
try {
$response = $request->send();
if ($response->getStatus() == 200) {
echo $response->getBody();
}
else {
echo 'Unexpected HTTP status: ' . $response->getStatus() . ' ' .
$response->getReasonPhrase();
}
}
catch(HTTP_Request2_Exception $e) {
echo 'Error: ' . $e->getMessage();
}
package main
import (
"fmt"
"strings"
"net/http"
"io/ioutil"
)
func main() {
url := "https://api.meedio.me/api/v3/rooms/queue"
method := "POST"
payload := strings.NewReader(`{
"name": "meedio_name",
"slug": "meedio_slug",
"type": "WAITING_ROOM"
}`)
client := &http.Client {
}
req, err := http.NewRequest(method, url, payload)
if err != nil {
fmt.Println(err)
return
}
req.Header.Add("API_SECRET", "meedio_secret")
req.Header.Add("API_KEY", "meedio_key")
req.Header.Add("Content-Type", "application/json")
res, err := client.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer res.Body.Close()
body, err := ioutil.ReadAll(res.Body)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(string(body))
}
To join a queue or get information about a queue, it needs to be created first. Pass the queue name, slug and type as arguments in your request.
Parameters
Key | Type | Description |
---|---|---|
name |
required (String) | a valid value of the queue name. |
slug |
required (String) | a valid value of the queue slug. |
type |
required (WAITING_ROOM or BOARD) | the type of a queue. |
closingMessage |
optional (String) | a valid value of the queue closing message. |
Returns
Returns the queue ID and redirect URL if the request was correct, and returns an error otherwise.
Get queue
GET /v3/rooms/queue
curl --location --request GET 'https://api.meedio.me/api/v3/rooms/queue/queue-id-example' \
--header 'API_KEY: meedio_key' \
--header 'API_SECRET: meedio_secret'
require "uri"
require "net/http"
url = URI("https://api.meedio.me/api/v3/rooms/queue/queue-id-example")
https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true
request = Net::HTTP::Get.new(url)
request["API_KEY"] = "meedio_key"
request["API_SECRET"] = "meedio_secret"
response = https.request(request)
puts response.read_body
import requests
url = "https://api.meedio.me/api/v3/rooms/queue/queue-id-example"
payload={}
headers = {
'API_KEY': 'meedio_key',
'API_SECRET': 'meedio_secret'
}
response = requests.request("GET", url, headers=headers, data=payload)
print(response.text)
var axios = require('axios');
var config = {
method: 'get',
url: 'https://api.meedio.me/api/v3/rooms/queue/queue-id-example',
headers: {
'API_KEY': 'meedio_key',
'API_SECRET': 'meedio_secret'
}
};
axios(config)
.then(function (response) {
console.log(JSON.stringify(response.data));
})
.catch(function (error) {
console.log(error);
});
<?php
require_once 'HTTP/Request2.php';
$request = new HTTP_Request2();
$request->setUrl('https://api.meedio.me/api/v3/rooms/queue/queue-id-example');
$request->setMethod(HTTP_Request2::METHOD_GET);
$request->setConfig(array(
'follow_redirects' => TRUE
));
$request->setHeader(array(
'API_KEY' => 'meedio_key',
'API_SECRET' => 'meedio_secret'
));
try {
$response = $request->send();
if ($response->getStatus() == 200) {
echo $response->getBody();
}
else {
echo 'Unexpected HTTP status: ' . $response->getStatus() . ' ' .
$response->getReasonPhrase();
}
}
catch(HTTP_Request2_Exception $e) {
echo 'Error: ' . $e->getMessage();
}
package main
import (
"fmt"
"net/http"
"io/ioutil"
)
func main() {
url := "https://api.meedio.me/api/v3/rooms/queue/queue-id-example"
method := "GET"
client := &http.Client {
}
req, err := http.NewRequest(method, url, nil)
if err != nil {
fmt.Println(err)
return
}
req.Header.Add("API_KEY", "meedio_key")
req.Header.Add("API_SECRET", "meedio_secret")
res, err := client.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer res.Body.Close()
body, err := ioutil.ReadAll(res.Body)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(string(body))
}
Gets a queue by ID.
Parameters
No parameters.
Returns
Returns the queue ID and redirect URL if the request was correct, and returns an error otherwise.
Update queue
POST /v3/rooms/queue
curl --location --request POST 'https://api.meedio.me/api/v3/rooms/queue/queue-id-example' \
--header 'API_KEY: meedio_key' \
--header 'API_SECRET: meedio_secret' \
--header 'Content-Type: application/json' \
--data-raw '{
"name": "meedio_name",
"slug": "meedio_slug",
"type": "WAITING_ROOM",
"closingMessage": "meedio_closing_message",
"membersIds": ["888d83dc-66a0-44df-b071-37d32da08524"],
"isActive": "true"
}'
require "uri"
require "json"
require "net/http"
url = URI("https://api.meedio.me/api/v3/rooms/queue/queue-id-example")
https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true
request = Net::HTTP::Post.new(url)
request["API_KEY"] = "meedio_key"
request["API_SECRET"] = "meedio_secret"
request["Content-Type"] = "application/json"
request.body = JSON.dump({
"name": "meedio_name",
"slug": "meedio_slug",
"type": "WAITING_ROOM",
"closingMessage": "meedio_closing_message",
"membersIds": [
"888d83dc-66a0-44df-b071-37d32da08524"
],
"isActive": "true"
})
response = https.request(request)
puts response.read_body
import requests
import json
url = "https://api.meedio.me/api/v3/rooms/queue/queue-id-example"
payload = json.dumps({
"name": "meedio_name",
"slug": "meedio_slug",
"type": "WAITING_ROOM",
"closingMessage": "meedio_closing_message",
"membersIds": [
"888d83dc-66a0-44df-b071-37d32da08524"
],
"isActive": "true"
})
headers = {
'API_KEY': 'meedio_key',
'API_SECRET': 'meedio_secret',
'Content-Type': 'application/json'
}
response = requests.request("POST", url, headers=headers, data=payload)
print(response.text)
var axios = require('axios');
var data = JSON.stringify({
"name": "meedio_name",
"slug": "meedio_slug",
"type": "WAITING_ROOM",
"closingMessage": "meedio_closing_message",
"membersIds": [
"888d83dc-66a0-44df-b071-37d32da08524"
],
"isActive": "true"
});
var config = {
method: 'post',
url: 'https://api.meedio.me/api/v3/rooms/queue/queue-id-example',
headers: {
'API_KEY': 'meedio_key',
'API_SECRET': 'meedio_secret',
'Content-Type': 'application/json'
},
data : data
};
axios(config)
.then(function (response) {
console.log(JSON.stringify(response.data));
})
.catch(function (error) {
console.log(error);
});
<?php
require_once 'HTTP/Request2.php';
$request = new HTTP_Request2();
$request->setUrl('https://api.meedio.me/api/v3/rooms/queue/queue-id-example');
$request->setMethod(HTTP_Request2::METHOD_POST);
$request->setConfig(array(
'follow_redirects' => TRUE
));
$request->setHeader(array(
'API_KEY' => 'meedio_key',
'API_SECRET' => 'meedio_secret',
'Content-Type' => 'application/json'
));
$request->setBody('{\n "name": "meedio_name",\n "slug": "meedio_slug",\n "type": "WAITING_ROOM",\n "closingMessage": "meedio_closing_message",\n "membersIds": ["888d83dc-66a0-44df-b071-37d32da08524"],\n "isActive": "true"\n}');
try {
$response = $request->send();
if ($response->getStatus() == 200) {
echo $response->getBody();
}
else {
echo 'Unexpected HTTP status: ' . $response->getStatus() . ' ' .
$response->getReasonPhrase();
}
}
catch(HTTP_Request2_Exception $e) {
echo 'Error: ' . $e->getMessage();
}
package main
import (
"fmt"
"strings"
"net/http"
"io/ioutil"
)
func main() {
url := "https://api.meedio.me/api/v3/rooms/queue/queue-id-example"
method := "POST"
payload := strings.NewReader(`{
"name": "meedio_name",
"slug": "meedio_slug",
"type": "WAITING_ROOM",
"closingMessage": "meedio_closing_message",
"membersIds": ["888d83dc-66a0-44df-b071-37d32da08524"],
"isActive": "true"
}`)
client := &http.Client {
}
req, err := http.NewRequest(method, url, payload)
if err != nil {
fmt.Println(err)
return
}
req.Header.Add("API_KEY", "meedio_key")
req.Header.Add("API_SECRET", "meedio_secret")
req.Header.Add("Content-Type", "application/json")
res, err := client.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer res.Body.Close()
body, err := ioutil.ReadAll(res.Body)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(string(body))
}
To update a queue, pass the allowed arguments in your request.
Parameters
Key | Type | Description |
---|---|---|
name |
optional (String) | a valid value of the queue name. |
slug |
optional (String) | a valid value of the queue slug. |
type |
optional (WAITING_ROOM or BOARD) | the type of a queue. |
closingMessage |
optional (String) | a valid value of the queue closing message. |
membersIds |
optional (Array) | a valid array consisting of member IDs |
Returns
Returns an updated object of the queue.
Delete queue
DELETE /v3/rooms/queue
curl --location --request DELETE 'https://api.meedio.me/api/v3/rooms/queue/queue-id-example' \
--header 'API_KEY: meedio_key' \
--header 'API_SECRET: meedio_secret'
require "uri"
require "net/http"
url = URI("https://api.meedio.me/api/v3/rooms/queue/queue-id-example")
https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true
request = Net::HTTP::Delete.new(url)
request["API_KEY"] = "meedio_key"
request["API_SECRET"] = "meedio_secret"
response = https.request(request)
puts response.read_body
import requests
url = "https://api.meedio.me/api/v3/rooms/queue/queue-id-example"
payload={}
headers = {
'API_KEY': 'meedio_key',
'API_SECRET': 'meedio_secret'
}
response = requests.request("DELETE", url, headers=headers, data=payload)
print(response.text)
var axios = require('axios');
var config = {
method: 'delete',
url: 'https://api.meedio.me/api/v3/rooms/queue/queue-id-example',
headers: {
'API_KEY': 'meedio_key',
'API_SECRET': 'meedio_secret'
}
};
axios(config)
.then(function (response) {
console.log(JSON.stringify(response.data));
})
.catch(function (error) {
console.log(error);
});
<?php
require_once 'HTTP/Request2.php';
$request = new HTTP_Request2();
$request->setUrl('https://api.meedio.me/api/v3/rooms/queue/queue-id-example');
$request->setMethod(HTTP_Request2::METHOD_DELETE);
$request->setConfig(array(
'follow_redirects' => TRUE
));
$request->setHeader(array(
'API_KEY' => 'meedio_key',
'API_SECRET' => 'meedio_secret'
));
try {
$response = $request->send();
if ($response->getStatus() == 200) {
echo $response->getBody();
}
else {
echo 'Unexpected HTTP status: ' . $response->getStatus() . ' ' .
$response->getReasonPhrase();
}
}
catch(HTTP_Request2_Exception $e) {
echo 'Error: ' . $e->getMessage();
}
package main
import (
"fmt"
"net/http"
"io/ioutil"
)
func main() {
url := "https://api.meedio.me/api/v3/rooms/queue/queue-id-example"
method := "DELETE"
client := &http.Client {
}
req, err := http.NewRequest(method, url, nil)
if err != nil {
fmt.Println(err)
return
}
req.Header.Add("API_KEY", "meedio_key")
req.Header.Add("API_SECRET", "meedio_secret")
res, err := client.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer res.Body.Close()
body, err := ioutil.ReadAll(res.Body)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(string(body))
}
Deletes a queue by ID.
Parameters
No parameters.
Returns
Returns the deleted queue object.
Customizing rooms/meetings
You can use URL parameters to customize the meeting experience for your users. It’s possible for each participant in a meeting to have different parameter combinations.
URL parameters are added to the meeting or room URL when embedding it in your web page or app.
Several parameters can be combined by using the ampersand symbol (&). For instance, the following URL parameters would open the meeting with the name - Simon and Terms of Service accepted:
https://subdomain.meedio.me/meetings/id?name=Simon&tosAccepted=true
URL parameters
URL parameter | Description |
---|---|
?minimal |
Applies a minimal UI. Turns off all controls except for cam and mic. |
?name=* |
Prefill name of the participant. |
?tosAccepted=true |
Marks the Terms of Service checkmark. |
?autoRequest=true |
Automatically requests the permissions (video and audio). |
?autoJoin=true |
You'll be joined to the meeting automatically, if following conditions are met: Terms of Service are accepted and camera permissions are set. |
?video=off |
Turns the local video feed off. |
?videoButton=off |
Hides the camera button. |
?audio=off |
Turns the local audio feed off. |
?audioButton=off |
Hides the microphone button. |
?screenshare=<on | off> |
Hides or shows the screenshare button. |
?logo=<on | off> |
Hides or shows the Meedio logo. |
?timer=<on | off> |
Hides or shows the timer. |
?title=<on | off> |
Hides or shows the title. |
?settingsButton=off |
Hides the settings button. |
?shareButton=off |
Hides the share meeting/room button |
?help=off |
Hides the help link. |
?tosVisible=off |
Hides guest Terms of Service checkbox and text. |
?floatSelf |
Enables participant's local view to be draggable. |
?font=Source Sans Pro |
Enables a custom font for the application. |
?theme=<light | dark> |
Enabled light or dark theme for the application. |
?hangup=<hidden | click | confirm> |
"confirm"- (default) toggles modal, "click"- ends the meeting immediately, "hidden"- hides end call button. |
?nameVisibility=<show | edit | hidden> |
Hides, shows, or let's edit guest's name. |
Meedio Embedded
Meedio Embedded makes it easy to quickly add boards, meetings, or queues. You can do this whether you're making a brand new app or adding these features to an app you already have.
On a webpage
Whether you're building your own web app or using a third-party framework, incorporating Meedio boards, meetings, or queues into your service is straightforward and hassle-free.
In an iframe
If you want to embed boards, meetings, or queues in a website using HTML, or a framework that supports HTML elements like React.js, a great option is to use a simple iframe. Replace YOUR_ROOM_URL
with the Meedio link to the board, meeting, or queue in the example on the right.
<iframe
src="YOUR_ROOM_URL"
width="100%"
allow="camera; microphone; capture-display; clipboard-write"
></iframe>
Errors
The Meedio API uses the following error codes:
Error Code | Meaning |
---|---|
400 | Bad Request -- Your request is invalid. |
401 | Unauthorized -- Your API credentials are wrong. |
403 | Forbidden -- The request is hidden for administrators only. |
404 | Not Found -- The specified Meedio route could not be found. |
405 | Method Not Allowed -- You tried to access a Meedio route with an invalid method. |
406 | Not Acceptable -- You requested a format that isn't json. |
410 | Gone -- The requested Meedio route has been removed from our servers. |
418 | I'm a teapot. |
429 | Too Many Requests -- You're requesting too many! Slow down! |
500 | Internal Server Error -- We had a problem with our server. Try again later. |
503 | Service Unavailable -- We're temporarily offline for maintenance. Please try again later. |