Skip to content

Migrate from Flussonic Media Server

Flussonic Media Server (FMS) is a media server you install and run yourself. Its documentation covers ingest, transcoding, DVR, restreaming, and an IPTV/OTT service chain from headend to restreamer. FrameWorks is a live video platform whose media edges run MistServer, with GraphQL, routing, analytics, billing, and playback access control above them. It is built by the MistServer team.

Three FrameWorks services come up in this guide. Foghorn routes viewers and encoders to an edge and tells an edge which other edge to pull a stream from. Helmsman runs next to MistServer on every edge and connects it to Foghorn. Chandler serves a cluster’s thumbnails, seek-preview sprites, VOD metadata, and assets cached from object storage.

The two overlap on live ingest, HTTP delivery, DVR, and multi-server routing. They differ most on broadcast-network work. Event streaming is the closest fit: encoders repoint to RTMP, SRT, or WHIP, and DVR, clips, multistreaming, playback policies, analytics, and StreamCrafter work as described in the builder guides. If you run IPTV or CCTV, read What’s up next, and what’s not planned first, because some of those workloads should stay where they are.

Your situationBest fitWhere to start
You need something that is up next, such as DRM, backup inputs, or built-in geo rulesKeep that workload on Flussonic until it ships, and move the restUp next
You depend on multicast or MPTS output, IPTV middleware, EPG extraction, session limits, or surveillance analyticsKeep that workload on FlussonicNot planned
You own servers and network position, and want routing, analytics, and a managed control plane on topHybrid: FrameWorks edges on your hardwareStay on your own hardware
You need the control plane, storage, and media inside your own network or jurisdictionFull self-hostSelf-host the whole stack
You want to stop running media servers, and your sources are public or can push to the internetManaged FrameWorksMove to managed FrameWorks
You want more delivery reach, but the headend must stay as it isKeep Flussonic as origin, add FrameWorksRun it in parallel
  • What stays: RTMP, SRT, and WHIP ingest; RTSP, SRT, and HLS sources; multicast TS sources on your own edges; HLS, DASH, LL-HLS, and WHEP delivery; DVR with catch-up-style replay; a webhook that allows or denies viewers.
  • What changes: flussonic.conf and /streamer/api/v3/ become GraphQL. Stream names become generated streamKey and playbackId values. on_play becomes a playback policy. event_sink becomes signed webhooks. Disk-backed archives become S3-backed recordings split into chapters. source and peer configuration becomes Foghorn routing.
  • What you gain: one control plane across your own and platform clusters, geo-balanced viewer routing, first-party player QoE analytics, ES256 signed playback, sprite-sheet seek previews, and API, dashboard, and MCP parity.
  • What’s up next: DRM, StreamCrafter cloud production with backup inputs, built-in password and geo rules, scheduled recordings, device discovery, pre-emptive stream replication, and team accounts.
  • What’s not planned: templates and dynamic stream names, always-on pull sources, multicast, UDP, and MPTS output, IPTV middleware, EPG, session limits, and per-stream hardware encoder selection.
FlussonicFrameWorks
stream block in /etc/flussonic/flussonic.confcreateStream(input), the dashboard, or the MCP create_stream tool
static: starts with the server, monitored and retriedA push stream from an always-running encoder. Pull streams do not run this way; see the caution below
ondemand: runs only while viewers request itPull stream. A viewer request opens the source, and it closes after a grace period when the last viewer leaves
input publish://Push stream with a stream key
template shared by many streamsNot planned. Settings are per stream, with tenant defaults for retention and ingest rules. Script createStream, or declare pull_streams in the bootstrap overlay when you self-host
prefix for dynamically named publishingNot planned. Each stream exists before the encoder connects
Several input lines with automatic failover and priorityOne sourceUri per pull stream today. Up next: backup inputs that take over when a primary source drops
backup file when the source is unavailableFrameWorks does not synthesize fallback media today. Up next: backup inputs
timeshift://stream/seconds as a delayed channelNot planned. Live viewers seek within the DVR window instead
thumbnailsGenerated automatically; see Thumbnails and Previews
FlussonicFrameWorks
input udp://239.0.0.1:1234 multicastPull source tsudp://239.0.0.1:1234, on a self-hosted edge cluster with allow_private_pull_sources: true
udp://[email protected]:1234 interface selectionNot documented. Test on multi-homed hosts before relying on it
rtsp:// camera sourcePull source rtsp://, with basic auth in the URI. rtsps:// is not supported yet
hls:// sourcePull source https://.../*.m3u8
tshttp:// sourcehttps://.../*.ts covers single-file TS only. For live TS, use tsudp:// or HLS
SRT publish with streamidSRT push; streamid carries the stream key. See Encoder Setup
RTMP publishRTMP or E-RTMP push on port 1935. There is no RTMPS ingest; use SRT or WHIP when the link must be encrypted
WebRTC publish over WHIPWHIP push, from an encoder or from StreamCrafter
RTSP or HTTP MPEG-TS publishRTSP only on a hybrid edge with that port exposed. HTTP MPEG-TS publish is not documented. Move encoders to SRT
Satellite receivers and DVB-S cardsDVB capture is not planned. Bring the feed in from your receiver as tsudp://, RTSP, or SRT
NDI ingestUp next, as part of Device Discovery and Contribution Inputs

