### Install yt-dlp and ffmpeg Binaries with Rust

Source: https://github.com/boul2gom/yt-dlp/blob/develop/README.md

Installs both the yt-dlp and ffmpeg binaries to specified directories. Ensure Tokio is set up for async operations.

```rust
use yt_dlp::Downloader;
use std::path::PathBuf;

#[tokio::main]
pub async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let executables_dir = PathBuf::from("libs");
    let output_dir = PathBuf::from("output");

    // Create fetcher and install binaries
    let downloader = Downloader::with_new_binaries(
        executables_dir,
        output_dir
    ).await?.build().await?;
    
    Ok(())
}
```

--------------------------------

### Install ffmpeg Binary Only with Rust

Source: https://github.com/boul2gom/yt-dlp/blob/develop/README.md

Installs only the ffmpeg binary to a specified destination directory. Requires the `LibraryInstaller` from `yt_dlp::client::deps`.

```rust
use yt_dlp::client::deps::LibraryInstaller;
use std::path::PathBuf;

#[tokio::main]
pub async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let destination = PathBuf::from("libs");
    let installer = LibraryInstaller::new(destination);
    
    let ffmpeg = installer.install_ffmpeg(None).await.unwrap();
    Ok(())
}
```

--------------------------------

### Download Video from TikTok

Source: https://github.com/boul2gom/yt-dlp/blob/develop/README.md

This example demonstrates downloading a video from TikTok. It requires setting up the Downloader with paths to yt-dlp and ffmpeg binaries.

```rust
use yt_dlp::Downloader;
use yt_dlp::client::deps::Libraries;
use std::path::PathBuf;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let libraries = Libraries::new(PathBuf::from("libs/yt-dlp"), PathBuf::from("libs/ffmpeg"));
    let downloader = Downloader::builder(libraries, PathBuf::from("output")).build().await?;

    let url = "https://www.tiktok.com/@user/video/123".to_string();
    let video = downloader.fetch_video_infos(url).await?;
    downloader.download_video(&video, "tiktok-video.mp4").await?;

    Ok(())
}
```

--------------------------------

### Create Downloader with Auto-Installed Binaries

Source: https://context7.com/boul2gom/yt-dlp/llms.txt

Instantiates a Downloader that automatically downloads and installs yt-dlp and ffmpeg binaries if they are not present. Requires specifying directories for executables and output.

```rust
use yt_dlp::Downloader;
use std::path::PathBuf;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let executables_dir = PathBuf::from("libs");
    let output_dir = PathBuf::from("output");

    // Automatically installs yt-dlp and ffmpeg if not present
    let downloader = Downloader::with_new_binaries(executables_dir, output_dir)
        .await? 
        .build()
        .await?;

    println!("Downloader ready with auto-installed dependencies");
    Ok(())
}
```

--------------------------------

### Install yt-dlp Binary Only with Rust

Source: https://github.com/boul2gom/yt-dlp/blob/develop/README.md

Installs only the yt-dlp binary to a specified destination directory. Requires the `LibraryInstaller` from `yt_dlp::client::deps`.

```rust
use yt_dlp::client::deps::LibraryInstaller;
use std::path::PathBuf;

#[tokio::main]
pub async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let destination = PathBuf::from("libs");
    let installer = LibraryInstaller::new(destination);

    let youtube = installer.install_youtube(None).await.unwrap();
    Ok(())
}
```

--------------------------------

### RPITIT Example

Source: https://github.com/boul2gom/yt-dlp/blob/develop/CONTRIBUTING.md

Defines a trait `VideoBackend` that returns futures for asynchronous operations. Requires `Send` and `Sync` bounds.

```rust
pub trait VideoBackend: Send + Sync + std::fmt::Debug {
    fn get(&self, url: &str) -> impl Future<Output = Result<Option<Video>>> + Send;
    fn put(&self, url: String, video: Video) -> impl Future<Output = Result<()>> + Send;
}
```

--------------------------------

### Event System Hook Example

Source: https://github.com/boul2gom/yt-dlp/blob/develop/CONTRIBUTING.md

Illustrates how to define a new event variant for the `DownloadEvent` enum. Emphasizes the use of named fields for clarity and consistency.

```rust
// In DownloadEvent — always use named fields:
// ✅ GOOD
MyNewEvent {
    download_id: u64,
    reason: String,
},

// ❌ BAD — No tuple variants
MyNewEvent(u64, String),
```

--------------------------------

### Create Downloader with Existing Binaries

Source: https://context7.com/boul2gom/yt-dlp/llms.txt

Creates a Downloader instance when yt-dlp and ffmpeg are already installed. Requires specifying the paths to the binaries and the output directory. Allows setting custom timeouts and maximum concurrent downloads.

```rust
use yt_dlp::Downloader;
use yt_dlp::client::deps::Libraries;
use std::path::PathBuf;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let libraries = Libraries::new(
        PathBuf::from("libs/yt-dlp"),
        PathBuf::from("libs/ffmpeg"),
    );

    let downloader = Downloader::builder(libraries, "output")
        .with_timeout(std::time::Duration::from_secs(120))
        .with_max_concurrent_downloads(4)
        .build()
        .await?;

    println!("Downloader created: {}", downloader);
    Ok(())
}
```

--------------------------------

### Implementing Display for Video Struct

Source: https://github.com/boul2gom/yt-dlp/blob/develop/CONTRIBUTING.md

Provides an example of implementing the `fmt::Display` trait for a `Video` struct. It formats essential fields and handles optional fields gracefully.

