miroslavpejic85/mirotalk: self-hosted WebRTC meetings in six commands
🚀 Open-source, self-hosted P2P WebRTC video conferencing for fast, private real-time communication. Create browser-based meeting rooms with no downloads or time limits, plus screen sharing, chat, whiteboard, recording, and collaboration.
At a glance
- What is it?
- A peer-to-peer video conferencing server built on Node.js and Socket.IO, with an AGPL licence, a full REST API and a Docker path that shares one template file with the bare-metal install.
- Who is it for?
- MiroTalk P2P is a credible self-hosted answer for anyone who needs video rooms without a third-party account or a per-minute bill, and the six-command install is genuinely short because the configuration lives in two template files you copy.
- Can I use it commercially?
- Yes, with strict conditions. AGPL-3.0 is a network copyleft licence: if people use a modified version over a network, for example as a hosted service, you must offer them its source code under the same licence.
- Is it still maintained?
- Yes. The repository received new commits within the last day.
- What is it written in?
- Mainly JavaScript, according to GitHub's language statistics.
Answers come from the project's GitHub data, last synced on October 8, 2026, and from our analysis. They are not legal advice.
Editorial analysis
Six commands from clone to working room
The README's quick start is the shortest thing in this repository and the clearest reason to try it:
git clone https://github.com/miroslavpejic85/mirotalk.git
cd mirotalk
cp .env.template .env
cp app/src/config.template.js app/src/config.js
npm install
npm startAfter that, the README says to open `http://localhost:3000`. Two of those six lines are configuration copies, which is the real design decision here: the project refuses to guess. Environment variables live in `.env`, and server settings live in `app/src/config.js`, both seeded from templates that ship in the repository.
The tree shows how much is bundled beyond the conferencing core. `app/` and `public/` are the server and client, `docs/` holds project documentation, `widgets/` holds the embeddable widget, `webhook/` handles outbound notifications, `tests/` holds Mocha tests, `kubernetes/` has deployment manifests, and `coturn/` is there for TURN relay configuration. A separate `install.sh` sits in the root for one-click installs.
One detail in `package.json` removes a step people usually trip over: a `prestart` script copies the config template for you if `config.js` is missing, so `npm start` works even if you skip that line.
Peer to peer changes the traffic path, not the feature list
MiroTalk's pitch is direct peer-to-peer WebRTC connections, and the README is concrete about what that buys: unlimited rooms with no time limits, end to end privacy, and resolution claimed up to 8K at 60fps. The comparison table it hides in a collapsed section puts it against paid plans and frames the difference as self-hosted versus cloud only.
The architectural consequence is worth stating plainly. In a peer-to-peer call, the media stream never touches your server, so the server's job is signalling, room membership and the chat and data channels. That is why the repository is small for what it does, and it is also why the `coturn/` directory exists. When two peers cannot establish a direct path, the call needs a relay, and a relay needs configuration. A deployment that works on the developer's laptop may not work for every pair of participants behind corporate NAT, and the README does not pretend otherwise, it points at the self-hosting documentation for it.
The README lists the collaboration surface as screen sharing, recording, picture-in-picture, Markdown chat with emoji, a collaborative whiteboard, file sharing, and integrations for Slack and Mattermost. Two of those deserve a caveat. Recording and speech recognition are server-side work rather than peer-to-peer work, so they pull in extra services, which is what the optional `docker-compose-whisper.yml` and `docker-compose-mailpit.yml` files at the repository root are for.
Docker path reuses the same template files
The Docker section of the README asks for Docker Engine and Docker Compose, and points at an image on Docker Hub. The command sequence repeats the clone and the two configuration copies before adding a compose file copy, which tells you the container reads the same `.env` and config template as a bare-metal run rather than baking settings into the image.
`package.json` carries a full set of Docker scripts, and they are worth reading as the operational documentation:
docker run -d -p 3000:3000 --name mirotalk mirotalk/p2p:latestAlongside that run script there are build, push, pull, stop, remove-container, and image-prune variants, plus a mount-aware variant that binds `.env`, `app/` and `public/` read-only into the container. The read-only mounts are the interesting detail, since they let you edit client files on the host and restart rather than rebuilding an image on every change.
The `Dockerfile` is short and worth reading for two decisions. It builds from `node:24-alpine`, and it runs `npm ci --omit=dev` so dev dependencies stay out of the image. It also copies the config template to `config.js` during the build and switches to the unprivileged `node` user before the start command, so the container does not run as root.
Auth, API and white-label options come from configuration
The README's feature list names OIDC authentication, host protection, JWT credentials, room passwords and peer-to-peer encryption. That is a reasonable set of controls for a tool people deploy on a public IP, and the fact that host protection has its own documentation page says the author expects people to enable it.
There is also a full REST API included rather than sold as an add-on, and the integration documentation covers an embeddable iframe and a widget. The `widgets/` directory in the tree is where that lives. Combined with the AGPL licence and the README's claim that the code is white-label ready, the picture is of a project aimed at people who want to put conferencing inside their own product rather than merely run a Zoom alternative.
Two features deserve the caveat that they are integrations rather than native capabilities. The ChatGPT integration talks to OpenAI, so it depends on a third-party service and its own key. Speech recognition is listed next to it and pulls in the Whisper compose file. Both are opt-in, and both move data away from the peer-to-peer promise for the audio or text involved.
What the version number and empty release history tell you
This repository publishes no GitHub releases, so there is no release history to read. The version lives in one place, `package.json`, which records 1.9.87. That is a meaningful difference from projects that tag releases: with no tags to diff, the practical pinning strategy is to track `package.json` and the Docker image tag rather than a release, and the npm scripts confirm that `mirotalk/p2p:latest` is the tag the workflow uses.
The package metadata also names the stack directly. Keywords include webrtc, socket.io, p2p, nodejs, openai, oidc and chatgpt, and the entry point is `node app/src/server.js` with `main` set to `server.js`. Development runs through nodemon via `start-dev`, tests are Mocha over `tests/*.js`, and linting is Prettier through `npx prettier --write .`.
On maintenance, GitHub reports the last push on 2026-09-21 and the repository is not archived. The default branch is `master` rather than `main`, which matters if you script anything against raw URLs. The repository has zero open issues, which usually means issues are handled somewhere other than the tracker rather than that nothing is outstanding.
Editorial conclusion
MiroTalk P2P is a credible self-hosted answer for anyone who needs video rooms without a third-party account or a per-minute bill, and the six-command install is genuinely short because the configuration lives in two template files you copy. What peer-to-peer changes is the traffic path, not the feature list: media goes between browsers, so the server is a signalling and room host rather than a media relay, and anything that makes peers unable to connect directly falls outside what this repository can fix. The `coturn/` directory is the visible acknowledgement of that. The package version in `package.json` is 1.9.87, the licence is AGPL-3.0, and GitHub reports the last push on 2026-09-21 with no releases published, so `package.json` is where the version to pin. Start with `cp .env.template .env` and the config copy, then read the self-hosting pages on docs.mirotalk.com for the TURN and OIDC decisions the README leaves open.
Frequently asked questions
Is MiroTalk safe?
The safety properties depend on the deployment rather than on the code alone. Media flows directly between browsers over WebRTC, and the server handles signalling and rooms. The README also lists OIDC authentication, host protection, JWT credentials, room passwords and peer-to-peer encryption as configuration options, and points at a dedicated host protection page in the documentation for details.
What is MiroTalk used for?
Browser-based meeting rooms you host yourself, with screen sharing, chat, a collaborative whiteboard, file sharing and recording. Because it is peer to peer, the server is a signalling host rather than a media relay, which suits internal tools, community calls and embedding a meeting widget into an existing product.
Is MiroTalk free?
The README describes it as free and open source under AGPLv3, with the source and Docker image available on GitHub and Docker Hub. The same README mentions one-time paid licences through CodeCanyon, so read the terms before rebranding it as part of a product you sell.
Official sources
Add this badge to your README
If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.
[](https://hysenlabs.com/projects/miroslavpejic85-mirotalk)