In an era dominated by digital communication, webinars and online meetings have become indispensable. Yet, many organizations find themselves trapped in the rigid, often expensive, ecosystems of proprietary software like Zoom or GoToWebinar. These tools, while convenient, often come with hidden costs, limited customization, and significant concerns about data privacy and ownership.
\nWhat if you could host professional webinars and meetings with unparalleled control, complete data privacy, and the flexibility to tailor every aspect to your brand and workflow? This is the promise of open source webinar software and self-hosted meeting platforms. At plugNmeet, we believe in empowering you to reclaim ownership of your digital interactions.
\nWhen you search for \"open source webinar software,\" you're looking for freedom. You want to own your brand, manage your audience, and create a unique, professional presentation without being locked into a vendor's ecosystem.
\nProprietary webinar tools often treat a webinar like a glorified meeting, lacking the specific features needed for a structured, engaging event. An open-source platform, however, allows for:
\nOpen source isn't just about cost; it's about community, transparency, and the ability to adapt the software to your exact needs, rather than adapting your needs to the software.
\nThe \"self-hosted meeting\" aspect takes control to the next level. When you host your own video conferencing infrastructure, you gain benefits that proprietary cloud services simply cannot offer:
\nplugNmeet is built from the ground up to deliver on these promises. As an open-source, WebRTC-based platform, it provides the flexible, powerful, and secure foundation you need to build a professional, branded, and automated webinar and meeting experience that is truly your own.
\nKey features that highlight our commitment to open source and self-hosting include:
\nIn a world where digital interactions are paramount, settling for generic, proprietary solutions means sacrificing control, privacy, and the ability to truly brand and tailor your user experience.
\nChoose an open source webinar software and self-hosted meeting platform like plugNmeet to empower your organization with a secure, scalable, and fully customized video conferencing solution. Reclaim ownership of your communication and deliver an unparalleled experience to your users.
\nReady to build your perfect webinar and meeting platform?
\nIn today's interconnected world, video conferencing has become indispensable. But as businesses, educators, and healthcare professionals rely more heavily on these tools, a critical question arises: who truly controls your communication? Proprietary solutions often come with hidden costs, limited flexibility, and significant privacy concerns.
\nEnter plugNmeet: an open-source, self-hosted WebRTC platform designed to give you ultimate control, unparalleled customization, and robust security, fundamentally outperforming generic, off-the-shelf alternatives.
\nWhen you choose a proprietary video conferencing service, your data resides on their servers, subject to their policies, security practices, and potential data mining. Self-hosting with plugNmeet flips this script, putting you firmly in command.
\nMany \"white-label\" solutions merely allow you to swap a logo. plugNmeet offers a level of customization that transforms the platform into an integral part of your ecosystem, not just an embedded tool.
\ngetClientFiles API even allows you to inject the client directly into your application for a truly native feel, as detailed in our Design Customization Guide and getClientFiles API Documentation.While control and customization are paramount, plugNmeet also boasts a rich set of features that rival, and often surpass, proprietary offerings.
\nWorried about switching from an existing platform? plugNmeet makes it easy.
\nIn a world increasingly reliant on digital communication, settling for generic, proprietary video conferencing solutions means sacrificing control, privacy, and the ability to truly brand and tailor your user experience.
\nplugNmeet offers a powerful, open-source alternative that empowers you to build a secure, scalable, and fully customized video conferencing platform that is truly your own. Reclaim ownership of your communication and deliver an unparalleled experience to your users.
\nReady to take control of your video conferencing?
\nYour organization relies on video conferencing. It's essential for team meetings, sales demos, and customer support. But as your company grows, your monthly bill from services like Zoom, Google Meet, or Microsoft Teams is growing with it. That predictable per-user, per-month fee is starting to look less like a convenience and more like a major operational expense.
\nWhat if you could cut that bill by up to 80% while gaining more control and better branding?
\nIt's not a fantasy. By switching from a proprietary SaaS \"rental\" model to a self-hosted \"ownership\" model with an open-source platform like Plug-N-Meet, you can dramatically reduce your Total Cost of Ownership (TCO). This article will break down the numbers and show you how.
\nThe pricing model for most SaaS video platforms is simple and seductive: a flat fee per host, per month. It's easy to budget for when you have 10 employees. But what happens when you have 100?
\nLet's look at a common scenario.
\nScenario: A Company with 50 Hosts
\nThis is a significant, recurring operational expense (OpEx). And it gets worse. This model penalizes you for success. If your company grows to 100 hosts, your bill doubles to nearly $20,000 per year. You are paying more for the exact same service, simply because your team is bigger.
\nNow, let's compare this to a self-hosted model using the open-source Plug-N-Meet platform. With this model, you don't pay any license fees. Your only significant cost is the server hardware you run the software on.
\nScenario: The Same Company with 50 Hosts (or 100, or 200)
\nLet's compare the annual costs:
\nThat's a cost reduction of over 92%.
\nEven if you choose a more expensive cloud provider or a larger server for higher capacity, the savings are dramatic. A comparable server on DigitalOcean or AWS might cost $150-$250 per month, which still represents a cost saving of over 80% compared to the SaaS alternative.
\nThe best part? This cost is fixed. If your company grows from 50 to 100 hosts, your server cost doesn't change. You can accommodate more users for the same price, rewarding your growth instead of penalizing it.
\nSkeptics of self-hosting often point to hidden costs like maintenance and setup. Let's address those directly.
\nWhen you weigh a few hours of optional maintenance per year against a potential saving of thousands of dollars, the financial case becomes overwhelmingly clear.
\nThe per-user, per-month SaaS model is a brilliant business strategy—for the provider. For the customer, it's a treadmill of escalating costs that actively works against your growth.
\nBy switching to a self-hosted, open-source platform like Plug-N-Meet, you move from being a tenant to an owner. You gain a predictable, low-cost infrastructure that scales with your success. You also get the invaluable strategic benefits of full brand control, deeper integration, and absolute data privacy.
\nIf your organization is feeling the pain of rising SaaS subscription costs, it's time to run the numbers. The move to self-hosting isn't just a technical decision; it's one of the smartest financial decisions you can make.
\nReady to slash your video conferencing costs?
\nAs an educator, your primary goal is to create a safe, respectful, and effective learning environment. In a physical classroom, you have established routines for this: you close the door to prevent interruptions, you set rules for speaking, and you manage the flow of the conversation.
\nBut how do you replicate this in a virtual classroom? An unsecured online meeting can quickly devolve into chaos, with uninvited guests, background noise, and constant interruptions.
\nThis guide will walk you through the simple but powerful tools available in Plug-N-Meet that allow you to take control of your digital classroom. Think of these features as your new classroom management toolkit, designed to ensure your online sessions are as safe, private, and productive as your in-person ones.
\nYou wouldn't let just anyone walk into your classroom off the street. The same principle should apply online. The Waiting Room is your digital lobby, giving you complete control over who enters your session.
\nHow to Enable it: You can enable the Waiting Room in your room settings when you create the class in your LMS (like Moodle) or via the API.
\nOnce your students are in the room, you need to set the ground rules for participation. Plug-N-Meet's Room Lock Settings panel is your command center for this.
\nPro Tip: Use these settings dynamically. Start your class with everything unlocked for a few minutes of social time, then lock microphones and chat when the formal lesson begins.
\nFor sensitive conversations, such as a one-on-one meeting with a student or a parent, you may need the highest possible level of privacy. End-to-End Encryption (E2EE) provides a mathematical guarantee that no one—not even the server administrator—can access the audio or video of your conversation.
\nHow to Enable it: E2EE can be enabled on a per-room basis. Our guide on How to Enable E2EE explains the simple steps. It's important to note that when you enable the highest level of E2EE, features that require the server to \"see\" the media, like cloud recording, are automatically disabled for your protection.
\nA secure and productive online classroom doesn't happen by accident. It happens by design. By using these simple but powerful features, you can move from being a passive host to an active and effective classroom manager.
\nStart with the Waiting Room to control who enters, use the Lock Settings to manage the flow of conversation, and deploy E2EE for sensitive discussions. With these tools at your fingertips, you can create a virtual learning environment that is just as safe, private, and conducive to learning as your physical classroom.
\nReady to take control of your virtual classroom?
\nYour brand is your most valuable asset. You've invested countless hours and resources into building a unique identity, a memorable customer experience, and a relationship of trust with your audience.
\nSo why, at the most critical moment of interaction—a sales demo, a customer support call, or a training session—do you send your customers to a third-party platform with someone else's logo on it?
\nUsing a generic, off-the-shelf video conferencing tool is like a Michelin-starred restaurant serving its food in a McDonald's box. It breaks the experience, erodes brand value, and misses a huge opportunity. This is why forward-thinking businesses are moving away from generic SaaS tools and embracing white-labeled video conferencing solutions like Plug-N-Meet.
\nA white-label platform isn't just about changing the logo. It's about owning the entire customer journey and transforming a simple utility into a powerful strategic asset.
\nImagine a new client is paying you for a premium consultation. You send them a meeting link. Which of these inspires more confidence?
\nyour-company.zoom.usmeet.your-company.comThe answer is obvious. When the entire experience—from the URL to the logo in the corner to the brand colors of the interface—is yours, it sends a powerful message: you are professional, you are established, and you have invested in your own platform. It removes the jarring feeling of being handed off to another company and keeps the focus entirely on your brand.
\nA white-labeled solution, especially one that can be deeply integrated, eliminates the \"context switching\" that plagues generic tools. Instead of your user having to open a separate app or a new tab that looks completely different from your website, the video experience feels like a natural extension of your own digital property.
\nWith a platform like Plug-N-Meet, you can use the getClientFiles API to embed the video client directly into your own application or customer portal. This means you can:
This seamlessness reduces friction, improves usability, and keeps your user engaged within your ecosystem.
\nNot all conversations are the same. A one-on-one sales call has very different needs than a 100-person training webinar.
\nGeneric platforms offer a one-size-fits-all approach. A white-label, API-first platform gives you granular control to tailor the experience to the specific use case.
\nThis ability to programmatically define the user journey means you can deliver the perfect, purpose-built tool for every interaction, which is a level of service generic platforms can't match.
\nWhen you pay a per-user subscription for a generic SaaS tool, video conferencing is a cost center that grows as your team grows.
\nWhen you own your platform, you flip the model. Because a self-hosted solution like Plug-N-Meet has no per-user fees, you can offer video conferencing services to your own customers. With our official plugins for WordPress and Joomla, you can even use membership and e-commerce extensions to sell access to premium, branded meeting rooms—no coding required.
\nYou transform a monthly expense into a revenue-generating product.
\nEvery time a customer joins a meeting on a generic platform, you are paying to advertise for that platform.
\nA white-labeled video conferencing solution is an investment in your own brand. It enhances trust, creates a superior customer experience, and gives you the control to build a communication tool that perfectly fits your business. In a competitive market, owning this critical touchpoint is not a luxury; it's a strategic necessity.
\nReady to put your brand front and center?
\nJoomla is a powerhouse for building robust, flexible websites, from community portals to sophisticated business sites. But when it's time to engage your audience with live video, you might find yourself sending them away from the beautiful site you've built to a generic, third-party conferencing tool. This breaks the user experience and undermines your brand.
\nWhat if you could integrate a secure, fully-branded, and powerful video conferencing solution directly into your Joomla site, making it a native part of your user's journey?
\nWith the official Plug-N-Meet component for Joomla, you can. This guide will show you how to transform your Joomla website into a dynamic communication platform, perfect for community meetings, webinars, online training, and even monetized services.
\nBefore we get into the setup, let's be clear about the strategic advantages of using a self-hosted, integrated solution like Plug-N-Meet instead of an external SaaS tool.
\nYou can have a live video meeting room on your Joomla site in under 15 minutes.
\nFirst, you need the server that will power your video calls. You can either self-host the open-source version with our simple installation script or get an instant, managed server from plugnmeet Cloud. Both will provide you with an API Key and API Secret.
\nFrom your Joomla administrator panel:
\nYour Joomla site is now fully connected to your video conferencing engine.
\nThat's it. A new link will appear on your site's main menu, leading directly to your fully functional, branded video conferencing room.
\nWith the basics in place, you can now leverage Plug-N-Meet to build sophisticated video-based services.
\nIf you're a consultant, coach, or provide any one-on-one service, you can create private, secure meeting rooms for your clients.
\nHost live webinars and events directly on your site to engage your community.
\nThis is where you can turn your Joomla site into a revenue-generating business. By combining Plug-N-Meet with a Joomla membership or e-commerce extension, you can sell access to premium video content. For a detailed walkthrough, see our guide on How to Launch Your Own No-Code Video Conferencing Service with Joomla.
\nNow, only paying subscribers will be able to see the link and join your exclusive video sessions, creating an automated paywall.
\nDon't let external tools dictate your user experience. With the Plug-N-Meet component, you can seamlessly integrate a secure, scalable, and fully-branded video conferencing platform into the Joomla ecosystem.
\nIt's a solution that's simple enough to get started in minutes but powerful enough to build a business on.
\nReady to power up your Joomla site?
\nAs an educator or administrator on Moodle, your goal is to create a seamless and engaging learning environment. But when it's time for a live virtual class, many are forced to compromise, sending students to an external Zoom or Teams link. This breaks the learning flow, creates a disjointed user experience, and raises valid concerns about student data privacy.
\nWhat if your virtual classroom was just another native Moodle activity, as easy to add as a quiz or a forum? What if it was a powerful, interactive space designed specifically for teaching, not just a generic meeting room?
\nWith the official Plug-N-Meet plugin for Moodle, this is not just possible; it's simple. This guide will show you how to transform your Moodle site into a world-class, interactive e-learning platform.
\nBefore we get to the \"how,\" let's focus on the \"why.\" Choosing a deeply integrated, self-hosted solution like Plug-N-Meet over a generic SaaS tool provides three critical advantages for any educational institution.
\nGetting started is incredibly fast. You can have your first meeting room live in under 15 minutes. For a more detailed walkthrough, you can also read our popular guide on How to Add No-Code Video Conferencing to Your Moodle Courses.
\nFirst, you need the server that will power your video calls. You can either self-host the open-source version with our simple installation script or get an instant, managed server from plugnmeet Cloud. Both will provide you with an API Key and API Secret.
\nFrom your Moodle Site Administration panel:
\nYour Moodle site is now fully integrated with your video conferencing engine.
\nThat's it. Your students can now join a powerful, interactive virtual classroom directly from their Moodle course page.
\nPlug-N-Meet is more than just a lecture tool. It's a suite of features designed for modern pedagogy.
\nTransform a passive lecture into an engaging, two-way experience.
\nFor project-based learning and group work, the Breakout Rooms feature is essential.
\nFor private conversations, you need a higher level of security.
\nStop compromising with external tools that break the learning experience. By integrating Plug-N-Meet, you can offer your teachers and students a powerful, secure, and seamlessly integrated virtual classroom that lives right where it belongs: inside Moodle.
\nIt's a solution that's simple enough for any teacher to use but powerful enough to support the most innovative online teaching methods.
\nReady to enhance your Moodle courses?
\nWordPress has empowered millions to build anything from a simple blog to a complex e-commerce empire. But when it comes to one of the most critical forms of modern communication—live video—many site owners hit a wall. You're often left juggling clunky Zoom links, sending your users to third-party platforms, and sacrificing the professional, branded experience your website was designed to provide.
\nWhat if you could integrate a powerful, secure, and fully-branded video conferencing solution directly into your WordPress site as easily as you add a new page?
\nThis is not just possible; it's simple. This guide will show you how to use the Plug-N-Meet plugin to transform your WordPress site into a true communication hub, whether you need a simple meeting room, a platform for webinars, or a full-fledged, monetized video service.
\nBefore we dive into the \"how,\" let's cover the \"why.\" While embedding a Zoom meeting is an option, a self-hosted solution like Plug-N-Meet offers three transformative advantages for any serious WordPress site owner:
\nGetting started is incredibly fast. You can have your first meeting room live in under 15 minutes.
\nFirst, you need the server that will power your video calls. You can either self-host the open-source version with our simple installation script or get an instant, managed server from plugnmeet Cloud. Both will provide you with an API Key and API Secret.
\nFrom your WordPress dashboard:
\nYour WordPress site is now fully integrated with your video conferencing engine.
\n[plugnmeet_room_view id=\"your_room_id\"]).That's it. You now have a fully functional, branded video conferencing room running directly on your own website.
\nOnce you've mastered the basics, you can leverage Plug-N-Meet to power a wide range of professional services.
\nAre you a coach, consultant, or therapist? You can easily create secure, private rooms for your client sessions.
\nWant to host a webinar for your audience? Plug-N-Meet is a powerful open-source webinar platform.
\nThis is where you can turn your video feature into a revenue stream. By combining Plug-N-Meet with a popular membership plugin (like Paid Memberships Pro, MemberPress, or Restrict Content Pro), you can create premium video content exclusively for paying subscribers. For a detailed walkthrough of this business model, see our guide on How to Launch Your Own No-Code Video Conferencing Service with WordPress.
\nNow, you have a secure, automated paywall for your exclusive video content.
\nThe Plug-N-Meet WordPress plugin isn't just for basic meetings. It gives you simple, one-click access to enterprise-grade features directly from your room settings.
\nStop treating live video as an afterthought. With Plug-N-Meet, you can seamlessly integrate a secure, scalable, and fully-branded video conferencing platform into the WordPress ecosystem you already know and love.
\nIt's a solution that's simple enough to start in minutes but powerful enough to grow with your biggest ambitions.
\nReady to power up your WordPress site?
\nYou've successfully integrated Plug-N-Meet into your application. You can create rooms, generate join tokens, and embed the client in an <iframe>. It's fast and it works. But now you want to go deeper. You want to break out of the <iframe> box and build a truly seamless user experience where the video client feels like a native part of your application's UI.
This is where Plug-N-Meet's \"headless\" integration mode comes in.
\nThis guide is for developers who want to move beyond basic embedding. We'll show you how to use the powerful getClientFiles API to render the Plug-N-Meet client directly into your own page's DOM, giving you ultimate control over layout, branding, and the user experience.
An <iframe> is a simple way to embed content, but it's essentially a \"window\" into another website. This creates several limitations for developers aiming for a professional, deeply integrated product:
<iframe> creates a hard boundary between your parent application and the video client, making communication between them complex and limited.src URL. You can't easily place your own application's components (like a custom header or a sidebar with user data) \"inside\" the video experience.getClientFilesThe getClientFiles API is the key to unlocking a truly \"headless\" video integration. Instead of providing you with a URL to embed, it gives you a list of the exact CSS and JavaScript assets you need to render the client yourself.
This approach transforms Plug-N-Meet from a separate application into a UI component library that you control.
\nThe logic is simple and can be implemented in any backend language (PHP, Node.js, Python, etc.).
\n/auth/getClientFiles endpoint.css and js, listing the filenames of all the necessary assets.<link> and <script> Tags: Your server-side templating engine loops through these arrays and dynamically injects the required tags into the HTML page that will be sent to the user's browser.Let's walk through a simplified example using Node.js and the EJS templating engine.
\nserver.js)This route will handle the API calls and render the final page.
\nimport express from 'express';
import { PlugNmeet } from 'plugnmeet-sdk-js';
const app = express();
app.set('view engine', 'ejs');
// Your Plug-N-Meet credentials (use environment variables in production)
const API_KEY = 'plugnmeet';
const API_SECRET = 'zumyyYWqv7KR2kUqvYdq4z4sXg7XTBD2ljT6';
const PLUGNMEET_URL = 'https://demo.plugnmeet.com';
const pnm = new PlugNmeet(PLUGNMEET_URL, API_KEY, API_SECRET);
app.get('/meeting', async (req, res) => {
try {
// 1. Get the asset files
const clientFiles = await pnm.getClientFiles();
// 2. Create a room and generate a join token for the user
const room = {
room_id: 'my-custom-room',
metadata: {
room_title: 'My Custom UI Room',
room_features: {
allow_webcams: true,
// ... other features
},
},
};
await pnm.createRoom(room);
const joinToken = await pnm.getJoinToken({
room_id: 'my-custom-room',
user_info: {
name: 'John Doe',
user_id: 'user-123',
},
});
// 3. Define dynamic branding options
const designOptions = {
primary_color: '#004D90',
secondary_color: '#24AEF7',
custom_logo: 'https://my-app.com/logo.png',
};
// 4. Render the view, passing all the necessary data
res.render('meeting', {
plugnmeetUrl: PLUGNMEET_URL,
clientFiles: clientFiles.res,
accessToken: joinToken.res.token,
designOptions: JSON.stringify(designOptions),
});
} catch (error) {
console.error(error);
res.status(500).send('Error setting up meeting');
}
});
app.listen(3000, () => console.log('Server started on port 3000'));
views/meeting.ejs)This EJS file will take the data from the backend and construct the HTML page.
\n<!DOCTYPE html>
<html lang=\"en\">
<head>
<title>My Custom Video App</title>
<!-- Dynamically inject CSS files -->
<% clientFiles.css.forEach(file => { %>
<link href=\"<%= plugnmeetUrl %>/assets/css/<%= file %>\" rel=\"stylesheet\" />
<% }); %>
<!-- Inject essential window variables BEFORE loading scripts -->
<script type=\"text/javascript\">
window.plugNmeetConfig = {
// Required: The URL of your plugNmeet server.
serverUrl: \"<%= plugnmeetUrl %>\",
// Required: The public path to the assets directory.
staticAssetsPath: \"<%= plugnmeetUrl %>/assets\",
// Required: Pass the design customization options.
designCustomization: <%- designOptions %>,
// Optional: Add any other custom configurations.
// See: https://github.com/mynaparrot/plugNmeet-client/blob/main/src/assets/config_sample.js
enableSimulcast: true,
enableDynacast: true
};
</script>
</head>
<body>
<!-- Your Custom Application UI -->
<header style=\"background: #0A1929; color: white; padding: 1rem;\">
<h1>My Application Header</h1>
</header>
<div style=\"display: flex;\">
<!-- The Plug-N-Meet client will mount itself in this div -->
<div id=\"plugNmeet-app\" style=\"flex-grow: 1; height: 90vh;\"></div>
<!-- Your Custom Application Sidebar -->
<aside style=\"width: 250px; background: #f4f4f4; padding: 1rem;\">
<h2>Meeting Notes</h2>
<p>This sidebar is part of my parent application!</p>
</aside>
</div>
<!-- Dynamically inject JavaScript files -->
<% clientFiles.js.forEach(file => { %>
<% if (file.startsWith('main-module.')) { %>
<script src=\"<%= plugnmeetUrl %>/assets/js/<%= file %>\" type=\"module\"></script>
<% } else { %>
<script src=\"<%= plugnmeetUrl %>/assets/js/<%= file %>\" defer></script>
<% } %>
<% }); %>
<script>
// Add the access token to the URL without reloading the page
const url = new URL(window.location);
url.searchParams.set('access_token', '<%= accessToken %>');
window.history.pushState({}, '', url);
</script>
</body>
</html>
When a user visits /meeting, they will see your application's custom header and sidebar, with the Plug-N-Meet video client rendered seamlessly in the middle. The client will be styled with the dynamic brand colors you passed from the backend.
You have successfully broken out of the <iframe> box.
From here, the possibilities are endless. You can use your own application's state to interact with the meeting, build custom layouts that respond to meeting events, and create a user experience that is completely unique to your product.
\nThis is the true power of a headless, API-first platform. It gives you the building blocks not just to add a feature, but to build a deeply integrated and professional product.
\nReady to build your custom UI?
\ngetClientFiles API Documentation.Your video service is a hit. User numbers are climbing, and engagement is high. But as you celebrate your success, a new problem emerges: your server bill is exploding. To keep up with demand, you keep buying bigger and bigger servers, paying a premium for resources that sit idle most of the day.
\nWhat went wrong? You've fallen into the monolith trap.
\nThis post explains how Plug-N-Meet's modern, decoupled architecture is designed to prevent this exact problem, enabling you to scale your service efficiently and control your costs. For a business, this isn't just a technical detail—it's a core financial advantage.
\nMany traditional video conferencing platforms are built as monoliths. This means the core application, the media processing, and the recording services are all bundled into a single, massive application.
\nThis creates a huge problem when it's time to scale:
\nA monolithic server is like renting a giant bus for a single passenger. You pay for all the empty seats, and if one part of the bus breaks down, the whole trip is canceled.
\nPlug-N-Meet was designed from the ground up to avoid this trap. It is not one giant application; it is a set of specialized, independent services that work together.
\nThe three core components are:
\nplugnmeet-server (The Brain): A lightweight Go application that handles all the API calls, authentication, and business logic.LiveKit (The Media Highway): A high-performance, open-source media server that manages all the real-time audio and video traffic.plugnmeet-recorder (The Factory): A dedicated Go application that handles CPU-intensive tasks like MP4 recording and RTMP broadcasting.These components are designed to be scaled independently. This is the key to cost-effective growth.
\nWith a decoupled architecture, you can scale each component based on your actual needs.
\nLiveKit media servers for the duration of the event, then spin them down afterward.This is like adding more cashiers to a store only during the holiday rush. You get the performance you need when you need it, and you don't pay for idle resources during quiet periods.
\nIn a monolith, a resource-hungry task can degrade the entire user experience. If someone starts a large recording, everyone's live video call could suffer.
\nPlug-N-Meet's architecture prevents this. Because the plugnmeet-recorder is a separate service, you can run it on entirely different machines from your live media servers.
\"Scalable\" isn't just a technical buzzword; it's a business feature. The ability to scale components independently and isolate workloads means you are not constantly over-provisioning your hardware. You pay only for the resources you actually use.
\nAs your platform grows, this intelligent design leads to a dramatically lower Total Cost of Ownership (TCO) compared to a monolithic solution. You can grow your user base sustainably without your infrastructure costs spiraling out of control.
\nPlug-N-Meet's architecture isn't just a technical implementation detail; it's a strategic advantage designed to help your business succeed at scale.
\nReady to learn more about scaling?
\nFor many platforms, the \"record\" button is the end of the story. You get an MP4 file, and that's it. But what if your recordings could be more? What if they could be a structured, searchable, and accessible content library for your students, your team, or your customers?
\nWith Plug-N-Meet's powerful API, your recordings aren't just video files; they are programmable assets.
\nThis guide will show you how to move beyond simply recording a meeting and start building a true content management system using the Recordings API. We'll cover how to find your recordings, enrich them with metadata, and even attach subtitles.
\nBy the end of this guide, you will be able to programmatically manage your entire recording lifecycle, turning a simple list of video files into a rich, queryable content library.
\ncURL for the examples).API_KEY and API_SECRET.First, you need to ensure your meetings are being recorded. You can do this on a per-room basis when you create it. In your createRoom API call, include the recording_features block and set is_allow_cloud to true.
For a \"record by default\" experience, you can also enable enable_auto_cloud_recording.
{
\"room_id\": \"my-recorded-session\",
\"metadata\": {
\"room_features\": {
// ... other features
\"recording_features\": {
\"is_allow\": true,
\"is_allow_cloud\": true,
\"enable_auto_cloud_recording\": true
}
}
}
}
After your meetings are over, the first step is to get a list of your available recordings. You can do this using the recording/fetch endpoint. You can fetch recordings for one or more specific rooms by providing their IDs in the room_ids array.
This call will return a paginated list of all recordings for the specified room(s).
\n# The raw JSON body as a string
BODY='{\"room_ids\":[\"room01\"],\"from\":0,\"limit\":20,\"order_by\":\"DESC\"}'
# Your API credentials
API_KEY=\"YOUR_API_KEY\"
SECRET=\"YOUR_API_SECRET\"
# Generate the HMAC-SHA256 signature
SIGNATURE=$(echo -n \"$BODY\" | openssl dgst -sha256 -mac HMAC -macopt key:\"$SECRET\" | awk '{print $2}')
# Make the POST request
curl -X POST https://YOUR_SERVER_URL/auth/recording/fetch \\
-H \"Content-Type: application/json\" \\
-H \"API-KEY: $API_KEY\" \\
-H \"HASH-SIGNATURE: $SIGNATURE\" \\
-d \"$BODY\"
The response will give you a list that includes the record_id, room_id, file_size, and creation_time for each recording—the essential building blocks for your content library.
A filename like rec_123.mp4 isn't very helpful. To make your recordings useful, you need to add context. The recording/update-metadata endpoint allows you to add a descriptive title, a detailed description, and even your own custom data.
Let's say you just finished a \"Q4 Marketing Sync\" and you want to tag it appropriately.
\n# The raw JSON body as a string
BODY='{\"record_id\":\"f031a270-20ab-433d-96e9-aed34db97c0a-1761814595173\",\"metadata\":{\"title\":\"Q4 Marketing Sync - Final Strategy\",\"description\":\"A detailed review of the Q4 marketing plan, including budget allocation and final campaign targets.\",\"extra_data\":{\"department\":\"Marketing\",\"quarter\":\"Q4-2025\",\"is_public\":\"true\"}}}'
# Your API credentials
API_KEY=\"YOUR_API_KEY\"
SECRET=\"YOUR_API_SECRET\"
# Generate the HMAC-SHA256 signature
SIGNATURE=$(echo -n \"$BODY\" | openssl dgst -sha256 -mac HMAC -macopt key:\"$SECRET\" | awk '{print $2}')
# Make the POST request
curl -X POST https://YOUR_SERVER_URL/auth/recording/update-metadata \\
-H \"Content-Type: application/json\" \\
-H \"API-KEY: $API_KEY\" \\
-H \"HASH-SIGNATURE: $SIGNATURE\" \\
-d \"$BODY\"
Now, when you fetch this recording, it will come with rich, structured data. You can use the extra_data field to build powerful filtering and search features in your own application (e.g., \"show me all recordings from the Marketing department\").
If you used the AI Meeting Assistant during your meeting, you can link the generated transcription file directly to your recording's metadata.
\nartifacts/fetch API to get the URL of the VTT subtitle file.recording/update-metadata again, this time adding a subtitles map.# The raw JSON body as a string
BODY='{\"record_id\":\"f031a270-20ab-433d-96e9-aed34db97c0a-1761814595173\",\"metadata\":{\"subtitles\":{\"en\":{\"label\":\"English\",\"url\":\"https://YOUR_SERVER_URL/path/to/your/transcript.vtt\"}}}}'
# Your API credentials
API_KEY=\"YOUR_API_KEY\"
SECRET=\"YOUR_API_SECRET\"
# Generate the HMAC-SHA256 signature
SIGNATURE=$(echo -n \"$BODY\" | openssl dgst -sha256 -mac HMAC -macopt key:\"$SECRET\" | awk '{print $2}')
# Make the POST request
curl -X POST https://YOUR_SERVER_URL/auth/recording/update-metadata \\
-H \"Content-Type: application/json\" \\
-H \"API-KEY: $API_KEY\" \\
-H \"HASH-SIGNATURE: $SIGNATURE\" \\
-d \"$BODY\"
By linking these assets together, you create a far more valuable piece of content. Your users can now watch the recording with closed captions, improving accessibility and comprehension.
\nStop thinking of your recordings as a simple archive. With Plug-N-Meet's API-first approach, you have the tools to build a sophisticated, searchable, and accessible content management system.
\nBy programmatically fetching, enriching, and linking your recordings with other assets, you can transform a simple folder of MP4 files into a powerful knowledge base for your organization.
\nReady to build your content library?
\nWe've all been there: a crucial meeting is about to start, but a key participant has a spotty internet connection, is traveling, or simply doesn't have access to a computer. In a world increasingly reliant on video calls, how do you ensure everyone can still participate, even if they can't join online?
\nAt Plug-N-Meet, we believe in inclusivity. That's why we're excited to introduce SIP Dial-In, a powerful feature that allows participants to join the audio of your video meetings using any standard telephone. No internet, no problem.
\nThis feature seamlessly bridges the gap between your online conference and the traditional telephone network, ensuring that every voice can be heard, regardless of their connectivity.
\nWhile WebRTC-based video conferencing is incredibly powerful, it relies on a stable internet connection. This can be a barrier for:
\nOur SIP Dial-In feature integrates your Plug-N-Meet meetings with the global telephone network. It works by setting up a SIP Gateway that acts as a bridge, allowing traditional phone calls to connect directly into your online conference.
\nModerators have full control over the SIP dial-in service from within the meeting:
\nUnder the hood, Plug-N-Meet leverages the robust livekit/sip project as its SIP gateway. This component is responsible for managing the connection between your meeting and an external SIP trunking provider.
\nTo enable SIP Dial-In, your system administrator must perform a one-time server-side configuration:
\nconfig.yaml Setup: The livekit_sip_info section in your Plug-N-Meet server's config.yaml file must be configured with your SIP provider's details.While the SIP audio stream itself cannot be end-to-end encrypted (as it must traverse the traditional phone network), the connection between your SIP gateway and your SIP provider can be secured. The livekit/sip service supports SIPMediaEncryption (SRTP), which encrypts the audio stream over the internet. It is the administrator's responsibility to enable this and ensure their chosen SIP provider supports it.
It's important to note that the SIP gateway must process unencrypted audio to bridge the call. Because of this, SIP Dial-In is automatically disabled for any room where End-to-End Encryption (E2EE) is active. This ensures that the integrity of your E2EE sessions is never compromised.
\nPlug-N-Meet's SIP Dial-In feature is more than just a convenience; it's a powerful tool for inclusivity and accessibility. It ensures that your meetings can reach a wider audience, providing a reliable audio connection even when internet access is a challenge.
\nBy bridging the gap between online and traditional telephony, Plug-N-Meet empowers you to connect with everyone, everywhere.
\nReady to expand your meeting's reach?
\nIf you're in the world of open-source education or communication, you owe a debt of gratitude to BigBlueButton. It was a pioneering platform that showed the world what was possible. However, as the web has evolved, the demands for scalability, developer experience, and cost-effective performance have grown exponentially.
\nMany long-time BigBlueButton users are now looking for a next-generation solution, one designed from the ground up to meet the new demands for scalability and flexibility that the modern web requires. This is where Plug-N-Meet comes in.
\nThis article provides a direct, head-to-head comparison to help you understand the key differences in philosophy and technology, so you can make an informed decision about which platform is right for you.
\n| Feature / Aspect | BigBlueButton (BBB) | Plug-N-Meet | Why It Matters |
|---|---|---|---|
| Core Architecture | Monolithic: Tightly coupled services (web, media, recording). | Decoupled: Independent microservices for the app, media, and recorder. | You can scale, update, or maintain one part of Plug-N-Meet without impacting the others, leading to higher stability and lower costs. |
| Technology Stack | Complex Mix: A combination of Scala, Java, JavaScript, Ruby, etc. | Unified & Modern: Go for the entire backend, TypeScript/React for the frontend. | A simpler, unified stack is far easier to maintain, debug, and contribute to, resulting in faster development cycles. |
| Media Server | FreeSWITCH & mediasoup (previously Kurento) | LiveKit (a modern, high-performance SFU) | LiveKit is purpose-built for scalable WebRTC, offering better performance, adaptive streaming (Simulcast/Dynacast), and lower resource usage out of the box. |
| Security & E2EE | Basic encryption. E2EE is not a native, fully integrated feature. | Native End-to-End Encryption (E2EE): A core, API-controlled feature with multiple key management models. | Plug-N-Meet provides true zero-trust security, ensuring not even the server can access meeting content. This is critical for privacy-sensitive applications. |
| Recording | Reconstructs a presentation from separately recorded raw streams. | High-Fidelity Capture: A headless browser records the final rendered output to a single MP4. | Plug-N-Meet's method produces a perfect, \"what you see is what you get\" replica of the live session, ensuring perfect synchronization. |
| Customization | Static Theming: Requires complex server-side configuration and often code modification. | Multi-Layered & Dynamic: Offers four levels of customization, from simple branding to a \"headless\" native integration. | Plug-N-Meet's API-driven approach enables true multi-tenant branding and a vastly superior white-label experience. |
| Installation | Scripted, but with heavy, specific OS dependencies. | Automated script using Docker containers. | Plug-N-Meet's containerized setup is faster and avoids conflicts with other services on the host machine. |
| Upgrades & Maintenance | Full Rebuild Required: OS upgrades require a new server and manual data migration. | Simple & In-Place: Docker abstracts the OS, allowing safe, independent updates. | You avoid the operational cost and risk of rebuilding your server for every major OS update. |
| Multi-Tenancy | Domain-Coupled: Difficult to serve multiple domains from one instance. | Domain-Agnostic: A single server can easily serve unlimited domains via a reverse proxy. | Greatly simplifies offering a white-labeled service to multiple clients from a single, cost-effective server instance. |
The most fundamental difference is in the design philosophy.
\nBigBlueButton is a monolith. Its core components are tightly interwoven. This means if your recording service is consuming all the CPU, it directly impacts the performance of your live meetings.
\nPlug-N-Meet is built on a decoupled, microservices-based architecture. The application server, the LiveKit media server, and the recorder are all independent services. This allows you to isolate workloads and scale intelligently, leading to a significantly lower Total Cost of Ownership (TCO).
\nThis is a game-changer for anyone building a white-label or multi-tenant service.
\nBigBlueButton uses a static theming approach. Customizing the look and feel is a complex, server-wide change that often requires modifying configuration files and restarting services.
\nPlug-N-Meet is API-first and dynamic, offering a multi-layered approach to white-labeling that allows you to choose the level of customization that fits your needs:
\ngetClientFiles API to render the client \"headless\" directly within your own application, giving you complete control over the layout and user experience.This layered flexibility makes it easy to get started but provides a path to a truly unique and deeply integrated product.
\nBigBlueButton's architecture requires the server to have access to unencrypted media streams for features like recording. This architectural choice is incompatible with a zero-trust E2EE model.
\nPlug-N-Meet was built with a \"privacy by design\" philosophy. E2EE is a core, native feature of the platform. As detailed in our Security Overview, we provide multiple API-controlled models, including a zero-trust option where the encryption key never touches the server, providing a mathematical guarantee of privacy.
\nBigBlueButton records individual streams and attempts to reassemble them in post-processing, which can be a complex task.
\nPlug-N-Meet, as detailed in our Recording Philosophy, uses a headless browser to capture the final, rendered output. This produces a \"what you see is what you get\" MP4 file that is a perfect, high-fidelity replica of the live experience, ensuring all elements are perfectly synchronized.
\nThis is a significant consideration for any administrator.
\nBigBlueButton is tightly coupled to a specific OS version. The official upgrade path for a new OS often requires provisioning a brand new server and manually migrating all data and recordings. This can be a time-consuming and complex undertaking.
\nPlug-N-Meet completely avoids this problem by using Docker. The entire application runs in isolated containers, abstracting it from the host OS. You can upgrade your server's OS without breaking the application, and updating Plug-N-Meet is as simple as pulling a new Docker image. This makes long-term maintenance dramatically simpler and safer.
\nWe understand that migrating from a deeply integrated platform is a big decision. That's why we made it painless.
\nPlug-N-Meet includes a BBB-compatible API layer. This means you can point your existing Greenlight, Moodle, or custom application to your Plug-N-Meet server, and it will work without any front-end code changes. This allows you to test the performance and stability of Plug-N-Meet in your own environment with zero risk.
\nReady to take the next step? Follow our simple, step-by-step Migration from BigBlueButton Tutorial to see how easy it is.
\nBigBlueButton laid the foundation for open-source communication. It proved what was possible. As we detailed in our founder's story, \"Why We Built Plug-N-Meet,\" our platform is the next step in that evolution, built from the ground up to meet the modern web's demands for elastic scalability, developer agility, and long-term maintainability.
\nIf you are feeling the pain points of a monolithic architecture and are looking for a more flexible, performant, and cost-effective solution, Plug-N-Meet is the modern alternative you've been waiting for.
\nReady to see the difference for yourself?
\nYou've set up your video conferencing service, but now you want to make it smarter. What if you could automatically log the duration of every meeting for billing? Or get a Slack notification when a VIP joins a call? This is where webhooks come in.
\nThis guide will walk you through building your very first automated workflow. We'll create a simple but powerful service that listens for a meeting to end and logs its duration to your console—a perfect starting point for a real-world billing or analytics system.
\nFor more high-level ideas on what's possible, check out our companion post on 5 Powerful Workflows You Can Build with Webhooks.
\nBy the end of this tutorial, you will have a simple webhook listener that can:
\nAPI_KEY and API_SECRET.POST requests.First, tell Plug-N-Meet where to send the events. Open your config.yaml file on your server and add the webhook_conf section.
webhook_conf:
# Set to true to enable webhooks globally.
enable: true
# The primary URL where all events will be sent.
url: \"https://yourapp.com/webhook-listener\"
Save the file and restart your PlugNmeet server. Now, all events will be sent to your specified URL.
\nBefore processing any data, you must verify that the webhook request is genuinely from your Plug-N-Meet server. An unprotected endpoint can be exploited by anyone on the internet.
\nPlug-N-Meet uses a JWT-based signature in the Authorization header to secure webhooks. The process is:
API_SECRET.sha256 claim inside the verified token.Here’s how to implement this in a Node.js/Express middleware.
\n// You'll need these packages: npm install express body-parser jsonwebtoken crypto
import express from 'express';
import bodyParser from 'body-parser';
import jwt from 'jsonwebtoken';
import crypto from 'crypto';
const app = express();
const API_SECRET = 'YOUR_PLUGNMEET_API_SECRET'; // Use environment variables in production!
// We need the raw body for hash comparison, so we use a custom verify function.
app.use(bodyParser.json({
type: 'application/webhook+json',
verify: (req, res, buf) => {
req.rawBody = buf.toString();
}
}));
// The validation middleware
function validateRequest(req, res, next) {
const token = req.header('Authorization');
if (!token) {
return res.status(401).send('Authorization header missing');
}
try {
// 1. Verify the JWT
const decoded = jwt.verify(token, API_SECRET);
// 2. Hash the raw request body
const sha256 = crypto.createHash('sha256');
sha256.update(req.rawBody);
const hash = sha256.digest('hex');
// 3. Compare hashes
if (decoded.sha256 !== hash) {
throw new Error('Signature hash does not match');
}
// Success! Proceed to the main handler.
next();
} catch (err) {
console.error('Webhook validation failed:', err.message);
return res.status(403).send('Invalid signature');
}
}
// Apply the middleware to your listener route.
app.post('/webhook-listener', validateRequest, (req, res) => {
console.log('Webhook received and validated!');
handleWebhook(req.body);
res.status(200).send('OK');
});
app.listen(3000, () => {
console.log('Webhook listener started on port 3000');
});
// We'll define handleWebhook in the next step.
function handleWebhook(payload) {
// ...
}
Now that our endpoint is secure, we can safely process the incoming data. We'll create our handleWebhook function to inspect the event property and act accordingly.
The session_ended event is perfect for this. It fires when the last participant leaves and includes creation_time and ended_time timestamps.
function handleWebhook(payload) {
switch (payload.event) {
case 'session_ended':
const room = payload.room;
const durationInSeconds = room.ended_time - room.creation_time;
const durationInMinutes = Math.ceil(durationInSeconds / 60);
console.log(`SUCCESS: Room '${room.room_id}' lasted for ${durationInMinutes} minutes.`);
// In a real application, you would save this to your database.
break;
case 'artifact_created':
handleArtifact(payload.room_artifact);
break;
}
}
The artifact_created event fires whenever an AI service generates a result. The key is to inspect the room_artifact.type and the nested metadata object.
// A mapping from the enum number to a human-readable string.
const ArtifactType = {
2: 'MEETING_SUMMARY',
5: 'SPEECH_TRANSCRIPTION_USAGE',
8: 'AI_TEXT_CHAT_INTERACTION_USAGE',
7: 'CHAT_TRANSLATION_USAGE',
};
function handleArtifact(artifact) {
const artifactType = ArtifactType[artifact.type] || 'UNKNOWN';
console.log(`Processing artifact of type: ${artifactType}`);
switch (artifactType) {
case 'MEETING_SUMMARY':
if (artifact.metadata && artifact.metadata.file_info) {
console.log(`New summary available at: ${artifact.metadata.file_info.file_path}`);
}
break;
case 'SPEECH_TRANSCRIPTION_USAGE':
if (artifact.metadata && artifact.metadata.duration_usage) {
const usage = artifact.metadata.duration_usage;
console.log(`Transcription usage: ${usage.duration_sec} seconds.`);
console.log(`Estimated Cost: $${usage.duration_sec_estimated_cost.toFixed(4)}`);
}
break;
case 'AI_TEXT_CHAT_INTERACTION_USAGE':
if (artifact.metadata && artifact.metadata.token_usage) {
const usage = artifact.metadata.token_usage;
console.log(`AI Chat usage: ${usage.total_tokens} tokens.`);
console.log(`Estimated Cost: $${usage.total_tokens_estimated_cost.toFixed(4)}`);
}
break;
}
}
That's it! You've just built a secure webhook handler that can intelligently process different types of events. Security is not optional when handling webhooks, and by validating the signature on every request, you ensure your application is safe from bad actors.
\nFrom here, you can easily extend this logic to build a sophisticated, real-time billing and analytics system, knowing your endpoint is properly protected.
\nReady to start automating?
\nYou sent a meeting link. Five minutes later, your most important client messages you: \"It's asking me to install something.\" The momentum is lost.
\nThis is a scenario every business, educator, and community manager dreads. In today's fast-paced world, friction is the enemy of engagement. The alternative? A world where users click a link and are instantly in the meeting, ready to collaborate.
\nThis is the promise of a truly browser-based platform, and this guide shows you how to deliver that experience with Plug-N-Meet—without compromising on features.
\nBefore we dive into the \"how,\" let's understand the \"why.\" A browser-first approach is a strategic choice that prioritizes:
\nHere’s how you can leverage Plug-N-Meet's browser-native architecture to build a complete video service that rivals desktop applications.
\nYour first step is to provide a core experience that feels complete. A browser doesn't mean \"basic.\" With a simple createRoom API call, you can enable a rich, desktop-class feature set that runs entirely in the browser.
What to Enable in Your API Call:\nIn your createRoom metadata, ensure these features are set to true:
allow_webcams and allow_screen_share. Modern browsers handle this natively and securely.whiteboard_features.is_allow, shared_note_pad_features.is_allow, and chat_features.is_allow to true. These tools are built-in and require no plugins.allow_raise_hand and polls_features.is_allow to create an interactive environment identical to what users expect from desktop apps.The most advanced features today aren't limited by a user's device; they are powered by the cloud. This is a natural fit for a browser-based platform.
\nHow to Configure It:
\nconfig.yaml, add your API keys for Azure and Google, as shown in our AI Features Guide.createRoom call, enable the insights_features block.What You Deliver to the User (in the browser):
\nmeeting_summarizing service to generate AI meeting notes, which are then available via the API.Some features aren't just possible in a browser; they are better. The Embedded Web Content feature is a perfect example.
\nHow to Enable It:\nIn your createRoom API call, simply ensure display_external_link_features.is_allow is set to true.
What This Unlocks:\nA moderator can now share any website directly within the meeting window. This is far more powerful than simple screen sharing. You can:
\nThis is a uniquely powerful feature that a sandboxed desktop application often can't replicate.
\nA common concern with web apps is performance on poor networks. Plug-N-Meet solves this in the browser using modern WebRTC standards.
\nHow to Enable It:\nThis is on by default! Simulcast and Dynacast are core features of the underlying media server.
What This Means for Your Users:
\nYou don't need to force your users to download, install, and update software to provide a professional video conferencing experience. By embracing a browser-first architecture, you can deliver a service that is faster, more accessible, and packed with powerful, modern features.
\nWith Plug-N-Meet, you can build a platform that \"just works,\" letting your users focus on the conversation, not the installation bar.
\nReady to build your frictionless platform?
\nIn an age of heightened privacy concerns, offering End-to-End Encryption (E2EE) is one of the most powerful ways to build trust with your users. It provides a mathematical guarantee that conversations are confidential and that not even your server can access the media streams.
\nWhile the technology is complex, implementing it doesn't have to be. This guide will walk you through the two E2EE models available in Plug-N-Meet and show you how to enable them with a simple API call.
\nBefore writing any code, you need to answer one question: Who should manage the encryption keys? Plug-N-Meet offers two distinct models, and your choice will determine the implementation.
\nEnabling E2EE is done within the end_to_end_encryption_features block of your createRoom API call.
Before we look at the two models, it's important to understand a key security feature that applies to both: every session gets its own unique encryption key.
\nNo matter where the initial secret comes from (the server or the user), the client's browser never uses it directly. Instead, it combines the secret with the unique Session ID of the meeting to generate a final, one-time encryption key.
\nThis process ensures that even if you reuse the same room ID for multiple meetings, every single session is cryptographically isolated, preventing any link between them.
\nThis is the recommended path for most applications. You get strong E2EE without needing to build any custom key-sharing logic.
\nIn your createRoom metadata, set is_enabled to true and enabled_self_insert_encryption_key to false.
{
\"room_id\": \"e2ee-room-simple\",
\"metadata\": {
\"room_features\": {
// ... other features
\"end_to_end_encryption_features\": {
\"is_enabled\": true,
\"enabled_self_insert_encryption_key\": false
}
}
}
}
How it works: When a user joins, the server provides a unique secret for the session. The client then uses the one-time key generation process described above to secure the meeting.
\nChoose this model if you need to guarantee that your infrastructure has zero knowledge of the encryption keys.
\nIn your createRoom metadata, set both is_enabled and enabled_self_insert_encryption_key to true.
{
\"room_id\": \"e2ee-room-zero-knowledge\",
\"metadata\": {
\"room_features\": {
// ... other features
\"end_to_end_encryption_features\": {
\"is_enabled\": true,
\"enabled_self_insert_encryption_key\": true
}
}
}
}
The User Experience:\nWhen a user joins this room, the Plug-N-Meet client will automatically prompt them to enter the shared secret key.
\nThis behavior is by design, as the server has zero knowledge of the key and therefore cannot validate it upon entry. You must provide your users with an \"out-of-band\" way to share this key (e.g., a secure chat app, a password manager, or verbally).
\nHow do you know E2EE is active? The most obvious sign is that certain server-side features will be automatically disabled.
\nIf you try to use the following features in an E2EE-enabled room, they will fail, which is the expected behavior and proof that your server cannot access the media:
\nThis is a core part of the security design, ensuring that your choice of privacy is enforced across the entire platform.
\nImplementing End-to-End Encryption is a powerful step, but it's just one part of a broader \"privacy by design\" philosophy. Plug-N-Meet was architected to be a secure data relay, not a data store.
\nWhether it's using the LiveKit SFU to route encrypted media packets or NATS to broadcast messages, the server's primary job is to pass data between participants. It has no interest in what that data is, and in the case of E2EE, it has no ability to inspect it. This philosophy extends to features like our use of client-side storage, where session data lives in your browser, not on our servers.
\nBy choosing Plug-N-Meet, you're not just getting a feature; you're adopting a platform built on the principle that the most secure user data is the data you never have to touch.
\nReady to learn more?
\nIn today's competitive landscape, a basic video call is no longer enough. Users expect intelligent, accessible, and productive experiences. What if you could offer an AI meeting assistant that provides live translation, generates AI meeting notes, and can even answer questions directly in the chat?
\nWith Plug-N-Meet, you can. This isn't a complex, multi-month integration project. It's a 15-minute configuration change.
\nThis guide will show you how to add world-class AI meeting assistant features—powered by Microsoft Azure for translation and Google Gemini for your meeting summary AI and live chat assistant—to your Plug-N-Meet integration.
\nBy the end of this guide, your meeting assistant AI will be able to:
\nThe first step is to tell your Plug-N-Meet server how to connect to the AI services. Open your config.yaml file on your server and find the insights section.
The new configuration is highly flexible. First, you define your providers (your accounts), and then you assign those providers to specific services.
Here is a minimal configuration to enable all three features:
\ninsights:
enabled: true
# 1. Define all available provider accounts ONCE.
providers:
azure:
- id: \"my-azure-account\" # A unique name you choose
credentials:
api_key: \"YOUR_AZURE_KEY\"
region: \"eastus\"
google:
- id: \"my-gemini-account\" # A unique name you choose
credentials:
api_key: \"YOUR_GEMINI_API_KEY\"
# 2. Define the services that USE the providers.
services:
# Transcription is required for both live captions and translation.
transcription:
provider: \"azure\"
id: \"my-azure-account\"
# The AI text chat assistant.
ai_text_chat:
provider: \"google\"
id: \"my-gemini-account\"
options:
chat_model: \"gemini-2.5-pro\" # Powerful model for in-depth answers
# The meeting summarizer will use the audio from the transcription service.
meeting_summarizing:
provider: \"google\"
id: \"my-gemini-account\"
options:
# Use gemini-2.5-flash for faster, cost-effective summaries.
summarize_model: \"gemini-2.5-flash\"
Save the file and restart your PlugNmeet server for the changes to take effect.
\nsudo systemctl restart plugnmeet
Now that the server is configured, you can enable these features on a per-room basis. When you make your createRoom API call, add the insights_features block to your metadata.
{
\"room_id\": \"ai-powered-room\",
\"metadata\": {
\"room_features\": {
// ... other features like allow_webcams, etc.
\"insights_features\": {
\"is_allow\": true,
\"transcription_features\": {
\"is_allow\": true,
\"is_allow_translation\": true
},
\"ai_features\": {
\"is_allow\": true,
\"ai_text_chat_features\": {
\"is_allow\": true
},
\"meeting_summarization_features\": {
\"is_allow\": true
}
}
}
}
}
}
That's it! Any room created with this metadata will now have the AI Meeting Assistant enabled.
\nWhen a user joins a room created with these settings, the AI features are available to be activated.
\nLive Captions & Translation: A moderator must first enable the service from the 3-dots menu > Transcription and Translation. Once enabled, participants will see a new \"T\" icon in their main control bar. Clicking this opens a menu where they can view the live captions and select their own preferred language for translation.
\nInteractive AI Chat Assistant: Any user can interact with the AI assistant. In the side panel, a new \"AI Assistant\" tab will appear. Clicking this opens a dedicated chat interface where a user can privately ask the AI questions about the meeting content, get clarifications, or ask for help without cluttering the main participant chat.
\nAutomated Meeting Notes: To generate AI meeting notes, a moderator must start the service from the 3-dots menu > AI Tools > Meeting Summarization. The meeting assistant AI will then process the audio in the background.
\nIn just a few minutes, you've transformed a standard video call into an intelligent, interactive, and globally inclusive meeting experience. By leveraging Plug-N-Meet's provider-agnostic AI layer, you can easily add a powerful meeting assistant AI that gives you a significant edge, all while maintaining full control over your self-hosted platform.
\nThe real power of this platform is that your data isn't trapped. After the meeting ends, you can use the Artifacts API to programmatically retrieve the summary and transcription, allowing you to build powerful integrations with your new AI meeting notes.
", "url": "https://www.plugnmeet.org/blog/how-to-add-ai-meeting-assistant-features", "title": "How to Add an Interactive AI Assistant to Your Video App in 15 Minutes", "summary": "In today's competitive landscape, a basic video call is no longer enough. Users expect intelligent, accessible, and productive experiences. What if you could offer an AI meeting assistant that provides live translation, generates AI meeting notes, and can even answer questions directly in the chat?", "date_modified": "2026-01-03T00:00:00.000Z", "author": { "name": "Jibon L. Costa", "url": "https://github.com/jibon57" }, "tags": [ "tutorial", "how-to", "ai-meeting-assistant", "ai-text-chat", "ai-meeting-notes", "meeting-summary-ai", "ai-meeting-summarizer", "meeting-assistant-ai", "developer" ] }, { "id": "https://www.plugnmeet.org/blog/obs-rtmp-whip-ingress", "content_html": "Have you ever wanted to share a high-quality video during a meeting, but the file was too large to upload? Or maybe you have a copyrighted video that you are allowed to show, but you can't share the file itself. Perhaps you're a power user who wants to create a professional presentation with multiple cameras, overlays, and smooth transitions using a tool like OBS Studio.
\nTraditionally, getting this kind of professional content into a live meeting has been complex or impossible.
\nAt plugNmeet, we believe you should be able to use the best tools for the job. That's why we've built a simple but powerful feature called Live Stream Input. Think of it as giving your meeting its own private, secure TV channel. You can broadcast directly into your meeting room from professional software like OBS, and your stream appears as a regular participant.
\nThis feature unlocks a world of new possibilities:
\nGetting started is incredibly easy. Here’s how you do it from within your plugNmeet room:
\nOpen the Settings Menu: Click the three-dots menu in the top-right corner of your meeting room and select Settings.
\nFind Live Stream Input: In the settings panel, navigate to the Live Stream Input tab.
\nChoose Your \"Channel\" Type (RTMP or WHIP):\nYou'll see an option called \"Input Type.\" This lets you choose the technology for your stream. Think of it like choosing between two types of cables to connect your camera:
\nGive Your Stream a Name: In the Display Name field, you can type in a name for your stream. This is the name that will appear in the participant list. For example, \"Main Presentation\" or \"Guest Speaker Cam.\" If you leave it blank, it will default to \"Broadcaster.\"
\nGenerate Your Private Link: Click the \"Generate link\" button. plugNmeet will instantly create a unique and secure address for your private stream. You'll see two fields: a URL and a Secret (or \"Stream Key\").
\nNow, you just need to tell your software (we'll use OBS as an example) where to send the stream.
\nFor RTMP (The Universal Standard):
\nFor WHIP (The Modern Choice):
\nhttps://your-plugnmeet-domain.com/whip/A_LONG_SECRET_KEY_HEREOnce you hit \"Start Streaming\" in OBS, your stream will magically appear as a new participant in your plugNmeet room for everyone to see!
\nThe Live Stream Input feature is a perfect example of our philosophy. We've taken a powerful, professional-grade technology and made it accessible to everyone with just a few clicks. You don't need to be a technical expert to create a high-quality, polished, and engaging presentation.
\nThe best tools are the ones that get out of your way and let your content shine.
\nReady to level up your presentations?
\nWe've all been in that frustrating video call. Someone is speaking, and suddenly their video freezes. Their voice becomes robotic and distorted. You miss a crucial piece of the conversation, and the flow of the meeting is completely broken.
\nOften, we blame our internet connection. But what if the problem isn't just the connection, but the software's inability to adapt to it?
\nAt plugNmeet, we believe that a video conferencing platform should work intelligently to provide the best possible experience, no matter what your internet situation is. That's why we've built a \"smart streaming\" philosophy into our core, using advanced techniques to ensure your calls are smooth, stable, and use as little data as possible.
\nMost video applications work like a firehose. They try to send a single, high-quality stream of video data to everyone, all the time. If your internet connection is a wide-open pipe, this works great.
\nBut what if your connection is more like a narrow straw? Trying to force a firehose of data through a tiny straw leads to a predictable result: a clog. In video terms, this \"clog\" is what you experience as lag, frozen video, and dropped calls.
\nInstead of a single firehose, we use several smart techniques to adapt the video stream to the reality of each person's connection and what they are actually seeing on their screen.
\nThink about watching a movie on Netflix. If your internet slows down, the picture might get a little less sharp for a moment, but the movie keeps playing. Netflix does this by having multiple quality versions of the movie available.
\nWe do the same thing for live video. This is called Simulcast.
\nFor every person speaking, our server intelligently prepares multiple versions of their video stream: a high-quality one, a medium one, and a low-quality one. Your device automatically \"tunes in\" to the best quality it can handle at any given moment without freezing. The result is a continuous, uninterrupted conversation, even if the video quality has to adjust temporarily.
\nImagine a meeting with 20 people. On your screen, you can probably only see 9 of them at once. So why should your computer waste precious data downloading the video streams of the 11 people who are off-screen?
\nIt shouldn't. This is called Dynacast.
\nplugNmeet is smart enough to automatically pause the video streams of participants who are not currently visible on your screen. The moment you scroll or switch pages to bring them into view, their video instantly resumes. This single technique can dramatically reduce the amount of data your computer needs to download, making the call more stable for you and everyone else.
\nOn your screen, the person speaking might be in a large main window, while other participants are in tiny thumbnail squares. It makes no sense to download a full, high-definition video stream just to display it in a tiny box.
\nOur platform is smart about this, too. It automatically sends a much smaller, lower-resolution video for thumbnails, while reserving the high-quality video for the main speaker. This further reduces data usage and frees up your connection to focus on what's most important.
\nWhat is the most important part of any conversation? Hearing what the other person is saying.
\nOur platform understands this fundamental rule. When a user's internet connection becomes very unstable, the system performs a kind of digital triage. It knows that it is always better to have a clear conversation with a frozen video than to have a choppy, robotic voice with a moving picture.
\nSo, it makes a smart choice: it will temporarily pause the video stream to dedicate all available, limited bandwidth to keeping the audio channel clear and uninterrupted. The moment the connection stabilizes, the video seamlessly resumes. This ensures that your conversation can always continue, even in the most challenging network conditions.
\nBy combining these smart streaming techniques, plugNmeet creates a video experience that is:
\nOur goal is to make real-time communication a stable, reliable utility for everyone, everywhere. Our smart streaming philosophy is how we deliver on that promise.
\nReady to experience a smoother call?
\nIn an era where data breaches are daily news and \"free\" services monetize your conversations, privacy can no longer be an afterthought. It must be the foundation.
\nWhen we built Plug-N-Meet, we didn't just want to create another video conferencing tool. We wanted to build a platform that respects the user's right to privacy by default. This meant making hard architectural choices—prioritizing security over easy data harvesting, and giving control back to the user rather than hoarding it on the server.
\nIf you are building a telehealth platform, a legal consultation app, or simply a secure meeting space for your team, you need more than just a \"secure\" sticker. You need an architecture designed for the Zero-Trust era.
\nHere is how Plug-N-Meet delivers on that promise.
\nMost video platforms claim to be \"secure\" because they use encryption in transit (TLS/DTLS). While this protects your data from hackers on the coffee shop Wi-Fi, it has a major flaw: the server itself still decrypts your video to process it. This means the service provider (and anyone who hacks them) can see and hear everything.
\nPlug-N-Meet offers a Zero-Trust alternative: User-Provided Key End-to-End Encryption (E2EE).
\nWhen you enable this mode (enabled_self_insert_encryption_key: true), the encryption keys are generated by the participants and shared directly between them (e.g., via a password manager or secure chat). These keys never leave the user's device.
A core principle of modern privacy (and regulations like GDPR) is Data Minimization: don't collect what you don't need, and don't keep it longer than necessary.
\nPlug-N-Meet is designed with ephemeral storage at its core:
\nIndexedDB, not permanently on our servers. This puts the user in control of their own data footprint.enable_analytics: false) or configure the system to store only metadata (e.g., \"User A spoke for 5 minutes\") without ever recording the content of what was said.Many web applications rely solely on application-level logic (e.g., if (user.isAdmin)) to check if a user should see a message. If that logic has a bug, data leaks.
Plug-N-Meet takes a more robust approach by leveraging the powerful security features of NATS JetStream to enforce the Principle of Least Privilege.
\nThis provides a hard security boundary that is rare in self-hosted web conferencing tools, ensuring that data isolation is enforced by the infrastructure, not just the code.
\nPrivacy relies on security, and security requires layers. Beyond NATS and E2EE, we employ multiple other safeguards:
\nsession_id as a salt when deriving encryption keys. This ensures that even if a room ID is reused, every single session has a unique, cryptographically isolated key.Integrating AI into meetings is powerful, but it's often a privacy nightmare. We've solved this with a \"Privacy First\" integration strategy.
\nThe system is designed to be context-aware. If you enable End-to-End Encryption (E2EE) with a user-provided key, Plug-N-Meet automatically disables all audio-based AI features (like transcription and recording).
\nWhy? Because the AI bot on the server cannot decrypt the audio stream. This prevents the dangerous scenario where a user thinks they are in a secure, private meeting, but an AI service is silently listening in the background. With Plug-N-Meet, if you choose maximum privacy, the system enforces it across the board.
\nFinally, the most important privacy feature of Plug-N-Meet is that you own it.
\nIn a world of surveillance capitalism, privacy is a competitive advantage. Whether you are building for healthcare (HIPAA), education (FERPA), or enterprise security, Plug-N-Meet provides a foundation that doesn't just \"support\" privacy—it enforces it.
\nBy combining Zero-Trust E2EE, protocol-level access control, and the transparency of open source, we've built a platform where you don't have to trust us. You just have to trust the code.
\nReady to build your secure platform?
\n