```rust
impl fmt::Display for Video {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "Video(id={}, title={:?}, channel={:?}, formats={})",
            self.id, self.title, self.channel.as_deref().unwrap_or("Unknown"), self.formats.len())
    }
}
```

--------------------------------

### Fetch and Download Video with Rust

Source: https://github.com/boul2gom/yt-dlp/blob/develop/README.md

Fetches video information for a given URL and then downloads the video with its audio. Requires yt-dlp and ffmpeg binaries to be installed.

```rust
use yt_dlp::Downloader;
use std::path::PathBuf;
use yt_dlp::client::deps::Libraries;

#[tokio::main]
pub async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let libraries_dir = PathBuf::from("libs");
    let output_dir = PathBuf::from("output");
    
    let youtube = libraries_dir.join("yt-dlp");
    let ffmpeg = libraries_dir.join("ffmpeg");
    
    let libraries = Libraries::new(youtube, ffmpeg);
    let downloader = Downloader::builder(libraries, output_dir)
        .build()
        .await?;

    let url = String::from("https://www.youtube.com/watch?v=gXtp6C-3JKo");
    let video = downloader.fetch_video_infos(url).await?;
    let video_path = downloader.download_video(&video, "my-video.mp4").await?;
    Ok(())
}
```

--------------------------------

### Stream Live Fragments with yt-dlp

Source: https://github.com/boul2gom/yt-dlp/blob/develop/README.md

Enable the 'live-streaming' feature to stream live video fragments. This example shows how to iterate over received fragments and print their sizes.

```rust
use yt_dlp::Downloader;
use yt_dlp::client::deps::Libraries;
use std::path::PathBuf;
use tokio_stream::StreamExt;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let libraries = Libraries::new(
        PathBuf::from("libs/yt-dlp"),
        PathBuf::from("libs/ffmpeg"),
    );
    let downloader = Downloader::builder(libraries, "output").build().await?;

    let video = downloader.fetch_video_infos("https://youtube.com/watch?v=LIVE_ID").await?;

    let mut stream = downloader.stream_live(&video)
        .execute()
        .await?;

    while let Some(fragment) = stream.next().await {
        let fragment = fragment?;
        println!("Fragment {} bytes", fragment.data.len());
    }

    Ok(())
}
```

--------------------------------

### Working with Automatic Captions in Rust

Source: https://github.com/boul2gom/yt-dlp/blob/develop/README.md

This snippet demonstrates the setup for working with automatic captions, likely involving fetching video information and preparing the downloader. Further implementation details for caption processing would follow.

```rust
use yt_dlp::Downloader;
use yt_dlp::model::caption::Subtitle;
use std::path::PathBuf;
use yt_dlp::client::deps::Libraries;

#[tokio::main]
pub async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let libraries_dir = PathBuf::from("libs");
    let output_dir = PathBuf::from("output");

    let youtube = libraries_dir.join("yt-dlp");
    let ffmpeg = libraries_dir.join("ffmpeg");

    let libraries = Libraries::new(youtube, ffmpeg);

```

--------------------------------

### Structured Tracing and Logging Example

Source: https://github.com/boul2gom/yt-dlp/blob/develop/CONTRIBUTING.md

Illustrates the correct usage of the `tracing` crate with structured fields and domain-specific emoji prefixes for debug and info messages. Avoids interpolation and incorrect emoji usage.

```rust
// ✅ GOOD
tracing::debug!(url = %url, timeout = ?timeout, "📥 Starting download");
tracing::info!(video_id = video_id, formats = formats.len(), "📡 Video fetched");
tracing::warn!(url = %url, attempt = attempt, "Retry after failure");

// ❌ BAD
tracing::debug!("Starting download for {}", url);  // No interpolation
tracing::info!("Video fetched");                     // No structured fields
tracing::warn!("⚠️ Retry");                          // No emoji on warn
```

--------------------------------

### Configure Multiple Cache Backends with Runtime Selection

Source: https://github.com/boul2gom/yt-dlp/blob/develop/README.md

When multiple persistent cache backends are compiled, you must explicitly set the desired backend at runtime using `CacheConfig::persistent_backend`. This example shows how to compile with multiple backends and configure Redb.

```rust
use yt_dlp::prelude::*;

let config = CacheConfig::builder()
    .cache_dir("cache")
    .persistent_backend(PersistentBackendKind::Redb) // required when multiple compiled in
    .build();
```

--------------------------------

### Configuring Retry Strategies

Source: https://github.com/boul2gom/yt-dlp/blob/develop/README.md

Provides examples of configuring different retry strategies for webhook requests. Supports exponential backoff, linear backoff, and disabling retries.

```rust
use yt_dlp::events::RetryStrategy;
use std::time::Duration;

// Exponential backoff (default)
let strategy = RetryStrategy::exponential(
    3,                              // max attempts
    Duration::from_secs(1),         // initial delay
    Duration::from_secs(30)         // max delay
);

// Linear backoff
let strategy = RetryStrategy::linear(
    3,                              // max attempts
    Duration::from_secs(5)          // fixed delay
);

// No retries
let strategy = RetryStrategy::none();
```

--------------------------------

### Initialize Downloader

Source: https://github.com/boul2gom/yt-dlp/blob/develop/README.md

Sets up the Downloader with paths to yt-dlp and ffmpeg executables, and an output directory. This is a prerequisite for most download operations.

```rust
use yt_dlp::Downloader;
use std::path::PathBuf;
use yt_dlp::client::deps::Libraries;

#[tokio::main]
pub async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let libraries_dir = PathBuf::from("libs");
    let output_dir = PathBuf::from("output");

    let youtube = libraries_dir.join("yt-dlp");
    let ffmpeg = libraries_dir.join("ffmpeg");

    let libraries = Libraries::new(youtube, ffmpeg);
    let downloader = Downloader::builder(libraries, output_dir)
        .build()
        .await?;

    // ... rest of the code

    Ok(())
}
```