See Pull-input Streams for source location rules and private-network sources.

FlussonicFrameWorks
/STREAMNAME/index.m3u8/play/{playbackId}/hls/index.m3u8, or /play/{playbackId}/cmaf/index.m3u8 for LL-HLS
/STREAMNAME/index.mpd/play/{playbackId}/cmaf/index.mpd
WHEP/play/{playbackId}/whep
HTTP MPEG-TS at /STREAMNAME/mpegts/play/{playbackId}.ts
RTMP, RTSP, and SRT playbackDirect edge protocols when the edge exposes them; not the managed default
MSS at .isml/manifestNot planned
embed.html@livepeer-frameworks/player-* for React, Svelte, Web Components, and vanilla JS

Every viewer URL changes. Set-top apps, middleware channel lists, and player embeds all need new URLs, because a playbackId is generated and is not your Flussonic stream name.

FlussonicFrameWorks
push rtmp://...createPushTarget(streamId, input) with an rtmp:// or rtmps:// URI
SRT pushcreatePushTarget with an srt:// URI
push udp://239.0.0.1:1234 multicastNot planned
HTTP MPEG-TS, HLS, or M4S pushNot planned
MPTS for a modulatorNot planned

Push targets accept rtmp://, rtmps://, and srt:// URIs only. They start only for streams with a push ingest, so a pull stream cannot feed a push target. See Multistreaming.

FlussonicFrameWorks
dvr /storage 1d, set per stream or in a templaterecord: true or startDVR(streamId), with retention set by tenant or asset
Disk limit such as dvr /storage 90% 5dNo per-stream disk limit. Retention sets lifetime
schedule 3-6,5-8,23-5; recording scheduleUp next: scheduled recordings in Scheduled Programming
Local disks or S3 cloud storageS3 is the authoritative tier; edge disk is a cache. See Media Storage
Catch-up URL index-START-DURATION.m3u8List chapters for a UTC range with dvrChapters, then play each chapter’s playbackId
Rewind with timeshift_abs or timeshift_rel URLsPlayer seeking within the live rewind window through dvrPlaybackId
Export to MP4createClip(input), or /play/{id}.mp4?startunix=...&stopunix=...&dl=1
Timelapse export, nPVRNot planned
Timezone-delayed viewingNot planned as a channel; request a past range from your application

The DVR model differs in one way that matters for catch-up TV. FrameWorks has two surfaces: a bounded live rewind window, with a platform ceiling of 72 hours, and finalized chapters for everything older. Chapters are at least one hour long when clock-aligned, and they use UTC. A programme that crosses a chapter boundary spans two playback IDs, so your application has to map EPG times to chapters. See DVR Chapters.

