> ## Documentation Index
> Fetch the complete documentation index at: /llms.txt
> Use this file to discover all available pages before exploring further.

# Co-Hosting

> Invite co-hosts, accept or decline invitations, join the broadcast together, and manage co-host permissions.

> [!NOTE]
>
> **SDK v7.x** · Last verified March 2026 · iOS · Android · Web

> [!TIP]
>
> **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.

> **Speed run — just the code**
>
> ```typescript theme={null}
> import { RoomRepository, InvitationRepository } from '@amityco/ts-sdk';
> import { Room as LiveKitRoom } from 'livekit-client';
>
> // HOST: invite a co-host
> await room.createInvitation('co-host-user-id');
>
> // CO-HOST: poll for invitation & accept
> const invitation = await room.getInvitation();
> if (invitation?.status === 'pending') await invitation.accept();
>
> // CO-HOST: get credentials & go live
> 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);
> ```
>
> Full walkthrough below ↓

![Livestream showing host in main view and co-host Carla Philips in secondary view, with live chat messages and reaction emojis](https://mintcdn.com/social-b97141fb-feat-user-history-moderation-detail/NVLFFvDF9Y1lT-Cj/images/Livestream%20\(1\).png?fit=max\&auto=format\&n=NVLFFvDF9Y1lT-Cj\&q=85\&s=d55ac371ed6a8401559749e929398905)

Co-host stage — host and co-host broadcasting together with live chat

Co-hosting lets multiple broadcasters share the stage during a live session. This guide covers both sides of the flow — the **host** sending and managing invitations, and the **co-host** accepting and joining the broadcast.

```mermaid theme={null}
sequenceDiagram
    participant Host
    participant SDK as social.plus SDK
    participant CoHost as Co-Host
    participant LK as LiveKit

    Host->>SDK: createInvitation(userId)
    SDK-->>CoHost: Invitation (pending)
    CoHost->>SDK: getMyRoomInvitations()
    CoHost->>SDK: accept()
    SDK-->>Host: Invitation status → approved
    CoHost->>SDK: getBroadcastData(roomId)
    SDK-->>CoHost: coHostUrl + coHostToken
    CoHost->>LK: connect(url, token)
    CoHost->>LK: setCameraEnabled(true)
    Note over Host,LK: Both are now broadcasting
```

> [!NOTE]
>
> **Prerequisites**: A room must already exist and the host must be connected to LiveKit. See [Go Live & Room Management](/use-cases/social/livestream/go-live-and-room-management.md) first.

***

## How Co-Hosting Works

| Role | Can do | Can't do |
| - | - | - |
| **Host** | Send / cancel invitations, remove co-hosts, stop room | — |
| **Co-Host** | Broadcast audio + video, interact in chat | Stop room, send invitations |

Invitation statuses:

| Status | Meaning |
| - | - |
| `pending` | Awaiting the invitee's response |
| `approved` | Invitee accepted — ready to join broadcast |
| `rejected` | Invitee declined |
| `cancelled` | Host cancelled before invitee responded |

***

## Host Side

**1. Send a co-host invitation**

Invitations are sent one user at a time. The host must already have a room.

```typescript theme={null}
await room.createInvitation(userId);
```

To invite multiple co-hosts, call `createInvitation` once per user.

**2. Track invitation status**

Observe all invitations you've sent to show pending / accepted / declined states in your UI.

```typescript theme={null}
const unsubscribe = InvitationRepository.getInvitations(
  {
    targetId: roomId,
    targetType: InvitationTargetType.Room,
    limit: 20,
  },
  ({ data, loading, error }) => {
    if (data) {
      data.forEach(inv => console.log(inv.userId, inv.status));
    }
  },
);
```

**3. Cancel a pending invitation**

Cancel before the invitee responds — e.g., if you sent the wrong user.

```typescript theme={null}
await invitation.cancel();
```

***

## Co-Host Side

**1. Retrieve your invitations**

Poll or observe your pending room invitations. Show them as an in-app notification or banner.

```typescript theme={null}
const unsubscribe = InvitationRepository.getMyCommunityInvitations(
  { limit: 20 },
  ({ data }) => {
    const pending = data?.filter(inv => inv.status === 'pending');
    // Show pending invitations to the user
  },
);
```

**2. Accept or decline**

Present an "Accept / Decline" UI. Both operations are one-liners.

```typescript theme={null}
// Accept
await invitation.accept();

// Decline
await invitation.reject();
```

**3. Join the broadcast**

After accepting, fetch broadcast credentials and connect to LiveKit — same flow as the host.

```typescript theme={null}
const broadcastData = await RoomRepository.getBroadcasterData(roomId);
const liveKitRoom = new LiveKitRoom();
await liveKitRoom.connect(broadcastData.coHostUrl, broadcastData.coHostToken);
await liveKitRoom.localParticipant.setCameraEnabled(true);
await liveKitRoom.localParticipant.setMicrophoneEnabled(true);
```

***

## UIKit: Pre-Built Co-Host Components

If you're using UIKit, the co-hosting UI is handled for you:

| Component | What it does | Platforms |
| - | - | - |
| `AmityLivestreamInviteCoHostPage` | Full-screen invite picker for the host | iOS, Android, Web |
| `AmityLivestreamCoHostStage` | Grid layout showing all active co-hosts | iOS, Android, Web |

> [!TIP]
>
> See the component reference → [Livestream Components](/uikit/components/social/livestream.md)

***

## Common Mistakes

> [!WARNING]
>
> **Calling `getBroadcastData` before accepting** — The co-host must accept the invitation first. Calling `getBroadcastData` while the invitation is still `pending` or `rejected` will fail.

> [!WARNING]
>
> **Not listening for invitation status changes** — Use the live collection (`getInvitations` / `getMyRoomInvitations`) instead of a one-shot fetch. Statuses update in real-time (e.g., host cancels while you're looking at the invite).

> [!WARNING]
>
> **Assuming the room is still live** — Between the invitation and the accept, the host may have stopped the stream. Always check `room.status === 'live'` before calling `getBroadcastData`.

## Best Practices

> **UX for invitation flow**
>
> * Show pending invitations as a prominent banner or bottom-sheet, not a buried list
> * Include the host's display name and room title in the invitation UI
> * After accepting, navigate directly to a "Preparing to go live…" screen

> **Handling disconnections**
>
> * If a co-host's LiveKit connection drops, listen for `RoomEvent.Disconnected` and show a "Reconnecting" state
> * Give co-hosts a "Leave stage" button that disconnects from LiveKit without ending the room
> * The host should see a visual indicator when a co-host goes offline

> **Scaling to many co-hosts**
>
> * Each co-host adds a video track — bandwidth and layout get complex above 4–6 hosts
> * Consider a grid layout that caps visible tiles and puts overflow in a scrollable strip
> * Test on lower-end devices to verify performance with multiple video tracks

***

## Next Steps

> **[Go Live & Room Management](/use-cases/social/livestream/go-live-and-room-management.md)**
>
> Room creation, broadcast setup, and lifecycle management.

> **[Live Chat & Engagement](/use-cases/social/livestream/live-chat-and-engagement.md)**
>
> Wire up chat, reactions, and viewer count alongside the video.

> **[Product Tagging](/use-cases/social/livestream/product-tagging.md)**
>
> Pin products to the stream for live commerce.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.