--------------------------------

### Initialize Downloader for YouTube

Source: https://github.com/boul2gom/yt-dlp/blob/develop/README.md

Sets up the `Downloader` with specified libraries and output path, then accesses YouTube-specific features like search and channel fetching.

```rust
use yt_dlp::Downloader;
use yt_dlp::client::deps::Libraries;
use std::path::PathBuf;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let libraries = Libraries::new(
        PathBuf::from("libs/yt-dlp"),
        PathBuf::from("libs/ffmpeg")
    );
    let downloader = Downloader::builder(libraries, "output")
        .build()
        .await?;

    // Access YouTube-specific features
    let youtube = downloader.youtube_extractor();
    let results = youtube.search("rust programming", 10).await?;
    let channel = youtube.fetch_channel("UCaYhcUwRBNscFNUKTjgPFiA").await?;

    Ok(())
}
```

--------------------------------

### Initialize Downloader for Generic Websites

Source: https://github.com/boul2gom/yt-dlp/blob/develop/README.md

Initializes the `Downloader` for general use, allowing fetching video information and downloading from any supported website like Vimeo or TikTok.

```rust
use yt_dlp::Downloader;
use yt_dlp::client::deps::Libraries;
use std::path::PathBuf;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let libraries = Libraries::new(
        PathBuf::from("libs/yt-dlp"), 
        PathBuf::from("libs/ffmpeg")
    );
    let downloader = Downloader::builder(libraries, "output")
        .build()
        .await?;

    // Works with any supported site
    let video = downloader.fetch_video_infos("https://vimeo.com/123456789").await?;
    let video_path = downloader.download_video(
        &video,
        "output.mp4"
    ).await?;
    Ok(())
}
```

--------------------------------

### Rustdoc Comment Template

Source: https://github.com/boul2gom/yt-dlp/blob/develop/CONTRIBUTING.md

A standard template for rustdoc comments, including sections for arguments, errors, returns, and examples. The `# Examples` section should be used for main public API entry points.

```rust
/// Brief one-line description.
///
/// Optional extended description.
///
/// # Arguments
///
/// * `param` - Description
///
/// # Errors
///
/// Returns an error if ...
///
/// # Returns
///
/// Description of return value.
///
/// # Examples
///
/// ```rust,no_run
/// # use yt_dlp::prelude::*;
/// # #[tokio::main]
/// # async fn main() -> Result<(), Box<dyn std::error::Error>> {
/// let downloader = Downloader::builder(libraries, "output").build().await?;
/// # Ok(())
/// # }
/// ```
```

--------------------------------

### Initialize Downloader and Fetch Video Info

Source: https://github.com/boul2gom/yt-dlp/blob/develop/README.md

Initializes the yt-dlp downloader and fetches video information from a given URL. Ensure libraries and output directory are correctly configured.

```rust
let downloader = Downloader::builder(libraries, output_dir)
    .build()
    .await?;

let url = String::from("https://www.youtube.com/watch?v=gXtp6C-3JKo");
let video = downloader.fetch_video_infos(url).await?;
```

--------------------------------

### Detect Extractor for URL

Source: https://github.com/boul2gom/yt-dlp/blob/develop/README.md

This example shows how to detect which yt-dlp extractor will handle a given URL. It prints the name of the detected extractor.

```rust
use yt_dlp::Downloader;
use yt_dlp::client::deps::Libraries;
use std::path::PathBuf;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let libraries = Libraries::new(
        PathBuf::from("libs/yt-dlp"),
        PathBuf::from("libs/ffmpeg")
    );
    let downloader = Downloader::builder(libraries, "output").build().await?;
    let extractor = downloader.detect_extractor("https://vimeo.com/123").await?;
    println!("This URL uses the '{}' extractor", extractor);
    Ok(())
}
```

--------------------------------

### Select and Download Specific Video/Audio Formats

Source: https://context7.com/boul2gom/yt-dlp/llms.txt

Access available video and audio formats, then download a specific one by examining format metadata. Ensure `yt_dlp` and `tokio` are set up.

```rust
use yt_dlp::Downloader;
use yt_dlp::client::deps::Libraries;
use yt_dlp::VideoSelection;
use std::path::PathBuf;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let libraries = Libraries::new(
        PathBuf::from("libs/yt-dlp"),
        PathBuf::from("libs/ffmpeg"),
    );
    let downloader = Downloader::builder(libraries, "output").build().await?;

    let video = downloader
        .fetch_video_infos("https://www.youtube.com/watch?v=gXtp6C-3JKo")
        .await?;

    // Get best video format
    if let Some(video_format) = video.best_video_format() {
        println!("Best video: {} - {}p",
            video_format.format_id,
            video_format.video_resolution.height.unwrap_or(0));
        let path = downloader.download_format(&video_format, "best-video.mp4").await?;
        println!("Downloaded: {}", path.display());
    }

    // Get worst audio format (smallest file)
    if let Some(audio_format) = video.worst_audio_format() {
        println!("Smallest audio: {} - {}kbps",
            audio_format.format_id,
            audio_format.rates_info.audio_rate.map(|r| *r as i32).unwrap_or(0));
        let path = downloader.download_format(&audio_format, "small-audio.mp3").await?;
        println!("Downloaded: {}", path.display());
    }

    Ok(())
}
```

--------------------------------

### Async Trait Example

Source: https://github.com/boul2gom/yt-dlp/blob/develop/CONTRIBUTING.md

Defines an asynchronous trait for video extraction using the `async_trait` macro. Requires `Downcast`, `Send`, and `Sync` bounds.

```rust
#[async_trait]
pub trait VideoExtractor: Downcast + Send + Sync + fmt::Debug {
    async fn fetch_video(&self, url: &str) -> Result<Video>;
    fn name(&self) -> ExtractorName;
    fn supports_url(&self, url: &str) -> bool;
}
impl_downcast!(VideoExtractor);
```

--------------------------------

### Download Specific Time Range

Source: https://github.com/boul2gom/yt-dlp/blob/develop/README.md

Use this to download a specific segment of a video by providing start and end timestamps in seconds. No re-encoding is performed.

```rust
use yt_dlp::Downloader;
use yt_dlp::client::deps::Libraries;
use std::path::PathBuf;

