Stream Live Video

You can show a camera’s live feed in your user’s browser. Your backend creates a client session for the user. The browser then uses that client session to open a live view session and exchanges a WebRTC offer and answer with Seam. The video flows straight to the browser, and your servers never handle it.

Live video is enabled by default in production and sandbox workspaces during public beta. You don’t need to request access. The request and response shapes on this page may change before general availability.

Supported Providers

Check a camera’s can_stream_live_video capability flag before you offer live video for it. The flag is at the top level of the device object and is true only for cameras whose provider supports live video and that are currently online.

Provider	Live video
TP-Link Tapo	✅ Through the paired Seam Bridge. The Bridge must be online.
UniFi Protect	✅ Through the paired Seam Bridge. The Bridge and the console must be online. H.264 video, with optional audio. The first live view turns on the camera’s low-quality RTSPS stream in UniFi Protect.
Reolink	✅ Through the paired Seam Bridge. Uses the camera’s H264 substream; browser audio is unsupported.
Arlo	✅ Through the Arlo cloud.
Ring	Seam Console only. Not available through the live view endpoints.

How It Works

All three /cameras/live_views endpoints accept only a client session token. Use your API key on your backend to create that client session, then send the returned client_session.token in the seam-client-session-token header for live view requests. Your API key stays on your backend. Authenticating a live view request directly with your workspace API key returns 401 Unauthorized. Follow Step 1 to create a client session scoped to the camera’s connected account.

Before You Begin

To stream live video, you need:

A production or sandbox workspace.
A connected account with a Tapo, Arlo, Reolink, or UniFi Protect camera whose can_stream_live_video is true.
A backend that can create client sessions with your API key.
A browser that supports WebRTC (RTCPeerConnection).

Step 1: Create a Client Session

On your backend, create a client session that has access to the camera’s connected account, and send its token to the browser. The live view can’t outlast the client session, so give the session a short lifetime.

Live video only works with client sessions created from connected_account_ids, connect_webview_ids, user_identifier_key, or user_identity_id. Client sessions created with customer_key can’t open a live view.

Request:

const client_session = await seam.clientSessions.create({
  connected_account_ids: ['c9d3f2a1-7b4e-4f0a-8e2d-5a6b7c8d9e0f'],
  expires_at: new Date(Date.now() + 60 * 60 * 1000).toISOString(),
})

// Send this token to the browser.
console.log(client_session.token)

from datetime import datetime, timedelta, timezone

client_session = seam.client_sessions.create(
    connected_account_ids=["c9d3f2a1-7b4e-4f0a-8e2d-5a6b7c8d9e0f"],
    expires_at=(datetime.now(timezone.utc) + timedelta(hours=1)).isoformat(),
)

# Send this token to the browser.
print(client_session.token)

client_session = seam.client_sessions.create(
  connected_account_ids: ["c9d3f2a1-7b4e-4f0a-8e2d-5a6b7c8d9e0f"],
  expires_at: (Time.now.utc + 3600).iso8601
)

# Send this token to the browser.
puts client_session.token

$client_session = $seam->client_sessions->create(
  connected_account_ids: ["c9d3f2a1-7b4e-4f0a-8e2d-5a6b7c8d9e0f"],
  expires_at: gmdate("c", time() + 3600)
);

// Send this token to the browser.
echo $client_session->token;

var clientSession = seam.ClientSessions.Create(
  connectedAccountIds: new List<string> { "c9d3f2a1-7b4e-4f0a-8e2d-5a6b7c8d9e0f" },
  expiresAt: DateTime.UtcNow.AddHours(1).ToString("o")
);

// Send this token to the browser.
Console.WriteLine(clientSession.Token);

var clientSession = seam.clientSessions().create(
  ClientSessionsCreateRequest.builder()
    .connectedAccountIds(List.of("c9d3f2a1-7b4e-4f0a-8e2d-5a6b7c8d9e0f"))
    .expiresAt(Instant.now().plus(Duration.ofHours(1)).toString())
    .build()
);

// Send this token to the browser.
System.out.println(clientSession.getToken());

curl -X 'POST' \
  'https://connect.getseam.com/client_sessions/create' \
  -H 'accept: application/json' \
  -H "Authorization: Bearer ${SEAM_API_KEY}" \
  -H 'Content-Type: application/json' \
  -d '{
  "connected_account_ids": ["c9d3f2a1-7b4e-4f0a-8e2d-5a6b7c8d9e0f"],
  "expires_at": "2026-09-25T18:00:00.000Z"
}'

Response:

{
  "client_session": {
    "client_session_id": "5e1b3f0c-2a4d-4c6e-8f0a-1b2c3d4e5f60",
    "token": "seam_cst1891oqCmE_6dBwV8PJ2Ffoe9dWYVyMfVHq",
    "connected_account_ids": ["c9d3f2a1-7b4e-4f0a-8e2d-5a6b7c8d9e0f"],
    "expires_at": "2026-09-25T18:00:00.000Z"
  }
}

The response includes more client session fields. See the client session object. Before you offer live video for a camera, get the device and check that can_stream_live_video is true:

const device = await seam.devices.get({
  device_id: 'a83690b2-2b70-409a-9a94-426699b84c97',
})

if (device.can_stream_live_video) {
  // Show the live view button.
}

device = seam.devices.get(device_id="a83690b2-2b70-409a-9a94-426699b84c97")

if device.can_stream_live_video:
    # Show the live view button.
    pass

device = seam.devices.get(device_id: "a83690b2-2b70-409a-9a94-426699b84c97")

if device.can_stream_live_video
  # Show the live view button.
end

$device = $seam->devices->get(device_id: "a83690b2-2b70-409a-9a94-426699b84c97");

if ($device->can_stream_live_video) {
  // Show the live view button.
}

var device = seam.Devices.Get(deviceId: "a83690b2-2b70-409a-9a94-426699b84c97");

if (device.CanStreamLiveVideo == true)
{
  // Show the live view button.
}

var device = seam.devices().get(
  DevicesGetRequest.builder()
    .deviceId("a83690b2-2b70-409a-9a94-426699b84c97")
    .build()
);

if (device.getCanStreamLiveVideo().orElse(false)) {
  // Show the live view button.
}

curl -X 'POST' \
  'https://connect.getseam.com/devices/get' \
  -H "Authorization: Bearer ${SEAM_API_KEY}" \
  -H 'Content-Type: application/json' \
  -d '{
  "device_id": "a83690b2-2b70-409a-9a94-426699b84c97"
}'
# The response includes "can_stream_live_video": true for a camera that can stream.

The flag is false when the provider does not support live video or the camera is offline. For local cameras, the paired Seam Bridge must also be online. Check the flag again right before opening a live view. A true flag describes device support and reported connectivity. Creating a session also depends on client-session authorization, workspace availability, and live-view capacity. Handle the live view errors even when the flag is true.

Step 2: Create a Live View Session

In the browser, call /cameras/live_views/create with the client session token in the seam-client-session-token header. A live view session reserves the camera for this viewer. Request:

const response = await fetch(
  'https://connect.getseam.com/cameras/live_views/create',
  {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'seam-client-session-token': clientSessionToken,
    },
    body: JSON.stringify({
      device_id: 'a83690b2-2b70-409a-9a94-426699b84c97',
      include_audio: false,
      duration_seconds: 300,
    }),
  },
)
const { camera_live_view_session } = await response.json()

curl -X 'POST' \
  'https://connect.getseam.com/cameras/live_views/create' \
  -H 'accept: application/json' \
  -H "seam-client-session-token: ${SEAM_CLIENT_SESSION_TOKEN}" \
  -H 'Content-Type: application/json' \
  -d '{
  "device_id": "a83690b2-2b70-409a-9a94-426699b84c97",
  "include_audio": false,
  "duration_seconds": 300
}'

Response:

{
  "camera_live_view_session": {
    "camera_live_view_session_id": "7f3c2a1b-4d5e-4f60-8a9b-0c1d2e3f4a5b",
    "device_id": "a83690b2-2b70-409a-9a94-426699b84c97",
    "expires_at": "2026-09-25T17:08:12.000Z",
    "token": "3q2-7wEXAMPLEtokenOnlyForThisLiveViewSession"
  }
}

Parameter	Type	Required	Description
`device_id`	string (UUID)	Yes	The camera to stream. The client session must have access to it.
`include_audio`	boolean	No	Whether to include the camera’s audio. Defaults to `false`.
`duration_seconds`	integer	No	Requested session length, from 1 to 600 seconds. Defaults to `600`.

The session ends at expires_at, the earliest of the requested duration, the provider’s session limit, or the client session’s expiration.
The response’s token authorizes the offer and stop calls for this session only. Keep it in memory, and don’t log it.
Seam sends Cache-Control: no-store on all live view responses.
See the camera live view objects for the complete camera_live_view_session and camera_live_view_answer reference.

Step 3: Send a WebRTC Offer

Create an RTCPeerConnection with a STUN server, add a receive-only video transceiver, and create an offer. Wait for ICE gathering to finish, then send the local description’s SDP to /cameras/live_views/offer, along with the session ID and token. Include the STUN server so you can use the same configuration for every camera.