FlussonicFrameWorks
on_play HTTP backend; 200 allows, 403 forbidssetPlaybackPolicy with type: WEBHOOK; any 2xx allows, anything else denies
Backend answers with X-UserId, session lifetime, and limitsStatus code only. The body gives you sessionId, viewerIp, viewerToken, and optional context
Keeps the previous status if the backend fails, and rechecks every 3 minDecides once per viewer session (about 10 minutes by default). A timeout or 5xx denies
on_play backend as an external system or a custom scriptWebhook URLs must be public HTTPS endpoints; private and loopback addresses are refused
securetoken shared-secret hashtype: JWT with customer-held ES256 keys, sent as ?jwt=
X-Max-Sessions per-user limitNot planned
allowed_countriesImplement in your webhook using viewerIp today. Up next: Built-In Password and Geo Rules, with no endpoint to run
domains domain lockAllowed origins on a JWT or webhook policy
on_publish backend and publish passwordStream keys with rotation. A publish-time webhook is not planned
DRM: Widevine, PlayReady, and named vendorsUp next: DRM. Keep DRM-protected channels where they are until it ships

Your on_play logic moves almost directly, with one design change: FrameWorks fails closed. Run the webhook endpoint with the same care as the player itself. See Playback Access Control.

Flussonic’s cluster page advises building new clusters on its Catena product rather than on FMS. If you are planning a new cluster, weigh that route as well. Existing FMS clusters translate as follows.

FlussonicFrameWorks
cluster_key shared by serversEnrollment tokens; each node joins a cluster through frameworks edge deploy
source restreamer pulling from an originEdges pull from the origin edge over DTSC on viewer demand, arranged by Foghorn. Up next: pre-emptive replication in Stream Replication Orchestration
balancer redirect by bitrate, clients, usage, or streamsFoghorn scores edges by geography, load, and health, and redirects viewers
Per-peer countries GeoIP routingViewer placement policy, plus geo-routed DNS for tenant domains
cluster_ingest: restarts a stream on another peer if one failssourceLocation limits where a source may run. More than one edge per region per cluster is planned; until then, test node loss on your topology
capture_at soft preference for a serversourceLocation with nodeIds, which is a hard restriction
config_external configuration backendA polling equivalent is not planned. Use GraphQL, or the GitOps manifest on a full self-host
FlussonicFrameWorks
REST + JSON under /streamer/api/v3/, described by OpenAPIGraphQL at /graphql, with TypeScript, Go, and Python SDKs
HTTP Basic through view_auth and edit_authDeveloper token (Bearer)
PUT /streamer/api/v3/streams/{name} upsertcreateStream and updateStream. IDs are generated, so keep a name-to-ID map
DELETE /streamer/api/v3/streams/{name}deleteStream(id)
event_sink to an HTTP handler, log file, or scriptUp to 10 HTTPS webhook endpoints, or the tenantEvents subscription
sign_key and X-SignatureStandard Webhooks signatures
resend_limit buffered retryRetries for about three days, with a 30-day delivery log and replay
source_opened, source_closedClosest by name: stream.connected, stream.idle. Confirm against your own event log
FlussonicFrameWorks
transcoder directive per stream or templateliveVideoAbr: INHERIT uses the tier policy, OFF removes video renditions. No per-stream ladder in the docs
NVENC through hw=nvenc, with deviceid GPU selectionPer-stream encoder or GPU selection is not planned. Local transcode slots are set with max_transcodes
hw=qsv; Flussonic Coder hardwareNot planned. Transcoding runs through Livepeer Gateway or local processing. Up next: GPU-aware placement in the Workload Cost Model
deinterlaceNot planned. Test interlaced broadcast feeds first
Burned-in logoIn the browser with StreamCrafter overlays. On the server, up next in Composition and SSAI
mosaic:// server-side mosaicServer-side compositing is in the pipeline, listed as Up next under Composition and SSAI. StreamCrafter composes multiple sources in the browser today

What’s up next, and what’s not planned

Section titled “What’s up next, and what’s not planned”

Statuses come from the roadmap, whose badges show relative order, not release dates. Until an item ships, keep that workload on Flussonic, or keep Flussonic as the origin and use FrameWorks for reach.

