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

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 in the repository root, ffmpeg is a required dependency, and 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.

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

Step 2: Generate Word-Level Transcripts

Run 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.

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, 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 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.

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.

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.

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: 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: 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: Defines the skill layout, environment variables, and the expected directory structure for <videos_dir>/edit/.
• install.md: Documents ffmpeg installation and the ELEVENLABS_API_KEY requirement.
• 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, 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.
• Render final output using 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 and 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 and enforced in helpers/transcribe.py.

How does the render script handle video formats?

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, Claude writes approved edit plans to the <videos_dir>/edit/ directory as JSON files. The helpers/render.py script expects this path as its primary argument to locate the cut list and arrangement instructions.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}