#[tokio::main]
pub async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let libraries = Libraries::new(
        PathBuf::from("libs/yt-dlp"),
        PathBuf::from("libs/ffmpeg"),
    );
    let downloader = Downloader::builder(libraries, "output").build().await?;

    let url = "https://www.youtube.com/watch?v=gXtp6C-3JKo";
    let video = downloader.fetch_video_infos(url).await?;

    // Download seconds [60, 120] only — no re-encoding
    let clip_path = downloader
        .download(&video, "clip.mp4")
        .time_range(60.0, 120.0)?
        .execute()
        .await?;

    Ok(())
}
```

--------------------------------

### Download Video Using Cookie File

Source: https://github.com/boul2gom/yt-dlp/blob/develop/README.md

Initialize the downloader with a Netscape formatted cookie file for authentication. Ensure the 'cookies.txt' file exists in the project directory.

```rust
use yt_dlp::Downloader;
use yt_dlp::client::deps::Libraries;
use std::path::PathBuf;

#[tokio::main]
pub async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let libraries = Libraries::new(
        PathBuf::from("libs/yt-dlp"),
        PathBuf::from("libs/ffmpeg"),
    );

    // Export cookies from your browser with a browser extension (e.g. "Get cookies.txt LOCALLY")
    let downloader = Downloader::builder(libraries, PathBuf::from("output"))
        .with_cookies("cookies.txt")
        .build()
        .await?;

    let video = downloader.fetch_video_infos("https://www.youtube.com/watch?v=gXtp6C-3JKo").await?;
    downloader.download_video(&video, "video.mp4").await?;

    Ok(())
}
```

--------------------------------

### Download Specific Playlist Videos by Index

Source: https://github.com/boul2gom/yt-dlp/blob/develop/README.md

Downloads a selection of videos from a playlist based on their 0-based index. Requires yt-dlp and ffmpeg setup.

```rust
use yt_dlp::Downloader;
use std::path::PathBuf;
use yt_dlp::client::deps::Libraries;

#[tokio::main]
pub async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let libraries_dir = PathBuf::from("libs");
    let output_dir = PathBuf::from("output");

    let youtube = libraries_dir.join("yt-dlp");
    let ffmpeg = libraries_dir.join("ffmpeg");

    let libraries = Libraries::new(youtube, ffmpeg);
    let downloader = Downloader::builder(libraries, output_dir)
        .build()
        .await?;

    let playlist_url = String::from("https://www.youtube.com/playlist?list=PLrAXtmErZgOeiKm4sgNOknGvNjby9efdf");
    let playlist = downloader.fetch_playlist_infos(playlist_url).await?;

    // Download specific videos by index (0-based)
    let indices = vec![0, 2, 5, 10]; // Videos at positions 1, 3, 6, and 11
    let video_paths = downloader
        .download_playlist_items(&playlist, &indices, "%s - %s.mp4")
        .await?;

    println!("Downloaded {} specific videos", video_paths.len());

    Ok(())
}
```

--------------------------------

### Benchmark yt-dlp Performance

Source: https://github.com/boul2gom/yt-dlp/blob/develop/README.md

Run this command to benchmark the library's performance against a public YouTube URL. It uses the 'profiling' feature and allows specifying cookie sources and the number of runs.

```bash
cargo bench --bench compare --features profiling -- https://www.youtube.com/watch?v=gXtp6C-3JKo --cookies-from-browser safari --runs 10
```

--------------------------------

### CPU Profiling with samply (macOS/Linux)

Source: https://github.com/boul2gom/yt-dlp/blob/develop/PROFILING.md

Build the project first, then profile using samply. It captures kernel-level samples with minimal overhead and opens the Firefox profiler UI automatically.

```bash
cargo install samply

# Build first, then profile
cargo build --bench profiling --features profiling --release
samply record ./target/release/deps/profiling-* <URL>
```

--------------------------------

### Download Video with Progress Callback

Source: https://github.com/boul2gom/yt-dlp/blob/develop/README.md

Initiates a video download and provides a callback function to monitor progress. Requires yt-dlp and ffmpeg libraries to be set up.

```rust
use yt_dlp::Downloader;
use std::path::PathBuf;
use yt_dlp::client::deps::Libraries;

