diff --git a/sylk/applications/webrtcgateway/configuration.py b/sylk/applications/webrtcgateway/configuration.py
index 79bb583..a895eae 100644
--- a/sylk/applications/webrtcgateway/configuration.py
+++ b/sylk/applications/webrtcgateway/configuration.py
@@ -1,144 +1,144 @@
 
 import os
 import re
 
 from application.configuration import ConfigFile, ConfigSection, ConfigSetting
 from application.configuration.datatypes import NetworkAddress, StringList
 
 from sylk.configuration import ServerConfig
 from sylk.configuration.datatypes import Path, SIPProxyAddress, VideoBitrate, VideoCodec
 
 
 __all__ = 'GeneralConfig', 'JanusConfig', 'get_room_config'
 
 
 # Datatypes
 
 class AccessPolicyValue(str):
     allowed_values = ('allow,deny', 'deny,allow')
 
     def __new__(cls, value):
         value = re.sub('\s', '', value)
         if value not in cls.allowed_values:
             raise ValueError('invalid value, allowed values are: %s' % ' | '.join(cls.allowed_values))
         return str.__new__(cls, value)
 
 
 class Domain(str):
     domain_re = re.compile(r"^[a-zA-Z0-9\-_]+(\.[a-zA-Z0-9\-_]+)*$")
 
     def __new__(cls, value):
         value = str(value)
         if not cls.domain_re.match(value):
             raise ValueError("illegal domain: %s" % value)
         return str.__new__(cls, value)
 
 
 class SIPAddress(str):
     def __new__(cls, address):
         address = str(address)
         address = address.replace('@', '%40', address.count('@')-1)
         try:
             username, domain = address.split('@')
             Domain(domain)
         except ValueError:
             raise ValueError("illegal SIP address: %s, must be in user@domain format" % address)
         return str.__new__(cls, address)
 
 
 class PolicyItem(object):
     def __new__(cls, item):
         lowercase_item = item.lower()
         if lowercase_item in ('none', ''):
             return 'none'
         elif lowercase_item in ('any', 'all', '*'):
             return 'all'
         elif '@' in item:
             return SIPAddress(item)
         else:
             return Domain(item)
 
 
 class PolicySettingValue(object):
     def __init__(self, value):
         if isinstance(value, (tuple, list)):
             items = [str(x) for x in value]
         elif isinstance(value, str):
             items = re.split(r'\s*,\s*', value)
         else:
             raise TypeError("value must be a string, list or tuple")
         self.items = {PolicyItem(item) for item in items}
         self.items.discard('none')
 
     def __repr__(self):
         return '{0.__class__.__name__}({1})'.format(self, sorted(self.items))
 
     def match(self, uri):
         if 'all' in self.items:
             return True
         elif not self.items:
             return False
         uri = re.sub('^(sip:|sips:)', '', str(uri))
         domain = uri.split('@')[-1]
         return uri in self.items or domain in self.items
 
 
 class ManagementInterfaceAddress(NetworkAddress):
     default_port = 20888
 
 
 # Configuration objects
 
 class GeneralConfig(ConfigSection):
     __cfgfile__ = 'webrtcgateway.ini'
     __section__ = 'General'
 
     web_origins = ConfigSetting(type=StringList, value=['*'])
     sip_domains = ConfigSetting(type=StringList, value=['*'])
     outbound_sip_proxy = ConfigSetting(type=SIPProxyAddress, value=None)
     trace_client = False
     websocket_ping_interval = 120
     recording_dir = ConfigSetting(type=Path, value=Path(os.path.join(ServerConfig.spool_dir.normalized, 'videoconference', 'recordings')))
     http_management_interface = ConfigSetting(type=ManagementInterfaceAddress, value=ManagementInterfaceAddress('127.0.0.1'))
     http_management_auth_secret = ConfigSetting(type=str, value=None)
     firebase_server_key = ConfigSetting(type=str, value=None)
 
 
 class JanusConfig(ConfigSection):
     __cfgfile__ = 'webrtcgateway.ini'
     __section__ = 'Janus'
 
     api_url = 'ws://127.0.0.1:8188'
     api_secret = '0745f2f74f34451c89343afcdcae5809'
     trace_janus = False
