Introduction

Since the latest Meedio API update, we present the new API version (v2) 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/v2/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/v2/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/v2/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/v2/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/v2/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/v2/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 /v2/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 /v2/organizations

import requests

url = "https://api.meedio.me/api/v2/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/v2/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/v2/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/v2/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/v2/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/v2/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 /v2/meeting/:id
POST /v2/meeting

A meeting could be created by any organization member using Meedio dashboard or Public API. Once you create a meeting 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 a meeting via Public API you will be provided by the redirect URL where the two parties should meet. Meedio handles all further actions.

Meeting object

Meeting 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 /v2/meeting

curl --location --request POST 'https://api.meedio.me/api/v2/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/v2/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/v2/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/v2/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/v2/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/v2/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.

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.

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. (If email is not provided, it's still possible to create meeting.).

Returns

Returns the meeting object if a valid request was made, and returns an error otherwise.

Get meeting

GET /v2/meeting

import requests

url = "https://api.meedio.me/api/v2/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/v2/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/v2/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/v2/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/v2/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/v2/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.

Rooms

Endpoints

GET /v2/room/:slug
POST /v2/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 /v2/room

import requests

url = "https://api.meedio.me/api/v2/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/v2/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/v2/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/v2/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/v2/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/v2/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 /v2/room

import requests

url = "https://api.meedio.me/api/v2/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/v2/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/v2/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/v2/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/v2/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/v2/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.

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\|hidden>`	Off - turns off the local video feed, hidden - hides the camera button.
`?audio=<off\|hidden>`	Off - turns off the local audio feed, hidden - 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.

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.