End of Life for Twilio Programmable Video - Upgrade to VideoSDKLearn More

How to Build Rocket.Chat WebRTC App with JavaScript?

Learn how to set up and integrate WebRTC with Rocket.Chat for real-time video and audio communication. This comprehensive guide covers installation, configuration, and implementation steps.

Introduction to Rocket.Chat WebRTC

What is Rocket.Chat?

Rocket.Chat is an open-source communication platform designed to facilitate seamless collaboration and communication within organizations. It offers a comprehensive suite of features including real-time chat, audio and video calls, file sharing, and powerful integration capabilities with various tools and services. As a highly customizable and scalable solution, Rocket.Chat is widely used by businesses of all sizes to enhance their internal communication and collaboration efforts.

What is WebRTC?

WebRTC, short for Web Real-Time Communication, is a cutting-edge technology that enables real-time audio, video, and data sharing directly between web browsers without the need for plugins or additional software. It leverages a set of standardized protocols and APIs to facilitate peer-to-peer communication, making it a robust and efficient solution for applications requiring real-time interaction, such as video conferencing, live streaming, and file transfer.

Rocket.Chat and WebRTC Integration

The integration of WebRTC into Rocket.Chat significantly enhances its communication capabilities by enabling real-time audio and video calls within the platform. This integration allows users to initiate and participate in video conferences, screen sharing sessions, and collaborative meetings seamlessly. Rocket.Chat's implementation of WebRTC is designed to be user-friendly and highly functional, providing a reliable and high-quality communication experience. By leveraging WebRTC, Rocket.Chat ensures that users can maintain effective and efficient communication, regardless of their location, making it an ideal solution for remote teams and distributed organizations.
With this foundational understanding of Rocket.Chat and WebRTC, the subsequent sections will delve into the practical steps of setting up and utilizing Rocket.Chat's WebRTC features, guiding you through the process with detailed instructions and code snippets.

Getting Started with Rocket.Chat WebRTC

Create a New Rocket.Chat App

Creating a new Rocket.Chat application involves setting up the necessary environment and initializing the project. Follow these steps to get started:

[a] Clone the Rocket.Chat Repository


1   git clone https://github.com/RocketChat/Rocket.Chat.git
2   cd Rocket.Chat

[b] Install Node.js and MongoDB

Ensure you have Node.js (version 12 or later) and MongoDB installed on your system. You can download Node.js from


and MongoDB from



[c] Install Dependencies


1   npm install

Install Rocket.Chat

After cloning the repository and setting up your environment, the next step is to install Rocket.Chat. Here’s how to do it:

[a] Set Up Environment Variables

Create a .env file in the root directory and add the following environment variables:


1   MONGO_URL=mongodb://localhost:27017/rocketchat
2   ROOT_URL=http://localhost:3000
3   PORT=3000

[b] Start Rocket.Chat


1   npm start
This command will start the Rocket.Chat server, and you can access it by navigating to http://localhost:3000 in your web browser.

Structure of the Project

Understanding the structure of the Rocket.Chat project is crucial for effective development. The key components include:
  • app/ Directory: Contains the main application code, including modules for different features like messaging, authentication, and video calls.
  • client/ Directory: Holds the client-side code, including UI components and frontend logic.
  • server/ Directory: Contains server-side logic, API definitions, and database interactions.
  • packages/ Directory: Includes various packages and integrations used by Rocket.Chat.

App Architecture

Rocket.Chat's architecture is designed to be modular and scalable. The integration with WebRTC is achieved through a series of well-defined modules and APIs. Here’s a brief overview:
  • Frontend (Client): The frontend is built using React.js, providing a responsive and interactive user interface. It communicates with the backend via REST APIs and WebSockets.
  • Backend (Server): The backend is powered by Node.js and handles all the core functionalities, including real-time messaging, user authentication, and video call management.
  • Database: MongoDB is used as the primary database, storing user data, chat logs, and configuration settings.
  • WebRTC Integration: WebRTC is integrated into the Rocket.Chat platform using libraries such as Jitsi Meet or BigBlueButton for handling video and audio calls.
