# How to Use video-use for Live Streaming: A Complete Workflow Guide

> Learn to live stream efficiently with video-use. Capture, transcribe with ElevenLabs, plan edits with Claude, and render for rebroadcast. Master your video production workflow.

- Repository: [Browser Use/video-use](https://github.com/browser-use/video-use)
- Tags: how-to-guide
- Published: 2026-07-10

---

**You can use video-use for live streaming by capturing the stream to disk with ffmpeg, transcribing segments with the ElevenLabs-powered transcribe helper, generating an edit plan with Claude, and rendering the final output for rebroadcast.**

The `video-use` repository from browser-use provides a CLI-driven skill framework for automated video editing with Claude Code. While primarily designed for post-production, the same architecture supports live streaming workflows by processing incoming video segments in real time. This guide walks through the complete pipeline from capture to broadcast using the actual source files and helper scripts found in the repository.

## Prerequisites

Before streaming, install ffmpeg and set your ElevenLabs API key. According to [`install.md`](https://github.com/browser-use/video-use/blob/main/install.md) in the repository root, ffmpeg is a required dependency, and [`helpers/transcribe.py`](https://github.com/browser-use/video-use/blob/main/helpers/transcribe.py) requires the `ELEVENLABS_API_KEY` environment variable to generate word-level timestamps.

## The Live Streaming Workflow

### Step 1: Capture the Live Stream to Disk

Use ffmpeg to write the incoming RTMP or HTTP stream to a local MP4 file. The `+faststart` flag ensures the file is readable even if processing begins while recording continues.

```bash
ffmpeg -i <STREAM_URL> -c copy -f mp4 -movflags +faststart live_capture.mp4

```

### Step 2: Generate Word-Level Transcripts

Run [`helpers/transcribe.py`](https://github.com/browser-use/video-use/blob/main/helpers/transcribe.py) to call the ElevenLabs API and produce a timestamped JSON transcript. This script accepts a video path and optional speaker count, creating the data foundation for Claude's editing decisions.

```bash
python helpers/transcribe.py live_capture.mp4 \
    --language en \
    --num-speakers 2

```

### Step 3: Create the Edit Plan

Claude Code reads the transcript output and proposes cuts, overlays, and arrangements. As documented in [`SKILL.md`](https://github.com/browser-use/video-use/blob/main/SKILL.md), the skill writes the approved edit plan as a JSON file to `<videos_dir>/edit/`.

### Step 4: Render the Final Cut

Execute [`helpers/render.py`](https://github.com/browser-use/video-use/blob/main/helpers/render.py) to process the edit plan. This script uses `ffprobe` to read source video properties and ffmpeg to compile the final output according to the JSON specifications.

```bash
python helpers/render.py <videos_dir>/edit/plan.json \
    --output final_stream.mp4

```

### Step 5: Broadcast to Your Platform

Stream the rendered file using ffmpeg's RTMP output. This step pushes the edited video to Twitch, YouTube Live, or any RTMP-compatible server.

```bash
ffmpeg -re -i final_stream.mp4 -c copy -f flv rtmp://live.twitch.tv/app/<STREAM_KEY>

```

## Continuous Chunk Processing for 24/7 Streams

For ongoing live streams, process video in timed segments rather than single files. This approach lets you transcribe and edit previous chunks while new ones record.

```bash
while :; do
  ts=$(date +%s)
  ffmpeg -i rtmp://example.com/live/stream -t 300 -c copy "chunk_${ts}.mp4"
  python helpers/transcribe.py "chunk_${ts}.mp4" --language en &
  # Once Claude generates edit/plan_${ts}.json:

  # python helpers/render.py edit/plan_${ts}.json --output "final_${ts}.mp4"

done

```

## Key Source Files and Architecture

Understanding the repository structure helps customize the workflow:

- **[`helpers/transcribe.py`](https://github.com/browser-use/video-use/blob/main/helpers/transcribe.py)**: Implements the ElevenLabs API integration for speech-to-text with word-level timestamps. Located at the repository root, this is the entry point for all transcription tasks.
- **[`helpers/render.py`](https://github.com/browser-use/video-use/blob/main/helpers/render.py)**: Consumes JSON edit plans and orchestrates ffmpeg/ffprobe commands to produce final video files. The script handles resolution filtering and codec selection via command-line arguments.
- **[`SKILL.md`](https://github.com/browser-use/video-use/blob/main/SKILL.md)**: Defines the skill layout, environment variables, and the expected directory structure for `<videos_dir>/edit/`.
- **[`install.md`](https://github.com/browser-use/video-use/blob/main/install.md)**: Documents ffmpeg installation and the `ELEVENLABS_API_KEY` requirement.
- **[`pyproject.toml`](https://github.com/browser-use/video-use/blob/main/pyproject.toml)**: Contains package metadata confirming the project name as `video-use`.

## Summary

- **Capture** live streams using ffmpeg with `-movflags +faststart` for immediate processing compatibility.
- **Transcribe** captured segments using [`helpers/transcribe.py`](https://github.com/browser-use/video-use/blob/main/helpers/transcribe.py), which requires the `ELEVENLABS_API_KEY` environment variable.
- **Edit** by letting Claude generate JSON plans stored in `<videos_dir>/edit/` as described in [`SKILL.md`](https://github.com/browser-use/video-use/blob/main/SKILL.md).
- **Render** final output using [`helpers/render.py`](https://github.com/browser-use/video-use/blob/main/helpers/render.py), which leverages `ffprobe` for metadata and ffmpeg for compilation.
- **Stream** the result to RTMP endpoints using standard ffmpeg broadcast commands.

## Frequently Asked Questions

### Can video-use process a live stream in real time without saving to disk?

No, the current architecture in `browser-use/video-use` requires local file access. [`helpers/transcribe.py`](https://github.com/browser-use/video-use/blob/main/helpers/transcribe.py) and [`helpers/render.py`](https://github.com/browser-use/video-use/blob/main/helpers/render.py) operate on file paths, not network streams. You must buffer segments to disk using ffmpeg before processing.

### What API key is required for transcription?

The transcription helper requires an `ELEVENLABS_API_KEY` environment variable to authenticate with the ElevenLabs API for word-level timestamp generation. This is documented in [`install.md`](https://github.com/browser-use/video-use/blob/main/install.md) and enforced in [`helpers/transcribe.py`](https://github.com/browser-use/video-use/blob/main/helpers/transcribe.py).

### How does the render script handle video formats?

[`helpers/render.py`](https://github.com/browser-use/video-use/blob/main/helpers/render.py) uses `ffprobe` to introspect source video properties automatically, then invokes ffmpeg with appropriate codecs and filters based on the edit plan JSON. You can override resolution and other parameters using command-line flags like `--filter`.

### Where does Claude store the edit plans during live streaming?

According to [`SKILL.md`](https://github.com/browser-use/video-use/blob/main/SKILL.md), Claude writes approved edit plans to the `<videos_dir>/edit/` directory as JSON files. The [`helpers/render.py`](https://github.com/browser-use/video-use/blob/main/helpers/render.py) script expects this path as its primary argument to locate the cut list and arrangement instructions.