Cloudflare on October 2, 2026 released Streamline, a developer playground and open-source project that demonstrates how to build custom video processing pipelines on its Developer Platform using Workers, Containers and Durable Objects. The company also deployed a public playground of an example application.
What Cloudflare is releasing
Cloudflare said Streamline shows how developers can deliver "bespoke video experiences" such as rendering dynamic annotations on a livestream or creating an alternate version of a hosted video with burned-in subtitles, use cases it said require a custom video pipeline rather than Cloudflare Stream alone.
According to the company, a Streamline deployment has two components: a Media Engine that handles media input, output and processing, and a controlling Application that creates, configures, observes and stops media sessions. The Media Engine runs in a Container and consists of a Go control harness exposing an HTTP server and a processor that currently uses FFmpeg, which Cloudflare described as an internal implementation detail rather than part of the user-facing API.
Cloudflare said processing continues even if the controlling Worker disconnects, and that sessions have a maximum duration so a pipeline cannot run indefinitely without external control. Container sleep behavior is handled by overriding the onActivityExpired() callback, the post said.
How the pipeline works
Cloudflare said the Media Engine can pull RTMPS playback from one Stream Live input and publish RTMPS output to another, ingest a Cloudflare Stream HLS manifest and its segments, accept video supplied by the controlling application such as a webcam, and publish preview video over an outbound WebSocket to a Durable Object relay.
The project exports two packages, @cloudflare/streamline/client for a high-level session-based API and a package exposing the Durable Object base class associated with the container. Client methods listed by Cloudflare include createStreamline(), sessions.create(), sessions.resume(id), start(config), ingest(chunk), annotation(png), metrics() and stop().
Pipelines are defined by a JSON configuration object specifying inputs, operations and output. The currently supported operations are filter, overlay, subtitle and encode. Cloudflare noted that the operation order is fixed by the engine and that the order specified in the configuration array is not significant.
For preview, the container publishes fMP4 fragments to the Durable Object, which forwards them to a relay available over a WebSocket at /relay/view relative to the application origin. Cloudflare said the application must connect before session.start(), or the relay rejects the publisher.
Security model
Cloudflare said the owner deployment is kept private using Workers' Access integration, that the Worker verifies the Access session before accepting control requests, and that only one session can run at a time, with a different principal unable to stop or replace an active session.
Stream Live Input keys are stored in Worker secrets or as write-only shared overrides in Durable Object storage and are never returned by the settings API or placed in browser storage, according to the post. The controlling application refers to RTMPS inputs and outputs by named profile, which the Worker resolves before contacting the container.
The preview stream uses two credentials: a Cloudflare Access service token that authenticates the container workload to the publisher endpoint, and a random per-session capability that authorizes publishing only for the active relay. Cloudflare said the initial deployment uses a temporary path-specific Access Bypass, replaced with Service Auth after a successful smoke test, and stressed that the owner deployment "is not the security model for a public multi-user service."
Limits and what comes next
Cloudflare said this iteration uses Container CPU for media processing, "which introduces a bottleneck at higher qualities or frame-rates."
The company said it wants to see the architecture extended to computer vision pipelines, hardware-accelerated media processing, real-time experiences with protocols such as WebRTC and MoQ, and eventually video encoding and decoding primitives natively in Workers.
What to do
- Try Cloudflare's hosted playground of the example application at playground.streamline-video.workers.dev.
- Get the open-source code from github.com/cloudflare/streamline for the media engine and package exports, and github.com/cloudflare/streamline-demo for the example Worker, Astro frontend, deployment profiles and Access tooling.
- Run the container locally with Docker during development, where Cloudflare says the Durable Object is not used, there is a single user, no authorization is required for local access, and preview connects directly to a WebSocket on localhost.
- When deploying on your own account, Cloudflare says to put the example application behind Cloudflare Access to control who can reach your Streamline instance.
- Connect the preview WebSocket before calling session.start(), because Cloudflare says the relay otherwise rejects the publisher, and queue fragments in a production MediaSource player while SourceBuffer.updating is true.
Key facts and where they come from
- Cloudflare released Streamline as a developer playground for custom video pipelines.
Today, we’re releasing a new developer playground, Streamline, that demonstrates how you can build a system to deliver these bespoke video experiences on Cloudflare’s Developer Platform.
- The media processor currently uses FFmpeg.
The current implementation uses FFmpeg, but that is an internal implementation detail rather than part of the user-facing API.
- Supported pipeline operations are filter, overlay, subtitle and encode.
filter
Applies filtering operations, e.g. blur, saturation.overlay
Overlays an image referenced by URL or a binary PNG specified separately in a call to annotation(). - Code is published in two open-source GitHub repositories.
https://github.com/cloudflare/streamline – Media engine, and package exports for applications.
- A public playground deployment is available.
You can try the public playground at:
https://playground.streamline-video.workers.dev - Container CPU processing is a stated bottleneck.
Streamline uses Container CPU for media processing, which introduces a bottleneck at higher qualities or frame-rates.
- Stream Live Input keys are kept out of the controlling application.
Stream Live Input keys are stored in Worker secrets or as write-only shared overrides in Durable Object storage. They are never returned by the settings API or placed in browser storage.