-    max_bitrate = ConfigSetting(type=VideoBitrate, value=VideoBitrate(4*1024*1024))  # 4 MBits/s
+    max_bitrate = ConfigSetting(type=VideoBitrate, value=VideoBitrate(2016000))  # ~2 MBits/s
     video_codec = ConfigSetting(type=VideoCodec, value=VideoCodec('vp9'))
 
 
 class RoomConfig(ConfigSection):
     __cfgfile__ = 'webrtcgateway.ini'
 
     record = False
     access_policy = ConfigSetting(type=AccessPolicyValue, value=AccessPolicyValue('allow, deny'))
     allow = ConfigSetting(type=PolicySettingValue, value=PolicySettingValue('all'))
     deny = ConfigSetting(type=PolicySettingValue, value=PolicySettingValue('none'))
     max_bitrate = ConfigSetting(type=VideoBitrate, value=JanusConfig.max_bitrate)
     video_codec = ConfigSetting(type=VideoCodec, value=JanusConfig.video_codec)
 
 
 class Configuration(object):
     def __init__(self, data):
         self.__dict__.update(data)
 
 
 def get_room_config(room):
     config_file = ConfigFile(RoomConfig.__cfgfile__)
     section = config_file.get_section(room)
     if section is not None:
         RoomConfig.read(section=room)
         config = Configuration(dict(RoomConfig))
         RoomConfig.reset()
     else:
         config = Configuration(dict(RoomConfig))  # use room defaults
     config.recording_dir = os.path.join(GeneralConfig.recording_dir, room)
     return config
diff --git a/webrtcgateway.ini.sample b/webrtcgateway.ini.sample
index 10f6e2b..21b4031 100644
--- a/webrtcgateway.ini.sample
+++ b/webrtcgateway.ini.sample
@@ -1,67 +1,67 @@
 ; SylkServer WebRTC gateway configuration file
 ;
 ; For the gateway to work Janus needs to be properly installed and configured,
 ; please refer to README.webrtc for detailed instructions
 ;
 [General]
 ; List of allowed web origins. The connection origin (Origin header in the
 ; HTTP request) will be checked against the list defined here, if the domain
 ; is no allowed the connection will be refused.
 ; * (the default) means any
 ; web_origins = *
 
 ; Proxy used for outbound SIP traffic
 ; outbound_sip_proxy =
 
 ; List of allowed SIP domains for managing accounts
 ; sip_domains = *
 
 ; Boolean indicating if the WebSocket messages sent to/from clients should be
 ; logged to a file
 ; trace_client = False
 
 ; WebSocket Ping frames are sent at the configured interval, this helps detect
 ; dead client connections
 ; websocket_ping_interval = 120
 
 ; IP and port for the HTTP management interface
 ; http_management_interface = 127.0.0.1:20888
 
 ; Shared secret for the HTTP management interface (Authorization: THE_KEY)
 ; http_management_auth_secret =
 
 ; Server key for Firebase Cloud Messaging
 ; firebase_server_key =
 
 [Janus]
 ; URL pointing to the Janus API endpoint (only WebSocket is supported)
 ; api_url = ws://127.0.0.1:8188
 
 ; API secret shared with Janus (must match the value in janus.cfg)
 ; A random UUID value is recommended, a new value can be generated with
 ; the following command:
 ; python -c 'import uuid; print(uuid.uuid4().hex)'
 api_secret = 0745f2f74f34451c89343afcdcae5809
 
 ; Boolean indicating if the messages between SylkServer and Janus should be
 ; logged to a file
 ; trace_janus = False
 
 ; Maximum video bitrate allowed per sender in a room in bits/s. This value is
 ; applied to any room that doesn't define its own. The value is any integer
-; number between 64000 and 4194304. Default value is 4194304 (4Mb/s).
-; max_bitrate = 4194304
+; number between 64000 and 4194304. Default value is 2016000 (~2Mb/s).
+; max_bitrate = 2016000
 
 ; The video codec to be used by all participants in a room. This value is
 ; applied to any room that doesn't define its own.
 ; Possible values are: h264, vp8 and vp9. Default is vp9.
 ; video_codec = vp9
 
 ; Per room configuration options
 ; [room1@videoconference.example.com]
 ; record = True
 ; access_policy = deny, allow
 ; deny = all
 ; allow = domain1.com, test1@example.com, test2@example.com
 ; max_bitrate = 512000
 ; video_codec = h264