With the project set up and an understanding of its structure and architecture, you are ready to dive into the detailed implementation steps. The next sections will guide you through configuring and customizing Rocket.Chat to utilize its WebRTC capabilities effectively.

Step 1: Get Started with Configuration

Clone the Repository

To get started with Rocket.Chat and its WebRTC integration, the first step is to clone the repository from GitHub. This will give you access to the latest version of the Rocket.Chat codebase.


1   git clone https://github.com/RocketChat/Rocket.Chat.git
2   cd Rocket.Chat
This command will create a local copy of the Rocket.Chat repository on your machine.

Setting Up the Environment

Before you can run Rocket.Chat, you need to set up your development environment. This involves installing the necessary dependencies and configuring the environment variables.

[a] Install Node.js and MongoDB

Ensure that you have Node.js (version 12 or later) and MongoDB installed on your system. If not, you can download Node.js from


and MongoDB from



[b] Install Dependencies

Navigate to the Rocket.Chat directory and install the required dependencies using npm:


1   npm install

Initial Configuration

Now that you have installed the necessary dependencies, it's time to configure Rocket.Chat for the first run.

[a] Create a .env File

In the root directory of the Rocket.Chat project, create a .env file and add the following environment variables to configure the MongoDB connection and the application URL:


1   MONGO_URL=mongodb://localhost:27017/rocketchat
2   ROOT_URL=http://localhost:3000
3   PORT=3000

[b] Run MongoDB

Ensure that your MongoDB server is running. You can start it using the following command (the command may vary based on your OS):


1   mongod

Running the App

With your environment configured and MongoDB running, you can now start the Rocket.Chat application.

Start Rocket.Chat


1   npm start

Access the Application

Open your web browser and navigate to http://localhost:3000. You should see the Rocket.Chat login screen. Create an admin account and log in to explore the platform.

Initial Checks

After logging in, perform some initial checks to ensure everything is running smoothly:

Check Server Logs

Monitor the server logs in your terminal for any errors or warnings. This can help you identify and resolve any setup issues early on.

Test Basic Functionality

Send a few messages, create channels, and explore the user interface to ensure that the basic features are working as expected.
With these steps, you have successfully set up and configured Rocket.Chat on your local machine. The next sections will guide you through integrating WebRTC into Rocket.Chat, starting with designing the wireframe for the components needed to support real-time communication.

Step 2: Wireframe All the Components

Understanding the UI Components

Before diving into the code, it's important to understand the key UI components involved in integrating WebRTC into Rocket.Chat. The main components include:
  • Chat Interface: The primary interface where users interact through text messages.
  • Video Call Interface: The interface for initiating and managing video calls.
  • Controls Interface: Buttons and controls for muting, unmuting, starting, and stopping video/audio streams.
  • Participant List: A list of users currently in the chat or video call.

Designing the Wireframe

Creating a wireframe helps visualize the layout and interaction flow of the application. Here’s a basic outline for the wireframe:

Chat Interface

  • Message Input: An input field at the bottom for typing messages.
  • Message Display Area: A scrollable area displaying chat messages.
  • Video Call Button: A button to initiate a video call.

Video Call Interface

  • Local Video Stream: A small video window showing the user’s own video stream.
  • Remote Video Streams: Larger video windows for each participant in the call.
  • Controls: Buttons for mute/unmute, start/stop video, and end call.

Participant List

  • User Avatars: Thumbnails of user avatars with online/offline indicators.
  • Active Participants: Highlight users who are currently in the video call.

Implementing the Wireframe

With the wireframe in place, the next step is to translate it into actual UI code using HTML/CSS and JavaScript.

[a] Setting Up the HTML Structure

Create a basic HTML structure for the chat and video call interfaces:


1   <div id="chat-interface">
2     <div id="message-display-area"></div>
3     <input type="text" id="message-input" placeholder="Type a message...">
4     <button id="video-call-button">Start Video Call</button>
5   </div>
7   <div id="video-call-interface" style="display:none;">
8     <div id="local-video-stream"></div>
9     <div id="remote-video-streams"></div>
10     <div id="controls">
11       <button id="mute-button">Mute</button>
12       <button id="video-button">Stop Video</button>
13       <button id="end-call-button">End Call</button>
14     </div>
15   </div>
17   <div id="participant-list">
18     <!-- User avatars and participant status will be dynamically generated here -->
19   </div>

[b] Styling with CSS

Add some basic styles to layout the components neatly:


1   #chat-interface, #video-call-interface {
2     width: 100%;
3     max-width: 800px;
4     margin: auto;
5   }
7   #message-display-area {
8     height: 400px;
9     overflow-y: scroll;
10     border: 1px solid #ccc;
11     padding: 10px;
12   }
14   #message-input {
15     width: calc(100% - 120px);
16     padding: 10px;
17   }
19   #video-call-button {
20     padding: 10px 20px;
21   }
23   #video-call-interface {
24     display: flex;
25     flex-direction: column;
26     align-items: center;
27   }
29   #local-video-stream, #remote-video-streams {
30     margin: 10px 0;
31   }
33   #controls {
34     display: flex;
35     justify-content: space-around;
36     width: 100%;
37   }
39   #participant-list {
40     margin: 20px 0;
41   }

[c] Implementing the JavaScript Logic

Add JavaScript to handle UI interactions, such as starting a video call and updating the participant list:


1   document.getElementById('video-call-button').addEventListener('click', () => {
2     document.getElementById('chat-interface').style.display = 'none';
3     document.getElementById('video-call-interface').style.display = 'block';
4     // Initialize WebRTC video call here
5   });
7   document.getElementById('end-call-button').addEventListener('click', () => {
8     document.getElementById('chat-interface').style.display = 'block';
9     document.getElementById('video-call-interface').style.display = 'none';
10     // End WebRTC video call here
11   });
13   // Additional code to manage video streams and participant list will go here
With these steps, you have a basic wireframe and initial implementation for the Rocket.Chat WebRTC components. The next sections will focus on adding functionality to the join screen, implementing controls, and managing participant views.

Step 3: Implement Join Screen

Creating the Join Screen

The join screen is the first interface users interact with before entering a WebRTC session. It should be user-friendly and secure, allowing users to easily join the chat or video call. Here’s how to create and implement the join screen:

[a] Join Screen HTML Structure

Start by creating a simple HTML structure for the join screen:


1   <div id="join-screen">
2     <h2>Join Video Call</h2>
3     <form id="join-form">
4       <input type="text" id="username" placeholder="Enter your username" required>
5       <button type="submit">Join</button>
6     </form>
7   </div>

[b] Styling the Join Screen

Add CSS to style the join screen and make it visually appealing:


1   #join-screen {
2     display: flex;
3     flex-direction: column;
4     align-items: center;
5     justify-content: center;
6     height: 100vh;
7     background-color: #f7f7f7;
8     border: 1px solid #ccc;
9   }
11   #join-form {
12     display: flex;
13     flex-direction: column;
14     align-items: center;
15   }
17   #username {
18     padding: 10px;
19     margin: 10px 0;
20     width: 80%;
21     max-width: 300px;
22   }
24   #join-form button {
25     padding: 10px 20px;
26   }

User Authentication

To ensure secure access to the video call, implement basic user authentication. For this example, we’ll focus on simple username entry, but in a real application, you might integrate with a more robust authentication system.

[a] Join Form Submission

Add JavaScript to handle the join form submission:


1   document.getElementById('join-form').addEventListener('submit', function(event) {
2     event.preventDefault();
3     const username = document.getElementById('username').value;
4     if (username) {
5       localStorage.setItem('username', username);
6       window.location.href = 'chat.html'; // Redirect to the chat interface
7     }
8   });