JavaScript

const peerConnection = new RTCPeerConnection({
  iceServers: [{ urls: 'stun:stun.l.google.com:19302' }],
})
peerConnection.addTransceiver('video', { direction: 'recvonly' })

await peerConnection.setLocalDescription(await peerConnection.createOffer())
await waitForIceGathering(peerConnection)

const offerResponse = await fetch(
  'https://connect.getseam.com/cameras/live_views/offer',
  {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'seam-client-session-token': clientSessionToken,
    },
    body: JSON.stringify({
      camera_live_view_session_id:
        camera_live_view_session.camera_live_view_session_id,
      token: camera_live_view_session.token,
      sdp_offer: peerConnection.localDescription.sdp,
    }),
  },
)
const { camera_live_view_answer } = await offerResponse.json()

function waitForIceGathering(peerConnection, timeoutMs = 3000) {
  if (peerConnection.iceGatheringState === 'complete') return Promise.resolve()
  return new Promise((resolve) => {
    const timer = setTimeout(done, timeoutMs)
    function done() {
      clearTimeout(timer)
      peerConnection.removeEventListener('icegatheringstatechange', onChange)
      resolve()
    }
    function onChange() {
      if (peerConnection.iceGatheringState === 'complete') done()
    }
    peerConnection.addEventListener('icegatheringstatechange', onChange)
  })
}

Response:

{
  "camera_live_view_answer": {
    "sdp_answer": "v=0\r\no=- 0 0 IN IP4 127.0.0.1\r\ns=-\r\n..."
  }
}

camera_live_view_answer.sdp_answer is Seam’s WebRTC SDP answer, at most 64 KiB. Seam connects to the camera while handling this request, so the response can take several seconds.

One offer per session. Once you send an offer, you can’t send another one on the same session. To reconnect, create a new live view session.
Send the offer promptly. If the stream hasn’t started within 30 seconds of creating the session, Seam closes the session.
Match audio to include_audio. If include_audio is false, the offer must not contain an audio section, so add only a video transceiver. If it’s true, also call peerConnection.addTransceiver('audio', { direction: 'recvonly' }).
No ICE trickling. Send one offer to /cameras/live_views/offer and apply the returned answer. There’s no endpoint for sending more ICE candidates, so wait for ICE gathering to finish (or a few seconds) and send peerConnection.localDescription.sdp. The SDP returned by createOffer() doesn’t include any candidates.
Size limit. sdp_offer can be at most 64 KiB.

Step 4: Play the Stream

Apply the answer, then attach the incoming track to a <video> element.

JavaScript

const video = document.querySelector('video')

peerConnection.ontrack = (event) => {
  video.srcObject = event.streams[0] ?? new MediaStream([event.track])
}

await peerConnection.setRemoteDescription({
  type: 'answer',
  sdp: camera_live_view_answer.sdp_answer,
})

Set ontrack before calling setRemoteDescription. Add autoplay, muted, and playsinline to the <video> element so that browsers start playback without a click. Unmute after a user gesture if you requested audio.

Step 5: Stop the Stream

When the user closes the viewer, close the peer connection and call /cameras/live_views/stop. This frees the camera for the next viewer right away. Always call /stop; closing the peer connection alone may leave the camera reserved until expires_at.

JavaScript

peerConnection.close()

await fetch('https://connect.getseam.com/cameras/live_views/stop', {
  method: 'POST',
  keepalive: true,
  headers: {
    'Content-Type': 'application/json',
    'seam-client-session-token': clientSessionToken,
  },
  body: JSON.stringify({
    camera_live_view_session_id:
      camera_live_view_session.camera_live_view_session_id,
    token: camera_live_view_session.token,
  }),
})

keepalive: true lets the request finish when it’s sent from a pagehide handler. Stopping a session that has already ended succeeds and returns {}.

Limits and Session Lifetime

Limit	Value
Maximum session length	Up to 600 seconds (10 minutes) for Tapo, Arlo, and Reolink. The client session’s expiration can shorten these limits.
Time to start streaming	30 seconds from creating the session.
Viewers per camera	One at a time. A second viewer gets `camera_live_view_limit` until the first session ends.
Offers per session	One.
`sdp_offer` size	64 KiB.

Seam keeps checking that the viewer still has access while the stream is open. A live view ends when any of the following happens:

The session reaches expires_at.
You call /cameras/live_views/stop.
The client session expires or is revoked, or it loses access to the camera.
The camera is removed from Seam, or its connected account is deleted.