Roadmap itemWhat it unblocks
DRMProtected channels that need FairPlay, Widevine, or PlayReady
Team AccountsShared operations, with roles and audit visibility
Composition and SSAIStreamCrafter cloud production: live switching, overlays, in-stream ads, and backup inputs that take over when a primary source drops
Built-In Password and Geo RulesPassword and country rules on every plan, with no webhook endpoint to run
Scheduled ProgrammingCalendar-driven recordings, and linear channels built from VOD
Device Discovery and Contribution InputsCameras, PTZ devices, NDI, USB, and HDMI sources becoming managed streams
Stream Replication OrchestrationStreams placed in a region ahead of demand
Live AI ProcessingObject detection and transcription on media edges
Workload Cost ModelTranscode placement based on predicted CPU and GPU cost
Placement Policy and Storage TieringData residency rules for where content may live
NAT-Aware Routing and TraversalSelf-hosted nodes behind NAT taking full part in the network
Edge ISO and Cloud ImagesBare-metal edge installs and on-demand cloud scaling
Dedicated Provider CapacityIsolated provider-operated nodes for one tenant
Public Cluster MarketplaceVetted third-party capacity under published terms
Federation State SynchronizationClusters of independent parties joining and leaving without a central coordinator
Platform Trust and Operations HardeningLive trust rotation, and OS updates that drain safely
Operator Settlement and AttributionPayouts to the operators whose clusters carried the traffic
Conferencing and ChatRemote guests mixed into a stream, and viewer chat
Rooms and InteractivityEngagement features synced to the stream timeline
Live CommerceShopping and auctions on live streams

Flussonic documents SCTE-35 handling and server-side ad insertion. On FrameWorks, SCTE-35 cue handling is in the media engine with platform controls still expanding, and server-side ad insertion arrives with Composition and SSAI.

Roadmap itemWhat it unblocks
Stream-Level BalancesPaywalled and pay-per-view streams
Managed DNS, Proxying, and Storage ServicesCustomer-facing DNS, CDN, and standalone storage products
More SDK LanguagesGenerated clients for PHP, Ruby, Elixir, Java, and C#
Mobile Apps and Help CenterNative mobile apps and an integrated help center

These items are not on the roadmap. Where a workaround exists, it is listed.

IPTV and broadcast

  • IPTV middleware. FrameWorks has no subscriber management, channel packages, or set-top portal, and no integration with middleware such as Stalker, which Flussonic documents. A custom middleware can use the GraphQL API, webhook policies, and JWT playback.
  • EPG. Flussonic can extract EPG from MPEG-TS and export XMLTV or JSON. FrameWorks does not read, store, or serve guide data. Your application maps guide times to chapters.
  • Multicast, UDP, and MPTS output. FrameWorks does not output to a multicast group or a modulator. Keep your existing output path, or run a separate gateway that takes SRT or HLS from FrameWorks and emits multicast.
  • Session limits. There is no per-user concurrent session limit.
  • DVB capture, MSS playback, nPVR, timelapse export, and delayed-channel streams.
  • Deinterlacing controls and per-stream hardware encoder selection.

CCTV and surveillance

  • A VMS. Flussonic Watcher is a video surveillance system. FrameWorks has no camera management product, operator console, access-control integration, or mobile surveillance app.
  • ONVIF configuration and motion events. Flussonic documents these. FrameWorks takes an RTSP URL. Device Discovery, above, covers finding cameras.
  • Face and plate recognition. Watcher lists these.

Streams and clusters

  • Always-on pull streams. Pull streams are on-demand, so with no viewer nothing is opened or recorded. To record around the clock, run a relay that pushes continuously.
  • Templates and dynamic stream names. Script stream creation from your export.
  • Publish-time webhooks and a config_external equivalent.
  • Federating a self-hosted platform with the FrameWorks network.

Path 1: Stay on your own hardware (hybrid)

Section titled “Path 1: Stay on your own hardware (hybrid)”