#[tokio::main]
pub async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let libraries_dir = PathBuf::from("libs");
    let output_dir = PathBuf::from("output");
    
    let youtube = libraries_dir.join("yt-dlp");
    let ffmpeg = libraries_dir.join("ffmpeg");
    
    let libraries = Libraries::new(youtube, ffmpeg);
    let downloader = Downloader::builder(libraries, output_dir)
        .build()
        .await?;

    let url = String::from("https://www.youtube.com/watch?v=gXtp6C-3JKo");
    let video = downloader.fetch_video_infos(url).await?;

    // Download with progress callback
    let download_id = downloader.download_video_with_progress(
        &video, 
        "video-with-progress.mp4", 
        |downloaded, total| {
            let percentage = if total > 0 {
                (downloaded as f64 / total as f64 * 100.0) as u64
            } else {
                0
            };
            println!("Progress: {}/{} bytes ({}%)", downloaded, total, percentage);
        }
    ).await?;

    // Wait for download completion
    downloader.wait_for_download(download_id).await;
    
    Ok(())
}

```

--------------------------------

### Tracing Conventions for media-seek Parsing

Source: https://github.com/boul2gom/yt-dlp/blob/develop/CONTRIBUTING.md

Use debug tracing at the start and end of parsing functions. Employ specific emojis for internal operations and success.

```rust
// At function start:
tracing::debug!(probe_len = probe.len(), "⚙️ Parsing <Format> stream");

// Just before each successful return:
tracing::debug!(segments = result.len(), "✅ <Format> index parsed");
```

--------------------------------

### Configure Proxy with Authentication

Source: https://context7.com/boul2gom/yt-dlp/llms.txt

Set up a downloader to route all requests through an HTTP proxy with optional username and password authentication. Exclude specific hosts from using the proxy.

```rust
use yt_dlp::Downloader;
use yt_dlp::client::deps::Libraries;
use yt_dlp::client::proxy::{ProxyConfig, ProxyType};
use std::path::PathBuf;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let libraries = Libraries::new(
        PathBuf::from("libs/yt-dlp"),
        PathBuf::from("libs/ffmpeg"),
    );

    // Configure proxy with authentication
    let proxy = ProxyConfig::new(ProxyType::Http, "http://proxy.example.com:8080")
        .with_auth("username", "password")
        .with_no_proxy(vec!["localhost".to_string(), "127.0.0.1".to_string()]);

    let downloader = Downloader::builder(libraries, "output")
        .with_proxy(proxy)
        .build()
        .await?;

    // All operations now use the proxy
    let video = downloader
        .fetch_video_infos("https://www.youtube.com/watch?v=gXtp6C-3JKo")
        .await?;
    downloader.download_video(&video, "via-proxy.mp4").await?;

    Ok(())
}
```

--------------------------------

### Cancel Video Download

Source: https://github.com/boul2gom/yt-dlp/blob/develop/README.md

Starts a video download, checks its status, and then cancels it. This is useful for stopping downloads that are no longer needed. Ensure yt-dlp and ffmpeg are configured.

```rust
use yt_dlp::Downloader;
use std::path::PathBuf;
use yt_dlp::client::deps::Libraries;

#[tokio::main]
pub async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let libraries_dir = PathBuf::from("libs");
    let output_dir = PathBuf::from("output");
    
    let youtube = libraries_dir.join("yt-dlp");
    let ffmpeg = libraries_dir.join("ffmpeg");
    
    let libraries = Libraries::new(youtube, ffmpeg);
    let downloader = Downloader::builder(libraries, output_dir)
        .build()
        .await?;

    let url = String::from("https://www.youtube.com/watch?v=gXtp6C-3JKo");
    let video = downloader.fetch_video_infos(url).await?;

    // Start a download
    let download_id = downloader.download_video_with_priority(
        &video, 
        "video-to-cancel.mp4", 
        None
    ).await?;

    // Check status
    let status = downloader.get_download_status(download_id).await;
    println!("Download status: {:?}", status);

    // Cancel the download
    let canceled = downloader.cancel_download(download_id).await;
    println!("Download canceled: {}", canceled);
    
    Ok(())
}

```

--------------------------------

### Download Specific Time Range (Clip Extraction)

Source: https://context7.com/boul2gom/yt-dlp/llms.txt

Extract and download a portion of a video by specifying start and end times in seconds. Requires ffmpeg for clipping.

```rust
use yt_dlp::Downloader;
use yt_dlp::client::deps::Libraries;
use std::path::PathBuf;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let libraries = Libraries::new(
        PathBuf::from("libs/yt-dlp"),
        PathBuf::from("libs/ffmpeg"),
    );
    let downloader = Downloader::builder(libraries, "output").build().await?;

    let video = downloader
        .fetch_video_infos("https://www.youtube.com/watch?v=gXtp6C-3JKo")
        .await?;

    // Download only seconds 60-120 (1 minute clip starting at 1:00)
    let clip_path = downloader.download(&video, "clip.mp4")
        .time_range(60.0, 120.0)?
        .execute()
        .await?;

    println!("Clip downloaded: {}", clip_path.display());
    Ok(())
}
```

--------------------------------

### Loading Webhook from Environment Variables

Source: https://github.com/boul2gom/yt-dlp/blob/develop/README.md

Demonstrates loading webhook configuration from environment variables. This is useful for externalizing sensitive information like URLs and tokens.

```rust
use yt_dlp::Downloader;
use yt_dlp::client::deps::Libraries;
use yt_dlp::events::WebhookConfig;
use std::path::PathBuf;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let libraries = Libraries::new(
        PathBuf::from("libs/yt-dlp"),
        PathBuf::from("libs/ffmpeg")
    );
    let mut downloader = Downloader::builder(libraries, PathBuf::from("output")).build().await?;

    // Load webhook from environment variables
    if let Some(webhook) = WebhookConfig::from_env() {
        downloader.register_webhook(webhook).await;
    }

    Ok(())
}
```

--------------------------------

### Download Playlist Videos by Range

Source: https://github.com/boul2gom/yt-dlp/blob/develop/README.md

Downloads a contiguous range of videos from a playlist, specified by start and end indices (inclusive, 0-based). Ensure yt-dlp and ffmpeg are configured.

```rust
use yt_dlp::Downloader;
use std::path::PathBuf;
use yt_dlp::client::deps::Libraries;

