Go Live & Room Management

Create broadcast rooms, connect to LiveKit, monitor room lifecycle, query live rooms, and access recordings.

SDK v7.x · Last verified March 2026 · iOS · Android · Web

Speed run — just the code

import { RoomRepository, PostRepository } from '@amityco/ts-sdk';
import { Room as LiveKitRoom } from 'livekit-client';

// 1. Create a room with live chat enabled
const { data: room } = await RoomRepository.createRoom({
  title: 'Friday AMA', channelEnabled: true,
});

// 2. Publish a livestream post
await PostRepository.createPost({
  targetType: 'community', targetId: communityId,
  dataType: 'livestream', data: { streamId: room.roomId },
});

// 3. Get broadcaster credentials & connect
const bd = await RoomRepository.getBroadcasterData(room.roomId);
const lk = new LiveKitRoom();
await lk.connect(bd.coHostUrl, bd.coHostToken);
await lk.localParticipant.setCameraEnabled(true);
await lk.localParticipant.setMicrophoneEnabled(true);

// 4. Stop & get recording
await lk.disconnect();
await RoomRepository.stopRoom(room.roomId);

Full walkthrough below ↓

Platform note — code samples below use TypeScript. Every method has an equivalent in the iOS (Swift) and Android (Kotlin) SDKs — see the linked SDK reference in each step.

Host broadcasting with live chat overlay

This guide covers the host’s journey: create a room, wire up the broadcast, monitor lifecycle transitions, query live rooms for a “Live Now” section, and access recordings after the stream ends.

Prerequisites: SDK + Video SDK installed and authenticated → Video Getting Started. A communityId is required — rooms are community-only.

---

Quick Start: Create a Room and Go Live

const { data: room } = await RoomRepository.createRoom({
  title: 'Product Launch Event',
  description: 'Join us for the unveiling',
  channelEnabled: true,  // auto-creates a live chat channel
});
console.log('Room created:', room.roomId, '— status:', room.status); // IDLE

Full reference → Create Room

---

Step-by-Step Implementation

1. Create a broadcast room

   A room is the container for a livestream session. Set channelEnabled: true to automatically create a live chat channel for viewer comments.

   import { RoomRepository } from '@amityco/ts-sdk';
   
   const { data: room } = await RoomRepository.createRoom({
     title: 'Weekly Q&A Session',
     description: 'Ask us anything',
     thumbnailFileId: null,
     metadata: { category: 'education' },
     channelEnabled: true,
     parentRoomId: null,
   });
   

   Full reference → Create Room

2. Publish a livestream post

   Create a post in the community feed that links to the room. This shows a “LIVE” badge in the feed while the room is broadcasting.

   import { PostRepository, PostContentType } from '@amityco/ts-sdk';
   
   const { data: post } = await PostRepository.createPost({
     dataType: PostContentType.LIVESTREAM,
     targetType: 'community',
     targetId: communityId,
     data: { text: 'We are live!', streamId: room.roomId },
   });
   

   Full reference → Live Stream Post

3. Get broadcaster credentials and connect to LiveKit

   Fetch the LiveKit URL and token, then connect the host’s camera and microphone.

   import { Room as LiveKitRoom, RoomEvent } from 'livekit-client';
   
   const broadcastData = await RoomRepository.getBroadcasterData(room.roomId);
   
   const liveKitRoom = new LiveKitRoom();
   liveKitRoom.on(RoomEvent.Connected, () => console.log('Connected!'));
   liveKitRoom.on(RoomEvent.Disconnected, (reason) => console.log('Disconnected:', reason));
   
   await liveKitRoom.connect(broadcastData.coHostUrl, broadcastData.coHostToken);
   await liveKitRoom.localParticipant.setCameraEnabled(true);
   await liveKitRoom.localParticipant.setMicrophoneEnabled(true);
   // Room status is now LIVE
   

   Full reference → Start Broadcasting

4. Monitor room lifecycle

   Observe the room to update your UI for each status transition.

   const roomLiveObject = RoomRepository.getRoom(room.roomId);
   
   roomLiveObject.on('dataUpdated', (room) => {
     switch (room.status) {
       case 'idle':     showUI('Ready to start'); break;
       case 'live':     showUI('Broadcasting'); break;
       case 'ended':    showUI('Stream ended — processing recording…'); break;
       case 'recorded': showUI('Recording available'); break;
     }
   });
   

   Full reference → Manage Rooms

5. Query live rooms for a 'Live Now' section

   Show currently-active livestreams in your app.

   const liveRooms = RoomRepository.getRooms({
     statuses: ['live'],
     types: ['co_hosts'],
     isDeleted: false,
     sortBy: 'lastCreated',
   });
   
   liveRooms.on('dataUpdated', (rooms) => {
     console.log('Currently live:', rooms.length, 'rooms');
   });
   

   Full reference → Manage Rooms

