I Built an Omegle Alternative Using WebRTC, Next.js, and AI Moderation

Lakshay Gupta — Sun, 15 Feb 2026 23:39:35 +0000

Omegle is gone. So I built Aznabee, a free anonymous video chat platform with real-time moderation, Duo Mode, no paywalls.

When Omegle shut down, millions of users were left without a true anonymous video chat platform. The alternatives that emerged were filled with paywalls, aggressive ads, fake users, or basic features locked behind subscriptions.

I wanted to build something better.

So I built Aznabee — a modern 2026 Omegle alternative powered by WebRTC, real-time sockets, and AI moderation. It's fast, anonymous, free, and designed from the ground up for genuine conversations.

This article breaks down the full architecture, the technical challenges, and how the system works under the hood.

You can try it live here => https://aznabee.com

What Makes Aznabee Different

Before diving into architecture, it's important to understand the product decisions. Most Omegle alternatives fail because they optimize for monetization first, and user experience second.

Aznabee does the opposite.

No Gender Paywalls

Most competitors charge ~$15/month just to filter by gender. This turns conversation into a transactional experience.

Aznabee has no paywalls. Everyone uses the same matching pool. The goal is authentic interaction, not artificial scarcity.

Built Like a Modern Product

Most alternatives still look like websites from 2010.

Aznabee is built using modern design language, better UX with smooth animations and optimized for mobile and desktop.

Real-Time AI Moderation

Instead of relying on manual reporting, Aznabee uses real-time ML moderation.

Violations are detected and sessions are terminated automatically. No reporting required.

Timed Calls Improve Conversation Quality

Each video call lasts 10 minutes. A countdown timer is visible throughout the call.

This encourages users to exchange contact information and keeps conversations intentional.

When time expires, both users are automatically rematched.

Duo Mode: Talk to Strangers With a Friend

This is Aznabee's most unique feature. Users can invite a friend using a short code and meet strangers together.

Instead of one-on-one, the system creates a three-person call:

One stranger
Your friend
You

This dramatically reduces awkwardness and improves engagement.

System Architecture Overview

Aznabee runs on three independent Dockerized services:

Service	Responsibilities	Stack
Frontend	UI and state management, WebRTC peer connection logic	Next.js 14
Socket Server	Signaling, Matchmaking	Socket.IO, Node.js
Moderation Service	Yahoo OpenNSFW model, ONNX Runtime	FastAPI

Critically, video and audio never pass through my servers. Everything flows peer-to-peer.

This makes the system extremely efficient and scalable.

How WebRTC Enables Peer-to-Peer Video Chat

WebRTC allows browsers to establish direct connections using RTCPeerConnection.

The connection flow works like this:

User enters matchmaking queue
Socket server pairs two users
Signaling messages are exchanged via Socket.IO
SDP offer and answer are exchanged
ICE candidates are exchanged
Direct peer-to-peer connection is established

Once connected, media flows directly between users. The backend is no longer involved.

This dramatically reduces:

Bandwidth requirements
Latency
Server costs

One Critical Trick: Camera Off Without Breaking the Connection

Stopping a video track entirely causes instability on some browsers.

The fix is surprisingly simple.

Instead of stopping the track, I generate a 1 FPS black frame using a hidden canvas and replace the track using replaceTrack().

The peer connection stays alive, and the remote user sees a black screen.

No renegotiation required. This improves stability significantly.

The Hardest Problem: Duo Mode WebRTC Mesh

Standard WebRTC is simple for two users.

Three users is exponentially harder.

Each participant must maintain peer connections with both other participants.

Connection graph:

Host ↔ Friend
Host ↔ Stranger
Friend ↔ Stranger

Total peer connections: 3

Challenges included:

Inconsistent ontrack behavior across browsers
Safari autoplay restrictions
Race conditions during connection setup
ICE candidates arriving out of order

I implemented a role-based connection system:

stranger
friend
host

This made connection handling predictable.

When the duo skips, only the stranger is disconnected. The friend connection persists. This enables instant rematching.

Real-Time Moderation Using ONNX and OpenNSFW

Moderation runs as a separate microservice.

Design goals:

No database dependency
Low latency
Minimal infrastructure usage

Architecture:

FastAPI server
Async job queue
Single worker
Thread pool for inference
TTL-based in-memory result storage

Frontend captures small image frames periodically. Frames are sent to moderation service.

If NSFW score exceeds threshold → Session terminates instantly.

Scaling Characteristics

Because media is peer-to-peer, scaling requirements are minimal.

Backend handles only:

Matchmaking
Signaling
Moderation inference

Not video streaming.

This allows Aznabee to scale efficiently with minimal infrastructure.

Lessons Learned

WebRTC is easy for simple use cases and extremely complex for advanced ones.
Multi-peer connections introduce race conditions, browser quirks, and timing issues that require careful handling.
Machine learning inference is viable even on small servers when designed correctly.
Most importantly, user experience matters more than monetization tricks.

People want genuine conversations, not locked features.

Try Aznabee

Aznabee is live and free to use: https://aznabee.com

If you're building with WebRTC, real-time communication, or peer-to-peer systems, I hope this breakdown helps.

I'm happy to answer technical questions or discuss architecture decisions.

DEV Community: Lakshay Gupta