[b] Retrieving Username

Ensure that the chat interface can retrieve the stored username:


1   document.addEventListener('DOMContentLoaded', function() {
2     const username = localStorage.getItem('username');
3     if (username) {
4       document.getElementById('welcome-message').textContent = `Welcome, ${username}`;
5     } else {
6       window.location.href = 'index.html'; // Redirect to join screen if no username found
7     }
8   });

UI/UX Considerations

Improving the user experience on the join screen is crucial. Here are a few tips:

[a] Responsive Design

Ensure that the join screen looks good on various devices and screen sizes.


1   @media (max-width: 600px) {
2     #join-screen {
3       padding: 20px;
4     }
6     #username {
7       width: 100%;
8     }
9   }

[b] Error Handling

Add error handling to guide users if they try to join without entering a username.


1   document.getElementById('join-form').addEventListener('submit', function(event) {
2     event.preventDefault();
3     const username = document.getElementById('username').value;
4     const errorMessage = document.getElementById('error-message');
5     if (username) {
6       localStorage.setItem('username', username);
7       window.location.href = 'chat.html'; // Redirect to the chat interface
8     } else {
9       errorMessage.textContent = 'Username is required to join the call.';
10       errorMessage.style.display = 'block';
11     }
12   });
Add the error message element to your HTML:


1   <p id="error-message" style="display:none; color:red;"></p>
With the join screen implemented, users now have a clear and secure entry point into the WebRTC-enabled Rocket.Chat interface. The next steps will involve implementing the controls for the video and audio streams, further enhancing the user experience and functionality of your Rocket.Chat application.

Step 4: Implement Controls

Adding Video/Audio Controls

To provide users with a fully functional video call experience, it's essential to implement controls for managing their audio and video streams. This includes features like muting/unmuting the microphone and starting/stopping the video.

[a] HTML Structure for Controls

Add the necessary buttons to the video call interface:


1   <div id="video-call-interface" style="display:none;">
2     <div id="local-video-stream"></div>
3     <div id="remote-video-streams"></div>
4     <div id="controls">
5       <button id="mute-button">Mute</button>
6       <button id="video-button">Stop Video</button>
7       <button id="end-call-button">End Call</button>
8     </div>
9   </div>

[b] JavaScript for Controls

Implement JavaScript functions to handle the controls:


1   let localStream;
3   document.getElementById('mute-button').addEventListener('click', () => {
4     const audioTrack = localStream.getAudioTracks()[0];
5     if (audioTrack.enabled) {
6       audioTrack.enabled = false;
7       document.getElementById('mute-button').textContent = 'Unmute';
8     } else {
9       audioTrack.enabled = true;
10       document.getElementById('mute-button').textContent = 'Mute';
11     }
12   });
14   document.getElementById('video-button').addEventListener('click', () => {
15     const videoTrack = localStream.getVideoTracks()[0];
16     if (videoTrack.enabled) {
17       videoTrack.enabled = false;
18       document.getElementById('video-button').textContent = 'Start Video';
19     } else {
20       videoTrack.enabled = true;
21       document.getElementById('video-button').textContent = 'Stop Video';
22     }
23   });
25   document.getElementById('end-call-button').addEventListener('click', () => {
26     // Logic to end the call and close connections
27     window.location.href = 'chat.html'; // Redirect back to chat interface
28   });
30   // Function to initialize local stream
31   async function initLocalStream() {
32     try {
33       localStream = await navigator.mediaDevices.getUserMedia({ video: true, audio: true });
34       document.getElementById('local-video-stream').srcObject = localStream;
35     } catch (error) {
36       console.error('Error accessing media devices.', error);
37     }
38   }
40   // Call the function to initialize the stream when video call interface loads
41   document.addEventListener('DOMContentLoaded', () => {
42     if (document.getElementById('video-call-interface').style.display !== 'none') {
43       initLocalStream();
44     }
45   });