To keep watching past expires_at, stop the current session or wait for it to end, then create a new live view session and a new peer connection. Watch peerConnection.connectionState for failed or closed to detect the end of a stream.

Errors

HTTP status	`error.type`	Cause
`400`	`invalid_input`	A parameter is missing or out of range. For example, `duration_seconds` isn’t between 1 and 600, or `sdp_offer` is larger than 64 KiB.
`401`	`invalid_client_session_token` or `unauthorized`	The request uses a workspace API key or omits the client session token. Create a client session on your backend and send its token in the `seam-client-session-token` header.
`401`	`client_session_expired`, `client_session_revoked`, or `client_session_not_found`	The client session has expired, was revoked, or doesn’t exist. Create a new client session with access to the camera’s connected account.
`404`	`camera_not_available`	The camera doesn’t exist, the client session doesn’t have access to it, the camera doesn’t support live video, or the live view session ID or token is wrong or has expired.
`409`	`camera_live_view_limit`	Another live view is already open for this camera, Seam has no live view capacity available right now, or an offer was already sent for this session.
`422`	`camera_video_codec_unsupported`	The camera uses H.265 (HEVC), but the browser’s WebRTC offer doesn’t support that codec. Use a client that supports H.265.
`503`	`camera_media_unavailable`	Seam couldn’t start the stream. For example, the camera or Bridge is offline, the provider refused the stream, or the offer contains audio when `include_audio` is `false`.

For 409 and 503, wait a few seconds and create a new live view session. Retry with backoff, and stop after a few attempts.

Complete Example

This example serves a web page that plays one camera’s live feed. It uses Node.js 18 or later and the seam package.

Run npm install seam.
Set SEAM_API_KEY, SEAM_CONNECTED_ACCOUNT_ID, and SEAM_DEVICE_ID to your API key, the camera’s connected account, and the camera’s device ID.
Save both files in the same directory and run node server.mjs.
Open http://localhost:3000 and click Start.

In production, authenticate your user before creating a client session, and only include the connected accounts that belong to that user.

server.mjs

JavaScript

import { createServer } from 'node:http'
import { readFile } from 'node:fs/promises'
import { Seam } from 'seam'

const { SEAM_API_KEY, SEAM_CONNECTED_ACCOUNT_ID, SEAM_DEVICE_ID } = process.env
if (!SEAM_API_KEY || !SEAM_CONNECTED_ACCOUNT_ID || !SEAM_DEVICE_ID) {
  throw new Error(
    'Set SEAM_API_KEY, SEAM_CONNECTED_ACCOUNT_ID, and SEAM_DEVICE_ID.',
  )
}

const seam = new Seam({ apiKey: SEAM_API_KEY })

createServer(async (req, res) => {
  if (req.method === 'GET' && req.url === '/') {
    res.writeHead(200, { 'Content-Type': 'text/html' })
    res.end(await readFile(new URL('./index.html', import.meta.url)))
    return
  }

  if (req.method === 'POST' && req.url === '/camera-session') {
    // Authenticate your user here before creating a client session.
    const client_session = await seam.clientSessions.create({
      connected_account_ids: [SEAM_CONNECTED_ACCOUNT_ID],
      expires_at: new Date(Date.now() + 15 * 60 * 1000).toISOString(),
    })
    res.writeHead(200, {
      'Content-Type': 'application/json',
      'Cache-Control': 'no-store',
    })
    res.end(
      JSON.stringify({
        client_session_token: client_session.token,
        device_id: SEAM_DEVICE_ID,
      }),
    )
    return
  }

  res.writeHead(404).end()
}).listen(3000, () => console.log('Open http://localhost:3000'))

index.html

HTML

