diff --git a/docusaurus.config.ts b/docusaurus.config.ts
index 9166045f0905..ea5cd661ee81 100644
--- a/docusaurus.config.ts
+++ b/docusaurus.config.ts
@@ -408,9 +408,6 @@ const config: Config = {
if (existingPath.startsWith('/theoplayer/how-to-guides/web/uplynk/')) {
return [existingPath.replace('/theoplayer/how-to-guides/web/uplynk/', '/theoplayer/how-to-guides/miscellaneous/verizon-media/')];
}
- if (existingPath.startsWith('/theolive/playback/web/')) {
- return [existingPath.replace('/theolive/playback/web/', '/theoplayer/how-to-guides/web/theolive/')];
- }
return undefined;
},
} satisfies ClientRedirectsPlugin.Options,
@@ -614,12 +611,11 @@ const config: Config = {
docsPluginId: 'theoplayer',
position: 'right',
},
- // TODO: Enable theolive version dropdown when v2 docs are finalized
- // {
- // type: 'docsVersionDropdown',
- // docsPluginId: 'theolive',
- // position: 'right',
- // },
+ {
+ type: 'docsVersionDropdown',
+ docsPluginId: 'theolive',
+ position: 'right',
+ },
],
},
footer: {
diff --git a/sidebarsTheolive.ts b/sidebarsTheolive.ts
index 0b63419a4f8e..70b57a6c29ca 100644
--- a/sidebarsTheolive.ts
+++ b/sidebarsTheolive.ts
@@ -5,25 +5,47 @@ const sidebars: SidebarsConfig = {
theolive: [
'index',
'getting-started',
+ 'manage-team',
+ 'architecture',
{
type: 'category',
- label: 'Contribution',
+ label: 'Channel',
+ customProps: {
+ icon: 'πΊ',
+ },
+ description: 'Configure channel-level settings and optional features.',
+ link: { type: 'generated-index', slug: 'channel' },
+ items: [{ type: 'autogenerated', dirName: 'channel' }],
+ },
+ {
+ type: 'category',
+ label: 'Ingest',
customProps: {
icon: 'π‘',
},
- description: 'THEOlive Contribution / Publishing guides',
+ description: 'Get your live media into the platform.',
link: { type: 'generated-index', slug: 'contribution' },
items: [{ type: 'autogenerated', dirName: 'contribution' }],
},
{
type: 'category',
- label: 'Platform',
+ label: 'Media Engine',
customProps: {
- icon: 'π',
+ icon: 'βοΈ',
},
- description: 'THEOlive Platform guides',
- link: { type: 'generated-index', slug: 'platform' },
- items: [{ type: 'autogenerated', dirName: 'platform' }],
+ description: 'How your stream is processed and packaged for delivery.',
+ link: { type: 'generated-index', slug: 'media-engine' },
+ items: [{ type: 'autogenerated', dirName: 'media-engine' }],
+ },
+ {
+ type: 'category',
+ label: 'Distribution',
+ customProps: {
+ icon: 'π€',
+ },
+ description: 'Control how and where your stream reaches viewers.',
+ link: { type: 'generated-index', slug: 'distribution' },
+ items: [{ type: 'autogenerated', dirName: 'distribution' }],
},
{
type: 'category',
@@ -31,31 +53,34 @@ const sidebars: SidebarsConfig = {
customProps: {
icon: 'βΆοΈ',
},
- description: 'THEOlive Playback / Player guides',
- link: { type: 'generated-index', slug: 'playback' },
+ description: 'Integrate the player into your app or website.',
+ link: { type: 'doc', id: 'playback/optiview-player' },
items: [{ type: 'autogenerated', dirName: 'playback' }],
},
+ {
+ type: 'category',
+ label: 'Platform',
+ customProps: {
+ icon: 'π',
+ },
+ description: 'THEOlive Platform guides',
+ link: { type: 'generated-index', slug: 'platform' },
+ items: [{ type: 'autogenerated', dirName: 'platform' }],
+ },
'troubleshooting',
{
type: 'html',
value: '',
},
- {
- type: 'doc',
- id: 'contribution/hardware-encoders/index',
- },
- {
- type: 'doc',
- id: 'contribution/software-encoders/index',
- },
{
type: 'link',
- label: 'THEOlive REST API',
+ label: 'REST API',
customProps: {
icon: 'π',
},
href: '/theolive/next/api/',
},
+ 'api/migration-from-v1',
],
theoLiveApi: [
{
@@ -64,6 +89,8 @@ const sidebars: SidebarsConfig = {
href: '/theolive/next/',
},
'api/index',
+ 'api/authentication',
+ 'api/full-example',
...apiSidebar.slice(1),
],
};
diff --git a/sidebarsTheoplayer.ts b/sidebarsTheoplayer.ts
index 15f74000cb17..438d489c373f 100644
--- a/sidebarsTheoplayer.ts
+++ b/sidebarsTheoplayer.ts
@@ -46,14 +46,6 @@ const sidebars: SidebarsConfig = {
exclude: platformNames,
},
},
- {
- type: 'category',
- label: 'THEOlive',
- customProps: {
- icon: 'π',
- },
- items: [{ type: 'link', label: 'Getting started', href: '/theolive/playback/web/getting-started/' }],
- },
{
type: 'autogenerated',
dirName: 'how-to-guides/web',
@@ -92,14 +84,6 @@ const sidebars: SidebarsConfig = {
exclude: platformNames,
},
},
- {
- type: 'category',
- label: 'THEOlive',
- customProps: {
- icon: 'π',
- },
- items: [{ type: 'link', label: 'Getting started', href: '/theolive/playback/android/getting-started/' }],
- },
{
type: 'autogenerated',
dirName: 'how-to-guides/android',
@@ -168,6 +152,10 @@ const sidebars: SidebarsConfig = {
exclude: platformNames,
},
},
+ {
+ type: 'autogenerated',
+ dirName: 'how-to-guides/react-native',
+ },
],
}),
connectorsCategory({
@@ -189,7 +177,13 @@ const sidebars: SidebarsConfig = {
'flutter/index',
'external/flutter-theoplayer-sdk/flutter_theoplayer_sdk/flutter_theoplayer_sdk/README',
howToGuidesCategory({
- items: [{ type: 'autogenerated', dirName: 'external/flutter-theoplayer-sdk/doc' }],
+ items: [
+ { type: 'autogenerated', dirName: 'external/flutter-theoplayer-sdk/doc' },
+ {
+ type: 'autogenerated',
+ dirName: 'how-to-guides/flutter',
+ },
+ ],
}),
'external/flutter-theoplayer-sdk/flutter_theoplayer_sdk/flutter_theoplayer_sdk/CHANGELOG',
githubLink({
@@ -239,12 +233,8 @@ const sidebars: SidebarsConfig = {
},
},
{
- type: 'category',
- label: 'THEOlive',
- customProps: {
- icon: 'π',
- },
- items: [{ type: 'link', label: 'Getting started', href: '/theolive/playback/roku/getting-started/' }],
+ type: 'autogenerated',
+ dirName: 'how-to-guides/roku',
},
],
}),
diff --git a/theolive/api/authentication.mdx b/theolive/api/authentication.mdx
new file mode 100644
index 000000000000..997c4326dce1
--- /dev/null
+++ b/theolive/api/authentication.mdx
@@ -0,0 +1,46 @@
+---
+sidebar_label: Authentication
+sidebar_position: 0
+---
+
+# Authentication
+
+
+To make secure calls to the REST API, both authentication and authorization are required. OptiView Live uses tokenβsecret pairs to authorize API requests and ensure secure access.
+
+## Creating an API token
+
+1. Navigate to **API Tokens** in the dashboard.
+2. Click **New** to create a new token.
+3. Enter a name for the token.
+4. Confirm to generate the token.
+
+The key and secret will be displayed once the token is created.
+
+:::warning[Note down your key and secret]
+
+Make sure to store the key and secret securely β they cannot be viewed again after this step.
+
+:::
+
+## Using the token-secret pair with Basic Authentication
+
+OptiView Live uses Basic Authentication for API requests. To authenticate, include your key-secret pair (base64-encoded) in the `Authorization` header, prepended with the word `Basic`.
+
+1. Combine your key and secret in the format `key:secret`.
+ Example: `my-token:my-secret`
+
+2. Base64 encode the combined value.
+ Example: `bXktdG9rZW46bXktc2VjcmV0`
+
+3. Include the encoded string in the Authorization header, prefixed with the word Basic.
+ Example header: `Authorization: Basic bXktdG9rZW46bXktc2VjcmV0`
+
+## Full example
+
+```bash
+curl -X GET https://api.theo.live/v2/channels \
+ -H "Authorization: Basic bXktdG9rZW46bXktc2VjcmV0"
+```
+
+You're now ready to make authenticated requests to the OptiView Live API.
diff --git a/theolive/api/full-example.mdx b/theolive/api/full-example.mdx
new file mode 100644
index 000000000000..ef3e1f3cb047
--- /dev/null
+++ b/theolive/api/full-example.mdx
@@ -0,0 +1,260 @@
+---
+sidebar_label: Full example
+sidebar_position: 2
+---
+
+# Full example
+
+
+This guide walks through setting up a complete channel via the API β from creating the channel to starting the stream. By the end, you will have a fully configured channel ready for playback.
+
+:::tip
+All requests require authentication. See the [Authentication](./authentication.mdx) guide for how to obtain and use your API credentials.
+:::
+
+## Overview
+
+Setting up a channel involves the following steps:
+
+1. **Create a channel** β the top-level container.
+2. **Create an ingest** β defines where the live source enters the platform.
+3. **Create an engine** β processes and packages the incoming media.
+4. **Create a distribution** β defines how the stream is delivered to viewers.
+5. **Start the channel** β begins transcoding and makes the stream available.
+
+## 1. Get available regions and ABR ladders
+
+Before creating ingests and engines, retrieve the available regions and ABR ladders for your organization.
+
+`GET https://api.theo.live/v2/regions`
+
+```bash
+curl -X GET https://api.theo.live/v2/regions \
+ -H "Authorization: Basic $AUTH"
+```
+
+```json title="Response"
+{
+ "data": [
+ { "id": "europe-west", "name": "Europe West" },
+ { "id": "us-east", "name": "US East" }
+ ]
+}
+```
+
+`GET https://api.theo.live/v2/abr`
+
+```bash
+curl -X GET https://api.theo.live/v2/abr \
+ -H "Authorization: Basic $AUTH"
+```
+
+```json title="Response"
+{
+ "data": [
+ {
+ "id": "abr_abc123",
+ "name": "1080p ladder",
+ "video": [
+ { "id": "v1", "label": "1080p", "width": 1920, "height": 1080, "bitrate": 6000000 },
+ { "id": "v2", "label": "720p", "width": 1280, "height": 720, "bitrate": 3000000 },
+ { "id": "v3", "label": "480p", "width": 854, "height": 480, "bitrate": 1500000 }
+ ]
+ }
+ ]
+}
+```
+
+Note the `id` values β you will need the region ID and ABR ladder ID in the next steps.
+
+## 2. Create a channel
+
+`POST https://api.theo.live/v2/channels`
+
+```bash
+curl -X POST https://api.theo.live/v2/channels \
+ -H "Authorization: Basic $AUTH" \
+ -H "Content-Type: application/json" \
+ -d '{
+ "name": "My first channel"
+ }'
+```
+
+```json title="Response"
+{
+ "data": {
+ "id": "ch_abc123",
+ "name": "My first channel",
+ "status": "stopped",
+ "timeout": 600,
+ "createdAt": "2026-03-30T12:00:00.000Z",
+ "organizationId": "org_xyz"
+ }
+}
+```
+
+Note the channel `id` β you will use it in all subsequent calls.
+
+## 3. Create an ingest
+
+Create an RTMP push ingest so you can push your live feed to the platform.
+
+`POST https://api.theo.live/v2/channels/{channelId}/ingests`
+
+```bash
+curl -X POST https://api.theo.live/v2/channels/ch_abc123/ingests \
+ -H "Authorization: Basic $AUTH" \
+ -H "Content-Type: application/json" \
+ -d '{
+ "name": "Primary ingest",
+ "type": "rtmp-push",
+ "region": "europe-west"
+ }'
+```
+
+```json title="Response"
+{
+ "data": {
+ "id": "ing_def456",
+ "name": "Primary ingest",
+ "type": "rtmp-push",
+ "url": "rtmp://ingest.theo.live/live",
+ "streamKey": "sk_xxxxxxxxxx",
+ "createdAt": "2026-03-30T12:01:00.000Z",
+ "tracks": { "audio": [] },
+ "captions": []
+ }
+}
+```
+
+Use the returned `url` and `streamKey` to configure your encoder (e.g. OBS, vMix, or a hardware encoder).
+
+## 4. Create an engine
+
+Create an engine that connects to the ingest and transcodes the stream.
+
+`POST https://api.theo.live/v2/channels/{channelId}/engines`
+
+```bash
+curl -X POST https://api.theo.live/v2/channels/ch_abc123/engines \
+ -H "Authorization: Basic $AUTH" \
+ -H "Content-Type: application/json" \
+ -d '{
+ "name": "Primary engine",
+ "ingestId": "ing_def456",
+ "region": "europe-west",
+ "priority": 1,
+ "quality": {
+ "abrLadderId": "abr_abc123"
+ },
+ "outputs": {
+ "hesp": true,
+ "hls": true
+ }
+ }'
+```
+
+```json title="Response"
+{
+ "data": {
+ "id": "eng_ghi789",
+ "name": "Primary engine",
+ "createdAt": "2026-03-30T12:02:00.000Z",
+ "updatedAt": "2026-03-30T12:02:00.000Z",
+ "quality": { "abrLadderId": "abr_abc123" },
+ "drm": false,
+ "priority": 1,
+ "daiAssetKey": null,
+ "outputs": { "hesp": true, "hls": true },
+ "overlays": []
+ }
+}
+```
+
+## 5. Create a distribution
+
+Create a distribution that connects to the engine and delivers the stream to viewers.
+
+`POST https://api.theo.live/v2/channels/{channelId}/distributions`
+
+```bash
+curl -X POST https://api.theo.live/v2/channels/ch_abc123/distributions \
+ -H "Authorization: Basic $AUTH" \
+ -H "Content-Type: application/json" \
+ -d '{
+ "name": "Main distribution",
+ "enabled": true,
+ "endpoints": {
+ "engineIds": ["eng_ghi789"]
+ }
+ }'
+```
+
+```json title="Response"
+{
+ "data": {
+ "id": "dist_jkl012",
+ "name": "Main distribution",
+ "enabled": true,
+ "createdAt": "2026-03-30T12:03:00.000Z",
+ "updatedAt": "2026-03-30T12:03:00.000Z",
+ "endpoints": { "engineIds": ["eng_ghi789"] },
+ "security": {
+ "geoBlocking": { "enabled": false, "mode": "deny", "countries": [] },
+ "ipBlocking": { "enabled": false, "mode": "deny", "cidrs": [] },
+ "keys": []
+ },
+ "dvr": { "enabled": false }
+ }
+}
+```
+
+## 6. Start the channel
+
+Once everything is configured and your encoder is streaming, start the channel.
+
+`POST https://api.theo.live/v2/channels/{channelId}/start`
+
+```bash
+curl -X POST https://api.theo.live/v2/channels/ch_abc123/start \
+ -H "Authorization: Basic $AUTH"
+```
+
+This starts all engines on the channel. The channel status will transition through `deploying` β `starting` β `ingesting` β `playing`.
+
+## 7. Verify and play
+
+Use the distribution ID to play the stream. With THEOplayer on web:
+
+```javascript
+player.source = {
+ sources: {
+ type: 'theolive',
+ src: 'dist_jkl012',
+ },
+};
+```
+
+Or access the HLS manifest directly:
+
+```text
+https://discovery.theo.live/v2/distributions/dist_jkl012/hls/main.m3u8
+```
+
+## 8. Stop the channel
+
+When done, stop the channel to avoid unnecessary transcoding costs.
+
+`POST https://api.theo.live/v2/channels/{channelId}/stop`
+
+```bash
+curl -X POST https://api.theo.live/v2/channels/ch_abc123/stop \
+ -H "Authorization: Basic $AUTH"
+```
+
+## Next steps
+
+- Add [redundancy](../distribution/redundancy.md) with a second ingest and engine
+- Configure [security](../distribution/security/geo-blocking.md) on your distribution
+- Set up [webhooks](../platform/real-time-update-with-webhooks.mdx) for real-time event notifications
+- Automate start/stop with [schedulers](../platform/scheduler.mdx)
diff --git a/theolive/api/index.mdx b/theolive/api/index.mdx
index 8d0e34c6613e..f8347e382b51 100644
--- a/theolive/api/index.mdx
+++ b/theolive/api/index.mdx
@@ -2,13 +2,17 @@
sidebar_label: Introduction
---
-# THEOlive REST API
+# OptiView Live REST API
import SidebarCategoryDocCardList from '@site/src/components/SidebarCategoryDocCardList';
-THEOlive provides a REST API to manage channels, receive events, create reports, and set up webhooks.
+OptiView Live provides a REST API to manage channels, receive events, create reports, and set up webhooks.
-Alternatively, you can perform the most common actions directly from the THEOlive management console.
+Alternatively, you can perform the most common actions directly from the OptiView Live dashboard.
See [our getting started guide](../getting-started.mdx) for more information.
+To get started with the API, see the [Authentication](./authentication.mdx) guide.
+
+The full API specification is also available as a [Swagger document](https://api.theo.live/v2/api-docs/swagger.json).
+
diff --git a/theolive/api/migration-from-v1.mdx b/theolive/api/migration-from-v1.mdx
new file mode 100644
index 000000000000..b2ae8026647d
--- /dev/null
+++ b/theolive/api/migration-from-v1.mdx
@@ -0,0 +1,200 @@
+---
+sidebar_label: Migration from V1
+sidebar_custom_props:
+ icon: β¬οΈ
+description: Key differences between the V1 and V2 REST APIs and how to migrate.
+---
+
+# Migration from V1
+
+
+This guide covers the key differences between the V1 and V2 REST APIs and explains how to migrate your integration.
+
+## Base URL
+
+The V1 API used separate base URLs per resource type. The V2 API uses a single, versioned base URL for all resources.
+
+| V1 | V2 |
+|---|---|
+| `https://api.theo.live/channels` | `https://api.theo.live/v2/channels` |
+| `https://api.theo.live/webhooks` | `https://api.theo.live/v2/webhooks` |
+| `https://api.theo.live/events` | `https://api.theo.live/v2/logs` |
+| `https://api.theo.live/schedulers` | `https://api.theo.live/v2/schedulers` |
+| `https://api.theo.live/reports` | _(removed)_ |
+
+Authentication remains the same β HTTP Basic Auth with your API credentials.
+
+## Architecture: from flat channels to a component model
+
+The most significant change in V2 is the introduction of a **component-based architecture**. In V1, a channel was a single monolithic resource that combined ingest, transcoding, and delivery settings. In V2, these are split into separate resources:
+
+| V1 | V2 |
+|---|---|
+| Channel (contains everything) | **Channel** β **Ingest** β **Engine** β **Distribution** |
+
+- **Channel** β a container that groups all components together.
+- **Ingest** β defines how media enters the platform (RTMP push, RTMP pull, SRT pull).
+- **Engine** β handles transcoding and packaging. Connected to an ingest and configured with an ABR ladder, DRM, output formats, etc.
+- **Distribution** β represents an output endpoint for viewers. Connected to one or more engines. Holds security, delivery, and player settings.
+
+This means that creating a channel in V2 requires multiple API calls: one to create the channel, then one each for the ingest, engine, and distribution. See the [full example](./full-example.mdx) for a complete walkthrough.
+
+### V1 create channel β V2 equivalent
+
+**V1** β a single call created the entire pipeline:
+
+```json
+POST https://api.theo.live/channels
+{
+ "ingestLocation": "europe-west",
+ "metadata": { "name": "my-channel" },
+ "streamConfig": {
+ "abr": true,
+ "resolution": "1080p",
+ "bitrate": 4.5,
+ "fps": 30
+ }
+}
+```
+
+**V2** β four calls to set up the same pipeline:
+
+```json
+// 1. Create channel
+POST https://api.theo.live/v2/channels
+{ "name": "my-channel" }
+
+// 2. Create ingest
+POST https://api.theo.live/v2/channels/{channelId}/ingests
+{ "name": "my-ingest", "type": "rtmp-push" }
+
+// 3. Create engine
+POST https://api.theo.live/v2/channels/{channelId}/engines
+{
+ "name": "my-engine",
+ "ingestId": "",
+ "region": "",
+ "quality": { "abrLadderId": "" }
+}
+
+// 4. Create distribution
+POST https://api.theo.live/v2/channels/{channelId}/distributions
+{
+ "name": "my-distribution",
+ "endpoints": { "engineIds": [""] }
+}
+```
+
+Available regions and ABR ladders can be retrieved via `GET /v2/regions` and `GET /v2/abr`.
+
+## Channel aliases β distributions
+
+V1 channel aliases are replaced by **distributions** in V2. The mapping is as follows:
+
+| V1 alias field | V2 distribution field |
+|---|---|
+| `metadata.name` | `name` |
+| `active` | `enabled` |
+| `customization.targetLatency` | `targetLatency` |
+| `hls.enabled` | `outputs.hls` |
+| `publicationConfig.geoBlocking` | `security.geoBlocking` |
+| `publicationConfig.ipBlocking` | `security.ipBlocking` |
+| `fallback.enabled` / `fallback.src` | Use [redundancy](../distribution/redundancy.md) (multiple engines on one distribution) |
+| _(not available)_ | `outputs.hesp`, `outputs.hlsMpegTs`, `maxBitrate`, `overrides`, `webRtc`, `dvr`, `security.refererBlocking` |
+
+### Geo-blocking mode values
+
+The geo-blocking mode names changed:
+
+| V1 | V2 |
+|---|---|
+| `whitelist` | `allow` |
+| `blacklist` | `deny` |
+
+## Stream configuration β ABR ladders
+
+In V1, stream settings (`resolution`, `bitrate`, `fps`, `abr`) were configured directly on the channel. In V2, transcoding is configured on the **engine** using an **ABR ladder** β a predefined set of resolution and bitrate combinations managed at the organization level.
+
+Retrieve available ABR ladders with `GET /v2/abr` and pass the desired `abrLadderId` when creating an engine.
+
+## Ingest configuration
+
+In V1, ingest settings (`ingestProtocol`, `ingestType`, `ingestPullUrl`) were part of the channel. In V2, ingest is a **separate resource** created under a channel.
+
+| V1 | V2 |
+|---|---|
+| `ingestProtocol: "rtmp"`, `ingestType: "push"` | `type: "rtmp-push"` |
+| `ingestProtocol: "rtmp"`, `ingestType: "pull"` | `type: "rtmp-pull"`, `url: ""` |
+| `ingestProtocol: "srt"`, `ingestType: "pull"` | `type: "srt-pull"`, `url: ""` |
+
+## Security
+
+### Geo-blocking and IP blocking
+
+In V1, these were part of `publicationConfig` on channels and aliases. In V2, they are part of the `security` object on distributions. See the [mode value changes](#geo-blocking-mode-values) above.
+
+### Token security β security keys
+
+V1 had dedicated endpoints to enable/disable token security on channels and aliases:
+
+- `POST /channels/{id}/token-security/enable`
+- `POST /channels/{id}/aliases/{aliasId}/token-security/enable`
+
+V2 uses **security keys** managed as sub-resources on distributions:
+
+- `POST /v2/distributions/{id}/security/keys` β add a key
+- `DELETE /v2/distributions/{id}/security/keys` β remove all keys
+- `GET /v2/distributions/{id}/security/keys` β list keys
+
+### CDN security keys
+
+V1 had CDN security key endpoints on both channels and aliases. In V2, security keys are managed exclusively on distributions using the endpoints above.
+
+## Webhooks
+
+The core webhook model is similar, but with some differences:
+
+| V1 | V2 |
+|---|---|
+| `webhookId` | `id` |
+| `creationDate` | `createdAt` |
+| Separate `POST /{id}/enable` and `POST /{id}/disable` endpoints | Set `active: true` or `active: false` via `PATCH /v2/webhooks/{id}` |
+| Events reference channels and aliases | Events reference channels, ingests, engines, and distributions |
+
+V2 webhooks also support additional event types for the new resource types (e.g. `engine.deploying`, `engine.playing`, `ingest.created`, `distribution.created`, etc.). See the [API reference](./index.mdx) for the full list.
+
+## Pagination
+
+V1 used page-based pagination (`page` parameter) or `startingAfter` with an ID. V2 uses **cursor-based pagination** across all list endpoints:
+
+```json
+{
+ "data": [...],
+ "pagination": {
+ "hasMore": true,
+ "cursor": ""
+ }
+}
+```
+
+Pass the `cursor` value as a query parameter to fetch the next page.
+
+## Removed V1 endpoints
+
+The following V1 APIs do not have a direct equivalent in V2:
+
+| V1 API | V2 alternative |
+|---|---|
+| **Reports** (`/reports`) | Removed. Use the analytics endpoints on channels (e.g. `/v2/channels/{id}/analytics/viewing-minutes`). |
+| **Channel status** (`/channels/{id}/status`) | The `status` field is included directly in the channel response from `GET /v2/channels/{id}`. |
+
+## Starting and stopping
+
+The intended way to start and stop streaming remains the same β you start and stop the **channel**, which controls all engines at once:
+
+| V1 | V2 |
+|---|---|
+| `POST /channels/{id}/start` | `POST /v2/channels/{id}/start` |
+| `POST /channels/{id}/stop` | `POST /v2/channels/{id}/stop` |
+
+In addition, V2 gives you the option to start or stop **individual engines** via `POST /v2/engines/{id}/start` and `POST /v2/engines/{id}/stop`. This is useful for live operations β for example, stopping a failing engine while keeping the rest of the channel running.
diff --git a/theolive/architecture.mdx b/theolive/architecture.mdx
new file mode 100644
index 000000000000..3fb82b6b070a
--- /dev/null
+++ b/theolive/architecture.mdx
@@ -0,0 +1,45 @@
+---
+sidebar_label: Architecture
+sidebar_custom_props:
+ icon: ποΈ
+description: How channels, ingests, engines and distributions fit together.
+---
+
+# Architecture
+
+The core building block of the Dolby OptiView Live platform is the **channel**. A channel represents a complete live streaming pipeline, from media ingestion through to viewer delivery. Each channel is composed of three main components: **ingests**, **engines**, and **distributions**.
+
+
+
+
+
+Example diagram of a channel setup with redundant ingests
+
+
+
+## Ingest
+
+An ingest is the entry point for your media into the platform. It defines where and how live content is received, supporting protocols such as [RTMP and SRT](./contribution/ingest-protocols.mdx).
+
+A channel can have **multiple ingests**, allowing you to set up redundant sources for failover or to receive content from different locations simultaneously.
+
+## Engine
+
+An engine is responsible for transcoding and packaging the incoming media. It takes the raw input from an ingest and processes it into the configured output formats and quality levels (ABR ladder).
+
+A channel can have **multiple engines**, enabling different levels of redundancy depending on your needs:
+
+- **Transcoder redundancy** β connect two engines to the same ingest. If one engine fails, the other continues processing the same source. This protects against transcoding failures while keeping a single ingest path.
+- **Full path redundancy** β connect each engine to a separate ingest. This protects the entire pipeline from ingest to transcoding β if either the ingest or the engine fails on one path, the other path remains fully operational.
+
+In both cases, the engine **priority** setting determines which engine is active. A lower priority number means higher precedence, so the platform automatically falls back to the next engine when the primary one becomes unavailable.
+
+## Distribution
+
+A distribution represents an output endpoint of an engine. It defines how the processed content is delivered to viewers, including CDN configuration, player settings, and security policies.
+
+A channel can have **multiple distributions** per engine, allowing you to serve different viewer groups with different configurations from the same source. This gives a lot of flexibility, for example:
+
+- **Regional reselling** β create separate distributions with different geo-blocking rules, so each reseller or region only has access to the content they are licensed for.
+- **Testing and beta rollouts** β spin up a dedicated distribution for beta testers to try out new settings or features without affecting your production audience.
+- **Live engine management** β if a certain ingest or engine path is misbehaving, you can remove that engine from the distribution live in production. New viewers will no longer be routed to the problematic flow, while existing viewers on that engine will remain on it until they encounter issues themselves.
diff --git a/theolive/assets/img/467abb8-overview.PNG b/theolive/assets/img/467abb8-overview.PNG
deleted file mode 100644
index e80f355099b8..000000000000
Binary files a/theolive/assets/img/467abb8-overview.PNG and /dev/null differ
diff --git a/theolive/assets/img/add-user-organization.png b/theolive/assets/img/add-user-organization.png
new file mode 100644
index 000000000000..cc300c20fe1c
Binary files /dev/null and b/theolive/assets/img/add-user-organization.png differ
diff --git a/theolive/assets/img/b636bf5-create-channel.PNG b/theolive/assets/img/b636bf5-create-channel.PNG
deleted file mode 100644
index 5cc2fa997484..000000000000
Binary files a/theolive/assets/img/b636bf5-create-channel.PNG and /dev/null differ
diff --git a/theolive/assets/img/cbe288c-start.PNG b/theolive/assets/img/cbe288c-start.PNG
deleted file mode 100644
index e7ec7b5a644f..000000000000
Binary files a/theolive/assets/img/cbe288c-start.PNG and /dev/null differ
diff --git a/theolive/assets/img/channel-overview.png b/theolive/assets/img/channel-overview.png
new file mode 100644
index 000000000000..6ef5d510bad7
Binary files /dev/null and b/theolive/assets/img/channel-overview.png differ
diff --git a/theolive/assets/img/configure-distribution.png b/theolive/assets/img/configure-distribution.png
new file mode 100644
index 000000000000..1601e7a8571a
Binary files /dev/null and b/theolive/assets/img/configure-distribution.png differ
diff --git a/theolive/assets/img/configure-dvr.png b/theolive/assets/img/configure-dvr.png
new file mode 100644
index 000000000000..15b3031a0889
Binary files /dev/null and b/theolive/assets/img/configure-dvr.png differ
diff --git a/theolive/assets/img/create-engine.png b/theolive/assets/img/create-engine.png
new file mode 100644
index 000000000000..8c4027835070
Binary files /dev/null and b/theolive/assets/img/create-engine.png differ
diff --git a/theolive/assets/img/create-ingest.png b/theolive/assets/img/create-ingest.png
new file mode 100644
index 000000000000..320e73cd0726
Binary files /dev/null and b/theolive/assets/img/create-ingest.png differ
diff --git a/theolive/assets/img/create-license.png b/theolive/assets/img/create-license.png
new file mode 100644
index 000000000000..d2b81e78f537
Binary files /dev/null and b/theolive/assets/img/create-license.png differ
diff --git a/theolive/assets/img/edit-organization.png b/theolive/assets/img/edit-organization.png
new file mode 100644
index 000000000000..049d2d9e820f
Binary files /dev/null and b/theolive/assets/img/edit-organization.png differ
diff --git a/theolive/assets/img/engine-drm.png b/theolive/assets/img/engine-drm.png
new file mode 100644
index 000000000000..4ae5b3cc8981
Binary files /dev/null and b/theolive/assets/img/engine-drm.png differ
diff --git a/theolive/assets/img/full-channel-pipeline.svg b/theolive/assets/img/full-channel-pipeline.svg
new file mode 100644
index 000000000000..66a0f00d950c
--- /dev/null
+++ b/theolive/assets/img/full-channel-pipeline.svg
@@ -0,0 +1,4 @@
+
+
+
+
\ No newline at end of file
diff --git a/theolive/assets/img/geo-blocking.png b/theolive/assets/img/geo-blocking.png
new file mode 100644
index 000000000000..8d766f36557c
Binary files /dev/null and b/theolive/assets/img/geo-blocking.png differ
diff --git a/theolive/assets/img/ip-blocking.png b/theolive/assets/img/ip-blocking.png
new file mode 100644
index 000000000000..43845458dfa1
Binary files /dev/null and b/theolive/assets/img/ip-blocking.png differ
diff --git a/theolive/assets/img/optiview-live-preview.png b/theolive/assets/img/optiview-live-preview.png
new file mode 100644
index 000000000000..1374d61edba0
Binary files /dev/null and b/theolive/assets/img/optiview-live-preview.png differ
diff --git a/theolive/assets/img/referrer-blocking.png b/theolive/assets/img/referrer-blocking.png
new file mode 100644
index 000000000000..0905328f9e8a
Binary files /dev/null and b/theolive/assets/img/referrer-blocking.png differ
diff --git a/theolive/assets/img/rtmp-push.png b/theolive/assets/img/rtmp-push.png
new file mode 100644
index 000000000000..d1bcc64b6512
Binary files /dev/null and b/theolive/assets/img/rtmp-push.png differ
diff --git a/theolive/assets/img/scheduler-channel-details.jpg b/theolive/assets/img/scheduler-channel-details.jpg
new file mode 100644
index 000000000000..6e18c1960352
Binary files /dev/null and b/theolive/assets/img/scheduler-channel-details.jpg differ
diff --git a/theolive/assets/img/scheduler-one-time.jpg b/theolive/assets/img/scheduler-one-time.jpg
new file mode 100644
index 000000000000..9b776eda72c6
Binary files /dev/null and b/theolive/assets/img/scheduler-one-time.jpg differ
diff --git a/theolive/assets/img/scheduler-recurring.jpg b/theolive/assets/img/scheduler-recurring.jpg
new file mode 100644
index 000000000000..285e664c84b5
Binary files /dev/null and b/theolive/assets/img/scheduler-recurring.jpg differ
diff --git a/theolive/assets/img/schedulers-overview.jpg b/theolive/assets/img/schedulers-overview.jpg
new file mode 100644
index 000000000000..3d3071d09f4e
Binary files /dev/null and b/theolive/assets/img/schedulers-overview.jpg differ
diff --git a/theolive/assets/img/software-encoders/ffmpeg_logo.svg b/theolive/assets/img/software-encoders/ffmpeg_logo.svg
new file mode 100644
index 000000000000..5b0573b7132b
--- /dev/null
+++ b/theolive/assets/img/software-encoders/ffmpeg_logo.svg
@@ -0,0 +1,34 @@
+
+
diff --git a/theolive/assets/img/software-encoders/wirecast_logo.svg b/theolive/assets/img/software-encoders/wirecast_logo.svg
new file mode 100644
index 000000000000..d4fe51388beb
--- /dev/null
+++ b/theolive/assets/img/software-encoders/wirecast_logo.svg
@@ -0,0 +1,45 @@
+
+
diff --git a/theolive/assets/img/srt-pull-ingest.png b/theolive/assets/img/srt-pull-ingest.png
new file mode 100644
index 000000000000..cd3bb733abd9
Binary files /dev/null and b/theolive/assets/img/srt-pull-ingest.png differ
diff --git a/theolive/assets/img/start-channel.png b/theolive/assets/img/start-channel.png
new file mode 100644
index 000000000000..e0065390a050
Binary files /dev/null and b/theolive/assets/img/start-channel.png differ
diff --git a/theolive/assets/img/theolive-license.png b/theolive/assets/img/theolive-license.png
deleted file mode 100644
index ca38e5f39c11..000000000000
Binary files a/theolive/assets/img/theolive-license.png and /dev/null differ
diff --git a/theolive/assets/img/token-security.png b/theolive/assets/img/token-security.png
new file mode 100644
index 000000000000..13e7befeb845
Binary files /dev/null and b/theolive/assets/img/token-security.png differ
diff --git a/theolive/channel/dvr.mdx b/theolive/channel/dvr.mdx
new file mode 100644
index 000000000000..8a1a3637e134
--- /dev/null
+++ b/theolive/channel/dvr.mdx
@@ -0,0 +1,39 @@
+---
+sidebar_position: 1
+sidebar_label: DVR window
+sidebar_custom_props:
+ icon: βͺ
+description: Enable time-shifted playback so viewers can rewind and catch up on live content.
+---
+
+# DVR window
+
+DVR (Digital Video Recording) enables viewers to pause, rewind, and replay your live stream content. The DVR window defines how far back viewers can seek during your live broadcast.
+
+## Configuration
+
+To enable DVR, set a **window size** in seconds on your channel. This determines the length of the rewindable buffer available to viewers. For example, a window size of 3600 seconds allows viewers to seek up to one hour back in the live stream.
+
+
+
+
+
+
+
+When DVR is enabled, viewers can scrub back through the live stream within the configured window. Once the window is exceeded, older content is no longer available for playback.
+
+## API example
+
+You can also enable DVR via the API by setting `dvr.enabled` to `true` and `dvr.windowInSeconds` to your desired window size (60β86400 seconds) when [creating](../api/create-channel.api.mdx) or [updating](../api/update-channel.api.mdx) your channel.
+
+`POST https://api.theo.live/v2/channels`
+
+```json
+{
+ "name": "my-channel",
+ "dvr": {
+ "enabled": true,
+ "windowInSeconds": 3600
+ }
+}
+```
diff --git a/theolive/platform/nielsen.mdx b/theolive/channel/nielsen.mdx
similarity index 69%
rename from theolive/platform/nielsen.mdx
rename to theolive/channel/nielsen.mdx
index b44d0e499dcc..cc30a1b27505 100644
--- a/theolive/platform/nielsen.mdx
+++ b/theolive/channel/nielsen.mdx
@@ -1,5 +1,9 @@
---
-sidebar_position: 11
+sidebar_position: 3
+sidebar_label: Nielsen
+sidebar_custom_props:
+ icon: π
+description: Track real-time audience measurement with Nielsen markers.
---
# Nielsen audience tracking
@@ -16,3 +20,18 @@ This guide explains how to enable Nielsen audience tracking on your streams in a
That is all the backend configuration work that is required. This will make sure your markers are converted to the correct ID3 messages that a player can then read and report back to Nielsen.
3. The final step is enabling Nielsen on your player. For THEOplayer on web for example, you can find the steps in our [guide to integrating Nielsen on Web](/theoplayer/connectors/web/nielsen).
+
+## API example
+
+You can also enable Nielsen via the API by setting `nielsen.enabled` to `true` when [creating](../api/create-channel.api.mdx) or [updating](../api/update-channel.api.mdx) your channel.
+
+`POST https://api.theo.live/v2/channels`
+
+```json
+{
+ "name": "my-channel",
+ "nielsen": {
+ "enabled": true
+ }
+}
+```
diff --git a/theolive/contribution/closed-captions.mdx b/theolive/contribution/closed-captions.mdx
new file mode 100644
index 000000000000..aba87075f8b8
--- /dev/null
+++ b/theolive/contribution/closed-captions.mdx
@@ -0,0 +1,54 @@
+---
+sidebar_position: 4
+sidebar_label: Closed captions
+sidebar_custom_props:
+ icon: π¬
+description: How to ingest and deliver closed captions via SRT.
+---
+
+# Closed captions
+
+The Dolby OptiView Live platform supports closed captions ingest and delivery. This functionality is essential for accessibility, allowing viewers to follow along with spoken content through on-screen text.
+
+:::caution
+This functionality is **only** supported through the SRT ingest protocol.
+:::
+
+## Configuring closed captions
+
+To deliver closed captions the following steps must be taken:
+
+1. Ensure your encoder is configured to include CEA-608/708 closed caption data in the video stream.
+2. Within the dashboard, configure the closed captions track by selecting the channel, language, and label.
+
+
+
+3. Start your channel and begin ingesting video with embedded caption data.
+4. Check the preview in the dashboard to validate the captions are being received correctly.
+
+## API example
+
+You can also configure closed captions via the API when [creating](../api/create-channel-ingest.api.mdx) or [updating](../api/update-ingest.api.mdx) an ingest. Include the `captions` array in your request body, where each track requires a `channel` number and a `language`.
+
+`POST https://api.theo.live/v2/channels/{channelId}/ingests`
+
+```json
+{
+ "name": "my-ingest",
+ "type": "srt-pull",
+ "url": "srt://your-srt-source:1234",
+ "region": "europe-west",
+ "captions": [{ "channel": 1, "language": "en", "label": "English" }]
+}
+```
+
+## Feature Compatibility and Limitations
+
+- Only CEA-608/708 embedded captions are supported.
+- Captions must be embedded in the video stream by the encoder.
+
+#### Ingest
+
+| RTMP Push | RTMP Pull | SRT Pull |
+| :-------: | :-------: | :------: |
+| No | No | Yes |
diff --git a/theolive/contribution/hardware-encoders/_category_.json b/theolive/contribution/hardware-encoders/_category_.json
index e7749d13ce2f..a9c9adeaba15 100644
--- a/theolive/contribution/hardware-encoders/_category_.json
+++ b/theolive/contribution/hardware-encoders/_category_.json
@@ -1,4 +1,8 @@
{
"label": "Hardware Encoders",
- "position": 4
+ "position": 2,
+ "description": "Setup guides for hardware encoders like Videon, Haivision, Magewell and Osprey.",
+ "customProps": {
+ "icon": "π₯οΈ"
+ }
}
diff --git a/theolive/contribution/hardware-encoders/haivision.mdx b/theolive/contribution/hardware-encoders/haivision.mdx
index f1826e1550c1..605c97da5a76 100644
--- a/theolive/contribution/hardware-encoders/haivision.mdx
+++ b/theolive/contribution/hardware-encoders/haivision.mdx
@@ -16,13 +16,13 @@ Follow the Create Channel Wizard prompts to create a channel as normal:
1. Enter the desired channel name.
2. Identify your live source for the channel input.
3. Choose RTMP for the channel output and copy the RTMP publish path from the Dolby _channel_ you have created.
- RTMP URL: `rtmps://rtmp..hesp.live/live`
+ RTMP URL: `rtmps://rtmp..theo.live/live`
4. Enter the RTMP publish stream name from the ingest server section.
Stream Name: ``
-import RtmpPush from '../../assets/img/hardware-encoders/theolive-ingest-server-rtmp-push.png';
+import RtmpPush from '../../assets/img/rtmp-push.png';
-
+
@@ -44,5 +44,5 @@ Here are some adjustments recommended by the [Haivision support](https://www.hai
\*Note: The timestamp seeding seemed to be the magic change on the KBs.
:::info π§ Frame rate and bandwidth
-Remember to set the frame rate to the same value as in your THEOlive channel ingest configuration and make sure that your encoder has a stable connection and enough upload bandwidth. See [Stream configuration](../stream-configuration.mdx) for more details.
+Remember to set the frame rate to the same value as in your channel ingest configuration and make sure that your encoder has a stable connection and enough upload bandwidth. See [Stream configuration](../../media-engine/abr.mdx) for more details.
:::
diff --git a/theolive/contribution/hardware-encoders/index.mdx b/theolive/contribution/hardware-encoders/index.mdx
index 8be08c8fce88..cfa7fc5bfbe2 100644
--- a/theolive/contribution/hardware-encoders/index.mdx
+++ b/theolive/contribution/hardware-encoders/index.mdx
@@ -1,4 +1,5 @@
---
+sidebar_position: 2
title: Hardware Encoders
description: Hardware-based Encoders for Broadcasting Live Streaming Content
slug: /hardware-encoders
@@ -6,39 +7,9 @@ slug: /hardware-encoders
In today's digital landscape, the demand for live streaming content has skyrocketed, prompting broadcasters and video creators to prioritize the efficient delivery of high-quality video and audio streams. Hardware-based encoders play a crucial role in this process with their offerings of superior encoding capabilities and seamless transmission. Needless to say, workflows don't have to be interrupted in order to better a stream.
-## Integration guides
-
-Review these guides for how to setup your preferred tools for live streaming integrations.
-
-import { IconGrid, IconGridButton } from '@site/src/components/IconGrid';
-
-
- [](haivision.mdx)
- [](magewell.mdx)
- [](osprey.mdx)
- [](videon.mdx)
-
-
-### Haivision
-
-[How-to integrate using Haivision KB Encoder](haivision.mdx)
-
-The **Haivision KB Encoder** is a high-performance video encoding device that efficiently converts video signals into compressed formats for reliable live streaming and distribution over IP networks.
-
-### Magewell
-
-[How-to integrate using Magewell Ultra Encode](magewell.mdx)
-
-The **Magewell Ultra Encode** is a leading encoder manufacturer that supports connecting to the Dolby OptiView Streaming Service for broadcasting real-time streams.
-
-### Osprey
-
-[How-to integrate using Osprey Talon Encoder](osprey.mdx)
-
-**Osprey Talon** is a form-factor H.264 (AVC) and H.265 (HEVC) encoder designed to be easy to use, portable, and easily stream low latency 4k and UHD video encoding from SDI and HDMI.
-
-### Videon
-
-[How-to integrate using Videon EdgeCaster](videon.mdx)
-
-**Videon EdgeCaster** is a versatile and powerful edge compute encoder that securely delivers high-quality live video streams to multiple platforms simultaneously, offering a comprehensive solution for efficient video distribution.
+| Logo | Encoder | Description |
+| :------------------------------------------------------------------------------------------------------------------------------------------------------------: | :----------------------------- | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| | **[Haivision](haivision.mdx)** | High-performance video encoding device that efficiently converts video signals into compressed formats for reliable live streaming and distribution over IP networks. |
+| | **[Magewell](magewell.mdx)** | Leading encoder manufacturer that supports connecting to the Dolby OptiView Streaming Service for broadcasting real-time streams. |
+| | **[Osprey](osprey.mdx)** | Form-factor H.264 (AVC) and H.265 (HEVC) encoder designed to be easy to use, portable, and easily stream low latency 4k and UHD video encoding from SDI and HDMI. |
+| | **[Videon](videon.mdx)** | Versatile and powerful edge compute encoder that securely delivers high-quality live video streams to multiple platforms simultaneously. |
diff --git a/theolive/contribution/hardware-encoders/magewell.mdx b/theolive/contribution/hardware-encoders/magewell.mdx
index a8fa2efebc9a..e5f8b5dbf782 100644
--- a/theolive/contribution/hardware-encoders/magewell.mdx
+++ b/theolive/contribution/hardware-encoders/magewell.mdx
@@ -16,12 +16,12 @@ To begin, first power on your Ultra Encode, connect it to the internet (Ethernet
import RtmpMagewell from '../../assets/img/hardware-encoders/magewell-rtmp.png';
-
+
- For the `URL` select `rtmps://` and enter the **URL** of the channel.
- RTMP URL: `rtmps://rtmp..hesp.live/live`
+ RTMP URL: `rtmps://rtmp..theo.live/live`
- For the `Stream key` input the **Stream key** from the ingest server section.
Stream key: ``
@@ -29,7 +29,7 @@ Finally, select which network you'd like the encoder to use to connect, and save
import RtmpDolbyMagewell from '../../assets/img/hardware-encoders/magewell-rtmp-live.png';
-
+
@@ -37,7 +37,7 @@ Once saved, make sure the stream is activated by toggling the server switch on t
import ConnectMagewell from '../../assets/img/hardware-encoders/magewell-connect.png';
-
+
@@ -45,6 +45,6 @@ With the stream enabled, you can navigate back to the main Dashboard page of the
import ConnectMagewellStream from '../../assets/img/hardware-encoders/magewell-connect-stream.png';
-
+
diff --git a/theolive/contribution/hardware-encoders/osprey.mdx b/theolive/contribution/hardware-encoders/osprey.mdx
index 2713cb0af0b1..11d725968976 100644
--- a/theolive/contribution/hardware-encoders/osprey.mdx
+++ b/theolive/contribution/hardware-encoders/osprey.mdx
@@ -13,7 +13,7 @@ You'll need to plug an ethernet connection and a power supply into your Talon en
import OspreyTalon2 from '../../assets/img/hardware-encoders/osprey-talon.jpg';
-
+
@@ -25,7 +25,7 @@ Once found in your browser, you'll be prompted to log into the device. Refer to
import OspreyTalon3 from '../../assets/img/hardware-encoders/osprey-login.jpeg';
-
+
@@ -34,13 +34,13 @@ import OspreyTalon3 from '../../assets/img/hardware-encoders/osprey-login.jpeg';
Inside the encoder UI, click on the _Channels_ tab. From the Channels tab, set the protocol to **RTMP/RTMPS**.
- For the `Destination` copy the RTMP publish path from the Dolby _channel_ you have created.
- RTMP URL: `rtmps://rtmp..hesp.live/live`
+ RTMP URL: `rtmps://rtmp..theo.live/live`
- For the `Stream Key` input RTMP publish stream name from the ingest server section.
Stream Name: ``
import OspreyTalon4 from '../../assets/img/hardware-encoders/osprey-rtmp-live.png';
-
+
diff --git a/theolive/contribution/hardware-encoders/videon.mdx b/theolive/contribution/hardware-encoders/videon.mdx
index c1542d8bad67..c91b8edeb1da 100644
--- a/theolive/contribution/hardware-encoders/videon.mdx
+++ b/theolive/contribution/hardware-encoders/videon.mdx
@@ -17,25 +17,25 @@ In your Videon EdgeCaster Streaming Dashboard configure the following settings:
import RtmpPush from '../../assets/img/hardware-encoders/Videon_Edgecaster_-_Input_Settings.jpg';
-
+
:::info π§ Frame rate and bandwidth
-Remember to set the frame rate to the same value as in your THEOlive channel ingest configuration and make sure that your encoder has a stable connection and enough upload bandwidth. See [Stream configuration](../stream-configuration.mdx) for more details.
+Remember to set the frame rate to the same value as in your channel ingest configuration and make sure that your encoder has a stable connection and enough upload bandwidth. See [Stream configuration](../../media-engine/abr.mdx) for more details.
:::
## 2. Set your Video Profile
- Under the "Video Profiles" section, please select your profile, or create a new one. In the example below we have selected the profile "hesp.live". If you would create a new profile, you can change the name by clicking on the pencil.
-- Under Video Scaling, select the desired resolution. Note that THEOlive support resolutions up to 1080p. The resolution of your ingested stream can be found under "Encoded Video Resolution". In the example below we have selected pass through, which means we keep our "Encoded Video Resolution" of 1080p25.
-- Match the "Video bitrate" value to the maximum value of the channel preset you are using. See [Stream configuration](../stream-configuration.mdx) for more details.
+- Under Video Scaling, select the desired resolution. Note that OptiView Live supports resolutions up to 1080p. The resolution of your ingested stream can be found under "Encoded Video Resolution". In the example below we have selected pass through, which means we keep our "Encoded Video Resolution" of 1080p25.
+- Match the "Video bitrate" value to the maximum value of the channel preset you are using. See [Stream configuration](../../media-engine/abr.mdx) for more details.
- Further configure your encoding settings. Select `Lowest`, `Low`, `Normal` or `High` in the Quality/Latency drop-down menu, depending on your preference. Selecting `Lowest` will give you lower quality but also the lowest latency and the other way around for `High` which gives the `Highest` quality but with slightly higher latency.
- Click on the "Save" button.
import VideoProfile from '../../assets/img/hardware-encoders/Videon_Edgecaster_-_Video_Profile.jpg';
-
+
@@ -47,7 +47,7 @@ import VideoProfile from '../../assets/img/hardware-encoders/Videon_Edgecaster_-
import AudioProfile from '../../assets/img/hardware-encoders/Videon_Edgecaster_-_Audio_Profile.jpg';
-
+
@@ -62,6 +62,6 @@ import AudioProfile from '../../assets/img/hardware-encoders/Videon_Edgecaster_-
import EdgecasterOutput from '../../assets/img/hardware-encoders/Videon_Edgecaster_-_Output.jpg';
-
+
diff --git a/theolive/contribution/ingest-protocols.mdx b/theolive/contribution/ingest-protocols.mdx
new file mode 100644
index 000000000000..cdd107611b39
--- /dev/null
+++ b/theolive/contribution/ingest-protocols.mdx
@@ -0,0 +1,36 @@
+---
+sidebar_position: 0
+sidebar_label: Ingest protocols
+sidebar_custom_props:
+ icon: π
+description: Supported ingest protocols (RTMP and SRT) and their trade-offs.
+---
+
+# Ingest protocols
+
+The Dolby OptiView Live platform supports low latency live streaming through two ingest protocols: **RTMP** and **SRT**.
+
+## RTMP β Real-Time Messaging Protocol
+
+RTMP is a widely adopted protocol originally developed by Adobe for transmitting audio, video, and data over the internet. It remains one of the most commonly supported protocols across hardware and software encoders.
+
+- **Pros**
+ - **Broad encoder support** β Nearly all hardware and software encoders support RTMP out of the box.
+ - **Simple setup** β Requires minimal configuration, typically just a server URL and stream key.
+ - **Low latency** β Provides low latency contribution suitable for most live streaming use cases.
+- **Cons**
+ - **Container limitation** β RTMP uses the FLV container, which only supports H.264 video and AAC audio. Newer codecs such as H.265/HEVC are not supported.
+ - **Single audio track** β RTMP is limited to a single audio track per stream, making it unsuitable for multi-audio use cases.
+
+## SRT β Secure Reliable Transport
+
+SRT is an open-source protocol designed for low latency, secure, and reliable video transport across unpredictable networks. It is increasingly adopted as a modern alternative to RTMP.
+
+- **Pros**
+ - **Resilient on unreliable networks** β SRT uses UDP with built-in error correction (ARQ), making it well suited for contribution over the public internet or unstable connections.
+ - **Multi-audio support** β SRT uses the MPEG-TS container, which supports multiple audio tracks within a single stream.
+ - **Closed captions and metadata** β The MPEG-TS container also supports embedded closed captions (CEA-608/708) and SEI metadata pass-through.
+ - **Codec flexibility** β MPEG-TS supports a broader range of codecs compared to FLV.
+- **Cons**
+ - **Less universal encoder support** β While adoption is growing, not all encoders support SRT, especially older hardware models.
+ - **More complex configuration** β SRT may require tuning parameters such as latency, overhead bandwidth, and encryption settings for optimal performance.
diff --git a/theolive/contribution/multi-audio-support.mdx b/theolive/contribution/multi-audio-support.mdx
index b928e92a6502..3841e9ac8ab1 100644
--- a/theolive/contribution/multi-audio-support.mdx
+++ b/theolive/contribution/multi-audio-support.mdx
@@ -1,31 +1,52 @@
---
-sidebar_position: 2
-sidebar_label: Multi-audio support
+sidebar_position: 3
+sidebar_label: Multi-audio
+sidebar_custom_props:
+ icon: π
+description: How to ingest and deliver multiple audio tracks via SRT.
---
-# Multi-audio support
+# Multi-audio
----
-
-The Dolby OptiView platform supports multi-audio ingest and delivery with our HESP solution. This functionality is perfect for
+The Dolby OptiView Live platform supports multi-audio ingest and delivery. This functionality is perfect for
use cases such as live events where multiple languages or commentary may be required.
:::caution
-This functionality is **only** supported through the SRT Pull ingest method. Playback is **only** supported on web.
+This functionality is **only** supported through the SRT ingest protocol.
:::
## Configuring multi-audio ingest and playback
To deliver multi audio SRT the following steps must be taken:
-1. Within your dashboard configure your SRT listener endpoint.
+1. Within the dashboard configure your SRT listener endpoint.
2. Configure your expected incoming "Audio tracks" by specifying a language, label, and the expected PID.
-
+
3. Start the Channel and begin ingesting video and audio into the engine.
-4. Your output will be available for playback on web only via the [channel alias](../platform/multi-channel.md).
-5. You can validate the audio tracks are being delivered via the demo player : `https://demo.theo.live/?channel=YOUR_CHANNEL_ID`
+4. Check the preview in the dashboard to validate the audio tracks are being received correctly.
+
+## API example
+
+You can also configure multi-audio tracks via the API when [creating](../api/create-channel-ingest.api.mdx) or [updating](../api/update-ingest.api.mdx) an ingest. Include the `tracks.audio` array in your request body, where each track requires a `language` and the `pid` matching your SRT stream.
+
+`POST https://api.theo.live/v2/channels/{channelId}/ingests`
+
+```json
+{
+ "name": "my-ingest",
+ "type": "srt-pull",
+ "url": "srt://your-srt-source:1234",
+ "region": "europe-west",
+ "tracks": {
+ "audio": [
+ { "pid": 256, "language": "en", "label": "English" },
+ { "pid": 257, "language": "es", "label": "Spanish" }
+ ]
+ }
+}
+```
## Feature Compatibility and Limitations
@@ -38,9 +59,3 @@ To deliver multi audio SRT the following steps must be taken:
| RTMP Push | RTMP Pull | SRT Pull |
| :-------: | :-------: | :------: |
| No | No | Yes |
-
-#### Playback
-
-| Web SDK | Android SDK | iOS SDK |
-| :-----: | :---------: | :-----: |
-| Yes | No | No |
diff --git a/theolive/contribution/sei-messages.mdx b/theolive/contribution/sei-messages.mdx
index 5dc06cf4afe3..676e5af31f7d 100644
--- a/theolive/contribution/sei-messages.mdx
+++ b/theolive/contribution/sei-messages.mdx
@@ -1,14 +1,17 @@
---
-sidebar_position: 3
-sidebar_label: In-stream Metadata
+sidebar_position: 5
+sidebar_label: In-stream SEI metadata
+sidebar_custom_props:
+ icon: π·οΈ
+description: How to embed and pass through SEI metadata in your live stream.
---
-# In-stream metadata through SEI messages
+# In-stream SEI metadata
----
-
-THEOlive allows you to embed metadata into your stream that is preserved throughout the THEOlive pipeline and can be accessed by the player.
+The Dolby OptiView Live platform allows you to embed metadata into your stream using SEI (Supplemental Enhancement Information) messages. This metadata is preserved throughout the pipeline and can be accessed by the player during playback.
-The first step is adding the metadata to your (h264) input stream in the form of picture timing SEI messages as defined in ITUT H264 Annex D 1.3. These messages allow you to add a timestamp to your frames and associate the timestamp with an event that happened on your backend.
+## Configuring in-stream SEI metadata
-The next step is [listening to these messages in the player](../playback/web/metadata.mdx).
+1. Add metadata to your H.264 input stream in the form of picture timing SEI messages, as defined in ITU-T H.264 Annex D 1.3. These messages allow you to attach a timestamp to individual frames and associate it with an event on your backend.
+2. Start your channel and begin ingesting video with embedded SEI data.
+3. [Listen to these messages in the player](/theoplayer/how-to-guides/web/theolive/metadata/) to consume the metadata during playback.
diff --git a/theolive/contribution/software-encoders/_category_.json b/theolive/contribution/software-encoders/_category_.json
index 59985b1d833f..925cf29cee21 100644
--- a/theolive/contribution/software-encoders/_category_.json
+++ b/theolive/contribution/software-encoders/_category_.json
@@ -1,4 +1,8 @@
{
"label": "Software Encoders",
- "position": 5
+ "position": 1,
+ "description": "Setup guides for software encoders like OBS, vMix and Wirecast.",
+ "customProps": {
+ "icon": "π»"
+ }
}
diff --git a/theolive/contribution/software-encoders/ffmpeg.md b/theolive/contribution/software-encoders/ffmpeg.md
index c5b875cbfa2c..6157c0159560 100644
--- a/theolive/contribution/software-encoders/ffmpeg.md
+++ b/theolive/contribution/software-encoders/ffmpeg.md
@@ -1,58 +1,60 @@
---
-sidebar_position: 6
+sidebar_position: 1
sidebar_label: FFmpeg
+description: Free open-source command-line tool for streaming media files.
---
-# Using FFmpeg with THEOlive
+# Using FFmpeg with OptiView Live
-**FFmpeg** is a free open-source software project with command-line tools for handling video, audio, and other multimedia. It is common practice to use Ffmpeg in production workflows when broadcasting from a media file on disk.
-
-Broadcasts are started using the `ffmpeg` command-line to forward a source using RTMP broadcast contribution protocol to stream content to THEOlive.
+**FFmpeg** is a free open-source command-line tool for handling video, audio, and other multimedia. It is commonly used in production workflows to broadcast a media file using RTMP to OptiView Live.
+:::tip
See the official [ffmpeg.org](https://ffmpeg.org/) documentation for installation instructions and additional support.
+:::
+
+## Streaming a file
-## Common Settings
+```shell
+ffmpeg -re -stream_loop -1 -i /path/to/file.mp4 \
+ -c:v copy -c:a copy -f flv \
+ -rtmp_playpath "your-stream-key" \
+ -rtmp_live live "rtmps://rtmp..theo.live/live"
+```
-| Parameter | Description |
-| :----------------- | :----------------------------------------------- |
-| \-stream_loop -1 | Loop the video indefinitely |
-| \-vb 4500k | Video Bitrate setting of 4.5 Mbps |
-| \-c:a copy | Copy the audio codec from the input |
-| \-bf 0 | Disable bframes |
-| \-g 60 | Group of pictures (GOP) size |
-| \-f flv | Package flash video |
-| \-preset veryfast | Video encoding speed to compression ratio preset |
-| \-tune zerolatency | Good for fast encoding and low-latency streaming |
-| \-vprofile main | H264 video profile |
+| Parameter | Description |
+| :--------------- | :------------------------------------------------------------ |
+| \-re | Read input at native frame rate (for file-based sources only) |
+| \-stream_loop -1 | Loop the video indefinitely |
+| \-c:v copy | Copy the video codec from the input |
+| \-c:a copy | Copy the audio codec from the input |
+| \-f flv | Package flash video |
:::warning -re flag
Do not use the `-re` flag when the input is an actual capture device or a live stream as it may cause packet loss and higher latency.
:::
-## Start the stream
+:::info Upload bandwidth
+Make sure that your encoder has a stable connection and enough upload bandwidth. This will ensure all data is correctly sent to the OptiView Live channel.
+:::
+
+## Low Latency Encoding Settings
+
+The following settings are recommended to achieve the lowest possible latency when re-encoding when streaming to OptiView Live. These prioritize encoding speed and reduced buffering at the cost of some video quality.
-Run the following command with the proper settings in order to start publishing to your channel.
+| Parameter | Description |
+| :----------------- | :---------------------------------------------------------- |
+| \-vb 4500k | Video Bitrate setting of 4.5 Mbps |
+| \-vprofile main | H264 video profile |
+| \-g 60 | Group of pictures (GOP) size |
+| \-preset veryfast | Faster encoding speed at the cost of compression efficiency |
+| \-tune zerolatency | Disables internal buffering for low-latency streaming |
+| \-bf 0 | Disable B-frames to reduce encoding delay |
```shell
-MEDIA_FILE="/path/to/file.mp4"
-RTMP_PUBLISH_URL="rtmps://rtmp..theo.live/live"
-RTMP_STREAM_KEY="Your stream key"
-
-ffmpeg -re -stream_loop -1 -i $VIDEO_FILE_PATH \
- -vcodec libx264 \
- -preset veryfast \
- -bf 0 \
- -g 60 \
- -vb 4500k \
- -vprofile main \
- -tune zerolatency \
- -level 3.0 \
- -c:a copy \
- -f flv \
- -rtmp_playpath $RTMP_STREAM_KEY \
- -rtmp_live live $RTMP_PUBLISH_URL
+ffmpeg -f decklink -i "DeckLink Mini Recorder" \
+ -vcodec libx264 -vb 4500k -vprofile main -g 60 \
+ -preset veryfast -tune zerolatency -bf 0 \
+ -c:a aac -ab 128k -f flv \
+ -rtmp_playpath "your-stream-key" \
+ -rtmp_live live "rtmps://rtmp..theo.live/live"
```
-
-:::info Upload bandwidth
-Make sure that your encoder has a stable connection and enough upload bandwidth. This will ensure all data is correctly sent to the THEOlive channel.
-:::
diff --git a/theolive/contribution/software-encoders/index.mdx b/theolive/contribution/software-encoders/index.mdx
index 7a30cdca4c19..96cfeae3896d 100644
--- a/theolive/contribution/software-encoders/index.mdx
+++ b/theolive/contribution/software-encoders/index.mdx
@@ -1,4 +1,5 @@
---
+sidebar_position: 1
title: Software Encoders
description: Software-based Encoders for Broadcasting Live Streaming Content
slug: /software-encoders
@@ -6,34 +7,12 @@ slug: /software-encoders
A software encoder can take raw video frames and convert it into a digital format that is compatible for distribution with the Dolby OptiView Live Streaming service. This type of integration can typically be done without additional hardware requirements and eases adoption of real-time streaming workflows.
-## Integration Guides
+import FfmpegLogo from '../../assets/img/software-encoders/ffmpeg_logo.svg';
+import WirecastLogo from '../../assets/img/software-encoders/wirecast_logo.svg';
-Review these guides for how to setup your preferred tools for real-time streaming integrations.
-
-import { IconGrid, IconGridButton } from '@site/src/components/IconGrid';
-
-
-
- [](ffmpeg.md)
-
- [](obs.md)
- [](vmix.md)
-
-
-### FFmpeg
-
-**FFmpeg** is a free open-source software project with command-line tools for handling video, audio, and other multimedia. This can be helpful for quickly streaming a media file from disk.
-
-[How-to integrate with FFmpeg](ffmpeg.md)
-
-### Open Broadcaster Software (OBS)
-
-**OBS** is a free open-source application for broadcasting and recording streams from your desktop computer.
-
-[How-to integrate with OBS](obs.md)
-
-### vMix
-
-**vMix** is a Windows desktop applicationi that provides a vision mixer and encoder.
-
-[How-to integrate with vMix](vmix.md)
+| Logo | Encoder | Description |
+| :------------------------------------------------------------------------------------------------------------------------------------------------: | :-------------------------- | :-------------------------------------------------------------------- |
+| | **[FFmpeg](ffmpeg.md)** | Free open-source command-line tool for streaming media files. |
+| | **[OBS](obs.md)** | Free open-source application for broadcasting and recording streams. |
+| | **[vMix](vmix.md)** | Windows desktop application that provides a vision mixer and encoder. |
+| | **[Wirecast](wirecast.md)** | Live video streaming production tool by Telestream. |
diff --git a/theolive/contribution/software-encoders/obs.md b/theolive/contribution/software-encoders/obs.md
index effe19e529b4..f1c7a4f2e41b 100644
--- a/theolive/contribution/software-encoders/obs.md
+++ b/theolive/contribution/software-encoders/obs.md
@@ -1,16 +1,15 @@
---
sidebar_position: 2
sidebar_label: OBS
+description: Free open-source application for broadcasting and recording streams.
---
-# Using OBS with THEOlive
+# Using OBS with OptiView Live
-**Open Broadcaster Software (OBS)** is a free open-source software created for broadcasting and recording on your desktop. You can take advantage of this tool to stream high-quality video to your viewers using THEOlive.
+**Open Broadcaster Software (OBS)** is a free open-source software created for broadcasting and recording on your desktop. You can take advantage of this tool to stream high-quality video to your viewers using OptiView Live.
-See the official [obsproject.com](https://obsproject.com) documentation for installation instructions and additional support about using OBS.
-
-:::tip Getting Started
-If you haven't already, begin by following the [Getting Started](../../getting-started.mdx) tutorial to create a THEOlive channel and start your first broadcast.
+:::tip
+See the official [obsproject.com](https://obsproject.com) documentation for installation instructions and additional support.
:::
## Setting up a broadcast
@@ -26,15 +25,15 @@ In the _Source_ section at the bottom of the OBS application, hit the + sign to
Select _Settings_ in the _Controls_ section at the bottom right of the OBS application. Click on the _Stream_ tab on the left menu bar and configure the following:
- Select "Custom..." as the _Service_
-- Copy your `rtmpPushUrl` from the channel details page in the THEOlive dashboard URL as _Server_
-- Copy your `streamKey` from the channel details page in the THEOlive dashboard as _Stream Key_
+- Copy your `rtmpPushUrl` from the channel details page in the dashboard URL as _Server_
+- Copy your `streamKey` from the channel details page in the dashboard as _Stream Key_
-Next, go to the _Output_ tab in the _Settings_ menu, and configure the following settings in order to achieve the lowest possible latency using THEOlive.
+Next, go to the _Output_ tab in the _Settings_ menu, and configure the following settings in order to achieve the lowest possible latency using OptiView Live.
- Output Mode: `Advanced`
-- Bitrate: match the max bitrate of the profile used in your channel (e.g.: 4500Kbps for "sport"). [More details](../stream-configuration.mdx).
+- Bitrate: match the max bitrate of the profile used in your channel (e.g.: 4500Kbps for "sport"). [More details](../../media-engine/abr.mdx).
- Keyframe interval: `2s`
- CPU Usage Preset (higher = less CPU): `veryfast`
- Profile: `main`
@@ -42,12 +41,12 @@ Next, go to the _Output_ tab in the _Settings_ menu, and configure the following
-Lastly, go to the _Video_ tab and set the frame rate to the same value you have set in your THEOlive channel. See [Stream configuration](../stream-configuration.mdx) for more details.
+Lastly, go to the _Video_ tab and set the frame rate to the same value you have set in your channel. See [Stream configuration](../../media-engine/abr.mdx) for more details.
:::info π§ Upload bandwidth
-Make sure that your encoder has a stable connection and enough upload bandwidth. This will ensure all data is correctly sent to the THEOlive channel.
+Make sure that your encoder has a stable connection and enough upload bandwidth. This will ensure all data is correctly sent to the channel.
:::
### 3. Start streaming
@@ -56,13 +55,9 @@ Hit apply on settings, close the window, and click on _Start Streaming_ in the _
-### 4. Start your THEOlive channel
-
-Your THEOlive channel must be started in order to receive video ingest from OBS. You can choose to start up your channel before or after you start streaming via OBS.
-
-Starting a channel can be done either [through the API](../../api/start-channel.api.mdx) or via [the console](https://console.theo.live/).
+### 4. Start your channel
-
+Your channel must be started in order to receive video ingest from OBS. You can choose to start up your channel before or after you start streaming via OBS.
## Feature compatibility and limitations
diff --git a/theolive/contribution/software-encoders/vmix.md b/theolive/contribution/software-encoders/vmix.md
index 54377fde8b73..2b5ea8fc2854 100644
--- a/theolive/contribution/software-encoders/vmix.md
+++ b/theolive/contribution/software-encoders/vmix.md
@@ -1,11 +1,12 @@
---
-sidebar_position: 4
+sidebar_position: 3
sidebar_label: vMix
+description: Windows desktop application that provides a vision mixer and encoder.
---
-# Using vMix with THEOlive
+# Using vMix with OptiView Live
-This guide explains to you how to set up vMix correctly so it can be used to stream your content with THEOlive.
+This guide explains to you how to set up vMix correctly so it can be used to stream your content with OptiView Live.
## 1. Set up sources
@@ -33,7 +34,7 @@ If you want to burn in a clock you can follow the steps documented by vMix. You
-**Note:** You can find your RTMP push URL and streamkey in the THEOlive management console.
+**Note:** You can find your RTMP push URL and streamkey in the management dashboard.
- Next, choose a set of stream values such as aspect ratio and bitrate from the _Quality_ list and click the cogwheel for advanced _Streaming Quality_ settings.
@@ -41,20 +42,20 @@ If you want to burn in a clock you can follow the steps documented by vMix. You
**Note:** If you have the hardware available: it's always a good idea to enable the _Hardware Ecoder_ setting.
-- In the _Streaming Quality_ menu you can make some more advanced changes to your stream settings. Please use the settings that are highlighted in yellow in the following image to achieve optimal performance when streaming to THEOlive. You are free to change the _Video Bit Rates_ and _Encode Size_ settings depending on your use case.
+- In the _Streaming Quality_ menu you can make some more advanced changes to your stream settings. Please use the settings that are highlighted in yellow in the following image to achieve optimal performance when streaming to OptiView Live. You are free to change the _Video Bit Rates_ and _Encode Size_ settings depending on your use case.
-**Note:\*** You are free to experiment with your encoding settings but the values shown in this image reflect the encoding setting THEOlive uses on the server side.
+**Note:\*** You are free to experiment with your encoding settings but the values shown in this image reflect the encoding setting used on the server side.
:::info π§ Frame rate and bandwidth
-Remember to set the frame rate to the same value as in your THEOlive channel ingest configuration and make sure that your encoder has a stable connection and enough upload bandwidth. See [Stream configuration](../stream-configuration.mdx) for more details.
+Remember to set the frame rate to the same value as in your channel ingest configuration and make sure that your encoder has a stable connection and enough upload bandwidth. See [Stream configuration](../../media-engine/abr.mdx) for more details.
:::
## 3. Start streaming
You can now save and exit out of all the _Streaming Settings_ menus and click the _Stream_ button to start streaming.
-## 4. Start your THEOlive channel
+## 4. Start your channel
-This can be done either through the [API](../../api/start-channel.api.mdx) or via the [management console](https://console.theo.live/).
+Your channel must be started in order to receive video ingest from vMix. You can choose to start up your channel before or after you start streaming via vMix.
diff --git a/theolive/contribution/software-encoders/wirecast.md b/theolive/contribution/software-encoders/wirecast.md
index 816d7c724243..32e2c0213ee1 100644
--- a/theolive/contribution/software-encoders/wirecast.md
+++ b/theolive/contribution/software-encoders/wirecast.md
@@ -1,11 +1,12 @@
---
-sidebar_position: 3
+sidebar_position: 4
sidebar_label: Wirecast
+description: Live video streaming production tool by Telestream.
---
-# Using Wirecast with THEOlive
+# Using Wirecast with OptiView Live
-This guide explains to you how to set up Wirecast correctly so it can be used to stream your content with THEOlive.
+This guide explains to you how to set up Wirecast correctly so it can be used to stream your content with OptiView Live.
## 1. Configure Output Settings
@@ -18,7 +19,7 @@ This guide explains to you how to set up Wirecast correctly so it can be used to
-- Go to the THEOlive management console, and copy the RTMP Push URL and Stream key of your channel.
+- Go to the management dashboard, and copy the RTMP Push URL and Stream key of your channel.
- Paste the RTMP Push URL into "Address".
:::warning βοΈ Not all versions/editions of Wirecast support RTMPS
@@ -36,14 +37,14 @@ Definitely check whether your Wirecast version/edition supports RTMPS. Older ver
- Define the appropriate encoder latency, taking into account your computer performance. "1 - (Ultra Fast encoding)" will give the lowest latency as it requires the least CPU time.
- Also select the encoding "Profile". For example, "Main" will give lower latencies than "High" but on the other hand "High" will provide for better quality than "Main".
-- Lastly, set "Frames per second" to the same value used in the THEOlive channel ingest config and set "Average bit rate" to match the max bitrate of the channel preset. See [Stream configuration](../stream-configuration.mdx) for more details.
+- Lastly, set "Frames per second" to the same value used in the channel ingest config and set "Average bit rate" to match the max bitrate of the channel preset. See [Stream configuration](../../media-engine/abr.mdx) for more details.
- Click "OK" and move to step 2 to add your live stream.
:::info π§ Upload bandwidth
-Make sure that your encoder has a stable connection and enough upload bandwidth. This will ensure all data is correctly sent to the THEOlive channel.
+Make sure that your encoder has a stable connection and enough upload bandwidth. This will ensure all data is correctly sent to the channel.
:::
## 2. Add a New Layer
@@ -62,10 +63,10 @@ Make sure that your encoder has a stable connection and enough upload bandwidth.
## 3. Start Streaming
-Click the "Stream" button. Wirecast will make a connection to the THEOlive RTMP server.
+Click the "Stream" button. Wirecast will make a connection to the OptiView Live RTMP server.
-## 4. Start your THEOlive channel
+## 4. Start your channel
-This can be done either through the [API](../../api/start-channel.api.mdx) or via the [management console](https://console.theo.live/).
+Your channel must be started in order to receive video ingest from Wirecast. You can choose to start up your channel before or after you start streaming via Wirecast.
diff --git a/theolive/contribution/stream-configuration.mdx b/theolive/contribution/stream-configuration.mdx
deleted file mode 100644
index 7db6f176ceaf..000000000000
--- a/theolive/contribution/stream-configuration.mdx
+++ /dev/null
@@ -1,113 +0,0 @@
----
-sidebar_position: 1
----
-
-# Stream Configuration
-
-Settings related to the THEOlive stream output
-
----
-
-THEOlive offers pre-defined ABR profiles (or "presets") which allows you to adjust the stream settings according to your use case. Different pricing per minute transcoded and viewed applies to each profile.
-
-**Note:** this is a breaking change compared to the method where you had to pass a `ingestConfig` object in the past. This old approach is still available for the time being. More information can be found later on in this [document](#setting-the-stream-configuration-via-the-ingestconfig-object-deprecated). You can pass both a `streamConfig` as well as a `ingestConfig` object (the API won't throw an error), but `streamConfig` will take precedence.
-
-## Setting the stream configuration via the `streamConfig` object
-
-The goal is to pass a `streamConfig` object during the [creation](../api/create-channel.api.mdx) of a channel, or when [updating](../api/update-channel.api.mdx) it. This object consists of:
-
-- `bitrate`: the max bitrate value that will be used in Mbps.
-- `resolution`: the max resolution that will be used. Possible values: `"1080p"`, `"720p"`, `"576p"`, `"480p"`.
-- `fps`: the max fps value that will be used. Can be `25`, `29.97`, `30`, `50`, `59.94`, `60`.
-- `abr`: a boolean to determine if ABR should be enabled or not.
-
-**Remarks:**
-
-- The `streamConfig`object is optional. When it's not passed, the following default values will be used:
- - `bitrate: 4.5`
- - `resolution: "1080p"`
- - `fps: 30`
-- When defining the `streamConfig` object, it's mandatory to pass _all_ properties (bitrate, resolution, fps). Otherwise, the API will return an error.
-
-In the table below you can find a complete overview of all possible values that can be passed and the ABR ladder in which it will result. Please refer to our [pricing page](https://www.theoplayer.com/pricing/theolive) for the latest pricings per profile.
-
-| Bitrate | Resolution | fps | ABR ladder |
-| :------- | :--------- | :------------ | :----------------------------------------------------------------------- |
-| 8 Mbps | 1080p | 50, 59.94, 60 | - 1080p @ 8 Mbps - 720p @ 4.5 Mbps - 576p @ 1.5 Mbps - 360p @ 0.9 Mbps |
-| 8 Mbps | 1080p | 25, 29.97, 30 | - 1080p @ 8 Mbps - 720p @ 4.5 Mbps - 576p @ 1.5 Mbps - 360p @ 0.9 Mbps |
-| 6 Mbps | 1080p | 50, 59.94, 60 | - 1080p @ 6 Mbps - 720p @ 3.5 Mbps - 576p @ 1.5 Mbps - 360p @ 0.9 Mbps |
-| 6 Mbps | 1080p | 25, 29.97, 30 | - 1080p @ 6 Mbps - 720p @ 3.5 Mbps - 576p @ 1.5 Mbps - 360p @ 0.9 Mbps |
-| 6 Mbps | 720p | 50, 59.94, 60 | - 720p @ 6 Mbps - 576p @ 4 Mbps - 360p @ 2 Mbps - 240p @ 0.9 Mbps |
-| 6 Mbps | 720p | 25, 29.97, 30 | - 720p @ 6 Mbps - 576p @ 4 Mbps - 360p @ 2 Mbps - 240p @ 0.9 Mbps |
-| 4.5 Mbps | 1080p | 50, 59.94, 60 | - 1080p @ 4.5 Mbps - 720p @ 3 Mbps - 576p @ 1.5 Mbps - 360p @ 0.9 Mbps |
-| 4.5 Mbps | 1080p | 25, 29.97, 30 | - 1080p @ 4.5 Mbps - 720p @ 3 Mbps - 576p @ 1.5 Mbps - 360p @ 0.9 Mbps |
-| 4.5 Mbps | 720p | 50, 59.94, 60 | - 720p @ 4.5 Mbps - 576p @ 2.5 Mbps - 360p @ 1.5 Mbps - 240p @ 0.9 Mbps |
-| 4.5 Mbps | 720p | 25, 29.97, 30 | - 720p @ 4.5 Mbps - 576p @ 2.5 Mbps - 360p @ 1.5 Mbps - 240p @ 0.9 Mbps |
-| 2.5 Mbps | 1080p | 25, 29.97, 30 | - 1080p @ 2.5 Mbps - 720p @ 2.2 Mbps - 576p @ 1.5 Mbps - 360p @ 0.9 Mbps |
-| 2.5 Mbps | 720p | 25, 29.97, 30 | - 720p @ 2.5 Mbps - 576p @ 1.5 Mbps - 360p @ 0.9 Mbps |
-| 2.5 Mbps | 576p | 25, 29.97, 30 | - 576p @ 2.5 Mbps - 360p @ 1.5 Mbps - 240p @ 0.9 Mbps |
-| 1.5 Mbps | 720p | 25, 29.97, 30 | - 720p @ 1.5 Mbps - 576p @ 1 Mbps - 360p @ 0.9 Mbps |
-| 1.5 Mbps | 576p | 25, 29.97, 30 | - 576p @ 1.5 Mbps - 360p @ 1 Mbps - 240p @ 0.9 Mbps |
-| 1.5 Mbps | 360p | 25, 29.97, 30 | - 360p @ 1.5 Mbps - 240p @ 0.9 Mbps |
-| 1 Mbps | 576p | 25, 29.97, 30 | - 576p @ 1 Mbps - 360p @ 0.9 Mbps - 240p @ 0.8 Mbps |
-| 1 Mbps | 360p | 25, 29.97, 30 | - 360p @ 1 Mbps - 240p @ 0.8 Mbps |
-
-:::info π§ Encoder settings
-
-**Frame rate**
-To obtain the best performance, set the same frame rate on both your encoder and in the channel configuration (the suggested values for this are 25, 29.97 or 30 fps). Frame rate differences between encoder and channel may lead to information loss and stalls.
-
-**Bandwidth**
-Make sure your encoder has a stable connection with enough upload bandwidth to correctly serve all frames. Dropped frames or connection interruptions may lead to increased latency, stalls and playback failures.
-:::
-
-## Setting the stream configuration via the `ingestConfig` object (deprecated)
-
-Before the `streamConfig` object was available in our API, you had to configure the settings using the `ingestConfig` object. This approach is still available to provide backwards compatibility for existing integrations, but it's not recommended to use anymore: it will be deprecated in the near future.
-
-We highly recommend to update your integration to make use of the new `streamConfig` object.
-
-For those still using the `ingestConfig` object: this object accepts a few properties.
-
-- `preset`: can be `"default"`, `"sport"`or `"presentation"`. Defaults to `"default"` when not passed. The connected ABR ladders can be found below
-- `abr`: boolean.
-- `aspectRatio`: used for setting the max resolution, but poorly named in the past. Depending on the resolution you choose, your ABR ladder will exist out of four steps (in case of `"1080p"`), three steps (in case of `"720p"`), two steps (in case of `"480p"`), or one step (in case of `"360p"`).
-- `fps`: a number that can be 25, 29.97, 30, 50, 50.94, 60.
-
-### Default preset values
-
-The default configuration that will work for most use cases.
-
-| Quality | Bit rate |
-| :--------- | :-------- |
-| HD - 1080p | 4000 kbps |
-| HQ - 720p | 2500 kbps |
-| MQ - 480p | 1200 kbps |
-| LQ - 360p | 900 kbps |
-
-### Sport preset values
-
-The ideal configuration for streams with fast-moving images and a lot of scene changes that have a high bit rate. An example can be a broadcasted football game.
-
-| Quality | Bit rate |
-| :--------- | :-------- |
-| HD - 1080p | 4500 kbps |
-| HQ - 720p | 2700 kbps |
-| MQ - 480p | 1400 kbps |
-| LQ - 360p | 1000 kbps |
-
-### Presentation preset values
-
-The configuration that can be used when not a lot of scene changes are expected, think about a meeting with a few slides.
-
-| Quality | Bit rate |
-| :--------- | :-------- |
-| HD - 1080p | 2200 kbps |
-| HQ - 720p | 900 kbps |
-| MQ - 480p | 800 kbps |
-| LQ - 360p | 450 kbps |
-
-:::info π Ingest configuration
-
-When configuring your RTMP ingest, it is important to match the highest bitrate of your bitrate ladder. When using the recommended preset at 1080p for example, the RTMP ingest should be configured at 4000 kbps.
-:::
diff --git a/theolive/distribution/distribution-override.mdx b/theolive/distribution/distribution-override.mdx
new file mode 100644
index 000000000000..6d45f0fc1fc6
--- /dev/null
+++ b/theolive/distribution/distribution-override.mdx
@@ -0,0 +1,176 @@
+---
+sidebar_position: 6
+sidebar_label: Distribution override
+sidebar_custom_props:
+ icon: π
+description: Redirect viewers to a different distribution based on their platform.
+---
+
+# Distribution override
+
+Distribution overrides are an advanced but powerful feature that allow you to redirect viewers to a different distribution based on their platform. When a viewer connects, the platform evaluates the override rules on the distribution and, if a match is found, transparently serves them the target distribution instead. This lets you use a single distribution URL while delivering platform-specific settings β such as a different [max bitrate](./max-bitrate.mdx), different output protocols, or different [security](../security) rules β without any changes on the viewer side.
+
+## How it works
+
+Each distribution can have an `overrides` array. Every entry in the array is a **rule** that consists of:
+
+1. **Matching criteria** β zero or more conditions that identify which viewers the rule applies to. A field set to `null` (or omitted) matches any value.
+2. **Targets** β one or more target distributions that matching viewers are redirected to, each with a `weight` for traffic splitting.
+
+When a viewer requests a distribution, the platform checks the override rules in order. The first rule where **all** specified criteria match the viewer's platform is applied, and the viewer is served one of the target distributions according to the configured weights.
+
+### Matching criteria
+
+| Field | Type | Values | Description |
+| ------------ | -------------- | ---------------------------------------------- | --------------------------------------------------------------- |
+| `deviceType` | string \| null | `tv`, `mobile`, `desktop`, `other` | The type of device the viewer is using. |
+| `sdkType` | string \| null | `native`, `web` | Whether the viewer is using a native SDK or a web-based player. |
+| `osName` | string \| null | `apple`, `android`, `windows`, `roku`, `other` | The operating system of the viewer's device. |
+| `profileId` | string \| null | any string | A custom profile identifier for advanced targeting. |
+
+Setting a criterion to `null` (or leaving it out) means it matches **all** values for that field.
+
+### Targets
+
+Each rule contains a `targets` array. Every target specifies:
+
+- **`distributionId`** β the ID of the distribution to redirect to.
+- **`weight`** β a value between 0 and 100 that determines how traffic is split when multiple targets are present. For a single target, set the weight to `100`.
+
+The target distributions can be connected to the same engine as the original distribution, or to a completely different engine β giving you full control over protocol, bitrate, and transcoding settings per platform.
+
+## Example: platform-specific delivery
+
+Suppose you are streaming a live event and want to optimize delivery per platform:
+
+- **Mobile viewers** should receive a capped bitrate to save bandwidth.
+- **TV viewers** (e.g. smart TVs, set-top boxes) should receive HLS MPEG-TS because their player does not support CMAF.
+- **All other viewers** should receive the default high-quality HESP stream.
+
+You would set up the following:
+
+1. Create the **main distribution** (Distribution A) connected to your engine, configured with HESP output and a high max bitrate. This is the distribution URL you share publicly.
+2. Create a **mobile distribution** (Distribution B) on the same engine with a lower [max bitrate](./max-bitrate.mdx) (e.g. 3 Mbps).
+3. Create a **TV distribution** (Distribution C) on an engine that has HLS MPEG-TS output enabled.
+4. Add override rules to Distribution A:
+
+| Rule | `deviceType` | `sdkType` | `osName` | Target |
+| ---- | ------------ | --------- | -------- | -------------- |
+| 1 | `mobile` | β | β | Distribution B |
+| 2 | `tv` | β | β | Distribution C |
+
+Viewers connecting to Distribution A on a mobile device are transparently redirected to Distribution B. TV viewers are redirected to Distribution C. Everyone else stays on Distribution A.
+
+Using the API, you can configure this by setting the `overrides` field when [creating](../api/create-channel-distribution.api.mdx) or [updating](../api/update-distribution.api.mdx) a distribution:
+
+```json
+{
+ "name": "main-distribution",
+ "overrides": [
+ {
+ "deviceType": "mobile",
+ "targets": [
+ {
+ "distributionId": "",
+ "weight": 100
+ }
+ ]
+ },
+ {
+ "deviceType": "tv",
+ "targets": [
+ {
+ "distributionId": "",
+ "weight": 100
+ }
+ ]
+ }
+ ]
+}
+```
+
+## Example: A/B testing
+
+By using weighted targets, you can split traffic across multiple distributions to compare different configurations. For example, suppose you want to test whether a lower target latency improves the viewing experience for desktop users:
+
+1. Create **Distribution A** with the current target latency (e.g. 3 seconds).
+2. Create **Distribution B** with a lower target latency (e.g. 1.5 seconds).
+3. Add an override rule to your main distribution that sends 80% of desktop viewers to Distribution A and 20% to Distribution B:
+
+| Rule | `deviceType` | `sdkType` | `osName` | Targets |
+| ---- | ------------ | --------- | -------- | -------------------------------------- |
+| 1 | `desktop` | β | β | 80% Distribution A, 20% Distribution B |
+
+You can then monitor the results and gradually shift the weights as confidence grows β for example moving to a 50/50 split or rolling out the new configuration to 100% of viewers.
+
+Using the API, this would look like:
+
+```json
+{
+ "overrides": [
+ {
+ "deviceType": "desktop",
+ "targets": [
+ {
+ "distributionId": "",
+ "weight": 80
+ },
+ {
+ "distributionId": "",
+ "weight": 20
+ }
+ ]
+ }
+ ]
+}
+```
+
+## Example: live platform switching for incident response
+
+Because overrides can be updated while a channel is live, they can be used as an operational tool to react to issues in real time. If a specific platform experiences playback problems β for example, HESP not working correctly on a certain smart TV firmware β you can instantly redirect those viewers to a different distribution without interrupting the stream for everyone else.
+
+Suppose your main distribution serves HESP to all viewers, and you start receiving reports that Roku devices are failing to play. You can:
+
+1. Prepare a **fallback distribution** connected to the same engine with HLS output enabled.
+2. Add an override rule to redirect Roku viewers to the fallback distribution while the issue is being investigated:
+
+| Rule | `deviceType` | `sdkType` | `osName` | Target |
+| ---- | ------------ | --------- | -------- | --------------------- |
+| 1 | β | β | `roku` | Fallback distribution |
+
+Using the API, you can apply this fix with a single `PATCH` call:
+
+`PATCH https://api.theo.live/v2/distributions/{distributionId}`
+
+```json
+{
+ "overrides": [
+ {
+ "osName": "roku",
+ "targets": [
+ {
+ "distributionId": "",
+ "weight": 100
+ }
+ ]
+ }
+ ]
+}
+```
+
+Once the issue is resolved, remove the override to restore normal routing:
+
+```json
+{
+ "overrides": []
+}
+```
+
+This approach lets you keep fallback distributions ready ahead of time and activate them on demand, avoiding downtime for affected viewers.
+
+## Notes
+
+- Override rules are evaluated in order β the first matching rule wins.
+- Criteria fields that are `null` or omitted act as wildcards and match any viewer.
+- Overrides can be updated while a channel is live β no restart is needed.
+- Target distributions can be on any engine within the same channel, allowing completely different transcoding and delivery configurations per platform.
diff --git a/theolive/distribution/max-bitrate.mdx b/theolive/distribution/max-bitrate.mdx
new file mode 100644
index 000000000000..d73772992099
--- /dev/null
+++ b/theolive/distribution/max-bitrate.mdx
@@ -0,0 +1,26 @@
+---
+sidebar_position: 4
+sidebar_label: Max bitrate
+sidebar_custom_props:
+ icon: π
+description: Limit the output qualities on a distribution by setting a maximum bitrate.
+---
+
+# Max bitrate
+
+A distribution can be configured with a maximum bitrate. When set, the platform filters the output of the connected engines so that only qualities with a bitrate at or below the configured limit are delivered to viewers.
+
+This is useful when you want to control bandwidth usage per distribution without changing the ABR ladder on the engine itself. For example, you may have a high-quality engine producing multiple rungs up to 8 Mbps, but a specific distribution intended for mobile viewers where you want to cap delivery at 3 Mbps.
+
+## API example
+
+You can also set the max bitrate via the API using the `maxBitrate` field (in bps) when [creating](../api/create-channel-distribution.api.mdx) or [updating](../api/update-distribution.api.mdx) a distribution.
+
+`POST https://api.theo.live/v2/channels/{channelId}/distributions`
+
+```json
+{
+ "name": "my-distribution",
+ "maxBitrate": 3000000
+}
+```
diff --git a/theolive/distribution/multi-distribution.mdx b/theolive/distribution/multi-distribution.mdx
new file mode 100644
index 000000000000..803fbcb6856d
--- /dev/null
+++ b/theolive/distribution/multi-distribution.mdx
@@ -0,0 +1,40 @@
+---
+sidebar_position: 1
+sidebar_label: Multi-distribution
+sidebar_custom_props:
+ icon: π€
+description: Serve a single stream through multiple distributions with independent settings.
+---
+
+# Multi-distribution
+
+A single engine can serve multiple distributions, each with its own configuration. Rather than duplicating the entire pipeline, you can create separate distributions on one engine to serve different audiences, regions, or partners independently.
+
+## How it works
+
+A channel only needs one ingest and one engine to transcode and package the stream once. From that engine, you can create multiple distributions. Each distribution acts as an independent output endpoint with its own configuration, including geo-blocking rules, security policies, and player settings.
+
+This means the stream is transcoded and packaged **once**, but delivered **many times** under different conditions β keeping costs and complexity low.
+
+## Example: regional rights management
+
+Suppose you are streaming a live event and have sold the rights to three resellers:
+
+- **Reseller A** has the rights for Europe
+- **Reseller B** has the rights for North America
+- **Reseller C** has the rights for Asia-Pacific
+
+You would set up your channel as follows:
+
+1. Create a single **ingest** and **engine** for transcoding.
+2. Create three **distributions** on that engine β one per reseller.
+3. Apply [geo-blocking](./security/geo-blocking.md) rules to each distribution so that only viewers in the licensed region can access the stream.
+4. Optionally, apply [token-based security](./security/token-based-security.mdx) per distribution so each reseller authenticates their own viewers.
+
+Each reseller receives their own channel alias and can only serve the stream to viewers within their licensed territory. From an operational perspective, you manage a single pipeline while maintaining full control over regional access.
+
+## Benefits
+
+- **Cost-efficient** β transcoding and packaging happens once, regardless of the number of resellers.
+- **Independent configuration** β each distribution has its own security, geo-blocking, and delivery settings.
+- **Scalable** β adding a new reseller is as simple as creating a new distribution with the appropriate rules.
diff --git a/theolive/distribution/redundancy.md b/theolive/distribution/redundancy.md
new file mode 100644
index 000000000000..17e839e39228
--- /dev/null
+++ b/theolive/distribution/redundancy.md
@@ -0,0 +1,54 @@
+---
+sidebar_position: 3
+sidebar_label: Redundancy
+sidebar_custom_props:
+ icon: π
+description: Configure failover and redundancy for high-availability streaming.
+---
+
+# Redundancy
+
+Redundancy ensures that viewers can continue watching even if part of the streaming pipeline fails. By connecting multiple engines to a single distribution, the platform can automatically fail over to a healthy engine when one becomes unavailable.
+
+## How it works
+
+A distribution can have multiple engines attached to it. Each engine processes the stream independently from its own ingest. When the player connects to a distribution, it receives the stream from the active engine. If that engine goes down, the player automatically fails over to the next available engine β without the viewer having to take any action.
+
+This approach protects the entire path from ingest to delivery:
+
+- **Ingest failure** β if an ingest source drops, only the engine connected to it is affected. The other engine, fed by a separate ingest, continues to serve the stream.
+- **Engine failure** β if an engine fails during transcoding or packaging, the player switches to the other engine on the same distribution.
+
+## Setting up redundancy
+
+To set up a redundant channel:
+
+1. Create **two ingests** on your channel, each receiving the same live source from a separate encoder or location.
+2. Create **two engines**, each connected to one of the ingests.
+3. Create a **distribution** and attach both engines to it.
+
+The engine **priority** determines which engine is active. A lower priority number means higher precedence. The platform serves the stream from the highest-priority engine that is available, and automatically falls back to the next one when needed.
+
+## What the viewer experiences
+
+When a failover occurs, the player detects that the current engine is no longer available and switches to the other engine on the distribution. Viewers may see a brief interruption but do not need to reload or take any action.
+
+### Example: geo-redundant setup with priorities
+
+Consider a sports broadcaster streaming a live match from a stadium in London. To protect against failures, they set up the following:
+
+| Component | Location | Details |
+| ---------------- | --------- | ------------------------------------- |
+| **Ingest A** | London | SRT feed from the on-site encoder |
+| **Ingest B** | Frankfurt | SRT feed from a backup encoder |
+| **Engine A** | London | Connected to Ingest A, priority **1** |
+| **Engine B** | Frankfurt | Connected to Ingest B, priority **2** |
+| **Distribution** | β | Both engines attached |
+
+**Normal operation:** Engine A (priority 1) is active. All viewers receive the stream processed in London.
+
+**Engine A fails** (e.g. a network issue at the London data center): The platform detects the failure and the player automatically switches to Engine B in Frankfurt. Viewers experience a brief interruption but playback resumes without any manual action.
+
+**Engine A recovers:** Once Engine A is healthy again, new viewer sessions will connect to Engine A because it has the higher precedence (lower priority number). Existing sessions remain on Engine B and will only switch back to Engine A if Engine B also experiences issues.
+
+This setup provides both **geographic redundancy** β the two engines run in separate locations, protecting against regional outages β and **priority-based failover** β the platform always prefers the highest-precedence engine that is available.
diff --git a/theolive/distribution/security/_category_.json b/theolive/distribution/security/_category_.json
new file mode 100644
index 000000000000..b4e83cd57174
--- /dev/null
+++ b/theolive/distribution/security/_category_.json
@@ -0,0 +1,11 @@
+{
+ "label": "Security",
+ "customProps": {
+ "icon": "π"
+ },
+ "description": "Geo-blocking, IP-blocking and token-based security for your distributions.",
+ "link": {
+ "type": "generated-index",
+ "slug": "distribution/security"
+ }
+}
diff --git a/theolive/distribution/security/geo-blocking.md b/theolive/distribution/security/geo-blocking.md
new file mode 100644
index 000000000000..e1e76bfc9eaf
--- /dev/null
+++ b/theolive/distribution/security/geo-blocking.md
@@ -0,0 +1,61 @@
+---
+sidebar_label: Geo-blocking
+sidebar_custom_props:
+ icon: π
+description: Restrict or allow access to your streams based on viewer location.
+---
+
+# Geo-blocking
+
+Geo-blocking restricts or allows access to your stream based on the geographical location of the viewer. This is commonly used to comply with licensing agreements, enforce regional distribution rights, or protect content from unauthorized access.
+
+## Configuration
+
+To configure geo-blocking, navigate to your distribution's security settings and enable geo-blocking. You can then choose between two modes:
+
+- **Allow list** β only viewers in the listed countries can access the stream. All other countries are blocked.
+- **Deny list** β viewers in the listed countries are blocked. All other countries can access the stream.
+
+Add countries to the list to define which regions are affected.
+
+
+
+
+
+
+
+## Example: regional distribution
+
+Suppose you are distributing a live event with the following regional rights:
+
+- Customer 1 can only show the stream to Belgian viewers
+- Customer 2 can only show the stream to UK and USA viewers
+- Customer 3 can only show the stream to French viewers
+
+Create a separate distribution for each customer and configure geo-blocking with an allow list containing only the permitted countries.
+
+
+
+## API example
+
+You can also configure geo-blocking via the API using the `security.geoBlocking` object when [creating](../../api/create-channel-distribution.api.mdx) or [updating](../../api/update-distribution.api.mdx) a distribution.
+
+`POST https://api.theo.live/v2/channels/{channelId}/distributions`
+
+```json
+{
+ "name": "my-distribution",
+ "security": {
+ "geoBlocking": {
+ "enabled": true,
+ "mode": "allow",
+ "countries": ["BE", "NL"]
+ }
+ }
+}
+```
+
+## Notes
+
+- Geo-blocking can be enabled or disabled while a stream is live β no restart is needed.
+- Geo-blocking is applied per distribution, so different distributions on the same engine can have different rules.
diff --git a/theolive/distribution/security/ip-blocking.md b/theolive/distribution/security/ip-blocking.md
new file mode 100644
index 000000000000..7dcfeec9a178
--- /dev/null
+++ b/theolive/distribution/security/ip-blocking.md
@@ -0,0 +1,50 @@
+---
+sidebar_label: IP-blocking
+sidebar_custom_props:
+ icon: π«
+description: Block or allow access based on IP addresses.
+---
+
+# IP-blocking
+
+IP-blocking restricts access to your stream based on specific IP addresses. This can be used to lock down access to known networks or block unwanted traffic. Only IPv4 and IPv6 CIDRs (Classless Inter-Domain Routing) are supported.
+
+## Configuration
+
+To configure IP-blocking, navigate to your distribution's security settings and enable IP-blocking. You can then choose between two modes:
+
+- **Allow list** β only the listed CIDRs can access the stream. All other IP addresses are blocked.
+- **Deny list** β the listed CIDRs are blocked. All other IP addresses can access the stream.
+
+Add CIDRs to the list to define which IP addresses are affected.
+
+
+
+
+
+
+
+## API example
+
+You can also configure IP-blocking via the API using the `security.ipBlocking` object when [creating](../../api/create-channel-distribution.api.mdx) or [updating](../../api/update-distribution.api.mdx) a distribution.
+
+`POST https://api.theo.live/v2/channels/{channelId}/distributions`
+
+```json
+{
+ "name": "my-distribution",
+ "security": {
+ "ipBlocking": {
+ "enabled": true,
+ "mode": "allow",
+ "cidrs": ["203.0.113.0/24", "198.51.100.0/24"]
+ }
+ }
+}
+```
+
+## Notes
+
+- IP-blocking can be enabled or disabled while a stream is live β no restart is needed.
+- IP-blocking is applied per distribution, so different distributions on the same engine can have different rules.
+- If [geo-blocking](./geo-blocking.md) is enabled for a country, IP-blocking rules for CIDRs originating from that country will not take effect.
diff --git a/theolive/distribution/security/referrer-blocking.mdx b/theolive/distribution/security/referrer-blocking.mdx
new file mode 100644
index 000000000000..ce221d30d6d2
--- /dev/null
+++ b/theolive/distribution/security/referrer-blocking.mdx
@@ -0,0 +1,41 @@
+---
+sidebar_label: Referrer blocking
+sidebar_custom_props:
+ icon: π
+description: Restrict access based on the referring website or domain.
+---
+
+# Referrer blocking
+
+Referrer blocking restricts access to your stream based on the HTTP `Referer` header sent by the viewer's browser. This allows you to control which websites are allowed to embed and play your content.
+
+When enabled, the platform checks the `Referer` header of each playback request against a list of allowed or blocked domains. Requests originating from unauthorized websites are rejected, preventing third parties from embedding your stream on their pages without permission.
+
+## Use cases
+
+- **Embed protection** β ensure your stream can only be played on your own website or approved partner sites.
+- **Content piracy prevention** β block unauthorized websites from hotlinking your stream.
+- **Partner control** β allow specific resellers or affiliates to embed the stream while blocking everyone else.
+
+Referrer blocking can be configured via the API or the dashboard on a per-distribution basis.
+
+
+
+## API example
+
+You can also configure referrer blocking via the API using the `security.refererBlocking` object when [creating](../../api/create-channel-distribution.api.mdx) or [updating](../../api/update-distribution.api.mdx) a distribution.
+
+`POST https://api.theo.live/v2/channels/{channelId}/distributions`
+
+```json
+{
+ "name": "my-distribution",
+ "security": {
+ "refererBlocking": {
+ "enabled": true,
+ "allowedDomains": ["example.com", "partner.com"],
+ "allowNativeApps": true
+ }
+ }
+}
+```
diff --git a/theolive/distribution/security/token-based-security.mdx b/theolive/distribution/security/token-based-security.mdx
new file mode 100644
index 000000000000..b533ec63f329
--- /dev/null
+++ b/theolive/distribution/security/token-based-security.mdx
@@ -0,0 +1,40 @@
+---
+sidebar_label: Token-based security
+sidebar_custom_props:
+ icon: π
+description: Require JWT tokens for viewer authentication.
+---
+
+# Token-based security
+
+Token-based security restricts access to your stream by requiring a valid JWT (JSON Web Token) on every playback request. This ensures that only authenticated viewers β those who have received a token from your backend β can access the stream.
+
+## How it works
+
+When token security is enabled on a distribution, the CDN validates an `Authorization` header containing a Bearer token on each request. The token is signed with a shared secret (HS256/HS512) or a public/private key pair (RS256/RS512) that you provide when enabling the feature.
+
+The token payload must include:
+
+- **`exp`** β expiration time in epoch format. The token is rejected after this time.
+- **`nbf`** _(optional)_ β "not before" time in epoch format. The token is rejected before this time.
+
+Requests without a valid token are rejected. If the distribution does not have token security enabled, the `Authorization` header is ignored.
+
+## Configuration
+
+To enable token-based security, navigate to your distribution's security settings and enable the token security toggle. Provide the shared secret or public key used to verify tokens.
+
+
+
+
+
+
+
+## Player configuration
+
+The player needs to be configured to pass the `Authorization` header with each request. Refer to the platform-specific guides:
+
+- [Web](/theoplayer/how-to-guides/web/theolive/token-based-security/)
+- [Android](/theoplayer/how-to-guides/android/theolive/token-based-security/)
+- [React Native](/theoplayer/how-to-guides/react-native/theolive/token-based-security/)
+- [Roku](/theoplayer/how-to-guides/roku/theolive/token-based-security/)
diff --git a/theolive/distribution/thumbnails-manifests.mdx b/theolive/distribution/thumbnails-manifests.mdx
new file mode 100644
index 000000000000..64e6fb391a88
--- /dev/null
+++ b/theolive/distribution/thumbnails-manifests.mdx
@@ -0,0 +1,19 @@
+---
+sidebar_position: 5
+sidebar_label: Thumbnails
+sidebar_custom_props:
+ icon: πΌοΈ
+description: Access live thumbnail images for your streams.
+---
+
+# Thumbnails
+
+A live thumbnail image is available for each distribution. This can be used for poster frames, stream previews, or channel listings outside of the player.
+
+The thumbnail is accessible at a deterministic URL:
+
+```text
+https://discovery.theo.live/v2/distributions//thumbnails/thumbnail.jpeg
+```
+
+Replace `` with your distribution identifier.
diff --git a/theolive/getting-started.mdx b/theolive/getting-started.mdx
index 8fdd166a50a7..d6b577099926 100644
--- a/theolive/getting-started.mdx
+++ b/theolive/getting-started.mdx
@@ -1,117 +1,117 @@
---
sidebar_position: 2
sidebar_label: Getting started
+sidebar_custom_props:
+ icon: π
+description: Create your first stream, from setup to embedding the player.
---
-# Backend
+# Getting started
-THEOlive provides a REST API to manage channels, configure them and start / stop them. Each possible call can be found at our [API Reference](./api/create-channel.api.mdx).
+This guide walks you through creating your first stream, from setting up an account to embedding the player on your page.
-However, to make things easier for non-developers, we built a management console on top of these API calls which makes it straightforward to perform the basic actions. To be able to create and use a THEOlive channel, you should register for an account and get a token to perform [authenticated requests](./platform/authorization.mdx) to our API.
+Optiview live streaming provides a REST API to manage channels, configure them and start / stop them. Each possible call can be found in the [API Reference](./api/create-channel.api.mdx). On top there also is a [management dashboard](https://dashboard.optiview.dolby.com/) on top of these API calls, making it straightforward to perform the basic actions without writing code.
-## 1. Create an account in the management console
+### Prerequisites
-To start your journey, you'll have to create a THEOlive account in the [management console](https://console.theo.live/) .
+- An OptiView account
+- An RTMP/SRT-capable encoder β see our [software encoder](./contribution/software-encoders/index.mdx) and [hardware encoder](./contribution/hardware-encoders/index.mdx) guides
+- A web page or app to embed the player
-Once you've entered your username and password, you can already create your first channel and start streaming.
+## 1. Create your first channel
-
+Time to start streaming! In the dashboard, click "create channel" and fill in a name. You will end up on the overview page for your channel, where you can configure the different components.
-:::info π API reference
+There are other options during channel creation that are more advanced and are explained in their respective guides, you can ignore them for now:
-This guide describes how to get started with the THEOlive management console. Please consult the [API reference](./api/create-channel.api.mdx) and [Authorization](./platform/authorization.mdx) if you would like to work with API calls.
-:::
+- [DVR](./channel/dvr.mdx)
+- [Nielsen](./channel/nielsen.mdx)
-## 2. Create your first channel
+
-Time to start streaming! In the management console, please click "create channel", which will return the following screen: here you can enter a name for your channel, choose the ingest location, and define your [Stream configuration](./contribution/stream-configuration.mdx). It is important to choose a location as close as possible to you to reduce latency.
+## 2. Configure your channel
-
+This section focuses on getting a simple example up and running. For a full breakdown of the platform architecture, see the [Architecture](./architecture.mdx) page.
-When hitting 'Create', you will be navigated towards the Details page of your newly created channel.
+A channel consists of three main components that need to be configured:
-
+- **Ingest** β where the media is retrieved from. This is the entry point for your content and multiple protocols are supported like RTMP and SRT.
+- **Engine** β processes the incoming media, handling transcoding and packaging.
+- **Distributions** β different output versions of an engine. Each distribution lets you enable or disable protocols, choose CDNs, and more.
-A channel can also be created through an API call to the `channels` endpoint, passing an ingest location and a name. It will return an `id` that you can use to start, stop, update or delete the channel later on. Also, a `streamKey` and `rtmpPushUrl` will be returned to stream your content to. More information about the Create channel endpoint and how to pass advanced properties can be found [here](./api/create-channel.api.mdx).
+
-```curl
-curl --location --request POST 'https://api.theo.live/channels'
---header 'Authorization: Basic dG9rZW46c2VjcmV0' \
---header 'Content-Type: application/json' \
---data-raw '{
- "ingestLocation": "europe-west",
- "metadata": {
- "name": "a-name"
- }
-}'
-```
+
-Note that for this API call you'll need a token that you can generate in the management console. More information can be found at the [Authorization](./platform/authorization.mdx) guide.
+Example diagram of a channel setup with redundant ingests
-## 3. Start streaming
+
-Using the RTMP push URL and the stream key you have received when creating a channel, you can start streaming content to that RTMP endpoint.
+### 2.1 Ingest
-:::info π§ RTMP pull
+Create a new ingest, give it a name, and select the protocol you want to use (RTMP or SRT) and which mode (pull or push).
-If you would like to do pull-based streaming instead of push-based streaming, you can also use your own RTMP pull endpoint and specify this when starting the channel in the next step.
+:::tip
+You only need a single ingest to start streaming but are free to create multiple ones for redundancy purposes for example.
:::
-One option to start streaming content is making use of [OBS](https://obsproject.com/). It's an easy, free and quick way to get you started. More information on how to get started with OBS can be found in our guide [Using OBS with THEOlive](./contribution/software-encoders/obs.md). If you would be using [Wirecast](https://www.telestream.net/wirecast) for your live streaming, then more information on how to get started can be found in the guide [Using Wirecast with THEOlive](./contribution/software-encoders/wirecast.md). There are also guides for [vMix](./contribution/software-encoders/vmix.md) and [Videon Edgecaster](./contribution/hardware-encoders/videon.mdx).
+
-:::info βοΈ RTMPS vs RTMP
+### 2.2 Engine
-The RTMP push URL generated by THEOlive shows as RTMPS. If you would like to do RTMP streaming then you will have to change "rtmps" to "rtmp". As an example, `rtmps://rtmp.europe-west.theo.live/live` will have to be changed to `rtmp://rtmp.europe-west.theo.live/live` for RTMP-based streaming.
-:::
+The engine is responsible for transcoding and packaging the incoming media. Create a new engine and configure the following properties:
+
+
+
+
+
-## 4. Player embed script
+
+
-Now we have to make sure that our viewers have access to the stream! Including a THEOlive channel on your page is very simple: all you need is our embed script and the channel ID. The [Player](./playback/web/getting-started.mdx) guide gives more information on how to do this, including a code snippet example.
+- **Name** β a descriptive name for your engine.
+- **Priority** β determines which engine takes precedence when multiple engines are configured. A lower number means higher priority.
+- **Ingest** β select which ingest this engine should use as its source.
+- **Region** β the region where the transcoding takes place. Choose one close to your ingest location.
+- **ABR Ladder** β the adaptive bitrate ladder used for transcoding, defining the resolution and bitrate combinations.
+- **Enable DRM** β secure your content with Digital Rights Management.
+- **Enable HESP** β output content in HESP format for low latency delivery.
+- **Enable HLS** β output content in HLS format for broad platform compatibility.
+- **Enable HLS MPEG-TS** β output content in HLS MPEG-TS format. Only recommended for very specific platforms that don't support HLS with CMAF segments.
+- **DAI Asset Key** β asset key for Dynamic Ad Insertion.
-### Obtaining a Player License for THEOlive
+
+
-THEOlive customers have access to THEOplayer Licenses with support for the following platforms:
+### 2.3 Distributions
-- `html5`
-- `android`
-- `androidtv`
-- `firetv`
-- `ios`
-- `tizen`
-- `tvos`
-- `webos`
+A distribution represents an output version of an engine. Create a new distribution, give it a name and a connected engine. The default properties are fine to get started, but a lot of properties can be configured:
-These licenses can be found in the "Playout Configurations" section for each of your created Channels on your [THEOlive dashboard](https://console.theo.live/login) as pictured below:
+
-
+- **Endpoints** β the connected engines that feed into this distribution.
+- **Outputs** β enable or disable streaming protocols (HESP, HLS, HLS MPEG-TS).
+- **Player** β configure player settings such as target latency and max bitrate.
+- **WebRTC** β optional WebRTC configuration for real-time delivery.
+- **Overrides** β add custom overrides for specific settings.
+- **Security** β configure access restrictions including geo blocking, IP blocking, referrer blocking and JWT security.
-Licenses will be automatically generated for each new channel you create. Aliases on the same channel will share the same license.
+## 3. Start the channel
-## 5. Start the channel
+When you're all set, you can start your channel from the channel details page by clicking the `Start all` button. This will start all engines at once. Starting your channel means your transcoding time will start counting for billing purposes.
-When you're all set, you can start your THEOlive channel. Starting your channel also means your [transcoding time](https://www.theoplayer.com/pricing/theolive) will start counting for billing purposes.
+For advanced use cases such as production updates, you can start and stop individual engines separately. However, for most use cases all engines will be started and stopped at the same time.
-You can easily start your channel on the channel details page, by clicking on the green "start" button.
+
-
+## 4. Verify playback
-In the background this will make a `POST` request to the `channels/start` endpoint. You can also start a channel via the Start channel API call, for which you can find more information [here](./api/start-channel.api.mdx). As mentioned in the last section, you can optionally pass the `rtmpPullUrl` property in the body of the request for pull-based streaming. Don't forget to stop streaming when you are done!
+Now we have to make sure that our viewers have access to the stream. In the dashboard you can already see the preview of the stream.
-```curl
-curl --location --request POST 'https://api.theo.live/channels/{channel-id}/start' \
---header 'Authorization: Basic dG9rZW46c2VjcmV0' \
---header 'Content-Type: application/json' \
---data-raw '{
- "rtmpPullUrl": "your-optional-rtmp-pull-url"
-}'
-```
+
-## 6. Stop the channel
+For production use cases, you should connect [THEOplayer](/theoplayer/how-to-guides/web/theolive/getting-started/).
-Have you finished your real-time streaming? Make sure to stop your channel by making a request to the `channels/stop` endpoint, either through a [Stop channel](./api/stop-channel.api.mdx) API call or by pressing the red "stop" button in the management console.
+## 5. Stop the channel
-```curl
-curl --location --request POST 'https://api.theo.live/channels/{channel-id}/stop' \
---header 'Authorization: Basic dG9rZW46c2VjcmV0' \
---header 'Content-Type: application/json'
-```
+When you are done streaming, make sure to stop your channel to avoid unnecessary transcoding costs.
diff --git a/theolive/index.mdx b/theolive/index.mdx
index b75af0c319a9..9b5ae138bf94 100644
--- a/theolive/index.mdx
+++ b/theolive/index.mdx
@@ -3,13 +3,16 @@ sidebar_label: Introduction
sidebar_position: 1
---
-# THEOlive
+# OptiView live streaming
import SidebarDocCardList from '@site/src/components/SidebarDocCardList';
-THEOlive is a low latency streaming solution across various platforms and devices. It
-delivers sub-second latency while maintaining exceptional playback quality and viewer experience. This all makes it perfect
-for all kinds of use cases including but not limited to: live sports, sports betting and interactivity.
+OptiView live is a streaming solution perfect for use cases such as live sports, sports betting and interactivity, with support for all kinds of platforms and devices.
+
+The supported streaming protocols are:
+
+- **HESP**: Ideal for the 1β5 second latency range, delivering low latency at scale for sports betting and interactive experiences.
+- **HLS**: An industry standard targeting 8 seconds and up, with broad platform support, ensuring compatibility across a wide range of devices and players.
On these pages, you'll learn how to get started with the THEOlive backend and player, how to use the various features,
and explore examples.
diff --git a/theolive/manage-team.mdx b/theolive/manage-team.mdx
new file mode 100644
index 000000000000..22c8f66c2cdf
--- /dev/null
+++ b/theolive/manage-team.mdx
@@ -0,0 +1,42 @@
+---
+sidebar_position: 0
+sidebar_label: Manage organization
+sidebar_custom_props:
+ icon: π₯
+description: Manage your organization, invite team members and assign roles.
+---
+
+# Manage organization
+
+Your organization is the top-level account that contains all your channels, distributions, and team members. From the organization settings you can manage who has access and what they can do.
+
+## Managing your organization
+
+Navigate to the organization settings to view and edit your organization name and details.
+
+
+
+
+
+
+
+## Adding team members
+
+To invite a colleague, navigate to the team section and click **Add member**. Enter their first name, last name, email address, and select their role, then confirm.
+
+The invited user will receive an email with instructions to access the dashboard. Once they accept, they appear as part of your organization.
+
+
+
+
+
+
+
+## Roles
+
+There are two roles: **admin** and **user**.
+
+- **Admin** β full access, including team management, billing, and token revocation.
+- **User** β access to day-to-day operations like managing channels and distributions, but no access to team management or billing.
+
+Only admins can invite or remove team members and change roles.
diff --git a/theolive/media-engine/abr.mdx b/theolive/media-engine/abr.mdx
new file mode 100644
index 000000000000..bbd09af29724
--- /dev/null
+++ b/theolive/media-engine/abr.mdx
@@ -0,0 +1,17 @@
+---
+sidebar_position: 2
+sidebar_label: ABR
+sidebar_custom_props:
+ icon: πΆ
+description: ABR ladder configuration with resolution and bitrate rungs.
+---
+
+# ABR
+
+When creating a media engine, you need to specify an ABR ladder. This ladder contains all the separate rungs with a resolution, bitrate and framerate.
+Since this ladder has impact on pricing and is difficult to get right, setting up available ABR ladders is done during onboarding. If later on new ladders are needed, don't hesitate to contact us.
+
+## Important considerations
+
+- **Frame rate** β the frame rate of the encoder and the channel configuration should match (suggested values: 25, 29.97, 30, 50, 59.94 or 60 fps). Mismatches may lead to information loss and stalls.
+- **Ingest bitrate** β the encoder bitrate should be at least as high as the highest rung of the ABR ladder so the transcoder receives a high-quality source for all output qualities.
diff --git a/theolive/media-engine/drm.mdx b/theolive/media-engine/drm.mdx
new file mode 100644
index 000000000000..5fac47baed56
--- /dev/null
+++ b/theolive/media-engine/drm.mdx
@@ -0,0 +1,36 @@
+---
+sidebar_position: 3
+sidebar_label: DRM
+sidebar_custom_props:
+ icon: π
+description: Protect your live streams with Digital Rights Management.
+---
+
+# DRM
+
+Digital Rights Management (DRM) protects live video content by encrypting the stream so that only authorized viewers can watch it. Without DRM, streams can be intercepted, redistributed, or recorded without permission.
+
+DRM is essential for content that requires legal or contractual protection, such as premium sports broadcasts, pay-per-view events, or licensed entertainment. It ensures that content owners retain control over who can access their streams and under what conditions.
+
+## Enabling DRM
+
+DRM is configured per engine, allowing fine-grained control over which streams are protected. To enable DRM, simply enable the DRM option on an engine.
+
+
+
+## API example
+
+You can also enable DRM via the API by setting `drm` to `true` when [creating](../api/create-channel-engine.api.mdx) or [updating](../api/update-engine.api.mdx) an engine.
+
+`POST https://api.theo.live/v2/channels/{channelId}/engines`
+
+```json
+{
+ "name": "my-engine",
+ "region": "europe-west",
+ "quality": {
+ "abrLadderId": "your-abr-ladder-id"
+ },
+ "drm": true
+}
+```
diff --git a/theolive/media-engine/encoding-quality.mdx b/theolive/media-engine/encoding-quality.mdx
new file mode 100644
index 000000000000..b5532b32922a
--- /dev/null
+++ b/theolive/media-engine/encoding-quality.mdx
@@ -0,0 +1,32 @@
+---
+sidebar_position: 3
+sidebar_label: Encoding quality
+sidebar_custom_props:
+ icon: ποΈ
+description: Configure encoding quality settings for your media engine.
+---
+
+# Encoding quality
+
+The choice of output protocols on your media engine directly impacts the encoding quality of your stream. This is because different protocols have different latency budgets, which affect how much time the encoder has to optimize each frame.
+
+## How protocol choice affects quality
+
+### Low latency (HESP enabled)
+
+When HESP is enabled on the engine, the encoder operates with a tight latency budget to achieve the ultra-low latency that HESP is designed for. This means fewer frames are available for look-ahead and reference, resulting in quality comparable to other low-latency encoders on the market. The trade-off is intentional: you get low latency at the cost of some encoding efficiency.
+
+### Higher quality (HLS only)
+
+If low latency is not a requirement for your use case, configure your engine to output **HLS only**. Without the constraint of a low-latency target, the encoder has a significantly larger latency budget. This allows it to use more advanced encoding techniques β such as longer GOP structures and deeper look-ahead β resulting in noticeably higher image quality at the same bitrate.
+
+## Choosing the right configuration
+
+| Use case | Recommended outputs | Latency | Image quality |
+| ---------------------------------------------- | ------------------- | ----------------- | ------------- |
+| Live sports betting, interactive entertainment | HESP + HLS | Ultra-low (1β5s) | Good |
+| Linear broadcast, non-interactive live events | HLS only | Standard (10β30s) | Higher |
+
+:::tip
+You can create multiple engines on the same channel with different output configurations. For example, use one engine with HESP for low-latency viewers and another with HLS only for viewers who prioritize quality over latency. Attach each to a separate distribution to serve both audiences from the same ingest.
+:::
diff --git a/theolive/media-engine/streaming-protocols.mdx b/theolive/media-engine/streaming-protocols.mdx
new file mode 100644
index 000000000000..a062dbebbff6
--- /dev/null
+++ b/theolive/media-engine/streaming-protocols.mdx
@@ -0,0 +1,54 @@
+---
+sidebar_position: 1
+sidebar_label: Streaming protocols
+sidebar_custom_props:
+ icon: π‘
+description: Output protocols supported by the media engine (HESP and HLS).
+---
+
+# Streaming protocols
+
+The media engine outputs your live stream in multiple protocols to ensure broad device and player compatibility. The following output protocols are supported: **HESP** and **HLS**.
+
+### HESP β High Efficiency Streaming Protocol
+
+HESP is a next-generation streaming protocol designed for ultra-low latency live delivery. It is the default and recommended output protocol for the Dolby OptiView Live platform.
+
+- **Ultra-low latency** β delivers end-to-end latency in the 1 to 5 seconds range, significantly lower than traditional HLS.
+- **Fast channel switching** β viewers experience near-instant startup and channel changes.
+
+### HLS (CMAF) β HTTP Live Streaming
+
+HLS is the industry-standard protocol developed by Apple for delivering live and on-demand content over HTTP. The media engine outputs HLS using modern CMAF (fragmented MP4) segments.
+
+- **Broad compatibility** β supported by virtually all modern browsers, devices and players.
+- **Higher latency** β compared to HESP, HLS typically introduces several seconds of additional latency.
+
+### HLS (MPEG-TS)
+
+HLS with MPEG-TS segments is an older variant of HLS that uses traditional transport stream segments instead of CMAF.
+
+:::warning
+Only use HLS MPEG-TS if you are targeting a platform that genuinely does not support CMAF-based HLS β for example, certain legacy set-top boxes or embedded devices. In all other cases, use the standard CMAF HLS output, which offers better performance and broader modern device support.
+:::
+
+## API example
+
+You can configure output protocols via the API using the `outputs` object when [creating](../api/create-channel-engine.api.mdx) or [updating](../api/update-engine.api.mdx) an engine.
+
+`POST https://api.theo.live/v2/channels/{channelId}/engines`
+
+```json
+{
+ "name": "my-engine",
+ "region": "europe-west",
+ "quality": {
+ "abrLadderId": "your-abr-ladder-id"
+ },
+ "outputs": {
+ "hesp": true,
+ "hls": true,
+ "hlsTs": false
+ }
+}
+```
diff --git a/theolive/platform/authorization.mdx b/theolive/platform/authorization.mdx
deleted file mode 100644
index e9db8096adb3..000000000000
--- a/theolive/platform/authorization.mdx
+++ /dev/null
@@ -1,55 +0,0 @@
----
-sidebar_position: 1
----
-
-# Authorization
-
-To make secure calls to the THEOlive REST API, both authentication and authorization are required. THEOlive uses tokenβsecret pairs to authorize API requests and ensure secure access.
-
-## 1. Getting a token-secret pair
-
-To generate a tokenβsecret pair, you must first have an account on the [THEOlive management console](https://console.theo.live/).
-
-1. Navigate to the _Developers section_ and click on "Tokens".
-2. Click the "Generate Token" button.
-3. Enter a name for your token.
-4. Click "Generate" to create the tokenβsecret pair.
-
-
-
-This will open a pop-up displaying your token "key" and its corresponding secret.
-
-
-
-:::warning[Please store the secret]
-
-Make sure to securely store the secret, as it will only be shown once. THEOlive stores a hashed version of the secret, meaning it cannot be recovered afterward.
-
-:::
-
-Once you close the pop-up window, the new token will be visible in your list of active tokens.
-
-
-
-If you forget your secret or if it gets exposed, you can easily regenerate a new tokenβsecret pair at any time.
-
-To revoke a token, click the arrow icon under the "Actions" column and the token will be moved to the list of revoked tokens after confirmation.
-
-## 2. Using the token-secret pair with Basic Authentication
-
-THEOlive uses Basic Authentication for API requests. To authenticate, include your token-secret pair (base64-encoded) in the 'Authorization' header, prepended with the word 'Basic'.
-
-Hereβs an example of how to set up the header:
-
-1. Combine your token and secret in the format `token:secret`.
- Example: `my-token:my-secret`
-
-2. Base64 encode the combined value.
- Example: `bXktdG9rZW46bXktc2VjcmV0`
-
-3. Include the encoded string in the Authorization header, prefixed with the word Basic.
- Example header: `Authorization: Basic bXktdG9rZW46bXktc2VjcmV0`
-
-4. The final Authorization header should look like this: `Authorization: Basic bXktdG9rZW46bXktc2VjcmV0`
-
-Youβre now ready to make authenticated requests to the THEOlive API.
diff --git a/theolive/platform/manage-team.mdx b/theolive/platform/manage-team.mdx
deleted file mode 100644
index 80bab42947b0..000000000000
--- a/theolive/platform/manage-team.mdx
+++ /dev/null
@@ -1,59 +0,0 @@
----
-sidebar_position: 0
-sidebar_label: Manage your team
----
-
-# How to manage your team
-
-After signing up for the [THEOlive console](https://console.theo.live/login), you may want to collaborate with your colleagues using the same account and channels. This guide walks you through how to set up team access and collaboration.
-
-## 1. Manage your team
-
-### 1.1 - Access the team
-
-Click on the βMy accountβ button, on the top right-hand corner of the screen and select _My Team_.
-
-
-
-This section displays all members of your team along with their current status. Each member is assigned a role as either an admin or user.
-
-
-
-:::warning π§ Only admins can access the _My Team_ section
-The _My Team_ section is only visible to admins. If you donβt see the _My team_ button, it means you currently donβt have admin rights. You can find more information about roles in the section below.
-:::
-
-### 1.2 - Add member
-
-To invite a colleague, click on the _Add member_ button. Enter their email address, select their role, and click _Add_ to confirm.
-
-
-
-An invitation has been sent to the specified email address, including a link and instructions to access the THEOlive console.
-
-If needed, you can resend the invitation from the _My Team_ page by clicking the envelope icon next to the user's name (see screenshot below).
-
-Once your colleagues accept the invitation, theyβll have access to the same console account. The _My Team_ page will then display them as part of your team.
-
-
-
-## 2. Determining the role of your new team members
-
-There are two roles defined in the THEOlive console: **admin** and **user**. While both roles have access to most of the same information and actions, admins have a few additional permissions.
-
-Admins can:
-
-- Access team management and billing pages
-- Grant or revoke admin access for other team members
-- Remove members from the team
-- Revoke tokens
-
-Users can perform most day-to-day tasks but do not have access to team management, billing, or token revocation.
-
-## 3. Complete your profile
-
-When a user is invited to a THEOlive team, they gain access to the _My Profile_ page. Here, they can update their personal details, including first name, last name, phone number, and password.
-
-Access to this page is restricted to the individual user. Neither other team members nor admins can view or edit someone elseβs personal information.
-
-
diff --git a/theolive/platform/multi-channel.md b/theolive/platform/multi-channel.md
deleted file mode 100644
index 653d9e160fb0..000000000000
--- a/theolive/platform/multi-channel.md
+++ /dev/null
@@ -1,45 +0,0 @@
----
-sidebar_position: 2
-sidebar_label: Alias
----
-
-# Multi-channel: aliases for channels
-
-This guide outlines THEOliveβs multi-channel approach: ingest your stream once and create multiple channel aliases, each with its own unique playout configuration. In addition to customized settings per alias, THEOlive also allows you to apply individual security featuresβsuch as geoblocking and token-based authentication on a per-alias basis.
-
-You can configure this via the [THEOlive management console](https://console.theo.live), as well via the [THEOlive API](/theolive/api/channels/create-channel-alias).
-
-## Multi-channel: player aliases
-
-Do you want to deliver your live stream to multiple customers at the same timeβeach with a personalized player experience, region-specific access restrictions, and separate usage analytics? THEOliveβs player alias capability makes this easy.
-
-From the "_Channel Details_" page, you can create channel aliases under the "_Playout Configurations section_". Each alias can be customized with its own playout settings, including player colors, poster image, announcement message, logo, and more.
-
-
-
-The key advantage of this approach is that you only need to configure your ingest once, and then distribute your content across multiple web pagesβeach using a different channel alias with its own unique Channel ID.
-
-Including an alias is straightforward: Copy the aliasβs Channel ID and paste it as the value of the `data-theo-live-id` attribute. For detailed instructions, go to the "_Include channel on your page_" tab, where youβll find a step-by-step guide on embedding a specific playout configuration (alias) into your web page.
-
-
-
-### Managing your alias
-
-At any time, you can [update](/theolive/api/channels/update-channel-alias), [enable](/theolive/api/channels/enable-channel-alias), [disable](/theolive/api/channels/disable-channel-alias) or [delete](/theolive/api/channels/delete-channel-alias) a channel alias. The default alias can't be deleted, you'll have to delete your whole channel in case you want to do so.
-
-
-
-### Analytics per channel alias
-
-You can visualize data for each channel alias individually. In the Console, the Analytics section of the Channel Details page provides insights such as concurrent viewers, latency, viewer locations, browser and operating system breakdowns, and total viewing minutes. Click on any of the links in the Analytics section to view detailed metrics for a specific alias.
-
-THEOlive also offers an API endpoint where you can query the minutes viewed on an hourly basis per channel alias. You can read more about it [here](/theolive/api/channels/get-channel-alias-analytics).
-
-
-
-# Multi-channel: Use-cases for channel aliases
-
-Creating channel aliases can serve useful in a couple of different ways. Here are a couple of examples where creating a channel alias can simplify your workflow
-
-- Creating a stream that requires multiple stream [redundancy](./redundancy.md) or fallback solutions
-- Creating a stream that requires different [geo-blocking](./security/geo-blocking.md) rules for different countries
diff --git a/theolive/platform/real-time-update-with-webhooks.mdx b/theolive/platform/real-time-update-with-webhooks.mdx
index 847139b146f9..181ab7065598 100644
--- a/theolive/platform/real-time-update-with-webhooks.mdx
+++ b/theolive/platform/real-time-update-with-webhooks.mdx
@@ -1,171 +1,348 @@
---
sidebar_position: 9
sidebar_label: Webhooks
+sidebar_custom_props:
+ icon: π
+description: Receive real-time notifications when channel events occur.
---
-# Real-Time Updates with webhooks
+# Webhooks
+
+Webhooks let you receive real-time notifications when events happen in your streaming infrastructure. Instead of polling for changes, you register an endpoint URL and the system pushes event data to it automatically.
---
-This guide describes how you can leverage THEOlive webhooks to receive real-time updates about your THEOlive components. You don't need to query for updates yourself anymore: we send you information when certain events happen. This guide will first explain what webhooks are, how you can create and manage them via the THEOlive console and/or API, and finally describe how you can secure your webhooks.
+## What is a Webhook?
-## 1. How it works
+A webhook is an HTTP callback that sends a `POST` request to your endpoint whenever a subscribed event occurs β for example, when a channel starts, an engine encounters an error, or a distribution is updated.
-When creating a webhook, you pass an endpoint URL that you control to THEOlive. This endpoint will be used by THEOlive to send real-time updates when certain events happen. It's important that this an HTTPS endpoint which is reachable by THEOlive.
+Each webhook has:
-You can choose on which events THEOlive has to send a message to your endpoint. For example: you can choose to get notified when a channel reaches the "playing" mode, but also when it got deleted, stopped, created, etc. A full list of available events can be found [at the bottom of this page](#5-list-of-possible-events).
+- **Name** β A human-readable label.
+- **Endpoint URL** β The URL that will receive the event payloads.
+- **Events** β The specific event types the webhook listens to, or all events via a wildcard.
+- **Active / Inactive** β Whether the webhook is currently receiving events.
+- **Secret** β A signing secret used to verify that incoming requests are genuinely from Dolby OptiView.
-The main advantage of webhooks is that THEOlive informs you in real-time when an event happens, and you don't have to pull our API continuously to check if there are any updates on an object.
+---
-
+## Supported Events
+
+Events are grouped by resource type:
+
+### Channel events
+
+| Event | Triggered when |
+| ------------------- | --------------------------- |
+| `channel.created` | A channel is created |
+| `channel.updated` | A channel is updated |
+| `channel.deploying` | A channel starts deploying |
+| `channel.stopping` | A channel begins stopping |
+| `channel.stopped` | A channel has fully stopped |
+| `channel.deleted` | A channel is deleted |
+
+### Engine events
+
+| Event | Triggered when |
+| ------------------ | ------------------------------ |
+| `engine.created` | An engine is created |
+| `engine.updated` | An engine is updated |
+| `engine.deploying` | An engine starts deploying |
+| `engine.waiting` | An engine is waiting for input |
+| `engine.starting` | An engine is starting up |
+| `engine.playing` | An engine begins playing |
+| `engine.ingesting` | An engine begins ingesting |
+| `engine.stopping` | An engine begins stopping |
+| `engine.stopped` | An engine has fully stopped |
+| `engine.deleting` | An engine is being deleted |
+| `engine.deleted` | An engine has been deleted |
+| `engine.error` | An engine encounters an error |
+| `engine.log.info` | An engine emits an info log |
+| `engine.log.warn` | An engine emits a warning log |
+| `engine.log.error` | An engine emits an error log |
+
+### Ingest events
+
+| Event | Triggered when |
+| ---------------- | -------------------------- |
+| `ingest.created` | An ingest point is created |
+| `ingest.updated` | An ingest point is updated |
+| `ingest.deleted` | An ingest point is deleted |
+
+### Distribution events
+
+| Event | Triggered when |
+| ------------------------------------ | ------------------------------------------------- |
+| `distribution.created` | A distribution is created |
+| `distribution.updated` | A distribution is updated |
+| `distribution.enabled` | A distribution is enabled |
+| `distribution.disabled` | A distribution is disabled |
+| `distribution.deleted` | A distribution is deleted |
+| `distribution.security.key.added` | A security key is added to a distribution |
+| `distribution.security.key.deleted` | A security key is removed from a distribution |
+| `distribution.security.keys.deleted` | All security keys are removed from a distribution |
+
+### Webhook events
+
+| Event | Triggered when |
+| ------------------ | ------------------------ |
+| `webhook.created` | A webhook is created |
+| `webhook.updated` | A webhook is updated |
+| `webhook.enabled` | A webhook is activated |
+| `webhook.disabled` | A webhook is deactivated |
+| `webhook.deleted` | A webhook is deleted |
+
+You can also use the **wildcard** (`*`) to listen to all events at once.
-## 2. Create and manage your webhooks
+---
-You can create a webhook through the THEOlive API, or via the management console. In this document we will mainly describe the console approach, the full API reference for the actions and methods can be found [here](/theolive/api/webhooks/create-webhook).
+## Creating a Webhook in the unified dashboard
-To create a webhook, click on "Webhooks" on the sidebar, followed by "Create". A webhook expects a name, a valid HTTPS endpoint, an optional description and a list of events it should listen and act on. A full list of events can be found at the bottom of this page. You can also select to listen to all possible events. When using the API, you can pass `events: ["*"]` when a webhook should listen to all events.
+1. Navigate to **Streaming β Webhooks**.
+2. Click the **New** button in the top right.
+3. Fill in the form:
+ - **Name** β Give your webhook a descriptive name (e.g. "Production event handler").
+ - **Endpoint URL** β The HTTPS URL that will receive event payloads (e.g. `https://example.com/webhooks`).
+ - **Events** β Either toggle **Listen to all events**, or expand the event groups and select individual events. Events are grouped by category (Channel, Engine, Ingest, Distribution, Webhook) and you can toggle an entire group at once.
+4. Click **Create** to save the webhook.
-
+After creation, you are redirected to the webhook detail page where you can view the signing secret.
-When such an event happens, THEOlive will try to send a request to your endpoint. **It's important that you inform us as soon as possible that you received the request with a status 200 code**: requests that take longer than 3 seconds will be terminated by THEOlive and marked as failed. When a webhook has too many failed attempts, THEOlive will disable the webhook automatically. Below, we show a small code example of an Express app where we inform THEOlive we have received the request, before we do all other actions:
+### API example β Create a webhook
-```javascript
-const express = require('express');
-const port = 3000;
+**Listen to specific events:**
-var app = express();
+`POST https://api.theo.live/v2/webhooks`
-app.use(express.json());
+```json
+{
+ "name": "Production event handler",
+ "url": "https://example.com/webhooks",
+ "events": ["channel.created", "channel.stopped", "engine.error"]
+}
+```
-app.post('/webhooks', (req, res) => {
- res.send('ok'); // let us know ASAP you received our request
+**Listen to all events:**
- // your app-specific implementation like updating your database etc.
-});
+`POST https://api.theo.live/v2/webhooks`
-app.listen(port, () => {
- console.log(`Example app listening on port ${port}`);
-});
+```json
+{
+ "name": "Catch-all webhook",
+ "url": "https://example.com/webhooks",
+ "events": ["*"]
+}
```
-:::warning π§ Newly created webhooks will be disabled by default
+---
-When you create a webhook, it won't be active yet. THEOlive does this so you can test things out before we actually start firing events to your endpoint. When you think you are fully ready to receive webhook messages from THEOlive, you can enable the webhook through the console, or via the [/webhooks/$\{webhook-id\}/enable](/theolive/api/webhooks/enable-webhook) endpoint.
-:::
+## Viewing Webhooks
-When a webhook is created, you can update or delete it through the API or management console. At the details page you can also see the history of all message that have been sent to your endpoint, and if they've failed or not.
+The **Webhooks** page shows a table of all your webhooks with:
-
+- **Name** β The webhook name. Click a row to navigate to the detail page.
+- **URL** β The endpoint URL.
+- **Status** β Active (green) or Inactive (red).
+- **Events** β Shows "All events" for wildcard webhooks, or the count of subscribed events.
+- **Actions** β Edit or delete the webhook.
-## 3. How to act on event
+### API example β List all webhooks
-THEOlive sends a JSON body along with the request which contains all necessary information. This JSON body has the following format:
+`GET https://api.theo.live/v2/webhooks`
-```json Request body example
+Optional query parameters:
+
+| Parameter | Description |
+| --------- | ----------------------------------- |
+| `cursor` | Pagination cursor for the next page |
+| `limit` | Number of results per page |
+
+### API example β Get a single webhook
+
+`GET https://api.theo.live/v2/webhooks/{webhookId}`
+
+---
+
+## Webhook Detail Page
+
+Click any webhook row to open its detail page. This shows:
+
+- **Name** and **URL** β The webhook configuration.
+- **Status** β Active or Inactive, with a colored indicator.
+- **Events** β Either "Listening to all events" or an expandable list of subscribed event types.
+- **Secret** β The signing secret (hidden by default). Click the eye icon to reveal it, and click the secret to copy it to your clipboard.
+
+### Delivery Logs
+
+The detail page includes a **Delivery logs** section that shows the history of webhook deliveries:
+
+- Filter logs by **start date** and **end date** (defaults to the last 7 days).
+- The left panel lists deliveries with a success (green check) or failure (red cross) indicator, the event type, and timestamp.
+- Click a log entry to view the full **request data** payload in the right panel.
+- The **status code** badge shows the HTTP response code returned by your endpoint.
+
+> **Note:** The status code reflects what your endpoint returned. A `400` status code means your endpoint rejected the request, not that delivery failed.
+
+---
+
+## Editing a Webhook
+
+Click the **edit icon** on the webhooks list, or click **Edit** on the webhook detail page.
+
+You can change:
+
+- **Name**
+- **Endpoint URL**
+- **Active / Inactive** toggle β Control whether the webhook receives events.
+- **Events** β Update which events the webhook listens to.
+
+Click **Save** to apply your changes.
+
+### API example β Update a webhook
+
+All fields are optional; only include the fields you want to change.
+
+`PATCH https://api.theo.live/v2/webhooks/{webhookId}`
+
+```json
{
- "created": 1661435007,
- "type": "channel.playing",
- "object": {
- "type": "channel",
- "id": ""
- },
- "livemode": true
+ "name": "Updated webhook name",
+ "url": "https://example.com/new-endpoint",
+ "events": ["channel.created", "channel.stopped"]
}
```
-- `created` is a Unix timestamp when the event happened
-- `type` is the [type of event](#5-list-of-possible-events) that got fired
-- `object` contains two properties: `type` is the type of the object, `id` the ID of it.
-- `livemode`: a boolean to indicate if the request was a test or not
+---
+
+## Activating and Deactivating a Webhook
+
+When editing a webhook, you can toggle the **Active / Inactive** switch.
+
+- **Active** β The webhook is receiving events. Shown with a green indicator.
+- **Inactive** β The webhook is disabled and will not receive events. Shown with a red indicator.
+
+This is useful when you want to temporarily stop receiving events without deleting the webhook.
+
+### API example β Activate or deactivate a webhook
+
+Use the update endpoint with the `active` field:
+
+`PATCH https://api.theo.live/v2/webhooks/{webhookId}`
+
+```json
+{ "active": false }
+```
+
+```json
+{ "active": true }
+```
-In your implementation, you can use this data to act on it accordingly. In the example below, we will act differently on receiving a `channel.playing` and `channel.deleted` event:
+---
-```javascript Act on events
-const express = require('express');
-const port = 3000;
+## Deleting a Webhook
-var app = express();
+Click the **trash icon** on the webhooks list, or click **Delete** on the webhook detail page. A confirmation dialog will appear. Deletion is permanent and cannot be undone.
-app.use(express.json());
+> **Note:** You must deactivate a webhook before deleting it.
-app.post('/webhooks', (req, res) => {
- res.send('ok'); // let us now ASAP you received our request
+### API example β Delete a webhook
- const data = req.body;
+`DELETE https://api.theo.live/v2/webhooks/{webhookId}`
- switch (data.type) {
- case 'channel.playing':
- setChannelActiveInMyDatabase(data.object.id); // Fictional code somewhere in your implementation
- case 'channel.deleted':
- console.log('Something got deleted');
- default:
- console.log('No code for this type implemented yet');
- }
-});
+---
-app.listen(port, () => {
- console.log(`Example app listening on port ${port}`);
-});
+## Webhook Payload Format
+
+When an event fires, Dolby sends a `POST` request to your endpoint with a JSON body:
+
+```json
+{
+ "type": "channel.stopped",
+ "created": 1711900800,
+ "object": {
+ "type": "channel",
+ "id": "ch_abc123"
+ },
+ "data": { ... }
+}
```
-## 4. Add security to your webhooks
+| Field | Description |
+| ------------- | ------------------------------------------------------------------------------ |
+| `type` | The event type string (e.g. `channel.stopped`, `engine.error`) |
+| `created` | Unix timestamp of when the event occurred |
+| `object.type` | The resource type: `channel`, `engine`, `ingest`, `distribution`, or `webhook` |
+| `object.id` | The ID of the resource that triggered the event |
+| `data` | Event-specific payload with additional details |
+
+---
-THEOlive makes use of webhook signatures to verify that the webhook request was coming from us, and not from a server that was acting like THEOlive. On every request THEOlive will send a `THEOlive-Signature` header that you can use to check if it was really THEOlive that sent the message.
+## Verifying Webhook Signatures
+
+Dolby uses webhook signatures to verify that the webhook request is genuinely coming from us, and not from a server acting like Dolby. On every request, Dolby sends a `Dolby-Signature` header that you can use to verify authenticity.
### How does the verification work?
-Upon the creation of a webhook, you'll receive a `secret` that looks like `theosec_some-random-characters`. This is a key you can use in a later stage to do the necessary security checks.
+Upon the creation of a webhook, you receive a **secret** that looks like `dolby_sec_some-random-characters`. You can retrieve this secret at any time from the webhook detail page or via the API.
+
+When receiving a webhook request, the `Dolby-Signature` header is always included and looks similar to:
-When receiving a webhook request from THEOlive, the `THEOlive-Signature` will always get sent with it and looks similar to the following:
-`t=1659622850,h=6bbe0553922a31ea48cb3af9903616c3a8b65351434653251949480f2a91c037`
+```
+t=1659622850,h=6bbe0553922a31ea48cb3af9903616c3a8b65351434653251949480f2a91c037
+```
+
+This string contains two parts that you need to extract:
-This is a string that you have to de-structure yourself to get the value of `t` and `h`:
+- **`t`** β The Unix timestamp when the request was made. This is included to prevent replay attacks.
+- **`h`** β A hexadecimal HMAC SHA-256 hash, which is a combination of the timestamp `t` and the JSON body of the request, signed with your secret.
-- `t` is the Unix timestamp when the request got made. THEOlive adds this to prevent replay attacks.
-- `h` is a hexadecimal HMAC SHA-256 hash, which is a combination of the timestamp `t` and the JSON body of the request, signed with your `secret`.
+To verify the signature, you recreate the hash yourself:
-As a user, you have to try to recreate the hash `h` yourself: you take `t`, add a stringified version of your JSON body after it, and hash it with the `secret` you received upon webhook creation. If the result equals to `h`, you can be sure the request was made by THEOlive. If not, someone tried to act like THEOlive.
+1. Take the timestamp `t` from the header.
+2. Append a `.` and the stringified JSON body of the request.
+3. Hash the resulting string with HMAC SHA-256, using your secret as the key.
+4. Compare the result with `h`. If they match, the request is authentic. If not, someone is impersonating Dolby.
### Full code sample
-```javascript Check THEOlive-Signature for security
+```javascript
const express = require('express');
const crypto = require('crypto');
const port = 3400;
var app = express();
-
app.use(express.json());
app.post('/webhooks', (req, res) => {
- res.send('ok'); // let us now ASAP you received our request
+ res.send('ok'); // acknowledge receipt ASAP
- const secret = 'theosec_myverylittlesecret'; // secret received on creation, can be retrieved anytime at the THEOlive console
- const data = req.body; // body of the request
+ const secret = 'dolby_sec_myverylittlesecret'; // secret received on creation
+ const data = req.body;
- // 1. Grab THEOlive-Signature from header
- const theoHeader = req.header('THEOlive-Signature'); // t=1659622850,h=6bbe0553922a31ea48cb3af9903616c3a8b65351434653251949480f2a91c037
+ // 1. Grab Dolby-Signature from header
+ const signatureHeader = req.header('Dolby-Signature');
+ // t=1659622850,h=6bbe0553922a31ea48cb3af9903616c3a8b65351434653251949480f2a91c037
// 2. Split string: you'll receive a timestamp (t) and hash (h)
- const timestampPart = theoHeader.split(',')[0]; // t=1659622850
- const hashPart = theoHeader.split(',')[1]; // h=6bbe0553922a31ea48cb3af9903616c3a8b65351434653251949480f2a91c037
+ const timestampPart = signatureHeader.split(',')[0]; // t=1659622850
+ const hashPart = signatureHeader.split(',')[1]; // h=6bbe05...
// 3. Get the values for both the timestamp and hash
const timestampValue = timestampPart.split('=')[1]; // 1659622850
- const hashValue = hashPart.split('=')[1]; // 6bbe0553922a31ea48cb3af9903616c3a8b65351434653251949480f2a91c037
+ const hashValue = hashPart.split('=')[1]; // 6bbe05...
// 4. Prepare the hash string: stringify the request body
- const dataAsString = JSON.stringify(data); // {"created":1659622849,"data":{"id":"9uiwh5owynp3ympsxqtjxa3zd","type":"channel"},"type":"channel.created","livemode":false}
- const stringToBeHashed = `${timestampValue}.${dataAsString}`; // 1659622850.{"created":1659622849,"data":{"id":"9uiwh5owynp3ympsxqtjxa3zd","type":"channel"},"type":"channel.created","livemode":false}
+ const dataAsString = JSON.stringify(data);
+ const stringToBeHashed = `${timestampValue}.${dataAsString}`;
// 5. Make a HMAC SHA-256 hash, using your secret as a key
- const hashToCheck = crypto.createHmac('sha256', secret).update(stringToBeHashed).digest('hex'); // 6bbe0553922a31ea48cb3af9903616c3a8b65351434653251949480f2a91c037
+ const hashToCheck = crypto.createHmac('sha256', secret).update(stringToBeHashed).digest('hex');
// 6. Check if both hashes are the same
if (hashToCheck === hashValue) {
// all good, continue with code
} else {
- // data not coming from THEOlive, throw an error
+ // data not coming from Dolby, throw an error
}
});
@@ -174,40 +351,17 @@ app.listen(port, () => {
});
```
-## 5. List of possible events
-
-| Type | Description |
-| :--------------------- | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `channel.creating` | Occurs when someone initiated a creation of a channel. |
-| `channel.created` | Occurs when the creation of a channel is completed. |
-| `channel.stopping` | Occurs when someone decides to stop a channel. |
-| `channel.stopped` | Occurs when all procedures to stop a channel are completed. |
-| `channel.deleting` | Occurs when someone decides to delete a channel. |
-| `channel.deleted` | Occurs when the process to delete a channel is completed. |
-| `channel.error` | Occurs when a channel goes into error state. |
-| `channel.deploying` | Occurs when someone starts a channel and all infrastructure starts deploying. |
-| `channel.starting` | Occurs when all infrastructure is deployed and channel is starting up. |
-| `channel.waiting` | Occurs when channel is ready, but isn't receiving ingest yet. |
-| `channel.ingesting` | Occurs when channel is receiving ingest. |
-| `channel.playing` | Occurs when manifest is ready and channel can playout content. |
-| `channel.scheduled` | Occurs when a channel has a scheduled start time due to a scheduler. The channel itself is ready, but the stream will be available for the viewers at scheduler start time. |
-| `channel.log.warn` | Occurs when a warning message for a channel gets received. |
-| `channel.log.error` | Occurs when an error message for a channel gets received. |
-| `channel.log.info` | Occurs when an info message for a channel gets received. |
-| `channel.updated` | Occurs when a channel got updated. |
-| `alias.created` | Occurs when an new alias got created. |
-| `alias.disabled` | Occurs when an alias got disabled. |
-| `alias.enabled` | Occurs when an alias got enabled. |
-| `alias.deleted` | Occurs when the process to delete an alias is finished. |
-| `alias.updated` | Occurs when an alias got updated. |
-| `webhook.created` | Occurs when a webhook got created. |
-| `webhook.enabled` | Occurs when a webhook got enabled. |
-| `webhook.disabled` | Occurs when a webhook got disabled. |
-| `webhook.updated` | Occurs when a webhook got updated. |
-| `webhook.deleted` | Occurs when a webhook got deleted. |
-| `scheduler.created` | Occurs when a scheduler got created. |
-| `scheduler.updated` | Occurs when a scheduler got updated. |
-| `scheduler.deleted` | Occurs when a scheduler got deleted. |
-| `scheduler.starting` | Occurs when a scheduler moves to starting mode: all connected channels will start up, stream will not be shown to your users yet. |
-| `scheduler.active` | Occurs when a scheduler moves to active mode: the stream is now shown to your users. |
-| `scheduler.terminated` | Occurs when a schedulers gets terminated. |
+### API example β Get the webhook secret
+
+`GET https://api.theo.live/v2/webhooks/{webhookId}/secret`
+
+---
+
+## Tips
+
+- **Use HTTPS endpoints.** Always use HTTPS for your webhook URLs to ensure event data is encrypted in transit.
+- **Return a 2xx status code quickly.** Your endpoint should acknowledge the webhook with a `200` or `204` response as fast as possible. Process the payload asynchronously if needed.
+- **Use the wildcard sparingly.** Subscribing to all events (`*`) is convenient for development but may generate a high volume of requests in production. Subscribe only to the events you need.
+- **Monitor delivery logs.** Check the delivery logs on the webhook detail page to verify events are being delivered successfully and your endpoint is responding correctly.
+- **Deactivate instead of deleting.** If you need to temporarily stop receiving events, deactivate the webhook rather than deleting and recreating it.
+- **Verify signatures in production.** Use the signing secret to verify that incoming requests are authentic before processing the payload.
diff --git a/theolive/platform/redundancy.md b/theolive/platform/redundancy.md
deleted file mode 100644
index 9249b590f18d..000000000000
--- a/theolive/platform/redundancy.md
+++ /dev/null
@@ -1,59 +0,0 @@
----
-sidebar_position: 3
----
-
-# Redundancy
-
-With THEOlive we want to make sure your viewers can continue watching your stream, even if there is an ingest failure or if there are connectivity problems in a certain location. It is hence possible to set up a fallback stream. This means that if one stream is unavailable for a short amount of time, the player checks if the fallback stream is available and switches the player source automatically to this stream. In this case, the viewers only see a small interruption and can continue watching without having to act.
-
-**Note:** Setting a fallback is possible on channel and on channel alias level. Example
-
-- Channel A has aliases A1 and A2
-- Channel B has aliases B1 and B2
-
-This means
-
-- Channel A can fallback to Channel B, or to one of the aliases of B (B1, B2)
-- An alias of channel A (for example alias A1), can fall back to channel B, or one of its aliases (B1, B2)
-- Channel B can fall back to channel A, or aliases A1, A2
-- An alias of channel B can fall back to channel A, or aliases of it (A1, A2)
-- It's not possible for channel A to fall back to an alias of itself (A1, A2), or for an alias to fall back to its parent channel (A1 to A). The same applies for channel B and its aliases.
-
-In what follows, we describe the approach to set a fallback for one channel.
-
-## 1. Create two channels and start them.
-
-You'll need to create two THEOlive channels via the [API](../api/create-channel.api.mdx) or [management console](https://console.theo.live/). Let's say for example that we have the following channels with fictive IDs:
-
-- Channel `` which is located in the `us-west` region
-- Channel `` which is located in the `us-east` region
-
-Don't forget to start both channels. If the fallback stream isn't started, it will be impossible to switch to it when something goes wrong with the primary one!
-
-## 2. Set the `fallback` using the THEOlive API
-
-Assume the channel with ID `` should have a fallback that links to the `` channel. To make this work, we need to send a request to the `PATCH https://api.theo.live/channels/` endpoint to update the settings of ``. Passing the following JSON body with the request will set the `` channel as the fallback channel.
-
-```json
-{
- "fallback": {
- "src": "",
- "enabled": true
- }
-}
-```
-
-This will work as follows:
-
-1. Before starting anything, the player will check if the primary channel has been started (`` in our case).
-2. If the channel is playing, the player will start playing. If the channel has not been started yet, a message will be shown that the live stream isn't started yet.
-3. When the primary stream becomes unavailable after a while, the player will check if a fallback is defined and switch to it if possible.
-4. If this fallback becomes unavailable after a while, the player will try to switch back to the primary stream.
-5. This process will continue to work this way. If both streams are unavailable, the pre-live settings will be shown (an announcement message and optionally a poster image too).
-6. When the primary channel is stopped, all players will stop playing (even if the fallback channel is still streaming).
-
-For more information, please visit our [API Reference](../api/update-channel.api.mdx).
-
-Note that the fallback can also easily be set in our management console on the Channel Details page. Scroll down to the **Playout Configurations** section and select the _Fallback_ tab.
-
-
diff --git a/theolive/platform/scheduler.mdx b/theolive/platform/scheduler.mdx
index 60342062fdc8..db65b5785611 100644
--- a/theolive/platform/scheduler.mdx
+++ b/theolive/platform/scheduler.mdx
@@ -1,80 +1,253 @@
---
sidebar_position: 10
-sidebar_label: Scheduler
+sidebar_label: Schedulers
+sidebar_custom_props:
+ icon: ποΈ
+description: Automatically start and stop channels on a schedule.
---
-# Schedule THEOlive channel start & stop
+# How to Use Schedulers
-## Define when a channel should be ready and when it should be stopped
+Schedulers let you automate when your channels go live and stop streaming. Instead of manually starting and stopping channels, you define a schedule and let the system handle it.
-THEOlive allows you to automatically schedule the start and stop of a channel, offering several key advantages:
+---
+
+## What is a Scheduler?
+
+A scheduler is a time-based rule that automatically starts and stops one or more streaming channels. You can create **one-time** schedules for a single event, or **recurring** schedules for repeated broadcasts like daily shows or weekly streams.
+
+Each scheduler has a **status** that reflects where it is in its lifecycle:
+
+| Status | Meaning |
+| -------------- | ----------------------------------------------------- |
+| **Idle** | Waiting for the next scheduled run or a manual start. |
+| **Starting** | The connected channels are being brought online. |
+| **Active** | The connected channels are live. |
+| **Stopping** | The connected channels are being taken offline. |
+| **Terminated** | The schedule has completed and will not run again. |
+
+---
+
+## Creating a Scheduler in the dashboard
+
+1. Navigate to **Streaming β Schedulers**.
+2. Click the **New** button in the top right.
+3. A two-step form opens.
+
+### Step 1 β Configure the schedule
+
+- **Name** β Give your scheduler a descriptive name (e.g. "Weekday morning show").
+- **Timezone** β Select the timezone the schedule should operate in. Start searching to filter the list.
+- **Schedule type** β Choose between:
+ - **One time** β The scheduler fires once at the specified date and time.
+ - **Recurring** β The scheduler repeats according to a pattern you define.
+
+#### One-time schedule
+
+- Set the **start date** and **start time**. This is when your channels will go live.
+- Optionally enable **Set end time** and provide an end date and time. If set, your channels will be automatically stopped at that point.
+
+
+
+#### Recurring schedule
+
+- Set the **first occurrence date** β the date from which the recurring schedule begins.
+- Set the **start time** and **end time** β each occurrence will run between these times.
+- Optionally set a **Repeat until** date. If left empty, the schedule repeats indefinitely.
+- Configure the **recurrence pattern**:
+ - **Frequency** β Daily, Weekly, or Monthly.
+ - **Interval** β e.g. every 1 week, every 2 days.
+ - **Days of the week** β (Weekly only) Select which days the schedule should run on.
+- A live preview shows a summary of the pattern, e.g. _"Every week on Mon, Wed, Fri from 08:00 to 12:00 (Europe/Brussels)"_.
+
+
+
+When using the API, recurrence is expressed as an [RRULE](https://datatracker.ietf.org/doc/html/rfc5545#section-3.3.10) string in the `recurrence` field. Examples:
+
+| Pattern | RRULE |
+| --------------------------------------- | ------------------------------------------ |
+| Every day | `RRULE:FREQ=DAILY` |
+| Every 2 days | `RRULE:FREQ=DAILY;INTERVAL=2` |
+| Every week on Monday, Wednesday, Friday | `RRULE:FREQ=WEEKLY;BYDAY=MO,WE,FR` |
+| Every 2 weeks on Tuesday and Thursday | `RRULE:FREQ=WEEKLY;INTERVAL=2;BYDAY=TU,TH` |
+| Every month | `RRULE:FREQ=MONTHLY` |
+| Every 3 months | `RRULE:FREQ=MONTHLY;INTERVAL=3` |
+| Every week on Saturday | `RRULE:FREQ=WEEKLY;BYDAY=SA` |
+
+### Step 2 β Select channels
+
+- Search and browse your streaming channels.
+- Click a channel row to select or deselect it. At least one channel is required.
+
+Click **Create** to save the scheduler.
+
+### API example β Create a scheduler
+
+**One-time schedule:**
+
+`POST https://api.theo.live/v2/schedulers`
+
+```json
+{
+ "name": "Product launch stream",
+ "startDate": "2026-04-15",
+ "startTime": "14:00",
+ "endDate": "2026-04-15",
+ "endTime": "16:00",
+ "timeZone": "Europe/Brussels",
+ "channelIds": ["ch_abc123", "ch_def456"],
+ "enabled": true
+}
+```
+
+**Recurring schedule:**
+
+`POST https://api.theo.live/v2/schedulers`
+
+```json
+{
+ "name": "Weekday morning show",
+ "startDate": "2026-04-01",
+ "startTime": "08:00",
+ "endTime": "12:00",
+ "timeZone": "Europe/Brussels",
+ "recurrence": "RRULE:FREQ=WEEKLY;BYDAY=MO,WE,FR",
+ "channelIds": ["ch_abc123"],
+ "enabled": true
+}
+```
+
+---
+
+## Viewing Schedulers
+
+The **Schedulers** page shows a table of all your schedulers with:
+
+- **Status** β Current lifecycle state. Disabled schedulers show a yellow "Disabled" badge.
+- **Name** β The scheduler name.
+- **Schedule** β A human-readable summary of the schedule. For idle recurring schedulers, a "Next run" date is shown below the summary.
+- **Timezone** β The timezone the schedule operates in.
+- **Channels** β A badge showing the number of connected channels. Click it to see the full list and navigate to individual channels.
+
+
+
+### API example β List all schedulers
+
+`GET https://api.theo.live/v2/schedulers`
+
+Optional query parameters:
+
+| Parameter | Description |
+| --------------- | --------------------------------------------------------- |
+| `cursor` | Pagination cursor for the next page |
+| `limit` | Number of results per page |
+| `status` | Comma-separated filter, e.g. `idle,active` |
+| `sortBy` | Sort field: `status`, `name`, `startDate`, or `startTime` |
+| `sortDirection` | `asc` or `desc` |
+
+### API example β Get a single scheduler
+
+`GET https://api.theo.live/v2/schedulers/{schedulerId}`
+
+---
+
+## Editing a Scheduler
+
+Any non-terminated scheduler can be edited.
-- System readiness: All necessary components of the THEOlive stack will be up and running at the scheduled time.
-- Lower development effort: No need to build and maintain your own scheduling system, saving time and reducing costs.
-- Avoid wasted resources: Prevent unnecessary transcoding minutes by ensuring channels stop automatically when no longer needed.
+- For **idle or stopped schedulers**, you can change all fields including the schedule timing, channels, and recurrence pattern.
+- For **active schedulers**, some fields are locked and cannot be changed while channels are live:
+ - Start date and start time
+ - Schedule type (one-time vs. recurring)
+ - Timezone
+ - Connected channels
-## How it works
+ You can still change the scheduler name, end time, and recurrence pattern.
-**What is a Scheduler in THEOlive?**
+Click **Save changes** to apply your edits.
-A scheduler is a configuration that includes a **start time**, an optional **end time**, and a **list of channels** to start and stop automatically at those times.
+### API example β Update a scheduler
-- **End time** is optional: If you donβt specify one, youβll need to manually terminate the scheduler. This can be useful if you're unsure when your event will end.
+All fields are optional; only include the fields you want to change.
-**How Scheduled Start Works**
+`PATCH https://api.theo.live/v2/schedulers/{schedulerId}`
-15 minutes before the scheduled start time, the associated channels enter a `scheduled` state. During this period:
+```json
+{
+ "name": "Updated scheduler name",
+ "endDate": "2026-06-30",
+ "endTime": "18:00"
+}
+```
-- The entire THEOlive stack begins spinning up.
-- The THEOlive player will show no contentβjust as if the channel were in a stopped state.
+---
+
+## Enabling and Disabling a Scheduler
+
+When editing a scheduler, you can toggle the **Scheduler enabled** switch.
+
+- **Enabled** β The scheduler will run according to its configured schedule.
+- **Disabled** β Scheduled runs will be skipped until the scheduler is re-enabled. The scheduler remains in the system and can be re-enabled at any time.
-Start times under 15 minutes: You can create a scheduler with a start time less than 15 minutes in the future or even immediately by omitting the `start` property in the API. While the channels will still attempt to go live, THEOlive cannot guarantee the stream will be ready exactly on time due to infrastructure startup time.
+This is useful when you want to temporarily pause a recurring schedule without deleting it.
-At the scheduled start time, the channel switches to `playing` mode and begins streaming to viewers.
+### API example β Enable or disable a scheduler
-At the end time (or if the scheduler is manually terminated) the channel will stop.
+Use the update endpoint with the `enabled` field:
-**Post-stream Usage Report**
+`PATCH https://api.theo.live/v2/schedulers/{schedulerId}`
-Approximately 15 minutes after the scheduler ends, THEOlive generates a usage report. This report includes:
+```json
+{ "enabled": false }
+```
-- Seconds viewed per channel
-- Channel alias
-- Viewer data by country
-- Viewer platform data (OS, browser, versions, etc.)
-- And more detailed insights
+---
+
+## Manually Starting and Stopping
-## Creating and managing a scheduler through the API
+You can override the schedule at any time:
-Setting up a schedule via the THEOlive API is quick and straightforward. For full implementation details, refer to the [Create scheduler](/theolive/api/schedulers/create-scheduler) API documentation.
+- **Start** β Available when a scheduler is **idle**. Immediately starts the connected channels regardless of the configured schedule.
+- **Stop** β Available when a scheduler is **active**. Immediately stops the connected channels.
-- **Updating a scheduler**: You can modify a scheduler at any time before or during its active period.
-- **Manual termination**: If your events ends early or you didn't set an end time, you can manually stop the scheduler using the [Terminate scheduler](/theolive/api/schedulers/terminate-scheduler) endpoint.
-- **Deleting a scheduler**: If the scheduler hasnβt started yet, it can be removed using the [Delete scheduler](/theolive/api/schedulers/delete-scheduler) endpoint.
-- **Accessing usage reports**: About 15 minutes after a scheduler has ended or been terminated, a detailed report becomes available via the [Get scheduler report](/theolive/api/schedulers/get-scheduler-report) endpoint.
+### API example β Manually start a scheduler
-## Scheduler management in the console
+`POST https://api.theo.live/v2/schedulers/{schedulerId}/start`
-You can view the status of all schedulers at any time, including those that are active, pending, or terminated.
+### API example β Manually stop a scheduler
-Active schedulers cannot be deleted.
+`POST https://api.theo.live/v2/schedulers/{schedulerId}/stop`
+
+---
-
+## Deleting a Scheduler
-When creating a new or managing an existing scheduler, you can pass a name, start and (optional) end date, and select the channels that are part of this scheduler and should start and stop at the given timestamps.
+A confirmation dialog will appear. Deletion of a non-active scheduler can be done at any time and is permanent and cannot be undone.
-As a user, you can also pass an optional _Client ID_, which is an ID you can use for your reference. You can also pass a metadata object, which consists of key-value pairs.
+> **Note:** You cannot delete a scheduler while it is active. Stop it first, then delete.
-When creating a new scheduler or managing an existing one, you can specify the following:
+### API example β Delete a scheduler
-- **Name**: A custom name for the scheduler.
-- **Start and End Dates**: Define the start time, and optionally, the end time.
-- **Channels**: Select the channels that will be part of this scheduler, specifying which should start and stop at the defined times.
-- **Repeat schedule**: Allow the specified schedule to be repeated based on settings.
+`DELETE https://api.theo.live/v2/schedulers/{schedulerId}`
-In addition, you can include the following optional fields as a user:
+---
+
+## Schedulers on the Channel Detail Page
+
+When viewing an individual channel, the **Channel Details** card shows a **Schedulers** section:
+
+- If the channel has connected schedulers, a badge shows the count (e.g. "2 schedulers") and an "Active" indicator if any scheduler is currently running.
+- Click the badge to open a dialog listing all non-terminated schedulers connected to that channel, along with their schedule summaries and next-run dates.
+- Click any scheduler row in the dialog to navigate to the schedulers overview page.
+
+
+
+---
-- **Client ID**: A unique identifier for your reference.
-- **Metadata Object**: A set of key-value pairs that you can use to store additional custom information.
+## Tips
-
+- **Plan your timezone carefully.** The scheduler operates in the timezone you select, not your local browser timezone. All start/end times are interpreted in the selected timezone.
+- **Use recurring schedules for regular events.** Rather than creating a new one-time scheduler for each event, set up a recurring schedule once and let it run.
+- **Disable instead of deleting.** If you need to pause a recurring schedule temporarily, disable it rather than deleting and recreating it.
+- **Check the "Next run" indicator.** For idle recurring schedulers, the table shows when the next occurrence will fire, so you can verify the schedule is correct.
+- **Start dates must be in the future.** When creating a new scheduler, the start date and time must be in the future (relative to the selected timezone).
diff --git a/theolive/platform/security/_category_.json b/theolive/platform/security/_category_.json
deleted file mode 100644
index c9fdf17d52a0..000000000000
--- a/theolive/platform/security/_category_.json
+++ /dev/null
@@ -1,6 +0,0 @@
-{
- "label": "Security",
- "customProps": {
- "icon": "π"
- }
-}
diff --git a/theolive/platform/security/geo-blocking.md b/theolive/platform/security/geo-blocking.md
deleted file mode 100644
index b983c97d6d15..000000000000
--- a/theolive/platform/security/geo-blocking.md
+++ /dev/null
@@ -1,103 +0,0 @@
-# Geo-blocking
-
-Geo-blocking refers to the action of restricting ("blacklisting") or allowing ("whitelisting") access to certain content based on the geographical location of the user. Filtering can be allowed or denied by countries as well as [IP addresses](./ip-blocking.md). Geo-blocking enables content providers to adhere to specific licensing agreements and distribution rights, protect copyrighted material, or service another layer of privacy when working on private content.
-
-Geo-blocking can be configured via the API or the console.
-
-## Geo-blocking via the API
-
-### Main channel
-
-You can enable geo-blocking on a channel by [updating](../../api/update-channel.api.mdx) the `geoBlocking` object within `publicationConfig`. The `mode` of geo-blocking can also be configured:
-
-- `whitelist`: Used by default when no `mode` is passed. This will make the content only available in the countries that have been specified in the `countries` property. Countries not listed in the `countries` property will not receive the stream.
-- `blacklist`: Blocks the content in the countries that have been specified in the `countries` property. All other countries not specified in the `countries` property will be able to view the content.
-
-:::tip
-Countries should be passed in [ISO 3166-1 alpha-2 codes](https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2)
-:::
-
-For example: If you want to restrict the viewers of your content to only Belgium and Germany, you can pass the following request:
-
-```json Enable geo-blocking on a channel
-{
- "publicationConfig": {
- "geoBlocking": {
- "enabled": true,
- "countries": ["BE", "DE"],
- "mode": "whitelist"
- }
- }
-}
-```
-
-If you would like to disable geo-blocking on this channel, you can pass the same request as above, but with:
-
-- `"enabled": false`
-- `countries` can be omitted as it will be ignored
-
-```json Enable geo-blocking on a channel
-{
- "publicationConfig": {
- "geoBlocking": {
- "enabled": false,
- "mode": "whitelist"
- }
- }
-}
-```
-
-If you would like to make your content available anywhere **except** Belgium, you can pass the following request:
-
-```json Use blacklist geo-block
-{
- "publicationConfig": {
- "geoBlocking": {
- "enabled": true,
- "countries": ["BE"],
- "mode": "blacklist"
- }
- }
-}
-```
-
-### Channel alias
-
-Geo-blocking can also be done on a [channel alias](../multi-channel.md) using the specified channel alias [endpoint](/theolive/api/channels/update-channel-alias) or via the console.
-
-## Geo-blocking on main channel and alias
-
-Combining geo-blocking rules on both the main channel and aliases can allow you to create custom rules on where your content can be viewed in the world.
-
-For example, a stream you have created must adhere to the following rules:
-
-- Customer 1 can only show the stream to Belgian viewers
-- Customer 2 can only show the stream to UK and USA viewers
-- Customer 3 can only show the stream to French viewers
-
-In this scenario, you can create 3 aliases of your main channel, one for each customer. This allows you to set custom geo-blocking rules for each customer as well as [track customer specific analytics](../multi-channel.md).
-
-The main channel's `channel-id` won't be used, we so can geo-block it completely. This means someone using this channel ID will not be able to see it anywhere in the world.
-
-We will configure the 3 aliases with the following configurations:
-
-- Customer 1 will use channel ID `alias-1` where we `enable` geo-blocking and restrict the access to `BE` using `whitelist` in the the `mode` property.
-- Customer 2 will use channel ID `alias-2` where we `enable` geo-blocking and restrict the access to `UK` and `US` using `whitelist` in the the `mode` property.
-- Customer 3 will use channel ID `alias-3` where we `enable` geo-blocking and restrict the access to `FR` using `whitelist` in the the `mode` property.
-
-
-
-## Geo-blocking via the console
-
-Updating geo-blocking settings can also be done via the console. Navigate to your channel's details page and scroll down to the playout configurations panel. Select the your default channel or alias and click on the security tabs. If you don't have an alias, click the _Create Alias_ button on the top right of the panel.
-
-Clicking the toggle button can enable and disable geo-blocking on the specified channel. When enabled, a mode can be selected and countries can be added to the list.
-
-Don't forget to hit "Save" to apply your changes.
-
-
-
-## Feature compatibility and limitations
-
-- Geo-blocking can be enabled or disabled during the middle of a stream without needing to restart the channel or restart ingests
-- IP-blocking for a specified CIDR will not work if geo-blocking is enabled for the country or region where the CIDR originates from
diff --git a/theolive/platform/security/ip-blocking.md b/theolive/platform/security/ip-blocking.md
deleted file mode 100644
index 772a7244a7b9..000000000000
--- a/theolive/platform/security/ip-blocking.md
+++ /dev/null
@@ -1,48 +0,0 @@
-# IP-blocking
-
-IP-blocking (or IP-banning) refers to a security measure that restricts access to content for specific IP addresses. Filtering can be allowed or denied by IP addresses or by [countries](./geo-blocking.md) as well. Only IPv4 and IPv6 CIDRs (Classless Inter-Domain Routing) are allowed.
-
-IP-blocking can be configured via the API or the console.
-
-## IP-blocking via the API
-
-### Main channel
-
-You can enable IP-blocking on a channel by [updating](../../api/update-channel.api.mdx) the `ipBlocking` object within `publicationConfig`. The `mode` of geo-blocking can also be configured:
-
-- `whitelist`: Used by default when no `mode` is passed. This will make the content only available for the CIDRs that have been specified in the `cidrs` property. CIDRs not listed in the `cidrs` property will not receive the stream.
-- `blacklist`: Blocks the content for the CIDRs that have been specified in the `cidrs` property. All CIDRs not specified in the `cidrs` property will be able to view the content.
-
-For example: If you want to restrict certain CIDRs from viewing your content, you can pass the following request:
-
-```json Enable ip-blocking on a channel
-{
- "publicationConfig": {
- "ipBlocking": {
- "enabled": true,
- "mode": "whitelist",
- "cidrs": ["170.123.145.2", "170.123.145.3"]
- }
- }
-}
-```
-
-### Channel Alias
-
-IP-blocking can also be done on a [channel alias](../multi-channel.md) using the specified channel alias [endpoint](/theolive/api/channels/update-channel-alias) or via the console.
-
-## IP-blocking via the console
-
-Updating IP-blocking settings can also be done via the console. Navigate to your channel's details page and scroll down to the playout configurations panel. Select the your default channel or alias and click on the security tabs. If you don't have an alias, click the _Create Alias_ button on the top right of the panel.
-
-Clicking the toggle button can enable and disable IP-blocking on the specified channel. When enabled, a mode can be selected and CIDRs can be added to the list.
-
-Don't forget to hit "Save" to apply your changes.
-
-
-
-## Feature compatibility and limitations
-
-- IP-blocking can be enabled or disabled during the middle of a stream without needing to restart the channel or restart ingests
-- IP-blocking for a specified CIDR will not work if geo-blocking is enabled for the country or region where the CIDR originates from
-- IP-blocking only allows IPv4 and IPv6 CIDRs
diff --git a/theolive/platform/security/token-based-security.mdx b/theolive/platform/security/token-based-security.mdx
deleted file mode 100644
index f5a4716a2dd2..000000000000
--- a/theolive/platform/security/token-based-security.mdx
+++ /dev/null
@@ -1,58 +0,0 @@
-# Token based security
-
-THEOlive offers the option to enable JWT token security for your distribution (formerly referred to as an alias). This can be interesting if you only want valid users to access your stream.
-
-In this document, we will
-
-- explain how it works
-- how to enable/disable it via the console and API
-- how to configure your THEOplayer to pass the mandatory headers
-
-## How it works
-
-When enabling token security on a distribution, we expect you to share the shared (private) key in case of HS256/HS512 or the public key in case of RS256/RS512 encryption. This will be used on CDN level to determine if a request (with a Bearer token passed in the `Authorization` header) is valid or not. It's up to you to configure this header correctly through our player. Later in this document we will explain how.
-
-In the bearer token that gets sent to us, we _require_ the following properties to be provided in the `payload`:
-
-- `exp`: date in epoch format until which the JWT token is valid
-- `nbf`: optional date in epoch format. Stands for "not before" and acts as a "start date" of the JWT to be valid.
-
-When not passing a bearer token for a secured distribution, the request will be rejected. If the distribution is not secured, you may still pass a token but it is not required.
-
-
-
-Putting it all together, here is an example of a token `payload`:
-
-```json
-{
- "nbf": 1750786626 // optional, viewers attempting to connect before this time will not be permitted
- "exp": 1750796626 // required, must be a valid time in the future to allow viewer access
-}
-```
-
-To view an example token, you can paste the following token into the [jwt.io debugger](https://jwt.io/#token=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpYXQiOjE3NTA4MTM5NDAsImV4cCI6MTc1MDgxNDU0MH0.hGnLRGO09AXNzMHgHLLz1HJ-9mRfDf-PnOd20w9CQmI):
-
-```
-eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpYXQiOjE3NTA4MTM5NDAsImV4cCI6MTc1MDgxNDU0MH0.hGnLRGO09AXNzMHgHLLz1HJ-9mRfDf-PnOd20w9CQmI
-```
-
-It was signed with the following random secret: `d2e166fdda89824a6c493d8a2af7a0754199eff9e38c579cba8783767a44039c`.
-
-## Enable or disable token security for an alias
-
-Please refer to the [Enable token security for alias](/theolive/api/channels/enable-token-security-for-alias) and [Disable token security for alias](/theolive/api/channels/disable-token-security-for-alias) API endpoints to manage the token security settings for an alias.
-
-When enabling for the first time, you have to pass the `key` property in the body. If you disable token security later on, and make it active again, you can omit this property if it should stay the same.
-
-If you're using the [THEOlive management console](https://console.theo.live), you can navigate to the player details page and select the alias you want to enable/disable token security for. When enabling, please pass the correct shared or public key to use. **Don't forget to confirm your changes by hitting the save button!**
-
-
-
-## Configuring THEOplayer to pass the necessary headers
-
-Refer to our platform specific guides for details on how to setup JWT security for your channels and information on any known limitations.
-
-- [React Native](../../playback/react-native/token-based-security.mdx)
-- [Web](../../playback/web/token-based-security.mdx)
-- [Android](../../playback/android/token-based-security.mdx)
-- [Roku](../../playback/roku/01-token-based-security.mdx)
diff --git a/theolive/platform/thumbnails-manifests.mdx b/theolive/platform/thumbnails-manifests.mdx
deleted file mode 100644
index 1914153e2051..000000000000
--- a/theolive/platform/thumbnails-manifests.mdx
+++ /dev/null
@@ -1,47 +0,0 @@
----
-sidebar_position: 5
-sidebar_label: Thumbnails and HLS
----
-
-# Thumbnails Images and HLS
-
-Thumbnail images representing what is currently happening in a live stream are available for populating a player poster frame, a scrollable list of available streams, and the like.
-
-Manifests for HLS fallback of THEOlive streams are available for serving a stream to a device that cannot deploy an OptiView player.
-
-Both thumbnails and HLS manifests are available from a deterministic URL.
-
-## Getting Thumbnail Images
-
-Thumbnails are available as jpeg images with URLs in the following format:
-
-```text
-http://discovery.theo.live/channels//stream/thumbnail.jpeg
-```
-
-- `channelId` is the identifier of the channel you wish to get the thumbnail for
-- There is currently no ability to control the size or compression level of a thumbnail image
-
-An example thumbnail image and URL for a channel:
-
-```text
-http://discovery.theo.live/channels/ar5c53uzm3si4h4zgkzrju44h/stream/thumbnail.jpeg
-```
-
-
-
-## Getting HLS Manifests
-
-HLS manifests are available in the following URL format:
-
-```text
-http://discovery.theo.live/channels//stream/main.m3u8
-```
-
-- `channelId` is the identifier of the channel you wish to get the HLS manifest for
-
-An example HLS manifest URL for a channel:
-
-```text
-http://discovery.theo.live/channels/ar5c53uzm3si4h4zgkzrju44h/stream/main.m3u8
-```
diff --git a/theolive/platform/viewer-insights.mdx b/theolive/platform/viewer-insights.mdx
index 92919bf63230..cfc83d83b3be 100644
--- a/theolive/platform/viewer-insights.mdx
+++ b/theolive/platform/viewer-insights.mdx
@@ -1,76 +1,13 @@
---
sidebar_position: 7
+sidebar_label: Viewer insights
+sidebar_custom_props:
+ icon: π
+description: Monitor concurrent viewers, latency, locations and platforms in real time.
---
-# Viewer Insights
-
-## Easily monitor and analyze viewer behavior of your live stream
-
-Curious about who's watching your live stream in real timeβand where they're located? Want to track when viewers join or leave your stream? These are just a few of the valuable viewer insights you can access to better understand audience behavior and optimize future streams.THEOlive provides detailed viewer insights for every user.
-
-This guide explains the types of viewer insights available for your THEOlive channel and shows you where to find them in the platform.
-
-## How to access viewer insights
-
-Viewer insights are available for each channel and can be accessed from your channel page.
-To view them, go to the _Details_ tab and click on _Viewer Insights_. The screenshot below highlights where to find this option.
-
-Each channel has its own dedicated viewer insights page. If you're running multiple channels at the same time (including any failover channels), you'll need to repeat this process for each one individually.
-
-
-
-## Analyzing viewer insights
-
-The viewer insights page of your channel includes:
-
-- Main channel information
-- Viewer sessions
-- Viewer latency
-- Viewer locations
-- Top browser and operating systems
-
-:::warning[Must use THEOlive in THEOplayer to receive viewer insights]
-
-Viewer insights will only work if you are using THEOlive inside a THEOplayer. Please refer to [this guide](../playback/web/getting-started.mdx) for implementation details.
+# Viewer insights
+:::info[Coming soon]
+Documentation for this feature is currently being written.
:::
-
-### Main channel information
-
-The top section displays key information about your channel, including the **channel ID**, channel **name**, and current **status**. This helps you confirm that you're viewing the correct channel data and whether the stream is currently live.
-
-At the bottom of this section, youβll find a selector to choose the **period** for the viewer insights graphs. You can choose from several time periodsβranging from _Last hour_ to _Last 30 days_. The data shown in the sections below will adjust based on the selected time range.
-
-
-
-### Viewer sessions
-
-This graph displays the number of concurrent viewer sessions during the selected time period. It also highlights the current number of active sessions, giving you real-time insight into how many viewers are watching your live stream at any given moment.
-
-
-
-### Viewer latency
-
-When interactivity matters, ultra-low latency is crucial.
-
-The next graph displays the viewer latency over the selected time period, showing the percentage of viewers who experienced a specific median latency value. For example, the graph may indicate that most viewers had a latency between 550ms and 950ms, with an overall median latency of 834ms. This helps you assess how closely your stream approaches real-time delivery.
-
-
-
-### Viewer locations
-
-Want to know where your viewers are tuning in from? The next table displays the geographic distribution of your viewers, showing the cities or locations they connected from and the number of connections per location.
-
-You can sort the table by any column (in ascending or descending order) and adjust the number of rows displayed per page to better explore the data.
-
-
-
-### Top browser and operating systems
-
-Curious about how your viewers are watching your streamβon mobile, desktop, or other platforms?
-
-The final table on the Viewer Insights page breaks down viewership by browser, browser version, operating system, and OS version. This helps you understand what devices and environments your audience is using.
-
-You can sort the table by browser, operating system, or session count (ascending or descending), and adjust the number of rows displayed per page to suit your needs.
-
-
diff --git a/theolive/platform/viewer-tracking.mdx b/theolive/platform/viewer-tracking.mdx
deleted file mode 100644
index 8c42c07db624..000000000000
--- a/theolive/platform/viewer-tracking.mdx
+++ /dev/null
@@ -1,59 +0,0 @@
----
-sidebar_position: 7
-sidebar_label: Viewer Tracking
-title: Viewer Tracking
----
-
-import CalloutPremiumFeature from '../callouts/_premium_feature.md';
-
-
-
-# Tracking Viewers
-
-With THEOlive, you can syndicate content through multiple distribution partners while utilizing the same channel, or alternatively track different groups through aliases. This can be helpful for aggregating viewing and billing data for a group of viewers.
-
-Additionally, when using the advanced reporting feature, you might want to assign tracking metadata to individual viewers to post-process later in your data and BI analysis tools. This is all possible with our viewer tracking workflows.
-
-## Tracking Workflow
-
-The following is an **example workflow** for setting up stream tracking:
-
-1. Create a THEOlive channel
-1. Enable [_Token Security_](security/token-based-security.mdx) on the channel or alias
-1. When you create your self-signed token, add one or both of the following parameters to a `streaming` object in the `payload` of your JWT:
- - **trackingId**: Groups viewers of the same channel, allows you to get the aggregated bandwidth usage of all viewers. This is useful for billing a single channel or alias if you use multiple distribution partners and want aggregated billing metrics back or viewer reports for groups of viewers. The maximum size is 128 characters
- - **customViewerData** : Access the bandwidth consumption of each viewer for analytics purposes and passthrough metadata from your CMS for a viewer and be able to retrieve it in a viewer report. This data is not parsed by our system and can be a series of key-value pairs for you to extract later. The maximum size is 1024 characters
-1. Pass the JWT through to the player as described in the [_Token Security_](security/token-based-security.mdx) section
-1. To get _Advanced Reports_, including user-reports, please contact your Dolby representative for access.
-
-_Note: Either or both `trackingId` and/or `customViewerData` may be used depending on what kind of tracking you need to achieve._
-
-To put it all together, here is an example `payload` for a JWT that includes sample `trackingId` and `customViewerData`:
-
-```json
-{
- "streaming": {
- "tracking": {
- "trackingId": "groupAbc"
- },
- "customViewerData": "user=user123;appVersion=x.y.x",
- "tokenType": "Subscribe"
- },
- "iat": 1750813271,
- "exp": 1750813871 // required for the token to be valid
-}
-```
-
-Here is the JWT that is used to generate this token, you can paste it into [jwt.io](https://jwt.io/#token=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdHJlYW1pbmciOnsidHJhY2tpbmciOnsidHJhY2tpbmdJZCI6Imdyb3VwQWJjIn0sImN1c3RvbVZpZXdlckRhdGEiOiJ1c2VyPXVzZXIxMjM7YXBwVmVyc2lvbj14LnkueCIsInRva2VuVHlwZSI6IlN1YnNjcmliZSJ9LCJpYXQiOjE3NTA4MTMyNzEsImV4cCI6MTc1MDgxMzg3MX0.OvIZAvs6XL4KQ8YTtIdjdJNZ5oS6Jkosj3mq274gdrw).
-
-```text
-eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdHJlYW1pbmciOnsidHJhY2tpbmciOnsidHJhY2tpbmdJZCI6Imdyb3VwQWJjIn0sImN1c3RvbVZpZXdlckRhdGEiOiJ1c2VyPXVzZXIxMjM7YXBwVmVyc2lvbj14LnkueCIsInRva2VuVHlwZSI6IlN1YnNjcmliZSJ9LCJpYXQiOjE3NTA4MTMyNzEsImV4cCI6MTc1MDgxMzg3MX0.OvIZAvs6XL4KQ8YTtIdjdJNZ5oS6Jkosj3mq274gdrw
-```
-
-To see the validation tool validate the token, insert the random secret used to sign the token: `d2e166fdda89824a6c493d8a2af7a0754199eff9e38c579cba8783767a44039c`.
-
-### Notes
-
-- Tracking can be used independently of secure channels. You can pass the same payload parameters in a JWT, however, we require that the token is "valid". This means that the required date fields _must_ be valid or the token will be ignored. If a channel does not have token security enabled, however, be aware that anyone can view the channel with or without a jwt token. If secure channels are not enabled, the signature is not validated, so there is a risk that a user _could_ change the values
-- If you are combining our OptiView real-time (Millicast) streaming solution and our live streaming solution (THEOlive), you may use the _secret_ from the Millicast subscriber token as the secret you provide to THEOlive and you can use the same JWTs across both streaming products
-- `tokenType` should be set to `Subscribe`
diff --git a/theolive/playback/android/_category_.json b/theolive/playback/android/_category_.json
deleted file mode 100644
index cc5eade20799..000000000000
--- a/theolive/playback/android/_category_.json
+++ /dev/null
@@ -1,8 +0,0 @@
-{
- "label": "Android",
- "description": "Start with THEOlive on Android smartphones, tablets and TVs.",
- "position": 2,
- "customProps": {
- "icon": "android"
- }
-}
diff --git a/theolive/playback/flutter/_category_.json b/theolive/playback/flutter/_category_.json
deleted file mode 100644
index 8b7a7f2eb783..000000000000
--- a/theolive/playback/flutter/_category_.json
+++ /dev/null
@@ -1,8 +0,0 @@
-{
- "label": "Flutter",
- "description": "Start with THEOlive on cross-platform apps with Flutter.",
- "position": 3,
- "customProps": {
- "icon": "flutter"
- }
-}
diff --git a/theolive/playback/further-feature-support.md b/theolive/playback/further-feature-support.md
deleted file mode 100644
index 25f3573625e0..000000000000
--- a/theolive/playback/further-feature-support.md
+++ /dev/null
@@ -1,12 +0,0 @@
----
-sidebar_position: 16
-sidebar_label: Further Feature Support in the Player
----
-
-# Further Feature Support
-
-The Dolby OptiView Streaming platform uses the [OptiView Player](/theoplayer/getting-started/sdks/web/getting-started/) for playback. Because this player operates on the client side, it may support additional features beyond basic streaming β such as UI controls, ad insertion, or advanced APIs.
-
-However, not all features available in the OptiView Player have been tested or verified with HESP-based OptiView streams. Some capabilities may work as expected, while others might be incompatible or require additional integration.
-
-If you're exploring extended functionality, we recommend checking the [OptiView Player documentation](/theoplayer/getting-started/sdks/web/getting-started/) for potential capabilities. Keep in mind that any features not explicitly documented by the OptiView team are not officially supported within our Streaming solution. For guidance on implementation or to confirm compatibility, please reach out to the OptiView support team.
diff --git a/theolive/playback/hls.mdx b/theolive/playback/hls.mdx
deleted file mode 100644
index b436c3b19380..000000000000
--- a/theolive/playback/hls.mdx
+++ /dev/null
@@ -1,14 +0,0 @@
----
-sidebar_position: 15
-sidebar_label: HLS
----
-
-# HLS on older platforms
-
-THEOlive uses the HESP protocol to deliver high quality at very low latencies. However, HESP only works on platforms
-that have streaming HTTP requests. On very old devices like 2015 smart TV's this is not possible and hence low-latency
-streaming is not really possible on those devices. Therefore, when there is no streaming HTTP we fallback to HLS.
-
-HLS has the advantage that it plays on almost any device, but with higher latency. So on those old Smart TV's, you will
-still get playback, but the latency will be a lot higher than on your modern laptop. The latency on HLS will be around
-10 seconds.
diff --git a/theolive/playback/ios/_category_.json b/theolive/playback/ios/_category_.json
deleted file mode 100644
index 0f9122e27322..000000000000
--- a/theolive/playback/ios/_category_.json
+++ /dev/null
@@ -1,8 +0,0 @@
-{
- "label": "iOS",
- "description": "Start with THEOlive on iOS/tvOS.",
- "position": 2,
- "customProps": {
- "icon": "π"
- }
-}
diff --git a/theolive/playback/optiview-player.mdx b/theolive/playback/optiview-player.mdx
new file mode 100644
index 000000000000..8230b01a9d02
--- /dev/null
+++ b/theolive/playback/optiview-player.mdx
@@ -0,0 +1,24 @@
+---
+sidebar_position: 1
+sidebar_label: OptiView Player
+---
+
+# OptiView Player
+
+The Dolby OptiView Streaming platform uses the [OptiView Player](/theoplayer/) for playback. The player is available on a wide range of platforms and supports HESP and HLS streaming, along with features like UI controls, ad insertion, and advanced APIs.
+
+## Supported platforms
+
+For platform-specific guides on integrating OptiView live streaming, refer to:
+
+- [Web](/theoplayer/how-to-guides/web/theolive/getting-started/)
+- [Android](/theoplayer/how-to-guides/android/theolive/getting-started/)
+- [iOS](/theoplayer/how-to-guides/ios/theolive/getting-started/)
+- [React Native](/theoplayer/how-to-guides/react-native/theolive/getting-started/)
+- [Flutter](/theoplayer/how-to-guides/flutter/theolive/getting-started/)
+- [Roku](/theoplayer/how-to-guides/roku/theolive/getting-started/)
+
+## HESP limitations
+
+- **Device compatibility** β HESP requires support for streaming HTTP requests, which is not available on very old devices such as 2015 smart TVs. On those devices, the player automatically falls back to HLS, which plays on almost any device but with higher latency β typically around 10 seconds.
+- **Feature compatibility** β Not all streaming protocol features (like liveoffset, ...), available in the OptiView Player, have been tested or verified with HESP streams. For guidance on compatibility, please reach out to the OptiView support team.
diff --git a/theolive/playback/other-hls-player.mdx b/theolive/playback/other-hls-player.mdx
new file mode 100644
index 000000000000..70edc48ff6c8
--- /dev/null
+++ b/theolive/playback/other-hls-player.mdx
@@ -0,0 +1,29 @@
+---
+sidebar_position: 2
+sidebar_label: Other HLS player
+sidebar_custom_props:
+ icon: πΊ
+description: Play streams directly via HLS on devices like Chromecast or set-top boxes.
+---
+
+# Other HLS player
+
+When using THEOplayer, the player automatically discovers a distribution and selects the appropriate streaming protocol. However, for certain use cases you may need direct access to the HLS manifest URL β for example, to cast to a Chromecast device, play on a set-top box, or integrate with a third-party player.
+
+The HLS manifest is accessible at a deterministic URL:
+
+```text
+https://discovery.theo.live/v2/distributions//hls/main.m3u8
+```
+
+Replace `` with your distribution identifier.
+
+For HLS-TS specifically, the manifest is available at:
+
+```text
+https://discovery.theo.live/v2/distributions//hls-ts/main.m3u8
+```
+
+:::warning
+The HLS-TS URL only works if HLS-TS output is enabled on the engine. See the [streaming protocols](../media-engine/streaming-protocols.mdx) guide for more information.
+:::
diff --git a/theolive/playback/react-native/_category_.json b/theolive/playback/react-native/_category_.json
deleted file mode 100644
index 44af645b9c1c..000000000000
--- a/theolive/playback/react-native/_category_.json
+++ /dev/null
@@ -1,8 +0,0 @@
-{
- "label": "React Native",
- "description": "Start with THEOlive on React Native.",
- "position": 3,
- "customProps": {
- "icon": "βοΈ"
- }
-}
diff --git a/theolive/playback/roku/02-migrating-to-v2.mdx b/theolive/playback/roku/02-migrating-to-v2.mdx
deleted file mode 100644
index 65ff6f43ce9d..000000000000
--- a/theolive/playback/roku/02-migrating-to-v2.mdx
+++ /dev/null
@@ -1,28 +0,0 @@
----
-sidebar_position: 2
-sidebar_label: Migrating to THEOlive v2
----
-
-# Migrating to THEOlive v2
-
-If you are using THEOlive v2 for your live streams, you will need to do some extra configuration to successfully play back your THEOlive streams on Roku.
-
-## Initial Setup
-
-1. Follow [our Getting Started guide](/theoplayer/getting-started/sdks/roku/getting-started)
- to set up THEOplayer in your Roku app.
-2. Add a THEOlive source to your player's source.
-
-### Configure THEOlive for v2
-
-THEOlive v2 sources do not use the default discovery URL (https://discovery.theo.live/v2/publications/). In order to use v2, you will need to specify one or more discovery URLs. On the player configuration object, you may add the discovery URLs using the `theoLive` property on the player configuration.
-
-```brightscript
-playerConfiguration = {
- license: "",
- theoLive: {
- discoveryUrls: ["https://discovery.theo.live/v2/distributions/"]
- }
-}
-m.player.callFunc("configure", playerConfiguration)
-```
diff --git a/theolive/playback/roku/_category_.json b/theolive/playback/roku/_category_.json
deleted file mode 100644
index 339e3eaf6910..000000000000
--- a/theolive/playback/roku/_category_.json
+++ /dev/null
@@ -1,8 +0,0 @@
-{
- "label": "Roku",
- "description": "Start with THEOlive on Roku smart TVs.",
- "position": 4,
- "customProps": {
- "icon": "πΊ"
- }
-}
diff --git a/theolive/playback/web/_category_.json b/theolive/playback/web/_category_.json
deleted file mode 100644
index 89bafcf65869..000000000000
--- a/theolive/playback/web/_category_.json
+++ /dev/null
@@ -1,8 +0,0 @@
-{
- "label": "Web",
- "description": "Start with THEOlive on web with the JavaScript player.",
- "position": 1,
- "customProps": {
- "icon": "web"
- }
-}
diff --git a/theolive/playback/web/casting/airplay.mdx b/theolive/playback/web/casting/airplay.mdx
deleted file mode 100644
index 7488a68c45da..000000000000
--- a/theolive/playback/web/casting/airplay.mdx
+++ /dev/null
@@ -1,8 +0,0 @@
----
-title: Airplay
-sidebar_position: 1
----
-
-# Airplay
-
-THEOlive streams have support for Airplay. However, a limitation for now is that the latency is higher while casting (about 12 seconds). Configuring it is exactly the same as for other streams you would play with THEOplayer. The instructions are described in the [Airplay guide](/theoplayer/how-to-guides/cast/airplay/introduction/).
diff --git a/theolive/playback/web/casting/chromecast.mdx b/theolive/playback/web/casting/chromecast.mdx
deleted file mode 100644
index 6a5cdcae0762..000000000000
--- a/theolive/playback/web/casting/chromecast.mdx
+++ /dev/null
@@ -1,8 +0,0 @@
----
-title: Chromecast
-sidebar_position: 2
----
-
-# Chromecast
-
-THEOlive streams have support for Chromecast. However, a limitation for now is that the latency is higher while casting (about 12 seconds). Configuring it is exactly the same as for other streams you would play with THEOplayer. The instructions are described in the [Chromecast guide](/theoplayer/how-to-guides/cast/chromecast/enable-chromecast-on-the-sender/).
diff --git a/theolive/troubleshooting.mdx b/theolive/troubleshooting.mdx
index 9605ba187e3a..3f73de47c210 100644
--- a/theolive/troubleshooting.mdx
+++ b/theolive/troubleshooting.mdx
@@ -1,5 +1,9 @@
---
sidebar_position: 12
+sidebar_label: Troubleshooting
+sidebar_custom_props:
+ icon: π οΈ
+description: Common issues and debugging tips.
---
# Troubleshooting
@@ -12,8 +16,8 @@ The network speed and bandwidth takes a crucial role in video delivery. Therefor
Some known issues and advisable configuration items:
-| Topic | Description |
-| -------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| What is the list of FQDNs THEOlive player is using? | https://theolive-anywhere.global.ssl.fastly.net https://theolive.global.ssl.fastly.net https://cdn.tla-prd.theostream.live https://discovery.theo.live https://theo-insights-prod-5cb0.ew.r.appspot.com https://time.akamai.com |
-| Why is my corporate VPN having issues when playing THEOlive streams? | In the past, we have seen 2 possible reasons for poor VPN playback: - The VPN might have a security gateway that does packet inspection. It is very important that all THEOlive domains are whitelisted so network requests are allowed to go through the VPN at real-time speeds. - The overhead of the VPN connection does not meet the bandwidth & network stability to play. |
-| Packet inspection | Packet inspection software (e.g. Zscaler) can have a negative impact on play-out causing buffering and stalling of the THEOlive stream. |
+| Topic | Description |
+| ------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| What is the list of FQDNs the player is using? | https://theolive-anywhere.global.ssl.fastly.net https://theolive.global.ssl.fastly.net https://cdn.tla-prd.theostream.live https://discovery.theo.live https://theo-insights-prod-5cb0.ew.r.appspot.com https://time.akamai.com |
+| Why is my corporate VPN having issues during playback? | In the past, we have seen 2 possible reasons for poor VPN playback: - The VPN might have a security gateway that does packet inspection. It is very important that all domains listed above are whitelisted so network requests are allowed to go through the VPN at real-time speeds. - The overhead of the VPN connection does not meet the bandwidth & network stability to play. |
+| Packet inspection | Packet inspection software (e.g. Zscaler) can have a negative impact on play-out causing buffering and stalling of the stream. |
diff --git a/theolive_versioned_docs/version-v1/playback/android/getting-started.mdx b/theolive_versioned_docs/version-v1/playback/android/getting-started.mdx
index bbc876ce8648..49b32384e8a1 100644
--- a/theolive_versioned_docs/version-v1/playback/android/getting-started.mdx
+++ b/theolive_versioned_docs/version-v1/playback/android/getting-started.mdx
@@ -10,7 +10,7 @@ To begin with the Dolby OptiView platform please review our guide for getting st
1. Support for THEOlive comes out of the box with the THEOplayer for Android. Please follow [this guide for installing the Player SDK](/theoplayer/getting-started/sdks/android/getting-started/) for Android development.
-2. Once the Player is installed, continue following the guide for setting up the player. Please note that THEOplayer licenses can be found for streaming customers [here](theolive/getting-started.mdx#obtaining-a-player-license-for-theolive) in the THEOlive dashboard.
+2. Once the Player is installed, continue following the guide for setting up the player. Please note that THEOplayer licenses can be found for streaming customers [here](../../getting-started.mdx#obtaining-a-player-license-for-theolive) in the THEOlive dashboard.
3. With the player installed and set up with a valid license, you can now import the `THEOliveSource` object from the SDK:
diff --git a/theoplayer/how-to-guides/android/theolive/_category_.json b/theoplayer/how-to-guides/android/theolive/_category_.json
new file mode 100644
index 000000000000..89be9f6ffdbd
--- /dev/null
+++ b/theoplayer/how-to-guides/android/theolive/_category_.json
@@ -0,0 +1,7 @@
+{
+ "label": "OptiView Live",
+ "description": "Integrate OptiView Live streaming into your Android app.",
+ "customProps": {
+ "icon": "π"
+ }
+}
diff --git a/theolive/playback/android/getting-started.mdx b/theoplayer/how-to-guides/android/theolive/getting-started.mdx
similarity index 82%
rename from theolive/playback/android/getting-started.mdx
rename to theoplayer/how-to-guides/android/theolive/getting-started.mdx
index bbc876ce8648..80eb31c56178 100644
--- a/theolive/playback/android/getting-started.mdx
+++ b/theoplayer/how-to-guides/android/theolive/getting-started.mdx
@@ -2,15 +2,15 @@
sidebar_position: 1
---
-# Getting started with THEOlive on Android
+# Getting started
-To begin with the Dolby OptiView platform please review our guide for getting started with [OptiView Streaming](../../getting-started.mdx).
+To begin with the Dolby OptiView platform please review our guide for getting started with [OptiView Streaming](/theolive/next/getting-started/).
### Installing the THEOplayer for Android
-1. Support for THEOlive comes out of the box with the THEOplayer for Android. Please follow [this guide for installing the Player SDK](/theoplayer/getting-started/sdks/android/getting-started/) for Android development.
+1. Support for OptiView Live comes out of the box with the THEOplayer for Android. Please follow [this guide for installing the Player SDK](/theoplayer/getting-started/sdks/android/getting-started/) for Android development.
-2. Once the Player is installed, continue following the guide for setting up the player. Please note that THEOplayer licenses can be found for streaming customers [here](theolive/getting-started.mdx#obtaining-a-player-license-for-theolive) in the THEOlive dashboard.
+2. Once the Player is installed, continue following the guide for setting up the player. Please note that THEOplayer licenses can be found for streaming customers [here](/theolive/next/getting-started/) in the OptiView Live dashboard.
3. With the player installed and set up with a valid license, you can now import the `THEOliveSource` object from the SDK:
@@ -18,7 +18,7 @@ To begin with the Dolby OptiView platform please review our guide for getting st
import com.theoplayer.android.api.theolive.TheoLiveSource
```
-Rather than set your Player `source` as a manifest as you would for a HLS stream, you can now instead set it as a `TheoLiveSource` including your [channel alias](../../platform/multi-channel.md):
+Rather than set your Player `source` as a manifest as you would for a HLS stream, you can now instead set it as a `TheoLiveSource` including your channel alias:
```Kotlin
theoPlayer.source = SourceDescription
@@ -32,11 +32,11 @@ theoPlayer.source = SourceDescription
For testing, you can use this HESP demo source: `ar5c53uzm3si4h4zgkzrju44h` which the OptiView team [keeps live 24/7](https://demo.theo.live/?channel=ar5c53uzm3si4h4zgkzrju44h).
-From here, your THEOlive source should be ready to playback in THEOplayer.
+From here, your OptiView Live source should be ready to playback in THEOplayer.
### Adding Player Controls
-At this stage in implementation, you should have a THEOlive stream playing within your Android app. The Player SDK provides functionality for controlling stream playback which can be extended to users in the form of controls or buttons. The platform also supports an [Open Video UI for the Android SDK](pathname:///open-video-ui/android/getting-started), which provides a component library for advanced styling and control of UI components.
+At this stage in implementation, you should have an OptiView Live stream playing within your Android app. The Player SDK provides functionality for controlling stream playback which can be extended to users in the form of controls or buttons. The platform also supports an [Open Video UI for the Android SDK](pathname:///open-video-ui/android/getting-started), which provides a component library for advanced styling and control of UI components.
#### 1. Adding Play/Pause Controls
diff --git a/theolive/playback/android/token-based-security.mdx b/theoplayer/how-to-guides/android/theolive/token-based-security.mdx
similarity index 79%
rename from theolive/playback/android/token-based-security.mdx
rename to theoplayer/how-to-guides/android/theolive/token-based-security.mdx
index f126581df31e..ff0b85073d80 100644
--- a/theolive/playback/android/token-based-security.mdx
+++ b/theoplayer/how-to-guides/android/theolive/token-based-security.mdx
@@ -4,13 +4,13 @@ sidebar_position: 2
# Token based security
-THEOlive offers the option to enable JWT token security on a distribution (formerly referred to as an alias) level. This can be interesting if you only want valid users to access your stream. Read more about the feature and configuring it on your channels on the [token based security guide](../../platform/security/token-based-security.mdx).
+OptiView Live offers the option to enable JWT token security on a distribution (formerly referred to as an alias) level. This can be interesting if you only want valid users to access your stream. Read more about the feature and configuring it on your channels on the [token based security guide](/theolive/next/distribution/security/token-based-security/).
This page will demonstrate how to configure the Android SDK for playback of channels with token based security enabled.
-## Setting up the Android THEOplayer SDK for THEOlive
+## Setting up the Android THEOplayer SDK for OptiView Live
-Refer to the [getting started guide](../getting-started) for the prerequisite steps in getting the web SDK up and running for THEOlive playback.
+Refer to the [getting started guide](./getting-started.mdx) for the prerequisite steps in getting the web SDK up and running for OptiView Live playback.
## Configuring THEOplayer to pass the token
@@ -21,7 +21,7 @@ val token = getToken() // Generate or request your token, for more information c
player.theoLive.authToken = token
```
-This will ensure the player includes your authorization header on all subsequent requests it performs for playback of your THEOlive distribution.
+This will ensure the player includes your authorization header on all subsequent requests it performs for playback of your OptiView Live distribution.
## Dealing with token expiry and rotation
@@ -95,7 +95,7 @@ dependencies {
## Clearing the token
-If the token isn't needed anymore, e.g. when switching to an unprotected distribution or a non-THEOlive source altogether, the header can be simply removed as follows:
+If the token isn't needed anymore, e.g. when switching to an unprotected distribution or a non-OptiView Live source altogether, the header can be simply removed as follows:
```kotlin
player.theoLive.authToken = null;
diff --git a/theolive/playback/flutter/00-getting-started.mdx b/theoplayer/how-to-guides/flutter/theolive/00-getting-started.mdx
similarity index 70%
rename from theolive/playback/flutter/00-getting-started.mdx
rename to theoplayer/how-to-guides/flutter/theolive/00-getting-started.mdx
index 64e92e411f3e..6206f5e09b96 100644
--- a/theolive/playback/flutter/00-getting-started.mdx
+++ b/theoplayer/how-to-guides/flutter/theolive/00-getting-started.mdx
@@ -1,21 +1,21 @@
---
sidebar_position: 1
-sidebar_label: Getting Started with Flutter
+sidebar_label: Getting started
---
-# Getting Started with Flutter
+# Getting started
## Usage
-We have migrated THEOlive Flutter support to be a feature of the THEOplayer Flutter SDK.
+We have migrated OptiView Live Flutter support to be a feature of the THEOplayer Flutter SDK.
-To use Flutter for THEOlive playback, you must use the [THEOplayer Flutter SDK](https://pub.dev/packages/theoplayer) which now supports Web, Android, and iOS devices. The following steps will ensure your project is setup optimally:
+To use Flutter for OptiView Live playback, you must use the [THEOplayer Flutter SDK](https://pub.dev/packages/theoplayer) which now supports Web, Android, and iOS devices. The following steps will ensure your project is setup optimally:
1. Review the [THEOplayer Flutter SDK limitations](/theoplayer/flutter/guides/limitations/) to ensure your use case needs are supported before starting development.
-2. Follow along with the [THEOplayer Flutter SDK minimal setup guide](/theoplayer/flutter/guides/creating-minimal-app/) to setup a basic THEOlive project.
-3. Check the [THEOlive support guide](/theoplayer/flutter/guides/theolive/) for the latest THEOlive Flutter updates.
+2. Follow along with the [THEOplayer Flutter SDK minimal setup guide](/theoplayer/flutter/guides/creating-minimal-app/) to setup a basic OptiView Live project.
+3. Check the [THEOlive support guide](/theoplayer/flutter/guides/theolive/) for the latest OptiView Live Flutter updates.
-For customers currently using the now deprecated THEOlive SDK for playback, please migrate to using the THEOplayer SDK with the following [THEOlive migration guide](/theoplayer/flutter/guides/theolive/#migration-from-theolive-flutter-sdk-to-theoplayer-flutter-sdk)
+For customers currently using the now deprecated OptiView Live SDK for playback, please migrate to using the THEOplayer SDK with the following [THEOlive migration guide](/theoplayer/flutter/guides/theolive/#migration-from-theolive-flutter-sdk-to-theoplayer-flutter-sdk)
to always have the latest updates.
### Flutter project setup
@@ -49,7 +49,7 @@ void initState() {
}
```
-### Add a THEOlive source
+### Add an OptiView Live source
After initializing a THEOplayer instance in your Flutter project, set its source with a `SourceDescription` containing a `TheoLiveSource`:
@@ -62,7 +62,7 @@ player.source = SourceDescription(sources: [
### Next steps
-If you've followed the steps above, you should now have a boilerplate THEOlive Flutter application to further develop your project from.
+If you've followed the steps above, you should now have a boilerplate OptiView Live Flutter application to further develop your project from.
Use Flutter documentation along with our [basic playback guide](./01-basic-playback-guide.mdx) for Flutter to develop your project.
diff --git a/theolive/playback/flutter/01-basic-playback-guide.mdx b/theoplayer/how-to-guides/flutter/theolive/01-basic-playback-guide.mdx
similarity index 96%
rename from theolive/playback/flutter/01-basic-playback-guide.mdx
rename to theoplayer/how-to-guides/flutter/theolive/01-basic-playback-guide.mdx
index d3d4c68ef0a8..baf39bdb8406 100644
--- a/theolive/playback/flutter/01-basic-playback-guide.mdx
+++ b/theoplayer/how-to-guides/flutter/theolive/01-basic-playback-guide.mdx
@@ -5,7 +5,7 @@ the volume, playing/pausing the stream, enabling full screen, and selecting qual
## Player Setup
-To get started with THEOlive playback using Flutter, you must first initialize a THEOplayer instance and set a THEOlive source.
+To get started with OptiView Live playback using Flutter, you must first initialize a THEOplayer instance and set an OptiView Live source.
Here is example code of initializing a THEOplayer instance with Flutter:
diff --git a/theoplayer/how-to-guides/flutter/theolive/_category_.json b/theoplayer/how-to-guides/flutter/theolive/_category_.json
new file mode 100644
index 000000000000..7c7a2a1b1b04
--- /dev/null
+++ b/theoplayer/how-to-guides/flutter/theolive/_category_.json
@@ -0,0 +1,7 @@
+{
+ "label": "OptiView Live",
+ "description": "Integrate OptiView Live streaming into your Flutter app.",
+ "customProps": {
+ "icon": "π"
+ }
+}
diff --git a/theolive/playback/ios/00-getting-started.mdx b/theoplayer/how-to-guides/ios/theolive/00-getting-started.mdx
similarity index 72%
rename from theolive/playback/ios/00-getting-started.mdx
rename to theoplayer/how-to-guides/ios/theolive/00-getting-started.mdx
index aacb734b1c94..49d2df3da227 100644
--- a/theolive/playback/ios/00-getting-started.mdx
+++ b/theoplayer/how-to-guides/ios/theolive/00-getting-started.mdx
@@ -1,20 +1,20 @@
---
sidebar_position: 1
-sidebar_label: Getting started with iOS
+sidebar_label: Getting started
---
-# Getting started with THEOlive on iOS
+# Getting started
## Usage
1. Follow [our Getting Started guide](/theoplayer/getting-started/sdks/ios/getting-started)
to set up THEOplayer in your iOS app.
-2. Add a THEOlive source to your player's source.
+2. Add an OptiView Live source to your player's source.
-### Add a THEOlive source
+### Add an OptiView Live source
After setting up your THEOplayer in your app, set its source to a `SourceDescription` containing a `TheoLiveSource`.
-You'll need a THEOlive channel ID:
+You'll need an OptiView Live channel ID:
```swift
theoplayer.source = SourceDescription(source: TheoLiveSource(channelId: "3aa5qylwwk7gijsobayq09yee"))
diff --git a/theoplayer/how-to-guides/ios/theolive/_category_.json b/theoplayer/how-to-guides/ios/theolive/_category_.json
new file mode 100644
index 000000000000..3983bbb78636
--- /dev/null
+++ b/theoplayer/how-to-guides/ios/theolive/_category_.json
@@ -0,0 +1,7 @@
+{
+ "label": "OptiView Live",
+ "description": "Integrate OptiView Live streaming into your iOS app.",
+ "customProps": {
+ "icon": "π"
+ }
+}
diff --git a/theolive/playback/react-native/00-getting-started.mdx b/theoplayer/how-to-guides/react-native/theolive/00-getting-started.mdx
similarity index 71%
rename from theolive/playback/react-native/00-getting-started.mdx
rename to theoplayer/how-to-guides/react-native/theolive/00-getting-started.mdx
index f893f085815c..6aeefa9b3212 100644
--- a/theolive/playback/react-native/00-getting-started.mdx
+++ b/theoplayer/how-to-guides/react-native/theolive/00-getting-started.mdx
@@ -1,20 +1,20 @@
---
sidebar_position: 1
-sidebar_label: Getting started with React Native
+sidebar_label: Getting started
---
-# Getting started with THEOlive on React Native
+# Getting started
## Usage
1. Follow [our Getting Started guide](/theoplayer/getting-started/frameworks/react-native/getting-started/)
to set up THEOplayer in your React Native app.
-2. Add a THEOlive source to your player's source.
+2. Add an OptiView Live source to your player's source.
-### Add a THEOlive source
+### Add an OptiView Live source
After setting up your THEOplayer on your web page, set its source to a `SourceDescription` containing a `THEOliveSource`.
-You'll need a THEOlive channel ID:
+You'll need an OptiView Live channel ID:
```javascript
player.source = {
diff --git a/theoplayer/how-to-guides/react-native/theolive/_category_.json b/theoplayer/how-to-guides/react-native/theolive/_category_.json
new file mode 100644
index 000000000000..2d6b30229afc
--- /dev/null
+++ b/theoplayer/how-to-guides/react-native/theolive/_category_.json
@@ -0,0 +1,7 @@
+{
+ "label": "OptiView Live",
+ "description": "Integrate OptiView Live streaming into your React Native app.",
+ "customProps": {
+ "icon": "π"
+ }
+}
diff --git a/theolive/playback/react-native/token-based-security.mdx b/theoplayer/how-to-guides/react-native/theolive/token-based-security.mdx
similarity index 84%
rename from theolive/playback/react-native/token-based-security.mdx
rename to theoplayer/how-to-guides/react-native/theolive/token-based-security.mdx
index 51c6ce999bd1..42496750be4c 100644
--- a/theolive/playback/react-native/token-based-security.mdx
+++ b/theoplayer/how-to-guides/react-native/theolive/token-based-security.mdx
@@ -1,23 +1,23 @@
# Token based security
-THEOlive offers the option to enable JWT token security on channel distribution level. This can be interesting if you only want valid users to access your stream. Read more about the feature and configuring it on your channels on the [token based security guide](../../platform/security/token-based-security.mdx).
+OptiView Live offers the option to enable JWT token security on channel distribution level. This can be interesting if you only want valid users to access your stream. Read more about the feature and configuring it on your channels on the [token based security guide](/theolive/next/distribution/security/token-based-security/).
This page will demonstrate how to configure the React Native Player SDK for playback of channels with token based security enabled.
-## Setting up the React Native THEOplayer SDK for THEOlive
+## Setting up the React Native THEOplayer SDK for OptiView Live
-Refer to the [getting started guide](../getting-started) for the prerequisite steps in getting the React Native SDK up and running for THEOlive playback.
+Refer to the [getting started guide](./00-getting-started.mdx) for the prerequisite steps in getting the React Native SDK up and running for OptiView Live playback.
## Configuring THEOplayer to pass the token
-The THEOlive API provides a simple property to configure your token:
+The OptiView Live API provides a simple property to configure your token:
```javascript
const token = getToken(); // Generate or request your token, for more information check the token based security guide linked above.
player.theolive.authToken = token;
```
-This will ensure the player includes your token in the authorization header on all subsequent requests it performs for playback of your THEOlive channel.
+This will ensure the player includes your token in the authorization header on all subsequent requests it performs for playback of your OptiView Live channel.
## Dealing with token expiry and rotation
@@ -47,7 +47,7 @@ setInterval(maybeUpdateToken, 30000); // Check every 30 seconds
## Clearing the token
-If the token isn't needed anymore, e.g. when switching to an unprotected channel or a non-THEOlive source altogether, the header can be simply removed as follows:
+If the token isn't needed anymore, e.g. when switching to an unprotected channel or a non-OptiView Live source altogether, the header can be simply removed as follows:
```javascript
player.theolive.authToken = undefined;
@@ -55,7 +55,7 @@ player.theolive.authToken = undefined;
## Enabling Token Based Security for Safari browsers on iOS \<17
-Apple devices running an iOS version lower than 17.1 do not support MSE, therefore there are limitations with what is possible when playing a THEOlive stream. One such limitation is that the above network API approach does not work on those devices. Instead, a service worker needs to be registered to support playback of JWT enabled streams.
+Apple devices running an iOS version lower than 17.1 do not support MSE, therefore there are limitations with what is possible when playing an OptiView Live stream. One such limitation is that the above network API approach does not work on those devices. Instead, a service worker needs to be registered to support playback of JWT enabled streams.
The service worker needs to intercept the `fetch` requests originating from the app, to be able to include the `Authorization` header to the requests.
@@ -84,7 +84,7 @@ self.addEventListener('fetch', (event) => {
try {
const url = new URL(event.request.url);
if (!url.origin.endsWith('theo.live')) {
- // Requests not made by the player for playback of the THEOlive channel should not be modified.
+ // Requests not made by the player for playback of the OptiView Live channel should not be modified.
return fetch(event.request);
}
const token = getToken(); // Generate or request your token, for more information check the token based security guide linked above.
diff --git a/theolive/playback/roku/00-getting-started.mdx b/theoplayer/how-to-guides/roku/theolive/00-getting-started.mdx
similarity index 70%
rename from theolive/playback/roku/00-getting-started.mdx
rename to theoplayer/how-to-guides/roku/theolive/00-getting-started.mdx
index 7b029cc836fe..a3f9581c4689 100644
--- a/theolive/playback/roku/00-getting-started.mdx
+++ b/theoplayer/how-to-guides/roku/theolive/00-getting-started.mdx
@@ -1,20 +1,20 @@
---
sidebar_position: 1
-sidebar_label: Getting started with Roku
+sidebar_label: Getting started
---
-# Getting started with THEOlive on Roku
+# Getting started
## Usage
1. Follow [our Getting Started guide](/theoplayer/getting-started/sdks/roku/getting-started)
to set up THEOplayer in your Roku app.
-2. Add a THEOlive source to your player's source.
+2. Add an OptiView Live source to your player's source.
-### Add a THEOlive source
+### Add an OptiView Live source
After setting up your THEOplayer on your App, set its source to a `SourceDescription` containing a `THEOliveSource`.
-You'll need a THEOlive channel ID:
+You'll need an OptiView Live channel ID:
```brightscript
m.THEOsdk.source = {
@@ -26,9 +26,9 @@ m.THEOsdk.source = {
}
```
-Please note that the playlist feature cannot be used with THEOlive. On Roku the THEOlive source falls back to the HLS stream.
+Please note that the playlist feature cannot be used with OptiView Live. On Roku the OptiView Live source falls back to the HLS stream.
-### Configure THEOlive
+### Configure OptiView Live
On the player configuration object, you may add extra configuration using the `theoLive` property on the player configuration. For instance, if you would like to provide an external ID to track the session, you may add it to the `theoLive` configuration:
@@ -45,4 +45,4 @@ m.player.callFunc("configure", playerConfiguration)
## More information
- [API references](/theoplayer/api-reference/roku)
-- [Migrating to THEOlive v2](./02-migrating-to-v2.mdx)
+- [Migrating to OptiView Live v2](./02-migrating-to-v2.mdx)
diff --git a/theolive/playback/roku/01-token-based-security.mdx b/theoplayer/how-to-guides/roku/theolive/01-token-based-security.mdx
similarity index 75%
rename from theolive/playback/roku/01-token-based-security.mdx
rename to theoplayer/how-to-guides/roku/theolive/01-token-based-security.mdx
index 1a09e536cc83..2f8770a253eb 100644
--- a/theolive/playback/roku/01-token-based-security.mdx
+++ b/theoplayer/how-to-guides/roku/theolive/01-token-based-security.mdx
@@ -1,23 +1,23 @@
# Token based security
-THEOlive offers the option to enable JWT token security on channel distribution level. This can be interesting if you only want valid users to access your stream. Read more about the feature and configuring it on your channels on the [token based security guide](../../platform/security/token-based-security.mdx).
+OptiView Live offers the option to enable JWT token security on channel distribution level. This can be interesting if you only want valid users to access your stream. Read more about the feature and configuring it on your channels on the [token based security guide](/theolive/next/distribution/security/token-based-security/).
This page will demonstrate how to configure the Roku Player SDK for playback of channels with token based security enabled.
-## Setting up the Roku THEOplayer SDK for THEOlive
+## Setting up the Roku THEOplayer SDK for OptiView Live
-Refer to the [getting started guide](../getting-started) for the prerequisite steps in getting the Roku SDK up and running for THEOlive playback.
+Refer to the [getting started guide](./00-getting-started.mdx) for the prerequisite steps in getting the Roku SDK up and running for OptiView Live playback.
## Configuring THEOplayer to pass the token
-The THEOlive API provides a simple property to configure your token:
+The OptiView Live API provides a simple property to configure your token:
```brightscript
token = getToken() // Generate or request your token, for more information check the token based security guide linked above.
player.theolive.authToken = token
```
-This will ensure the player includes your token in the authorization header on all subsequent requests it performs for playback of your THEOlive channel.
+This will ensure the player includes your token in the authorization header on all subsequent requests it performs for playback of your OptiView Live channel.
## Dealing with token expiry and rotation
@@ -75,7 +75,7 @@ end function
## Clearing the token
-If the token isn't needed anymore, e.g. when switching to an unprotected channel or a non-THEOlive source altogether, the header can be simply removed as follows:
+If the token isn't needed anymore, e.g. when switching to an unprotected channel or a non-OptiView Live source altogether, the header can be simply removed as follows:
```brightscript
player.theolive.authToken = ""
diff --git a/theoplayer/how-to-guides/roku/theolive/02-migrating-to-v2.mdx b/theoplayer/how-to-guides/roku/theolive/02-migrating-to-v2.mdx
new file mode 100644
index 000000000000..d9e23d6fd269
--- /dev/null
+++ b/theoplayer/how-to-guides/roku/theolive/02-migrating-to-v2.mdx
@@ -0,0 +1,28 @@
+---
+sidebar_position: 2
+sidebar_label: Migrating to OptiView Live v2
+---
+
+# Migrating to OptiView Live v2
+
+If you are using OptiView Live v2 for your live streams, you will need to do some extra configuration to successfully play back your OptiView Live streams on Roku.
+
+## Initial Setup
+
+1. Follow [our Getting Started guide](/theoplayer/getting-started/sdks/roku/getting-started)
+ to set up THEOplayer in your Roku app.
+2. Add an OptiView Live source to your player's source.
+
+### Configure OptiView Live for v2
+
+OptiView Live v2 sources do not use the default discovery URL (https://discovery.theo.live/v2/publications/). In order to use v2, you will need to specify one or more discovery URLs. On the player configuration object, you may add the discovery URLs using the `theoLive` property on the player configuration.
+
+```brightscript
+playerConfiguration = {
+ license: "",
+ theoLive: {
+ discoveryUrls: ["https://discovery.theo.live/v2/distributions/"]
+ }
+}
+m.player.callFunc("configure", playerConfiguration)
+```
diff --git a/theoplayer/how-to-guides/roku/theolive/_category_.json b/theoplayer/how-to-guides/roku/theolive/_category_.json
new file mode 100644
index 000000000000..2e10da771571
--- /dev/null
+++ b/theoplayer/how-to-guides/roku/theolive/_category_.json
@@ -0,0 +1,7 @@
+{
+ "label": "OptiView Live",
+ "description": "Integrate OptiView Live streaming into your Roku app.",
+ "customProps": {
+ "icon": "οΏ½"
+ }
+}
diff --git a/theoplayer/how-to-guides/web/theolive/_category_.json b/theoplayer/how-to-guides/web/theolive/_category_.json
new file mode 100644
index 000000000000..18881ae58d61
--- /dev/null
+++ b/theoplayer/how-to-guides/web/theolive/_category_.json
@@ -0,0 +1,7 @@
+{
+ "label": "OptiView Live",
+ "description": "Integrate OptiView Live streaming into your web app.",
+ "customProps": {
+ "icon": "π"
+ }
+}
diff --git a/theolive/playback/web/basic-playback-guide.mdx b/theoplayer/how-to-guides/web/theolive/basic-playback-guide.mdx
similarity index 95%
rename from theolive/playback/web/basic-playback-guide.mdx
rename to theoplayer/how-to-guides/web/theolive/basic-playback-guide.mdx
index 1d9c9ee1807a..11218083b504 100644
--- a/theolive/playback/web/basic-playback-guide.mdx
+++ b/theoplayer/how-to-guides/web/theolive/basic-playback-guide.mdx
@@ -9,9 +9,9 @@ After following our [Getting Started on Web guide](./getting-started.mdx) or the
## Player Setup
-To get started with THEOlive playback using the THEOplayer, you must first initialize your player with reference to your THEOlive channel as the source.
+To get started with OptiView Live playback using THEOplayer, you must first initialize your player with reference to your OptiView Live channel as the source.
-Here is an example of initializing a THEOplayer instance for THEOlive:
+Here is an example of initializing a THEOplayer instance for OptiView Live:
```javascript
const player = new THEOplayer.Player(element, configuration);
diff --git a/theolive/playback/web/casting/_category_.json b/theoplayer/how-to-guides/web/theolive/casting/_category_.json
similarity index 100%
rename from theolive/playback/web/casting/_category_.json
rename to theoplayer/how-to-guides/web/theolive/casting/_category_.json
diff --git a/theoplayer/how-to-guides/web/theolive/casting/airplay.mdx b/theoplayer/how-to-guides/web/theolive/casting/airplay.mdx
new file mode 100644
index 000000000000..b7d608af5ac3
--- /dev/null
+++ b/theoplayer/how-to-guides/web/theolive/casting/airplay.mdx
@@ -0,0 +1,8 @@
+---
+title: Airplay
+sidebar_position: 1
+---
+
+# Airplay
+
+OptiView Live streams have support for Airplay. However, a limitation for now is that the latency is higher while casting (about 12 seconds). Configuring it is exactly the same as for other streams you would play with THEOplayer. The instructions are described in the [Airplay guide](/theoplayer/how-to-guides/cast/airplay/introduction/).
diff --git a/theoplayer/how-to-guides/web/theolive/casting/chromecast.mdx b/theoplayer/how-to-guides/web/theolive/casting/chromecast.mdx
new file mode 100644
index 000000000000..637aa744b1cc
--- /dev/null
+++ b/theoplayer/how-to-guides/web/theolive/casting/chromecast.mdx
@@ -0,0 +1,8 @@
+---
+title: Chromecast
+sidebar_position: 2
+---
+
+# Chromecast
+
+OptiView Live streams have support for Chromecast. However, a limitation for now is that the latency is higher while casting (about 12 seconds). Configuring it is exactly the same as for other streams you would play with THEOplayer. The instructions are described in the [Chromecast guide](/theoplayer/how-to-guides/cast/chromecast/enable-chromecast-on-the-sender/).
diff --git a/theolive/playback/web/getting-started.mdx b/theoplayer/how-to-guides/web/theolive/getting-started.mdx
similarity index 90%
rename from theolive/playback/web/getting-started.mdx
rename to theoplayer/how-to-guides/web/theolive/getting-started.mdx
index a2cb2baec1aa..d4a2a5050be3 100644
--- a/theolive/playback/web/getting-started.mdx
+++ b/theoplayer/how-to-guides/web/theolive/getting-started.mdx
@@ -2,19 +2,19 @@
sidebar_position: 1
---
-# Getting started with THEOlive on Web
+# Getting started
## Usage
1. Follow [our Getting Started guide](/theoplayer/getting-started/sdks/web/getting-started/)
to set up THEOplayer in your web app or website.
2. Register the service worker if necessary.
-3. Add a THEOlive source to your player's source.
+3. Add an OptiView Live source to your player's source.
### Register the service worker
On Apple devices running an iOS version lower than 17.1, a service worker needs to be registered to support low
-latency play-out of THEOlive streams.
+latency play-out of OptiView Live streams.
```javascript
function needsServiceWorkerForTHEOlive() {
@@ -31,12 +31,12 @@ if (needsServiceWorkerForTHEOlive()) {
The service worker `theoplayer.sw.js` is part of the THEOplayer SDK and needs to be on the same domain and path as the
page initiating the player.
-### Add a THEOlive source
+### Add an OptiView Live source
After setting up your THEOplayer on your web page, set its source to a `SourceDescription` containing a `THEOliveSource`.
Take into account that the source must be set after awaiting the registration of the service worker for streams to work
on iOS versions lower than 17.1.
-You'll need a THEOlive channel ID:
+You'll need an OptiView Live channel ID:
```javascript
const player = new THEOplayer.Player(element, configuration);
@@ -50,7 +50,7 @@ player.source = {
### Add configuration
-Optionally, you can provide additional configuration to the player, specific for THEOlive streams. To
+Optionally, you can provide additional configuration to the player, specific for OptiView Live streams. To
configure these settings, add a `theolive` property to the player configuration. For an exhaustive list of these options,
please visit the [documentation](pathname:///theoplayer/v9/api-reference/web/interfaces/TheoLiveConfiguration.html).
diff --git a/theolive/playback/web/metadata.mdx b/theoplayer/how-to-guides/web/theolive/metadata.mdx
similarity index 96%
rename from theolive/playback/web/metadata.mdx
rename to theoplayer/how-to-guides/web/theolive/metadata.mdx
index 47e356c99635..dc8578dbef43 100644
--- a/theolive/playback/web/metadata.mdx
+++ b/theoplayer/how-to-guides/web/theolive/metadata.mdx
@@ -5,7 +5,7 @@ sidebar_position: 3
# Metadata
-The messages added to your stream using the [Backend Metadata guide](../../contribution/sei-messages.mdx), you can access
+The messages added to your stream using the [Backend Metadata guide](/theolive/contribution/sei-messages/), you can access
as a metadata text track.
First listen to the event to see if a new metadata track has been added, and add an `onTimeCode` listener:
diff --git a/theolive/playback/web/migrating-from-theolive-player.mdx b/theoplayer/how-to-guides/web/theolive/migrating-from-theolive-player.mdx
similarity index 88%
rename from theolive/playback/web/migrating-from-theolive-player.mdx
rename to theoplayer/how-to-guides/web/theolive/migrating-from-theolive-player.mdx
index 1dccb97ff575..7a7c269f2db3 100644
--- a/theolive/playback/web/migrating-from-theolive-player.mdx
+++ b/theoplayer/how-to-guides/web/theolive/migrating-from-theolive-player.mdx
@@ -47,7 +47,7 @@ var player = new THEOplayer.Player(element, {
```
Note that you now need a license, either use the THEOplayer license you had before, or use the one provided in the
-[THEOlive console](https://console.theo.live) when creating a channel.
+[OptiView Live dashboard](https://dashboard.optiview.dolby.com) when creating a channel.
## Loading a channel
@@ -71,7 +71,7 @@ player.source = {
## Calling methods and listening to events
-Most of the old functionality is right there on THEOplayer and can be found in the [THEOplayer docs](pathname:///theoplayer/v9/api-reference/web/classes/ChromelessPlayer.html). For THEOlive specific API, check out [player.theolive](pathname:///theoplayer/v9/api-reference/web/interfaces/TheoLiveApi.html).
+Most of the old functionality is right there on THEOplayer and can be found in the [THEOplayer docs](pathname:///theoplayer/v9/api-reference/web/classes/ChromelessPlayer.html). For OptiView Live specific API, check out [player.theolive](pathname:///theoplayer/v9/api-reference/web/interfaces/TheoLiveApi.html).
## More information
diff --git a/theolive/playback/web/token-based-security.mdx b/theoplayer/how-to-guides/web/theolive/token-based-security.mdx
similarity index 88%
rename from theolive/playback/web/token-based-security.mdx
rename to theoplayer/how-to-guides/web/theolive/token-based-security.mdx
index 52368f2b03a0..fdae62cace44 100644
--- a/theolive/playback/web/token-based-security.mdx
+++ b/theoplayer/how-to-guides/web/theolive/token-based-security.mdx
@@ -4,13 +4,13 @@ sidebar_position: 6
# Token based security
-THEOlive offers the option to enable JWT token security on a distribution (formerly referred to as an alias) level. This can be interesting if you only want valid users to access your stream. Read more about the feature and configuring it on your channels on the [token based security guide](../../platform/security/token-based-security.mdx).
+OptiView Live offers the option to enable JWT token security on a distribution (formerly referred to as an alias) level. This can be interesting if you only want valid users to access your stream. Read more about the feature and configuring it on your channels on the [token based security guide](/theolive/next/distribution/security/token-based-security/).
This page will demonstrate how to configure the Web SDK for playback of channels with token based security enabled.
-## Setting up the Web THEOplayer SDK for THEOlive
+## Setting up the Web THEOplayer SDK for OptiView Live
-Refer to the [getting started guide](../getting-started) for the prerequisite steps in getting the web SDK up and running for THEOlive playback.
+Refer to the [getting started guide](./getting-started.mdx) for the prerequisite steps in getting the web SDK up and running for OptiView Live playback.
## Configuring THEOplayer to pass the token
@@ -21,7 +21,7 @@ const token = getToken(); // Generate or request your token, for more informatio
player.theoLive.authToken = token;
```
-This will ensure the player includes your authorization header on all subsequent requests it performs for playback of your THEOlive distribution.
+This will ensure the player includes your authorization header on all subsequent requests it performs for playback of your OptiView Live distribution.
## Dealing with token expiry and rotation
@@ -51,7 +51,7 @@ setInterval(maybeUpdateToken, 30000); // Check every 30 seconds
## Clearing the token
-If the token isn't needed anymore, e.g. when switching to an unprotected distribution or a non-THEOlive source altogether, the header can be simply removed as follows:
+If the token isn't needed anymore, e.g. when switching to an unprotected distribution or a non-OptiView Live source altogether, the header can be simply removed as follows:
```javascript
player.theoLive.authToken = undefined;
@@ -59,7 +59,7 @@ player.theoLive.authToken = undefined;
## Enabling Token Based Security for Safari browsers on iOS \<17
-Apple devices running an iOS version lower than 17.1 do not support MSE, therefore there are limitations with what is possible when playing a THEOlive stream. One such limitation is that the above network API approach does not work on those devices. Instead, a service worker needs to be registered to support playback of JWT enabled streams.
+Apple devices running an iOS version lower than 17.1 do not support MSE, therefore there are limitations with what is possible when playing an OptiView Live stream. One such limitation is that the above network API approach does not work on those devices. Instead, a service worker needs to be registered to support playback of JWT enabled streams.
The service worker needs to intercept the `fetch` requests originating from the app, to be able to include the `Authorization` header to the requests.
@@ -88,7 +88,7 @@ self.addEventListener('fetch', (event) => {
try {
const url = new URL(event.request.url);
if (!url.origin.endsWith('theo.live')) {
- // Requests not made by the player for playback of the THEOlive distribution should not be modified.
+ // Requests not made by the player for playback of the OptiView Live distribution should not be modified.
return fetch(event.request);
}
const token = getToken(); // Generate or request your token, for more information check the token based security guide linked above.
@@ -44,5 +44,5 @@ Here are some adjustments recommended by the [Haivision support](https://www.hai
\*Note: The timestamp seeding seemed to be the magic change on the KBs.
:::info π§ Frame rate and bandwidth
-Remember to set the frame rate to the same value as in your THEOlive channel ingest configuration and make sure that your encoder has a stable connection and enough upload bandwidth. See [Stream configuration](../stream-configuration.mdx) for more details.
+Remember to set the frame rate to the same value as in your channel ingest configuration and make sure that your encoder has a stable connection and enough upload bandwidth. See [Stream configuration](../../media-engine/abr.mdx) for more details.
:::
diff --git a/theolive/contribution/hardware-encoders/index.mdx b/theolive/contribution/hardware-encoders/index.mdx
index 8be08c8fce88..cfa7fc5bfbe2 100644
--- a/theolive/contribution/hardware-encoders/index.mdx
+++ b/theolive/contribution/hardware-encoders/index.mdx
@@ -1,4 +1,5 @@
---
+sidebar_position: 2
title: Hardware Encoders
description: Hardware-based Encoders for Broadcasting Live Streaming Content
slug: /hardware-encoders
@@ -6,39 +7,9 @@ slug: /hardware-encoders
In today's digital landscape, the demand for live streaming content has skyrocketed, prompting broadcasters and video creators to prioritize the efficient delivery of high-quality video and audio streams. Hardware-based encoders play a crucial role in this process with their offerings of superior encoding capabilities and seamless transmission. Needless to say, workflows don't have to be interrupted in order to better a stream.
-## Integration guides
-
-Review these guides for how to setup your preferred tools for live streaming integrations.
-
-import { IconGrid, IconGridButton } from '@site/src/components/IconGrid';
-
-.default})
| **[Haivision](haivision.mdx)** | High-performance video encoding device that efficiently converts video signals into compressed formats for reliable live streaming and distribution over IP networks. |
+| .default})
| **[Magewell](magewell.mdx)** | Leading encoder manufacturer that supports connecting to the Dolby OptiView Streaming Service for broadcasting real-time streams. |
+| .default})
| **[Osprey](osprey.mdx)** | Form-factor H.264 (AVC) and H.265 (HEVC) encoder designed to be easy to use, portable, and easily stream low latency 4k and UHD video encoding from SDI and HDMI. |
+| .default})
| **[Videon](videon.mdx)** | Versatile and powerful edge compute encoder that securely delivers high-quality live video streams to multiple platforms simultaneously. |
diff --git a/theolive/contribution/hardware-encoders/magewell.mdx b/theolive/contribution/hardware-encoders/magewell.mdx
index a8fa2efebc9a..e5f8b5dbf782 100644
--- a/theolive/contribution/hardware-encoders/magewell.mdx
+++ b/theolive/contribution/hardware-encoders/magewell.mdx
@@ -16,12 +16,12 @@ To begin, first power on your Ultra Encode, connect it to the internet (Ethernet
import RtmpMagewell from '../../assets/img/hardware-encoders/magewell-rtmp.png';
-
- For the `URL` select `rtmps://` and enter the **URL** of the channel.
- RTMP URL: `rtmps://rtmp.
@@ -37,7 +37,7 @@ Once saved, make sure the stream is activated by toggling the server switch on t
import ConnectMagewell from '../../assets/img/hardware-encoders/magewell-connect.png';
-
@@ -45,6 +45,6 @@ With the stream enabled, you can navigate back to the main Dashboard page of the
import ConnectMagewellStream from '../../assets/img/hardware-encoders/magewell-connect-stream.png';
-
diff --git a/theolive/contribution/hardware-encoders/osprey.mdx b/theolive/contribution/hardware-encoders/osprey.mdx
index 2713cb0af0b1..11d725968976 100644
--- a/theolive/contribution/hardware-encoders/osprey.mdx
+++ b/theolive/contribution/hardware-encoders/osprey.mdx
@@ -13,7 +13,7 @@ You'll need to plug an ethernet connection and a power supply into your Talon en
import OspreyTalon2 from '../../assets/img/hardware-encoders/osprey-talon.jpg';
-
@@ -25,7 +25,7 @@ Once found in your browser, you'll be prompted to log into the device. Refer to
import OspreyTalon3 from '../../assets/img/hardware-encoders/osprey-login.jpeg';
-
@@ -34,13 +34,13 @@ import OspreyTalon3 from '../../assets/img/hardware-encoders/osprey-login.jpeg';
Inside the encoder UI, click on the _Channels_ tab. From the Channels tab, set the protocol to **RTMP/RTMPS**.
- For the `Destination` copy the RTMP publish path from the Dolby _channel_ you have created.
- RTMP URL: `rtmps://rtmp.
diff --git a/theolive/contribution/hardware-encoders/videon.mdx b/theolive/contribution/hardware-encoders/videon.mdx
index c1542d8bad67..c91b8edeb1da 100644
--- a/theolive/contribution/hardware-encoders/videon.mdx
+++ b/theolive/contribution/hardware-encoders/videon.mdx
@@ -17,25 +17,25 @@ In your Videon EdgeCaster Streaming Dashboard configure the following settings:
import RtmpPush from '../../assets/img/hardware-encoders/Videon_Edgecaster_-_Input_Settings.jpg';
-
@@ -47,7 +47,7 @@ import VideoProfile from '../../assets/img/hardware-encoders/Videon_Edgecaster_-
import AudioProfile from '../../assets/img/hardware-encoders/Videon_Edgecaster_-_Audio_Profile.jpg';
-
@@ -62,6 +62,6 @@ import AudioProfile from '../../assets/img/hardware-encoders/Videon_Edgecaster_-
import EdgecasterOutput from '../../assets/img/hardware-encoders/Videon_Edgecaster_-_Output.jpg';
-
diff --git a/theolive/contribution/ingest-protocols.mdx b/theolive/contribution/ingest-protocols.mdx
new file mode 100644
index 000000000000..cdd107611b39
--- /dev/null
+++ b/theolive/contribution/ingest-protocols.mdx
@@ -0,0 +1,36 @@
+---
+sidebar_position: 0
+sidebar_label: Ingest protocols
+sidebar_custom_props:
+ icon: π
+description: Supported ingest protocols (RTMP and SRT) and their trade-offs.
+---
+
+# Ingest protocols
+
+The Dolby OptiView Live platform supports low latency live streaming through two ingest protocols: **RTMP** and **SRT**.
+
+## RTMP β Real-Time Messaging Protocol
+
+RTMP is a widely adopted protocol originally developed by Adobe for transmitting audio, video, and data over the internet. It remains one of the most commonly supported protocols across hardware and software encoders.
+
+- **Pros**
+ - **Broad encoder support** β Nearly all hardware and software encoders support RTMP out of the box.
+ - **Simple setup** β Requires minimal configuration, typically just a server URL and stream key.
+ - **Low latency** β Provides low latency contribution suitable for most live streaming use cases.
+- **Cons**
+ - **Container limitation** β RTMP uses the FLV container, which only supports H.264 video and AAC audio. Newer codecs such as H.265/HEVC are not supported.
+ - **Single audio track** β RTMP is limited to a single audio track per stream, making it unsuitable for multi-audio use cases.
+
+## SRT β Secure Reliable Transport
+
+SRT is an open-source protocol designed for low latency, secure, and reliable video transport across unpredictable networks. It is increasingly adopted as a modern alternative to RTMP.
+
+- **Pros**
+ - **Resilient on unreliable networks** β SRT uses UDP with built-in error correction (ARQ), making it well suited for contribution over the public internet or unstable connections.
+ - **Multi-audio support** β SRT uses the MPEG-TS container, which supports multiple audio tracks within a single stream.
+ - **Closed captions and metadata** β The MPEG-TS container also supports embedded closed captions (CEA-608/708) and SEI metadata pass-through.
+ - **Codec flexibility** β MPEG-TS supports a broader range of codecs compared to FLV.
+- **Cons**
+ - **Less universal encoder support** β While adoption is growing, not all encoders support SRT, especially older hardware models.
+ - **More complex configuration** β SRT may require tuning parameters such as latency, overhead bandwidth, and encryption settings for optimal performance.
diff --git a/theolive/contribution/multi-audio-support.mdx b/theolive/contribution/multi-audio-support.mdx
index b928e92a6502..3841e9ac8ab1 100644
--- a/theolive/contribution/multi-audio-support.mdx
+++ b/theolive/contribution/multi-audio-support.mdx
@@ -1,31 +1,52 @@
---
-sidebar_position: 2
-sidebar_label: Multi-audio support
+sidebar_position: 3
+sidebar_label: Multi-audio
+sidebar_custom_props:
+ icon: π
+description: How to ingest and deliver multiple audio tracks via SRT.
---
-# Multi-audio support
+# Multi-audio
----
-
-The Dolby OptiView platform supports multi-audio ingest and delivery with our HESP solution. This functionality is perfect for
+The Dolby OptiView Live platform supports multi-audio ingest and delivery. This functionality is perfect for
use cases such as live events where multiple languages or commentary may be required.
:::caution
-This functionality is **only** supported through the SRT Pull ingest method. Playback is **only** supported on web.
+This functionality is **only** supported through the SRT ingest protocol.
:::
## Configuring multi-audio ingest and playback
To deliver multi audio SRT the following steps must be taken:
-1. Within your dashboard configure your SRT listener endpoint.
+1. Within the dashboard configure your SRT listener endpoint.
2. Configure your expected incoming "Audio tracks" by specifying a language, label, and the expected PID.
-
| **[OBS](obs.md)** | Free open-source application for broadcasting and recording streams. |
+| 
| **[vMix](vmix.md)** | Windows desktop application that provides a vision mixer and encoder. |
+|