You run edge nodes on your servers: MistServer, Helmsman, and Caddy. FrameWorks operates Foghorn, Livepeer, Chandler, object storage, DNS and TLS, analytics, billing, and the control plane. See Selfhosters for the ownership table.

  1. Use a separate box first. Edges need their own ports, including 80, 443, 1935, and 8889/udp. Do not replace a working Flussonic server on day one.

  2. Check reachability. An edge needs a public IP or a reachable public DNS name for viewers, plus a path to the FrameWorks control plane. NAT-aware routing is up next. An isolated network points to Path 2.

  3. Deploy the edge.

    Terminal window
    frameworks login
    frameworks edge deploy --ssh [email protected] --email [email protected]
  4. Allow private sources where needed. Multicast and RFC1918 sources need a cluster that opted in, and a stream sourceLocation restricted to it:

    {
    "input": {
    "name": "Channel 1",
    "ingestMode": "PULL",
    "pullSource": { "sourceUri": "tsudp://239.0.0.1:1234", "enabled": true },
    "sourceLocation": {
    "mode": "RESTRICTED",
    "clusters": [{ "clusterId": "headend-edge", "nodeIds": ["headend-edge-1"] }]
    }
    }
    }
  5. Add reach if you want it. A paid tenant can route across its own nodes and platform clusters under one hostname.

  6. Plan for storage. FrameWorks operates durable object storage on this path, so archives leave your site. For footage that must stay on your network, use Path 2.

FrameWorks is public domain (Unlicense), and full self-hosting is supported. The frameworks CLI deploys and upgrades the control plane, Foghorn, edges, Livepeer, Chandler, databases, analytics, and interfaces from a GitOps repository. You own all of the data, including recordings.

This is a larger operational step than running a media server. You operate a platform, with databases, Kafka, ClickHouse, object storage, DNS, and TLS, and you validate capacity, backups, and upgrade runbooks before carrying production traffic. A self-hosted platform is independent, and it cannot federate with the FrameWorks network. Start with the deployment overview.

Use this when your sources can reach the internet and you want to stop running media servers. Platform clusters reject private literal source addresses, so multicast and LAN cameras need a hybrid edge or an encoder that pushes out.

The same steps apply on all three paths.

Export streams from /streamer/api/v3/streams and keep a copy of flussonic.conf. For each stream, record its type, inputs, template, dvr, transcoder, push, and on_play settings.

  • Direct: published streams and on-demand sources with public or edge-reachable URLs.
  • Needs a relay: static channels and cameras that must record with no viewers.
  • Waits for the roadmap: anything that needs an up next item, such as DRM.
  • Stays on Flussonic: anything that needs a not planned item, such as multicast output or middleware integration.

Expand templates by hand, since each stream carries its own settings. Script it from your export, and store the mapping from Flussonic name to id, streamKey, and playbackId.

mutation CreateChannel {
createStream(input: { name: "channel-1", record: true }) {
... on Stream {
id
streamKey
playbackId
}
}
}

Repoint encoders, or set up pull sources and relays. Encoders on RTMPS move to RTMP, or to SRT or WHIP for an encrypted link.

Port on_play to a webhook policy. Verify X-Frameworks-Signature, read viewerToken, and return 200 or 403. Test with testPlaybackAccess before enforcing it.

Set retention, choose a chapter mode, and map your catch-up URLs to dvrChapters lookups. Existing Flussonic archives do not transfer automatically. Exported MP4 files can be imported as VOD with importVodAsset, and larger library imports are concierge work; contact us before you start.

Create a webhook endpoint for the events you handle, then update signature checks and event names.

Replace viewer URLs in players, middleware, and embeds. Signed URLs need ?jwt=.

Follow Run it in parallel. Flussonic gives you two ways to do this without touching the encoder:

  • Add an RTMP push to the stream, pointed at a FrameWorks stream key. This keeps multistream targets available.
  • Have FrameWorks pull Flussonic’s HLS output as a pull-input stream. Remember that a pull stream only runs with viewers and cannot start push targets.
  • Hybrid production cutovers need operator validation. Test DNS, TLS, firewall policy, capacity, node enrollment, and upgrade runbooks before moving production traffic.
  • Billing rates are still maturing. Rates may adjust as the platform matures.
  • Marketplace primitives ship; the vetted public program is up next.
  • Two viewers arriving at once on an idle pull stream can briefly open two upstream connections before fanout takes over. Check this against sources with connection limits.

You work directly with the video engineers who have built MistServer for more than 15 years. Send us your inventory from step 1 and we will tell you which streams fit and which should stay put.

ChannelBest forWhere
In-app ticketingMigration scoping, account-specific questionsDashboard /support
SkipperAPI discovery, diagnostics, after-hours helpDashboard /skipper, ⌘J in docs, MCP at /mcp
ForumLong-form Q&Aforum.frameworks.network
DiscordReal-time discussionJoin