6. Stop broadcasting and access recordings

   Disconnect LiveKit first, then stop the room. Recordings become available within a few minutes.

   // 1. Disconnect from LiveKit
   await liveKitRoom.disconnect();
   
   // 2. Stop the room
   await RoomRepository.stopRoom(room.roomId);
   
   // 3. Poll for recording (room status transitions: ENDED → RECORDED)
   const { url } = await RoomRepository.getRecordedUrl(room.roomId);
   console.log('Recording:', url);
   

   Full reference → Recorded Playback

---

Admin Console: Manage & Monitor Streams

After streams are created, you can manage them from Admin Console → Live stream.

Live stream management — view all streams with status, type, and moderation flags

Click any stream to see its detail page with recording playback, metadata, and moderation status.

Stream detail — recording playback, stream ID, creator info, and moderation status

To review stream performance, go to Admin Console → Video Analytics → Live stream.

Livestream analytics dashboard — total streams, views, unique viewers, and watch time

Click any row in the stream table to see per-stream metrics including concurrent viewers over time and chat messages.

Per-stream analytics — unique viewers, chat messages, and reactions over time

---

Connect to Moderation & Analytics

Stream analytics in Admin Console

Track peak concurrent viewers, total watch time, and engagement per stream in Admin Console → Analytics → Video.

→ Video Analytics

Livestream moderation

Moderators can view and manage all active and past livestreams in Admin Console → Moderation → Livestream Moderation.

→ Livestream Moderation

Webhook: stream lifecycle events

Receive stream.started, stream.ended, recording.completed webhook events for backend automation (e.g., notify followers, archive recordings).

→ Stream Events · Webhooks

---

Common Mistakes

Stopping the room before disconnecting LiveKit — Always call liveKitRoom.disconnect() first, then RoomRepository.stop(roomId). Reversing the order can leave orphaned media tracks.

Forgetting to end rooms when the stream stops — If the broadcaster disconnects without calling stop(), the room stays in live status and appears in “Live Now” feeds as a ghost stream. Always call stop in your cleanup logic.

// ❌ Bad — broadcaster crashes, room stays live
window.onbeforeunload = () => { /* nothing */ };

// ✅ Good — end room on disconnect
window.onbeforeunload = () => {
  RoomRepository.stopRoom(roomId);
};

Not refreshing the LiveKit token — LiveKit tokens expire. If you don’t handle token refresh, the video connection drops mid-stream. Implement a token renewal callback.

Creating rooms without channelEnabled: true — Without this flag, no live chat channel is created and viewers can’t comment during the stream. Almost all livestream UIs need live chat.

Not observing the room lifecycle — The status transitions (idle → live → ended → recorded) are asynchronous. Hardcoding delays instead of observing the room live object results in brittle UI states.

Polling for recordings too aggressively — Recordings take a few minutes to process. Use the room’s live object with a dataUpdated listener to detect when status === 'recorded' rather than polling every second.

Best Practices

Startup latency

• Pre-fetch getBroadcastData() before the user taps “Go Live” to cut startup time
• Request camera and microphone permissions during the room creation step, not at connect time
• Show a preview of the camera feed while the LiveKit connection is establishing

Reconnection handling

• Listen for RoomEvent.Reconnecting and RoomEvent.Reconnected from LiveKit
• Show a “Reconnecting…” banner to the host — don’t silently drop to ended
• Configure LiveKit’s autoSubscribe and reconnectPolicy for aggressive retry

Broadcasting UX

• Show a 3-second countdown before going live so the broadcaster can prepare
• Display a “LIVE” badge with a pulsing animation on the post card in the feed
• Show concurrent viewer count in real-time using the room’s participant data
• Provide camera flip, mute, and end-stream controls in a floating overlay

Viewer experience

• Auto-play the livestream on mute when the post enters the viewport — require a tap for audio
• Show the live chat alongside the video in a split-screen layout
• Allow viewers to send reactions (emoji) that float across the video
• When the stream ends, show a “Stream ended” card with a link to the recording when available

Recordings

• The livestream post stays in the feed after the stream ends — update it to show the recording thumbnail
• Store recording URLs in your backend; platform URLs may have retention policies
• Offer a “Watch replay” CTA on the post once status === 'recorded'

---

Next Steps

Your next step → Short-Form Video Clips

Livestreams are running — now add TikTok-style clip posts for shorter, snackable video content.

Or explore related guides:

Co-Hosting

Invite co-hosts to share the stage during a broadcast.

Live Chat & Engagement

Wire up chat, reactions, and viewer count alongside the video.

Product Tagging

Pin products to the stream for live commerce.