#[tokio::main]
pub async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let libraries_dir = PathBuf::from("libs");
    let output_dir = PathBuf::from("output");

    let youtube = libraries_dir.join("yt-dlp");
    let ffmpeg = libraries_dir.join("ffmpeg");

    let libraries = Libraries::new(youtube, ffmpeg);
    let downloader = Downloader::builder(libraries, output_dir)
        .build()
        .await?;

    let playlist_url = String::from("https://www.youtube.com/playlist?list=PLrAXtmErZgOeiKm4sgNOknGvNjby9efdf");
    let playlist = downloader.fetch_playlist_infos(playlist_url).await?;

    // Download videos 5-15 (0-based, inclusive)
    let video_paths = downloader
        .download_playlist_range(&playlist, 5, 15, "%s - %s.mp4")
        .await?;

    println!("Downloaded {} videos from range", video_paths.len());

    Ok(())
}
```

--------------------------------

### Implement RangeFetcher for Local Files

Source: https://github.com/boul2gom/yt-dlp/blob/develop/crates/media-seek/README.md

Implement the `RangeFetcher` trait for reading byte ranges from a local file. This example reads directly from a `Vec<u8>` representing file content.

```rust
struct FileFetcher(Vec<u8>);

impl RangeFetcher for FileFetcher {
    type Error = std::io::Error;

    async fn fetch(&self, start: u64, end: u64) -> std::result::Result<Vec<u8>, Self::Error> {
        let s = start as usize;
        let e = (end as usize + 1).min(self.0.len());
        Ok(self.0[s..e].to_vec())
    }
}
```

--------------------------------

### Basic Live Stream Recording

Source: https://github.com/boul2gom/yt-dlp/blob/develop/README.md

Record a live stream using the reqwest engine. This example shows how to set a maximum duration for the recording. Ensure the `live-recording` feature is enabled in Cargo.toml.

```rust
use yt_dlp::Downloader;
use yt_dlp::client::deps::Libraries;
use std::path::PathBuf;
use std::time::Duration;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let libraries = Libraries::new(
        PathBuf::from("libs/yt-dlp"),
        PathBuf::from("libs/ffmpeg"),
    );
    let downloader = Downloader::builder(libraries, "output").build().await?;

    let video = downloader.fetch_video_infos("https://youtube.com/watch?v=LIVE_ID").await?;

    // Record for 1 hour maximum
    let result = downloader.record_live(&video, "live-recording.ts")
        .with_max_duration(Duration::from_secs(3600))
        .execute()
        .await?;

    println!("Recorded {} bytes in {:.1}s", result.total_bytes, result.total_duration.as_secs_f64());
    Ok(())
}
```

--------------------------------

### Update yt-dlp Binary with Rust

Source: https://github.com/boul2gom/yt-dlp/blob/develop/README.md

Updates the yt-dlp and ffmpeg binaries located in the specified libraries directory. This example uses `Downloader::builder` and requires `yt_dlp::client::deps::Libraries`.

```rust
use yt_dlp::Downloader;
use std::path::PathBuf;
use yt_dlp::client::deps::Libraries;

#[tokio::main]
pub async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let libraries_dir = PathBuf::from("libs");
    let output_dir = PathBuf::from("output");
    
    let youtube = libraries_dir.join("yt-dlp");
    let ffmpeg = libraries_dir.join("ffmpeg");
    
    let libraries = Libraries::new(youtube, ffmpeg);
    let downloader = Downloader::builder(libraries, output_dir)
        .build()
        .await?;

    downloader.update_downloader().await?;
    Ok(())
}
```

--------------------------------

### Download Video Using .netrc File

Source: https://github.com/boul2gom/yt-dlp/blob/develop/README.md

Initialize the downloader using credentials from a .netrc file for authentication. This is a standard way to store login information for network services.

```rust
use yt_dlp::Downloader;
use yt_dlp::client::deps::Libraries;
use std::path::PathBuf;

