Real-time video chat,
without the infrastructure.

Drop in one script tag (or one ESM import) and call init(). STUN/TURN servers, ICE negotiation, signaling — all handled invisibly. Your app never touches a socket directly.

Anyone can join with just a name and a room code — no accounts, no passwords, no OAuth flows. Perfect for lightweight embed scenarios and quick prototypes.

Entering a room puts you in PRE-LIVE — camera preview is available but no WebRTC connection is open yet. Call startLive() when the user is ready to broadcast. The two-step design lets you build waiting rooms, lobby screens, and "ready" confirmations naturally.

One-line on/off for camera and mic. The SDK distinguishes between off (hardware released) and muted (track silenced but still capturing), giving your UI the full signal it needs for accurate indicators.

Any member — not just the host — can share their screen at the same time. Each screenshare arrives as its own independent stream tile, so multiple screens can be visible simultaneously.

Members enter a staging area with camera preview before WebRTC connects. Build waiting rooms, "knock to enter" flows, or device-check screens — all without any streaming cost until startLive() is called.

One unified event carries every member's full state — live status, camera, mic, and screenshare — for both local and remote members. Drive all your indicators, placeholders, and visibility from a single event handler. No polling, no duplicated logic.

Register a tile element once and the SDK handles everything: stream attachment, member exit cleanup, screenshare end, room leave, and kick. Tiles are auto-removed from the DOM — your code never needs a teardown path for remote media.

Fetch display names and statuses for everyone in the room. Use this to populate a participants list, name labels on tiles, or a roster sidebar — with one async call after entering.

Opt-in per-connection quality scoring — good / fair / poor / lost — derived from RTT, jitter, packet loss, and freeze rate. Fires events when quality changes for you or for any remote member. Can auto-render a status bar on affected tiles with no extra code.

The host can kick any member from the room. The SDK surfaces the event cleanly on the removed member's end so your app can show a message and clean up gracefully.

Play chimes, notification sounds, or custom audio cues when members arrive or leave — just hook your own AudioContext into the SDK's presence events.

Send messages to the whole room — backed by the database, so history survives after the session ends. Fetch past messages by page and display them in chronological order.

Incoming messages from other members arrive instantly over the SDK's WebSocket — no polling required. Register one handler and it fires for both channel-wide messages and private DMs addressed to you.

Send and retrieve private messages between two members — scoped to their shared channel. Threads are persistent and paginated, separate from channel-wide chat.

One flag at room creation injects a complete, ready-made DM interface directly onto every remote camera tile — chat toggle, slide-out input, conversation history, live updates. No additional app code required.

Let users broadcast that they're open to connect right now — scoped to a project context, with a configurable TTL and optional profile hints. Other users in the same project can list who's available and reach out via invite. Updates are pushed over WebSocket as availabilityUpdate events (added / changed / removed) — no polling. Optional role and attributes fields feed pluggable matchmaking strategies (see feature 19a).

Invite a specific user to a room you own. They receive a real-time inviteReceived event with a TTL and message; you receive an inviteResponse when they accept, decline, or let it expire. On accept, the SDK can auto-enter them into the room.

Create a fresh room and invite a list of users in a single call. Each invitee receives the same inviteReceived event and can accept independently — handy for one-tap "start a chat with these people" flows.

When a project flips autoMatchEnabled=true, the server becomes a producer of invites: any user who calls setAvailable({ open: true }) enters a project-scoped pool and the matchmaker pairs them up automatically. Each invitee gets the same inviteReceived event used for manual invites, with an extra match block describing the strategy and peers — so existing invite-aware apps light up with zero code changes. Pluggable strategies (random_pair ships; bucketed / role-aware to follow) read each user's optional role and attributes declared via setAvailable or init({ autoMatch }).

When a user declines an invite, the matchmaker records a short cooldown between the decliner and every other invitee/inviter in that room, so the same pair isn't re-matched on the next pool tick. Cooldowns are pair-symmetric, project-scoped, and TTL'd. Discovery is unaffected — declined users still appear in getAvailableUsers and can be invited manually. Applies to both auto-matched and hand-sent invites.