<!doctype html>
<html>
  <body>
    <video autoplay muted playsinline controls width="640"></video>
    <p>
      <button id="start">Start</button>
      <button id="stop" disabled>Stop</button>
      <span id="status"></span>
    </p>
    <script type="module">
      const SEAM_API_URL = 'https://connect.getseam.com'
      const video = document.querySelector('video')
      const startButton = document.querySelector('#start')
      const stopButton = document.querySelector('#stop')
      const status = document.querySelector('#status')

      let clientSessionToken
      let liveViewSession
      let peerConnection

      async function seamPost(path, body, options = {}) {
        const response = await fetch(SEAM_API_URL + path, {
          method: 'POST',
          headers: {
            'Content-Type': 'application/json',
            'seam-client-session-token': clientSessionToken,
          },
          body: JSON.stringify(body),
          ...options,
        })
        const json = await response.json().catch(() => ({}))
        if (!response.ok) {
          throw new Error(json.error?.type ?? `HTTP ${response.status}`)
        }
        return json
      }

      function waitForIceGathering(peerConnection, timeoutMs = 3000) {
        if (peerConnection.iceGatheringState === 'complete') {
          return Promise.resolve()
        }
        return new Promise((resolve) => {
          const timer = setTimeout(done, timeoutMs)
          function done() {
            clearTimeout(timer)
            peerConnection.removeEventListener(
              'icegatheringstatechange',
              onChange,
            )
            resolve()
          }
          function onChange() {
            if (peerConnection.iceGatheringState === 'complete') done()
          }
          peerConnection.addEventListener('icegatheringstatechange', onChange)
        })
      }

      async function start() {
        startButton.disabled = true
        status.textContent = 'Connecting…'
        try {
          // 1. Get a client session token from your backend.
          const session = await fetch('/camera-session', { method: 'POST' })
          const { client_session_token, device_id } = await session.json()
          clientSessionToken = client_session_token

          // 2. Reserve the camera.
          const { camera_live_view_session } = await seamPost(
            '/cameras/live_views/create',
            { device_id, include_audio: false, duration_seconds: 300 },
          )
          liveViewSession = camera_live_view_session

          // 3. Create a receive-only offer.
          peerConnection = new RTCPeerConnection({
            iceServers: [{ urls: 'stun:stun.l.google.com:19302' }],
          })
          peerConnection.addTransceiver('video', { direction: 'recvonly' })
          peerConnection.ontrack = (event) => {
            video.srcObject = event.streams[0] ?? new MediaStream([event.track])
          }
          peerConnection.onconnectionstatechange = () => {
            status.textContent = peerConnection.connectionState
            if (['failed', 'closed'].includes(peerConnection.connectionState)) {
              stop()
            }
          }
          await peerConnection.setLocalDescription(
            await peerConnection.createOffer(),
          )
          await waitForIceGathering(peerConnection)

          // 4. Exchange the offer for Seam's answer.
          const { camera_live_view_answer } = await seamPost(
            '/cameras/live_views/offer',
            {
              camera_live_view_session_id:
                liveViewSession.camera_live_view_session_id,
              token: liveViewSession.token,
              sdp_offer: peerConnection.localDescription.sdp,
            },
          )
          await peerConnection.setRemoteDescription({
            type: 'answer',
            sdp: camera_live_view_answer.sdp_answer,
          })
          stopButton.disabled = false
        } catch (error) {
          status.textContent = `Could not start: ${error.message}`
          await stop()
        }
      }

      async function stop() {
        stopButton.disabled = true
        startButton.disabled = false
        peerConnection?.close()
        peerConnection = undefined
        video.srcObject = null
        const session = liveViewSession
        liveViewSession = undefined
        if (session == null) return
        // 5. Free the camera for the next viewer.
        await seamPost(
          '/cameras/live_views/stop',
          {
            camera_live_view_session_id: session.camera_live_view_session_id,
            token: session.token,
          },
          { keepalive: true },
        ).catch(() => {})
      }

      startButton.addEventListener('click', start)
      stopButton.addEventListener('click', stop)
      window.addEventListener('pagehide', stop)
    </script>
  </body>
</html>

Next Steps

Camera Live Views reference: Full request and response reference for /cameras/live_views/create, /cameras/live_views/offer, and /cameras/live_views/stop.
Retrieve event media: Get the clip and thumbnail for motion and doorbell events.
Client session tokens: Scope client sessions to each user’s devices.
Seam Bridge: Set up the Bridge that Tapo cameras need.

Getting Started

Use Cases

Core Concepts

Capability Guides

UI Components

Developer Tools

Industry Guides

Device Manufacturer Guidance

Low-Level APIs

Stream Live Video

Supported Providers

How It Works

Before You Begin

Step 1: Create a Client Session

Step 2: Create a Live View Session

Step 3: Send a WebRTC Offer

Step 4: Play the Stream

Step 5: Stop the Stream

Limits and Session Lifetime

Errors

Complete Example

Next Steps

​Supported Providers

​How It Works

​Before You Begin

​Step 1: Create a Client Session

​Step 2: Create a Live View Session

​Step 3: Send a WebRTC Offer

​Step 4: Play the Stream

​Step 5: Stop the Stream

​Limits and Session Lifetime

​Errors

​Complete Example

​Next Steps

Supported Providers

How It Works

Before You Begin

Step 1: Create a Client Session

Step 2: Create a Live View Session

Step 3: Send a WebRTC Offer

Step 4: Play the Stream

Step 5: Stop the Stream

Limits and Session Lifetime

Errors

Complete Example

Next Steps