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 and meedio_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 organization
- id - 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 and CONSULTATION. 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 queue
- userId - 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.

Introduction

Authentication

API keys

Key examples and description

API limits

Organization

The organization object

Get the organization

Parameters

Returns

Meeting

Meeting object (response)

MEETING type object

CONSULTATION type object

Create meeting

Parameters

Medical organization

Basic organization

Returns

Get meeting

Parameters

Returns

Meeting types

Delete meeting

Parameters

Returns

Rooms

Room object

Create Room

Parameters

Returns

Get Room

Parameters

Returns

Queue

Queue object

Create queue

Parameters

Returns

Get queue

Parameters

Returns

Update queue

Parameters

Returns

Delete queue

Parameters

Returns

Customizing rooms/meetings

URL parameters

Meedio Embedded

On a webpage

In an iframe

Errors

`MEETING` type object

`CONSULTATION` type object