When two or more users in a project context are simultaneously available, the server can automatically create a room and invite them — no app code required. Group size is configurable (2–8). Gated behind a project config flag so it stays off by default.

Every room gets a short, shareable code on creation. Only people with the code can enter. Share it however you like — link, QR code, email — and revoke access by rotating the code from your console.

The server automatically removes members who go silent for too long (~5 minutes). Your app can intercept the liveness check to prompt the user and keep their session alive.

Lock your project key so it only works when embedded on specific domains. Prevents your project from being used by other sites even if someone extracts your key from the source.

Require users to verify a real email address before entering a room — independently of whether that address is whitelisted. Use this when you want identity accountability without restricting who can join. Fully anonymous entry (allowsGuests) and email-verified entry are separate, combinable settings.

Restrict room entry to a pre-approved list of email addresses or domains. Only users whose verified email matches the whitelist can join, keeping rooms closed to uninvited participants.

Rotate your project's API key without downtime. Old keys expire on a configurable grace period so you can update your deploys before access is revoked.

Enable or disable features at any scope. Room-level settings override project defaults; project defaults override account defaults. Configure text chat, anonymous entry, room creation permissions, domain restrictions, tile messaging, and more without touching code.

createRoom(title, options) accepts a full set of options that control who can enter, how long sessions run, and which features are active. Flat DB columns (allowsGuests, maxSize) apply immediately; config flags are stored as room-level JSONB that cascades from room → project → default. Omit any option to inherit the project-level default.

All createRoom() options, their storage layer, cascade path, and current status. Flat DB columns take effect immediately on the channels row. JSONB config keys cascade room → project → hardcoded default, so omitting an option inherits the project-level setting without any extra work.

Prevent guests and standard members from creating new rooms. Only project managers or designated hosts can spin up rooms — useful for controlled event or classroom deployments.

Restrict screensharing or video broadcasting to specific members only. Host a panel discussion where only speakers can share video while viewers watch — with the same SDK on both ends.

Account owners can retrieve lists of their rooms and users — either as client-side JS calls (within an authenticated session) or via server-side API calls using their project key. Useful for building admin dashboards, room pickers, and member management UIs.

Run multiple independent room connections on the same page simultaneously — each with its own state, event handlers, and tile set. Useful for monitoring dashboards, sidebars, and multi-feed layouts.

Let users choose which camera and microphone to use from all available devices — essential for multi-camera setups, external mics, and accessibility requirements.

Use the SDK's event model cleanly inside React component lifecycle. Subscribe in useEffect, manage state with useState, and avoid the common ESM/IIFE scoping issues that trip up React setups.

Rooms support up to 12 concurrent live members and stay active for up to 24 hours without reconnecting. Members can freely join and leave within that window.

Remove the "Powered by VibeLive" overlay on paid plans. Replace it with your own branding, or suppress it entirely for white-label deployments.

See who joined each room, when, how long they stayed, and what they did — from the VibeLive developer console without writing any logging code yourself.

Share files directly within a room — stored and accessible to all room members. Rooms become a lightweight document exchange layer alongside the video stream.

Mix ambient audio or background music into the outgoing stream — useful for meditation sessions, virtual events, and waiting room experiences.

Automatically transcribe meetings and generate AI summaries — retrievable after the session ends via the messages API or a dedicated transcript endpoint.

Tag named segments within a meeting (agenda items, topics, breaks) and extract per-interval summaries and transcripts after the fact. Useful for long standup calls, interviews, and structured workshops.

Simulate multiple remote members joining, speaking, and leaving — with no real devices or network — so you can build and test your UI without a second browser or person.

Tiered access unlocks features progressively. Starter covers core video, text chat, and room management. Builder adds watermark removal, domain restrictions, key rotation, reporting, and AI features.