Screen Sharing

Screen sharing is a valuable feature for collaborative work, allowing users to share their screens during a video call.

[a] HTML Structure for Screen Sharing

Add a screen sharing button to the controls:


1   <button id="screen-share-button">Share Screen</button>

[b] JavaScript for Screen Sharing

Implement the screen sharing functionality:


1   document.getElementById('screen-share-button').addEventListener('click', async () => {
2     try {
3       const screenStream = await navigator.mediaDevices.getDisplayMedia({ video: true });
4       const videoTrack = screenStream.getVideoTracks()[0];
5       videoTrack.onended = () => {
6         document.getElementById('screen-share-button').textContent = 'Share Screen';
7       };
8       localStream.getVideoTracks()[0].stop();
9       localStream.removeTrack(localStream.getVideoTracks()[0]);
10       localStream.addTrack(videoTrack);
11       document.getElementById('local-video-stream').srcObject = localStream;
12       document.getElementById('screen-share-button').textContent = 'Stop Sharing';
13     } catch (error) {
14       console.error('Error sharing screen.', error);
15     }
16   });

Additional Features

Enhancing the controls with additional features can greatly improve the user experience.

[a] Chat During Video Call

Allow users to send chat messages during a video call.


1   <div id="video-chat-interface">
2     <div id="video-chat-messages"></div>
3     <input type="text" id="video-chat-input" placeholder="Type a message...">
4     <button id="video-chat-send-button">Send</button>
5   </div>

[b] JavaScript for Video Chat

Implement the functionality for sending and displaying chat messages:


1   document.getElementById('video-chat-send-button').addEventListener('click', () => {
2     const message = document.getElementById('video-chat-input').value;
3     if (message) {
4       // Display the message in the chat interface
5       const messageElement = document.createElement('div');
6       messageElement.textContent = message;
7       document.getElementById('video-chat-messages').appendChild(messageElement);
8       document.getElementById('video-chat-input').value = '';
9     }
10   });
By implementing these controls and additional features, users can effectively manage their audio and video streams, share their screens, and communicate through chat during video calls. The next step will focus on implementing the participant view, allowing users to see and interact with multiple participants during a video call.

Get Free 10,000 Minutes Every Months

No credit card required to start.

Step 5: Implement Participant View

Participant Layout

To provide a seamless video conferencing experience, it's essential to design a participant view that displays all active participants in a video call. This section will guide you through setting up a layout to handle multiple video streams.

[a] HTML Structure for Participant View

Modify the HTML to include a section for participant video streams:


1   <div id="video-call-interface" style="display:none;">
2     <div id="local-video-stream"></div>
3     <div id="remote-video-streams"></div>
4     <div id="participant-view">
5       <!-- Participant video elements will be added here dynamically -->
6     </div>
7     <div id="controls">
8       <button id="mute-button">Mute</button>
9       <button id="video-button">Stop Video</button>
10       <button id="screen-share-button">Share Screen</button>
11       <button id="end-call-button">End Call</button>
12     </div>
13   </div>

[b] Styling the Participant View

Add CSS to style the participant video streams:


1   #participant-view {
2     display: flex;
3     flex-wrap: wrap;
4     justify-content: center;
5     margin-top: 20px;
6   }
8   .participant-video {
9     width: 200px;
10     height: 150px;
11     margin: 10px;
12     border: 1px solid #ccc;
13   }

Real-time Updates

Ensure that the participant view updates in real-time as participants join or leave the video call.

JavaScript for Adding/Removing Participants

Implement JavaScript to handle participant updates:


1   const participants = {};
3   function addParticipant(id, stream) {
4     const videoElement = document.createElement('video');
5     videoElement.classList.add('participant-video');
6     videoElement.srcObject = stream;
7     videoElement.autoplay = true;
8     videoElement.id = `participant-${id}`;
9     document.getElementById('participant-view').appendChild(videoElement);
10     participants[id] = videoElement;
11   }
13   function removeParticipant(id) {
14     const videoElement = document.getElementById(`participant-${id}`);
15     if (videoElement) {
16       videoElement.srcObject = null;
17       videoElement.remove();
18       delete participants[id];
19     }
20   }
22   // Example usage: Adding a participant
23   // addParticipant('participant1', someStream);
25   // Example usage: Removing a participant
26   // removeParticipant('participant1');

Customizing Views

Allow users to customize their participant views for a better user experience.

[a] Toggling Layouts

Add functionality to toggle between different participant view layouts (e.g., grid view, speaker view).


1   <button id="toggle-layout-button">Toggle Layout</button>


1   let isGridView = true;
3   document.getElementById('toggle-layout-button').addEventListener('click', () => {
4     isGridView = !isGridView;
5     document.getElementById('participant-view').style.flexDirection = isGridView ? 'row' : 'column';
6   });

[b] Highlighting Active Speaker

Highlight the video stream of the active speaker.


1   function highlightActiveSpeaker(id) {
2     Object.keys(participants).forEach(participantId => {
3       const videoElement = participants[participantId];
4       if (participantId === id) {
5         videoElement.style.border = '2px solid blue';
6       } else {
7         videoElement.style.border = '1px solid #ccc';
8       }
9     });
10   }
12   // Example usage: Highlight active speaker
13   // highlightActiveSpeaker('participant1');
With these implementations, users can see all participants in the call, and the view will update dynamically as participants join or leave. Additionally, they can toggle between different layouts and easily identify the active speaker. The next and final step will focus on running the complete code and performing necessary checks to ensure everything is functioning correctly.

Step 6: Run Your Code Now

Final Checks

Before running your Rocket.Chat application with WebRTC integration, ensure that all configurations and implementations are correctly set up. Here are some final checks to perform:

Environment Setup

  • Verify that Node.js and MongoDB are installed and running.
  • Ensure that your .env file is correctly configured with the necessary environment variables.


  • Ensure that all dependencies are installed. Run npm install to check and install any missing packages.

Code Review

  • Review your code for any syntax errors or missing components.
  • Ensure that all necessary HTML elements, CSS styles, and JavaScript functions are implemented as described in the previous sections.

Running the Application

With everything set up, you can now run your Rocket.Chat application and test the WebRTC integration.

Start Rocket.Chat


1   npm start

Access the Application

Open your web browser and navigate to http://localhost:3000. You should see the Rocket.Chat login screen.

Create Admin Account

Follow the prompts to create an admin account and log in to the application.

Test Functionality

  • Join Screen:
    • Navigate to the join screen and enter a username to join the video call.
  • Video Call Interface:
    • Verify that the video call interface displays correctly.
    • Test the video/audio controls, screen sharing, and participant view features.
  • Participant View:
    • Ensure that participant video streams are displayed and updated correctly as users join and leave the call.
    • Test the layout toggling and active speaker highlighting functionalities.


If you encounter any issues, here are some common troubleshooting tips:

No Video/Audio

  • Ensure that your browser has permission to access the camera and microphone.
  • Check for any errors in the console log related to media device access.

Participants Not Displaying

  • Verify that the participant management functions (addParticipant and removeParticipant) are correctly implemented.
  • Ensure that the WebRTC peer connection is established correctly between participants.

Screen Sharing Issues

  • Ensure that your browser supports screen sharing and that the necessary permissions are granted.
  • Check for any errors in the console log related to screen sharing.


Congratulations! You have successfully set up Rocket.Chat with WebRTC integration, providing real-time video and audio communication capabilities. This implementation enhances the collaboration experience within Rocket.Chat, making it a powerful tool for remote teams and distributed organizations.

Want to level-up your learning? Subscribe now

Subscribe to our newsletter for more tech based insights