#[tokio::main]
pub async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let libraries = Libraries::new(
        PathBuf::from("libs/yt-dlp"),
        PathBuf::from("libs/ffmpeg"),
    );

    let downloader = Downloader::builder(libraries, PathBuf::from("output"))
        .with_netrc()
        .build()
        .await?;

    let video = downloader.fetch_video_infos("https://www.youtube.com/watch?v=gXtp6C-3JKo").await?;
    downloader.download_video(&video, "video.mp4").await?;

    Ok(())
}
```

--------------------------------

### Post-build Mutation on Downloader

Source: https://github.com/boul2gom/yt-dlp/blob/develop/CONTRIBUTING.md

Illustrates how to mutate a `Downloader` instance after it has been built using `set_*` and `add_*` methods. These methods take `&mut self` and return `&mut Self` for chaining.

```rust
downloader.set_user_agent("my-agent");
downloader.set_timeout(Duration::from_secs(30));
downloader.set_args(vec!["--no-playlist".into()]);
downloader.add_arg("--flat-playlist");
downloader.set_cookies("cookies.txt");
downloader.set_cookies_from_browser("chrome");
downloader.set_netrc();
```

--------------------------------

### Track and Snapshot Download Statistics

Source: https://github.com/boul2gom/yt-dlp/blob/develop/README.md

Utilize the StatisticsTracker to monitor download progress and performance. Call snapshot() to get an atomic view of metrics like completed downloads, total bytes, and success rates.

```rust
use yt_dlp::Downloader;
use yt_dlp::client::deps::Libraries;
use std::path::PathBuf;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let libraries = Libraries::new(PathBuf::from("libs/yt-dlp"), PathBuf::from("libs/ffmpeg"));
    let downloader = Downloader::builder(libraries, "output").build().await?;

    // Perform some downloads and fetches ...
    let video = downloader.fetch_video_infos("https://youtube.com/watch?v=...".to_string()).await?;
    downloader.download_video(&video, "video.mp4").await?;

    let snapshot = downloader.statistics().snapshot().await;
    println!("Downloads completed:  {}", snapshot.downloads.completed);
    println!("Total bytes:          {}", snapshot.downloads.total_bytes);
    println!("Avg speed (B/s):      {:?}", snapshot.downloads.avg_speed_bytes_per_sec);
    println!("Download success %:   {:?}", snapshot.downloads.success_rate);
    println!("Fetch success %:      {:?}", snapshot.fetches.success_rate);
    println!("Post-process success: {:?}", snapshot.post_processing.success_rate);

    Ok(())
}
```

--------------------------------

### Download with Custom Download Manager Configuration

Source: https://github.com/boul2gom/yt-dlp/blob/develop/README.md

Configures a custom download manager with settings like max concurrent downloads, segment size, and retry attempts, then downloads a video with high priority.

```rust
use yt_dlp::Downloader;
use yt_dlp::download::manager::{ManagerConfig, DownloadPriority};
use std::path::PathBuf;
use yt_dlp::client::deps::Libraries;

#[tokio::main]
pub async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Custom download manager configuration using the typed builder
    let config = ManagerConfig::builder()
        .max_concurrent_downloads(5)        // Maximum 5 concurrent downloads
        .segment_size(1024 * 1024 * 10)    // 10 MB per segment
        .parallel_segments(8)               // 8 parallel segments per download
        .retry_attempts(5)                  // 5 retry attempts on failure
        .max_buffer_size(1024 * 1024 * 20) // 20 MB maximum buffer
        .build();

    let libraries_dir = PathBuf::from("libs");
    let output_dir = PathBuf::from("output");

    let youtube = libraries_dir.join("yt-dlp");
    let ffmpeg = libraries_dir.join("ffmpeg");

    let libraries = Libraries::new(youtube, ffmpeg);

    // Create a fetcher with custom configuration
    let downloader = Downloader::with_download_manager_config(libraries, output_dir, config)
        .build()
        .await?;

    // Download a video with high priority
    let url = String::from("https://www.youtube.com/watch?v=gXtp6C-3JKo");
    let video = downloader.fetch_video_infos(url).await?;

    let download_id = downloader.download_video_with_priority(
        &video,
        "video-high-priority.mp4",
        Some(DownloadPriority::High)
    ).await?;

    // Wait for download completion
    let status = downloader.wait_for_download(download_id).await;
    println!("Final download status: {:?}", status);

    Ok(())
}
```

--------------------------------

### Translate Timestamps to Byte Ranges

Source: https://github.com/boul2gom/yt-dlp/blob/develop/crates/media-seek/README.md

Translate specific time ranges (in seconds) into byte ranges within a media file. This example demonstrates finding a byte range and fetching the corresponding data, including the initialization segment.

```rust
use media_seek::{parse, RangeFetcher};

struct FileFetcher(Vec<u8>);

impl RangeFetcher for FileFetcher {
    type Error = std::io::Error;

    async fn fetch(&self, start: u64, end: u64) -> std::result::Result<Vec<u8>, Self::Error> {
        let s = start as usize;
        let e = (end as usize + 1).min(self.0.len());
        Ok(self.0[s..e].to_vec())
    }
}

#[tokio::main] async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let fetcher = FileFetcher(std::fs::read("video.mp4")?);
    let probe: Vec<u8> = fetcher.fetch(0, 512 * 1024).await?;
    let total_size: Option<u64> = Some(1_234_567_890);

    let index = parse(&probe, total_size, &fetcher).await?;

    if let Some(range) = index.find_byte_range(60.0, 120.0) {
        // Always prefetch the init segment so decoders have codec parameters
        let init = fetcher.fetch(0, index.init_end_byte).await?;
        let clip = fetcher.fetch(range.start, range.end).await?;

        // Write init + clip to a file, then trim with FFmpeg stream copy:
        // ffmpeg -i combined.mp4 -ss 60 -t 60 -c copy -avoid_negative_ts 1 -y out.mp4
        let _ = (init, clip);
    }
    Ok(())
}
```

--------------------------------

### Select Thumbnail by Minimum Resolution with yt-dlp Rust

Source: https://github.com/boul2gom/yt-dlp/blob/develop/README.md

This snippet is incomplete and appears to be a placeholder for selecting a thumbnail by minimum resolution. It sets up the downloader but does not include the logic for thumbnail selection or download.

```rust
use yt_dlp::Downloader;
use std::path::PathBuf;
use yt_dlp::client::deps::Libraries;

