yt-dlp Web UI

yt-dlp Web UI is a lightweight, high‑performance web interface coupled with an RPC server that orchestrates the yt-dlp downloader. It is engineered for low resource consumption while providing a rich set of developer‑oriented features such as custom argument injection, concurrent download throttling, and optional authentication via JWT. The application is intended to run on a self‑hosted NAS or any Linux host where automated video ingestion and livestream monitoring are required. Its architecture is intentionally minimalistic, avoiding heavy frameworks so that the container footprint remains small and the daemon can be integrated into existing CI/CD or media pipelines without significant overhead.

Key Features

• RPC‑driven download queue – Exposes a REST/JSON API that accepts download jobs, returns status updates, and allows cancellation or priority re‑ordering.
• Customizable argument passing – Users can safely inject arbitrary yt-dlp flags through the UI or API, enabling fine‑grained control over format selection, output templating, and extraction options.
• Concurrent download limits – The --qs flag or the UI queue size setting caps simultaneous downloads, making it suitable for bandwidth‑constrained environments.
• Authentication & Authorization – Optional JWT support allows secure API access; the UI can be protected behind an authentication layer without modifying core logic.
• Extensible format selection – Although disabled by default, the UI can expose a dropdown of available formats returned by yt-dlp, facilitating user‑driven quality choice.

Technical Stack

• Backend: Go (Golang) – the core server is a single binary that bundles yt-dlp as an external process, spawns workers, and serves HTTP endpoints.
• Frontend: Vue.js (or similar lightweight SPA framework) – renders the dashboard, manages WebSocket connections for real‑time status updates, and handles user configuration.
• Database: None – the application persists state in a simple JSON/YAML config file under /config, making it stateless and container‑friendly.
• Containerization: Official Docker images are published to Docker Hub and GitHub Container Registry, with multi‑arch support. The Dockerfile uses a scratch or minimal Alpine base to keep the image below 50 MB.

Deployment & Infrastructure

The service is designed for container‑first deployment. A single docker run command mounts a host directory as /downloads, optionally /config for persistent settings, and exposes port 3033. For orchestration, a minimal Docker‑Compose snippet is provided, including health checks and restart policies. The application scales horizontally by running multiple instances behind a load balancer; the RPC queue is local to each instance, so scaling does not introduce shared state. For high‑availability, a reverse proxy (NGINX/Traefik) can handle TLS termination and JWT authentication before requests reach the Go backend.

Integration & Extensibility

• Webhooks – The API can trigger custom scripts or external services upon download completion, enabling integration with media servers (Plex, Jellyfin) or CI pipelines.
• Plugin hooks – Developers can extend the Go binary by adding new command handlers or middleware; the repository exposes a clean interface for adding custom RPC endpoints.
• Custom CLI flags – The Docker entrypoint accepts arguments such as --auth, --user, and --pass to toggle authentication without code changes.
• Format parsing – The UI can consume the JSON output of yt-dlp --list-formats to build dynamic selection menus, allowing downstream applications to pick the best quality programmatically.

Developer Experience

The codebase follows idiomatic Go practices, with comprehensive unit tests and clear module boundaries. Documentation is available in the README and inline comments; community support is active via Discord, GitHub Discussions, and a dedicated poll for UI roadmap decisions. The project’s licensing is permissive (MIT), encouraging reuse and modification in commercial or open‑source projects. The minimal dependency set means that developers can fork, patch, and rebuild the binary in minutes, making it an attractive choice for custom media ingestion pipelines.

Use Cases

1. NAS Video Harvesting – Automate downloading of lecture recordings or conference streams onto a home media server, with the UI providing a quick status overview.
2. Live‑Stream Monitoring – Schedule checks for upcoming livestreams and trigger downloads when they go live, integrating with notification services (Telegram, Slack).
3. Edge‑Compute Media Caching – Deploy on edge nodes to cache popular video content locally, reducing upstream bandwidth and latency for downstream clients.
4. CI/CD Artifact Retrieval – Use the RPC API to pull video artifacts from remote repositories as part of a build pipeline, ensuring reproducible media assets.

Advantages Over Alternatives

• Lightweight – No heavy JavaScript frameworks or monolithic servers; the Go binary stays under 30 MB.
• Low Resource Footprint – Designed for NAS and IoT devices where CPU/memory are limited.
• Developer‑Friendly API – Exposes a clean JSON interface that can be consumed by any language.
• Extensible Argument Injection – Unlike some GUIs that hard‑code options, this UI lets developers pass arbitrary yt-dlp flags safely.
• Open Source & Flexible – MIT license, active community, and the ability to fork or extend