Cloudflare's Streamline shows how to build custom video pipelines on Stream and Workers

Cloudflare has released Streamline, a developer playground that demonstrates how to build custom video pipelines on top of its Developer Platform. According to the Cloudflare blog post published on 2 October 2026, the aim is to cover cases the standard Stream product does not handle on its own — rendering dynamic annotations onto a livestream, for example, or producing a copy of a hosted video with subtitles burned into the picture — and to publish the processed result straight back to Stream as a new livestream or hosted video.

How the pipeline is put together

A Streamline deployment has two parts. The first is the Media Engine, which handles media input, output and transformation, and runs inside a Cloudflare Container. The engine splits into a Controller — a control harness written in Go that exposes an HTTP server and turns incoming requests into operations — and a Processor that performs the actual media work. Cloudflare notes that the current Processor uses FFmpeg, but treats that as an internal implementation detail rather than part of the user-facing API.

The engine is flexible about where video comes from and where it goes. It can ingest an RTMPS feed from one Stream Live input and republish processed output to another. It can fetch a Stream HLS manifest and its segments so that hosted videos can serve as pipeline input. It can accept a source supplied by the controlling application, such as a webcam, and it can push preview video over an outbound WebSocket to a Durable Object relay that other applications subscribe to.

The second part is the controlling Application, built on Workers. It can take the form of a full-stack browser app, an agent or an embedded system, and consists of a user interface covering client logic, identity and access policy, plus an Orchestrator — implemented as a Durable Object — responsible for session management, container lifecycle and the preview relay.

Local development is deliberately simpler: the container is just a local Docker instance, the Durable Object is not used, there is a single user with no authorization requirement, and the video preview connects directly to a WebSocket on localhost.

Sessions that outlive their requests

Video streams can run for minutes or hours, so the media process needs a lifecycle independent of whatever request started it. Cloudflare Containers normally go to sleep after a defined interval with no incoming requests, which is wrong for a pipeline that must keep running while its controller is disconnected. Streamline handles this by overriding the container's onActivityExpired() callback: if the session has not yet reached its expiry time the activity timeout is renewed, otherwise the container destroys itself. A maximum duration guarantees every session is eventually torn down even with no external control. While a session runs, the container instance is unavailable to other applications.

A session-based API

To hide backend details, Streamline exports two packages: @cloudflare/streamline/client, a high-level session-based API, and @cloudflare/streamline/, which exposes the Durable Object base class associated with the container, routes API requests, runs the preview relay and provides hooks for security and access policy. In a remote deployment, the controlling Worker imports the package and defines a concrete subclass of that Durable Object to add application-specific logic and storage. In local mode, a thin adapter layer preserves the same session API while talking directly to the Docker instance.

The client surface covers creating a Streamline instance, creating and resuming sessions, starting a pipeline from a JSON configuration, sending video chunks in webcam mode, updating a transparent PNG annotation overlay, reading session metrics and stopping processing. Pipelines themselves are defined declaratively as inputs, operations and an output.

Why it matters

Stream has largely been an opinionated product that handles common broadcasting workflows out of the box, which leaves developers stuck when they need something slightly different. Streamline points toward a more programmable model, where teams assemble their own processing stages on Cloudflare's edge infrastructure rather than waiting for a specific feature to ship or running their own transcoding servers.

The architecture is also a reference implementation for a broader pattern on the platform: Containers for long-running compiled workloads, Durable Objects for orchestration, and Workers for control signaling and monitoring. Cloudflare adds that the design is deliberately modular, so the FFmpeg-based engine could later be swapped for dedicated encoding products — a hint that this playground is groundwork for productised video processing rather than a one-off demo. For teams building bespoke video features, the practical appeal is that pipelines start, run and stop through an API while Stream handles ingest and delivery.