Real-Time Video & Audio Infrastructure

Build powerful video experiences with VideoRayan.

Q: What is VideoRayan?

VideoRayan is a self-hosted real-time video and audio infrastructure: a LiveKit SFU media plane, a small REST control API, and a hosted meeting UI — all running on servers you control.

Q: Do I need an account to start a meeting?

No. Create a room on /create or with one POST to /api/v1/public/rooms and share the invite link. Participants join with a display name — no account, no install.

Q: Can I integrate VideoRayan into my own product?

Yes. A REST API creates rooms and mints short-lived guest tokens, and any LiveKit SDK (Web, React, iOS, Android, Flutter) connects to the media plane. Full docs at /docs and API reference at /api.

Q: Can AI agents use the platform?

Yes — by design. Free rooms need no signup, the API contract is machine-readable (OpenAPI + llms.txt), and agents can create rooms and invite humans with a single POST. See /agents.

A developer-friendly video infrastructure for your applications. Integrate real-time audio and video communication into your product through a dedicated API and compatible SDKs.

Start a Meeting — Free View Developer Docs

API-First Integration

Self-Hosted Infrastructure

Room-Based Communication

Developer-Friendly Architecture

consultation-room-419

RTC Connected • 00:24:18

Dr. E. Vance • Host

Create a room in one call REST • JSON


              const res = await fetch('/api/v1/public/rooms', { method: 'POST' });

              const { roomId } = await res.json();

              joinRoom(roomId); // → live in <1s

Why VideoRayan

Everything real-time communication needs. Nothing it doesn't.

VideoRayan packages a production-grade WebRTC stack into a clean, room-based platform you fully control — from the SFU to the database.

Self-Hosted by Design

Runs on your own servers — your media never touches a third-party cloud. Full ownership of data, logging, and compliance posture.

Developer-First API

Create rooms, issue guest tokens, and manage access with a small, predictable REST surface. No SDK lock-in — any WebRTC client works.

Built for Real-Time

An SFU-based media plane with adaptive quality, active-speaker switching, screen share, in-call chat, and file hand-off up to 10 MB.

Use Cases

One platform, every conversation that matters

From clinical consultations to classrooms and customer meetings — VideoRayan adapts to the way your product talks.

Telehealth

Private, password-protected consultation rooms with guest access links — no account required for patients.

Online Education

Run live classes and office hours with screen sharing, persistent rooms, and join-by-link simplicity.

Business Meetings

Reliable internal and client calls on infrastructure you own — with recording and chat transcripts when needed.

Client Consultations

Embed branded video sessions directly into your product and keep every conversation on your domain.

Built for Developers

Integrate in an afternoon, not a sprint.

A single REST call creates a room. A second issues a guest token. Hand the token to any LiveKit-compatible client and you are live — encryption, TURN, and scaling are already handled by the platform.

Works With Your Stack

REST API LiveKit SDKs JavaScript / TypeScript WebRTC Docker PostgreSQL

Start Building API Reference Guides & Docs

guest-token.js

// 1 — create a room
const room = await fetch('/api/v1/public/rooms', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({ name: 'consultation-419' })
}).then(r => r.json());

// 2 — issue a guest token
const { token } = await fetch(
  `/api/v1/guest/rooms/${room.roomId}/tokens`, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ identity: 'sara' })
  }
).then(r => r.json());

// 3 — connect with any LiveKit client
const live = new LivekitClient.Room();
await live.connect('wss://rtc.videorayan.ir', token);

Architecture

A clean, inspectable media pipeline

Four moving parts, each running on hardware you control. No opaque cloud middlemen between your users and their conversations.

Your Application

Web or mobile client — join by link or embedded SDK

Client

2
VideoRayan Control API
Rooms, guest tokens, access rules — Node.js + Fastify
Control Plane

LiveKit SFU (Self-Hosted)

Selective forwarding over DTLS-SRTP — media never stored

Media Plane

PostgreSQL

Rooms, tenants, and access metadata on your own disk

State

Security & Ownership

Private by architecture, not by policy

Every layer is designed so that conversations stay between the participants — and under your administration.

Encrypted Transport

All media is secured with DTLS-SRTP end-to-end between participants and your SFU; signaling runs over authenticated WebSocket (WSS).

Token-Based Room Access

Rooms are reachable only with short-lived, signed guest tokens. Private rooms add a shared password on top — enforced server-side.

Your Servers, Your Data

The full stack — SFU, control API, and database — is self-hosted. No third-party cloud processes, records, or relays your users' media.

Operated, Monitored, Backed Up

Automated backups with scheduled restore drills, hardened SSH access, and health-checked services — covered in the public ops runbook.

Reliability

Operated like production, because it is

The platform ships with the operational discipline of a hosted service — without handing your traffic to one.

Availability

Always-On Services

Systemd supervision with automatic restart, TLS renewal watch, and health endpoints for proactive monitoring.

Media Quality

Adaptive SFU

Dynacast and connection-state handling keep calls stable on weak links; audio is always preserved first.

Resilience

Auto-Reconnect

Client-side retries with backoff for signaling and API calls — flaky mobile networks don't end the meeting.

Recovery

Tested Backups

Scheduled encrypted backups plus periodic restore tests, so recovery is a drill — never an experiment.

Under the Hood

A boring stack you can audit

Proven, mainstream components — chosen so any engineer on your team can operate the platform, not just us.

LiveKit SFU self-hosted

Open-source selective-forwarding unit for audio/video — scales room capacity without transcoding.

Control API Node.js + Fastify

TypeScript service owning rooms, tenants, and token issuance — with an OpenAPI contract and negative-test suite.

PostgreSQL versioned migrations

Single source of truth for rooms and access rules, with forward-only migrations and automated backups.

FAQ

Questions, answered

The short version. Deeper detail lives in the docs and the API reference.

What is VideoRayan?

A self-hosted real-time video and audio infrastructure: a LiveKit SFU media plane, a small REST control API, and a hosted meeting UI — all running on servers you control. No third-party cloud touches your calls.

Do I need an account to start a meeting?

No. Create a room on /create — or with one POST to the API — and share the invite link. Participants join with a display name; private rooms add a password. No account, no install.

Can I integrate it into my own product?

Yes. The REST API creates rooms and mints short-lived guest tokens, and any LiveKit SDK — Web, React, iOS, Android, Flutter — connects to the media plane. Start at the developer portal.

Where does my data live?

On your infrastructure. The SFU, control API, and database are self-hosted; media is encrypted in transit (DTLS-SRTP) and never stored or relayed by a third-party cloud. In-call chat and files are ephemeral by design.

Can AI agents use the platform?

By design. Free rooms need no signup, the API contract is machine-readable (OpenAPI + llms.txt), and an agent can stand up a meeting for its humans with a single POST. See VideoRayan for AI Agents.

How much does it cost?

The hosted portal and public API are free to use within fair-use limits. For production products, you self-host the same stack on your own servers — you pay your infrastructure bill, not per-minute seats. Talk to us about tenant keys.