```

--------------------------------

### Working with Video Chapters and Heatmap

Source: https://context7.com/boul2gom/yt-dlp/llms.txt

Fetches video information to access chapter markers and viewer engagement data (heatmap). Demonstrates how to iterate through chapters, find a chapter at a specific time, and analyze heatmap segments.

```rust
use yt_dlp::Downloader;
use yt_dlp::client::deps::Libraries;
use std::path::PathBuf;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let libraries = Libraries::new(
        PathBuf::from("libs/yt-dlp"),
        PathBuf::from("libs/ffmpeg"),
    );
    let downloader = Downloader::builder(libraries, "output").build().await?;

    let video = downloader
        .fetch_video_infos("https://www.youtube.com/watch?v=gXtp6C-3JKo")
        .await?;

    // Work with chapters
    if video.has_chapters() {
        for chapter in video.get_chapters() {
            println!("Chapter: {} ({:.2}s - {:.2}s, duration: {:.2}s)",
                chapter.title.as_deref().unwrap_or("Untitled"),
                chapter.start_time,
                chapter.end_time,
                chapter.duration());
        }

        // Find chapter at specific timestamp
        if let Some(chapter) = video.get_chapter_at_time(120.0) {
            println!("At 2:00: {}", chapter.title.as_deref().unwrap_or("Untitled"));
        }
    }

    // Work with heatmap (most replayed)
    if let Some(heatmap) = video.get_heatmap() {
        println!("Heatmap segments: {}", heatmap.points().len());

        // Find most replayed segment
        if let Some(most_replayed) = heatmap.most_engaged_segment() {
            println!("Most replayed: {:.2}s - {:.2}s (engagement: {:.2})",
                most_replayed.start_time,
                most_replayed.end_time,
                most_replayed.value);
        }

        // Get segments with high engagement (> 0.7)
        let highly_engaged = heatmap.get_highly_engaged_segments(0.7);
        println!("Found {} highly engaged segments", highly_engaged.len());

        // Get engagement at specific timestamp
        if let Some(point) = heatmap.get_point_at_time(120.0) {
            println!("Engagement at 2:00: {:.2}", point.value);
        }
    }

    Ok(())
}

```

--------------------------------

### Analyze YouTube Video Engagement by Threshold

Source: https://github.com/boul2gom/yt-dlp/blob/develop/README.md

Retrieves heatmap data and filters segments with engagement above a specified threshold. It also demonstrates how to get the engagement value at a particular timestamp. Ensure yt-dlp and ffmpeg libraries are configured.

```rust
use yt_dlp::Downloader;
use std::path::PathBuf;
use yt_dlp::client::deps::Libraries;

#[tokio::main]
pub async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let libraries_dir = PathBuf::from("libs");
    let output_dir = PathBuf::from("output");

    let youtube = libraries_dir.join("yt-dlp");
    let ffmpeg = libraries_dir.join("ffmpeg");

    let libraries = Libraries::new(youtube, ffmpeg);
    let downloader = Downloader::builder(libraries, output_dir)
        .build()
        .await?;

    let url = String::from("https://www.youtube.com/watch?v=gXtp6C-3JKo");
    let video = downloader.fetch_video_infos(url).await?;

    if let Some(heatmap) = video.get_heatmap() {
        // Get segments with high engagement (> 0.7)
        let highly_engaged = heatmap.get_highly_engaged_segments(0.7);
        println!("Found {} highly engaged segments", highly_engaged.len());

        for segment in highly_engaged {
            println!(
                "High engagement: {:.2}s - {:.2}s (value: {:.2})",
                segment.start_time,
                segment.end_time,
                segment.value
            );
        }

        // Get engagement at specific timestamp
        if let Some(point) = heatmap.get_point_at_time(120.0) {
            println!(
                "Engagement at 2:00 is {:.2}",
                point.value
            );
        }
    }

    Ok(())
}
```

--------------------------------

### Fetch Video Info and Thumbnails

Source: https://github.com/boul2gom/yt-dlp/blob/develop/README.md

Fetches video information and demonstrates how to retrieve the best thumbnail or an HD thumbnail.

```rust
use yt_dlp::Downloader;
use std::path::PathBuf;
use yt_dlp::client::deps::Libraries;

#[tokio::main]
pub async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let libraries = Libraries::new(
        PathBuf::from("libs/yt-dlp"),
        PathBuf::from("libs/ffmpeg"),
    );
    let downloader = Downloader::builder(libraries, "output").build().await?;

    let url = "https://www.youtube.com/watch?v=gXtp6C-3JKo";
    let video = downloader.fetch_video_infos(url).await?;

    // Best thumbnail by area (width × height)
    if let Some(thumb) = video.best_thumbnail() {
        println!("Best thumbnail: {} — {:?}", thumb.url, thumb.resolution);
    }

    // Smallest thumbnail that is at least 1280×720
    if let Some(thumb) = video.thumbnail_for_size(1280, 720) {
        println!("HD thumbnail: {}", thumb.url);
    }

    Ok(())
}
```

--------------------------------

### Registering a Webhook with yt-dlp

Source: https://github.com/boul2gom/yt-dlp/blob/develop/README.md

Shows how to register an HTTP webhook for receiving download events. Configure method, headers, filters, and timeouts for reliable event notification.

```rust
use yt_dlp::events::{WebhookConfig, WebhookMethod, EventFilter};
use std::time::Duration;
use yt_dlp::Downloader;
use std::path::PathBuf;
use yt_dlp::client::deps::Libraries;

#[tokio::main]
pub async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let libraries_dir = PathBuf::from("libs");
    let output_dir = PathBuf::from("output");

    let libraries = Libraries::new(
        libraries_dir.join("yt-dlp"),
        libraries_dir.join("ffmpeg")
    );

    let webhook = WebhookConfig::new("https://example.com/webhook")
        .with_method(WebhookMethod::Post)
        .with_header("Authorization", "Bearer your-token")
        .with_filter(EventFilter::only_completed())
        .with_timeout(Duration::from_secs(10));

    let mut downloader = Downloader::builder(libraries, output_dir).build().await?;
    downloader.register_webhook(webhook).await;

    Ok(())
}
```