diff --git a/build.rs b/build.rs
index f1a659a..883837e 100644
--- a/build.rs
+++ b/build.rs
@@ -1,4 +1,4 @@
-use rustc_version::{version_meta, Channel};
+use rustc_version::{Channel, version_meta};
 
 fn main() {
     // Set cfg flags depending on release channel
@@ -8,5 +8,5 @@ fn main() {
         Channel::Nightly => "CHANNEL_NIGHTLY",
         Channel::Dev => "CHANNEL_DEV",
     };
-    println!("cargo:rustc-cfg={}", channel)
-}
\ No newline at end of file
+    println!("cargo:rustc-cfg={channel}");
+}
diff --git a/cli/Cargo.toml b/cli/Cargo.toml
index 143c90b..da3e49f 100644
--- a/cli/Cargo.toml
+++ b/cli/Cargo.toml
@@ -25,9 +25,10 @@ clap = { version = "3.0.0-rc.7", features = ["derive", "wrap_help"] }
 fern = { version = "0.6.0", features = ["colored"] }
 log = "0.4.14"
 mime = "0.3.16"
-rustube = { path = "..", version = "0.6", features = ["download", "std"] }
+rustube = { path = "..", version = "0.6", features = ["download", "std", "callback"] }
 tokio = { version = "1.12.0", features = ["rt-multi-thread"] }
 serde = "1.0.130"
 strum = { version = "0.22.0", features = ["derive"] }
 serde_json = "1.0.68"
 serde_yaml = "0.8.21"
+pbr = "1.0.4"
diff --git a/cli/src/args/logging.rs b/cli/src/args/logging.rs
index 76153b6..016d785 100644
--- a/cli/src/args/logging.rs
+++ b/cli/src/args/logging.rs
@@ -14,6 +14,10 @@ pub struct LoggingArgs {
     #[clap(long, short, parse(from_occurrences))]
     verbose: u8,
 
+    /// Show a progress bar
+    #[clap(long, short, conflicts_with = "verbose")]
+    progress: bool,
+
     /// When to log coloredd
     #[clap(long, default_value = "always", possible_values = & ["always", "never"], value_name = "WHEN")]
     color: ColorUsage,
@@ -25,7 +29,7 @@ pub struct LoggingArgs {
 
 impl LoggingArgs {
     pub fn init_logger(&self) {
-        if self.quiet { return; }
+        if self.quiet || self.progress { return; }
 
         let formatter = self.log_msg_formatter();
 
@@ -38,6 +42,19 @@ impl LoggingArgs {
             .expect("The global logger was already initialized");
     }
 
+    pub fn init_progress_bar(&self, total: u64) -> pbr::ProgressBar<Box<dyn std::io::Write + Send + Sync>> {
+        let writer = match self.progress {
+            true => Box::new(std::io::stderr()) as _,
+            false => Box::new(std::io::sink()) as _,
+        };
+        let mut pb = pbr::ProgressBar::on(writer, total);
+        pb.set_units(pbr::Units::Bytes);
+        pb.format("[=> ]");
+        pb.add(0);
+
+        pb
+    }
+
     fn log_msg_formatter(&self) -> fn(FormatCallback, &Arguments, &Record) {
         #[inline(always)]
         fn format_msg(
diff --git a/cli/src/args/stream_filter.rs b/cli/src/args/stream_filter.rs
index 4d3620d..f071bac 100644
--- a/cli/src/args/stream_filter.rs
+++ b/cli/src/args/stream_filter.rs
@@ -121,6 +121,6 @@ impl StreamFilter {
 }
 
 fn parse_json<T: for<'de> serde::Deserialize<'de>>(s: &str) -> anyhow::Result<T> {
-    let args = format!("\"{}\"", s);
+    let args = format!("\"{s}\"");
     Ok(serde_json::from_str(&args)?)
 }
diff --git a/cli/src/main.rs b/cli/src/main.rs
index 53a781a..4e5b8e9 100644
--- a/cli/src/main.rs
+++ b/cli/src/main.rs
@@ -6,6 +6,7 @@ use clap::Parser;
 use args::DownloadArgs;
 use args::StreamFilter;
 use rustube::{Error, Id, IdBuf, Stream, Video, VideoFetcher, VideoInfo};
+use rustube::Callback;
 
 use crate::args::{CheckArgs, Command, FetchArgs};
 use crate::video_serializer::VideoSerializer;
@@ -48,8 +49,11 @@ async fn check(args: CheckArgs) -> Result<()> {
     let (video_info, streams) = get_streams(id, &args.stream_filter).await?;
     let video_serializer = VideoSerializer::new(video_info, streams, args.output.output_level);
 
-    let output = args.output.output_format.serialize_output(&video_serializer)?;
-    println!("{}", output);
+    let output = args
+        .output
+        .output_format
+        .serialize_output(&video_serializer)?;
+    println!("{output}");
 
     Ok(())
 }
@@ -59,22 +63,27 @@ async fn download(args: DownloadArgs) -> Result<()> {
 
     let id = args.identifier.id()?;
     let (video_info, stream) = get_stream(id.as_owned(), args.stream_filter).await?;
-    let download_path = download_path(
-        args.filename,
-        stream.mime.subtype().as_str(),
-        args.dir,
-        id,
-    );
+    let download_path = download_path(args.filename, stream.mime.subtype().as_str(), args.dir, id);
+
+    let mut pb = args.logging.init_progress_bar(stream.content_length().await?);
+    let callback = Callback::new()
+        .connect_on_progress_closure(|cargs| {
+            // update progress bar
+            pb.add(cargs.current_chunk.saturating_sub(cargs.current_chunk) as u64);
+        });
 
-    stream.download_to(download_path).await?;
+    stream
+        .download_to_with_callback(&download_path, callback)
+        .await?;
+    pb.finish_println(&format!("Finished downloading video to {download_path:?}\n"));
 
     let video_serializer = VideoSerializer::new(
         video_info,
         std::iter::once(stream),
         args.output.output_level,
     );
-    let output = args.output.output_format.serialize_output(&video_serializer)?;
-    println!("{}", output);
+    let output = args.output.output_format.serialize_output(&video_serializer).unwrap();
+    println!("{output}");
 
     Ok(())
 }
@@ -83,20 +92,15 @@ async fn fetch(args: FetchArgs) -> Result<()> {
     args.logging.init_logger();
 
     let id = args.identifier.id()?;
-    let video_info = rustube::VideoFetcher::from_id(id)?
-        .fetch_info()
-        .await?;
+    let video_info = rustube::VideoFetcher::from_id(id)?.fetch_info().await?;
 
     let output = args.output.output_format.serialize_output(&video_info)?;
-    println!("{}", output);
+    println!("{output}");
 
     Ok(())
 }
 
-async fn get_stream(
-    id: IdBuf,
-    stream_filter: StreamFilter,
-) -> Result<(VideoInfo, Stream)> {
+async fn get_stream(id: IdBuf, stream_filter: StreamFilter) -> Result<(VideoInfo, Stream)> {
     let (video_info, streams) = get_streams(id, &stream_filter).await?;
 
     let stream = streams
@@ -111,9 +115,7 @@ async fn get_streams(
     id: IdBuf,
     stream_filter: &'_ StreamFilter,
 ) -> Result<(VideoInfo, impl Iterator<Item=Stream> + '_)> {
-    let (video_info, streams) = get_video(id)
-        .await?
-        .into_parts();
+    let (video_info, streams) = get_video(id).await?.into_parts();
 
     let streams = streams
         .into_iter()
@@ -131,9 +133,14 @@ async fn get_video(id: IdBuf) -> Result<Video> {
         .context("Could not descramble the video information")
 }
 
-pub fn download_path(filename: Option<PathBuf>, extension: &str, dir: Option<PathBuf>, video_id: Id<'_>) -> PathBuf {
-    let filename = filename
-        .unwrap_or_else(|| format!("{}.{}", video_id.as_str(), extension).into());
+pub fn download_path(
+    filename: Option<PathBuf>,
+    extension: &str,
+    dir: Option<PathBuf>,
+    video_id: Id<'_>,
+) -> PathBuf {
+    let filename =
+        filename.unwrap_or_else(|| format!("{}.{}", video_id.as_str(), extension).into());
 
     let mut path = dir.unwrap_or_else(PathBuf::new);
 
diff --git a/cli/src/output_format.rs b/cli/src/output_format.rs
index efd8ae4..3b41f29 100644
--- a/cli/src/output_format.rs
+++ b/cli/src/output_format.rs
@@ -16,8 +16,8 @@ impl OutputFormat {
         use OutputFormat::*;
 
         match self {
-            Debug => Ok(format!("{:?}", output)),
-            PrettyDebug => Ok(format!("{:#?}", output)),
+            Debug => Ok(format!("{output:?}")),
+            PrettyDebug => Ok(format!("{output:#?}")),
             Json => Ok(serde_json::to_string(output)?),
             PrettyJson => Ok(serde_json::to_string_pretty(output)?),
             Yaml => Ok(serde_yaml::to_string(output)?)
diff --git a/src/descrambler/cipher.rs b/src/descrambler/cipher.rs
index 4802c2b..9a6a249 100644
--- a/src/descrambler/cipher.rs
+++ b/src/descrambler/cipher.rs
@@ -1,6 +1,6 @@
 use std::collections::HashMap;
-use once_cell::sync::Lazy;
 
+use once_cell::sync::Lazy;
 use regex::Regex;
 
 use crate::{Error, Result, TryCollect};
@@ -51,7 +51,7 @@ impl Cipher {
             let js_fun = self.transform_map
                 .get(name)
                 .ok_or_else(|| Error::UnexpectedResponse(format!(
-                    "no matching transform function for `{}`", js_fun_name
+                    "no matching transform function for `{js_fun_name}`",
                 ).into()))?
                 .0;
             js_fun(signature, argument);
@@ -93,8 +93,7 @@ impl Cipher {
                 )
             )),
             (name, arg) => Err(Error::UnexpectedResponse(format!(
-                "expected a Javascript transformer function and an argument, got: `{:?}` and `{:?}`",
-                name, arg
+                "expected a Javascript transformer function and an argument, got: `{name:?}` and `{arg:?}`",
             ).into()))
         }
     }
@@ -109,8 +108,8 @@ impl Cipher {
             transform_map: {:?}",
             signature, self.transform_plan, self.transform_map_dbg()
         );
-        log::error!("{}", error);
-        eprintln!("{}", error);
+        log::error!("{error}");
+        eprintln!("{error}");
         error
     }
 
@@ -134,13 +133,12 @@ impl Cipher {
 
 fn get_transform_plan(js: &str) -> Result<Vec<String>> {
     let name = regex::escape(get_initial_function_name(js)?);
-    let pattern = Regex::new(&format!(r#"{}=function\(\w\)\{{[a-z=.(")]*;(.*);(?:.+)}}"#, name)).unwrap();
+    let pattern = Regex::new(&format!(r#"{name}=function\(\w\)\{{[a-z=.(")]*;(.*);(?:.+)}}"#)).unwrap();
     Ok(
         pattern
             .captures(js)
             .ok_or_else(|| Error::UnexpectedResponse(format!(
-                "could not extract the initial JavaScript function: {}",
-                pattern
+                "could not extract the initial JavaScript function: {pattern}",
             ).into()))?
             .get(1)
             .expect("the pattern must contain at least one capture group")
@@ -172,8 +170,7 @@ fn get_initial_function_name(js: &str) -> Result<&str> {
         .find_map(|pattern| pattern.captures(js))
         .map(|c| c.get(1).unwrap().as_str())
         .ok_or_else(|| Error::UnexpectedResponse(format!(
-            "could not find the JavaScript function name: `{}`",
-            js
+            "could not find the JavaScript function name: `{js}`",
         ).into()))
 }
 
@@ -186,8 +183,7 @@ fn get_transform_map(js: &str, var: &str) -> Result<HashMap<String, TransformerF
         let (name, function) = obj
             .split_once(':')
             .ok_or_else(|| Error::UnexpectedResponse(format!(
-                "expected the transform-object to contain at least one ':', got {}",
-                obj
+                "expected the transform-object to contain at least one ':', got {obj}",
             ).into()))?;
         let fun = map_functions(function)?;
         mapper.insert(name.to_owned(), fun);
@@ -249,8 +245,7 @@ fn map_functions(js_func: &str) -> Result<TransformerFn> {
         .find(|(pattern, _fun)| pattern.is_match(js_func))
         .map(|(_pattern, fun)| *fun)
         .ok_or_else(|| Error::UnexpectedResponse(format!(
-            "could not map the JavaScript function `{}` to any Rust equivalent",
-            js_func
+            "could not map the JavaScript function `{js_func}` to any Rust equivalent",
         ).into()))
 }
 
@@ -260,8 +255,7 @@ fn get_transform_object(js: &str, var: &str) -> Result<String> {
             .unwrap()
             .captures(js)
             .ok_or_else(|| Error::UnexpectedResponse(format!(
-                "could not extract the transform-object `{}`",
-                var
+                "could not extract the transform-object `{var}`",
             ).into()))?
             .get(1)
             .expect("the regex pattern must contain at least one capture group")
diff --git a/src/fetcher.rs b/src/fetcher.rs
index d839985..ad058c4 100644
--- a/src/fetcher.rs
+++ b/src/fetcher.rs
@@ -1,12 +1,11 @@
 use once_cell::sync::Lazy;
-
 use regex::Regex;
 use reqwest::Client;
 use serde::Deserialize;
 use url::Url;
 
-use crate::{Error, Id, IdBuf, PlayerResponse, VideoDescrambler, VideoInfo};
 use crate::video_info::player_response::playability_status::PlayabilityStatus;
+use crate::{Error, Id, IdBuf, PlayerResponse, VideoDescrambler, VideoInfo};
 
 /// A fetcher used to download all necessary data from YouTube, which then could be used
 /// to extract video-URLs.
@@ -63,7 +62,7 @@ use crate::video_info::player_response::playability_status::PlayabilityStatus;
 ///
 /// [`Video`]: crate::video::Video
 #[derive(Clone, derive_more::Display, derivative::Derivative)]
-#[display(fmt = "VideoFetcher({})", video_id)]
+#[display(fmt = "VideoFetcher({video_id})")]
 #[derivative(Debug, PartialEq, Eq)]
 pub struct VideoFetcher {
     video_id: IdBuf,
@@ -80,8 +79,7 @@ impl VideoFetcher {
     #[inline]
     #[cfg(feature = "regex")]
     pub fn from_url(url: &Url) -> crate::Result<Self> {
-        let id = Id::from_raw(url.as_str())?
-            .into_owned();
+        let id = Id::from_raw(url.as_str())?.into_owned();
         Self::from_id(id)
     }
 
@@ -147,7 +145,9 @@ impl VideoFetcher {
         let is_age_restricted = is_age_restricted(&watch_html);
         Self::check_downloadability(&watch_html, is_age_restricted)?;
 
-        let (video_info, js) = self.get_video_info_and_js(&watch_html, is_age_restricted).await?;
+        let (video_info, js) = self
+            .get_video_info_and_js(&watch_html, is_age_restricted)
+            .await?;
 
         Ok(VideoDescrambler {
             video_info,
@@ -176,7 +176,9 @@ impl VideoFetcher {
         let watch_html = self.get_html(&self.watch_url).await?;
         let is_age_restricted = is_age_restricted(&watch_html);
         Self::check_fetchability(&watch_html, is_age_restricted)?;
-        let (video_info, _js) = self.get_video_info_and_js(&watch_html, is_age_restricted).await?;
+        let (video_info, _js) = self
+            .get_video_info_and_js(&watch_html, is_age_restricted)
+            .await?;
 
         Ok(video_info)
     }
@@ -193,13 +195,16 @@ impl VideoFetcher {
         &self.watch_url
     }
 
-    fn check_downloadability(watch_html: &str, is_age_restricted: bool) -> crate::Result<PlayabilityStatus> {
+    fn check_downloadability(
+        watch_html: &str,
+        is_age_restricted: bool,
+    ) -> crate::Result<PlayabilityStatus> {
         let playability_status = Self::extract_playability_status(watch_html)?;
 
         match playability_status {
             PlayabilityStatus::Ok { .. } => Ok(playability_status),
             PlayabilityStatus::LoginRequired { .. } if is_age_restricted => Ok(playability_status),
-            ps => Err(Error::VideoUnavailable(Box::new(ps)))
+            ps => Err(Error::VideoUnavailable(Box::new(ps))),
         }
     }
 
@@ -211,30 +216,31 @@ impl VideoFetcher {
             PlayabilityStatus::Unplayable { .. } => Ok(()),
             PlayabilityStatus::LiveStreamOffline { .. } => Ok(()),
             PlayabilityStatus::LoginRequired { .. } if is_age_restricted => Ok(()),
-            ps => Err(Error::VideoUnavailable(Box::new(ps)))
+            ps => Err(Error::VideoUnavailable(Box::new(ps))),
         }
     }
 
     /// Checks, whether or not the video is accessible for normal users.
     fn extract_playability_status(watch_html: &str) -> crate::Result<PlayabilityStatus> {
-        static PLAYABILITY_STATUS: Lazy<Regex> = Lazy::new(||
-            Regex::new(r#"["']?playabilityStatus["']?\s*[:=]\s*"#).unwrap()
-        );
+        static PLAYABILITY_STATUS: Lazy<Regex> =
+            Lazy::new(|| Regex::new(r#"["']?playabilityStatus["']?\s*[:=]\s*"#).unwrap());
 
         PLAYABILITY_STATUS
             .find_iter(watch_html)
-            .map(|m| json_object(
-                watch_html
-                    .get(m.end()..)
-                    .ok_or(Error::Internal("The regex does not match meaningful"))?
-            ))
+            .map(|m| {
+                json_object(
+                    watch_html
+                        .get(m.end()..)
+                        .ok_or(Error::Internal("The regex does not match meaningful"))?,
+                )
+            })
             .filter_map(Result::ok)
             .map(serde_json::from_str::<PlayabilityStatus>)
             .filter_map(Result::ok)
             .next()
-            .ok_or_else(|| Error::UnexpectedResponse(
-                "watch html did not contain a PlayabilityStatus".into()
-            ))
+            .ok_or_else(|| {
+                Error::UnexpectedResponse("watch html did not contain a PlayabilityStatus".into())
+            })
     }
 
     #[inline]
@@ -243,7 +249,10 @@ impl VideoFetcher {
         watch_html: &str,
         is_age_restricted: bool,
     ) -> crate::Result<(VideoInfo, String)> {
-        let (js, player_response) = self.get_js(is_age_restricted, watch_html).await?;
+        let api_response = self.get_api_for(&self.video_id).await?;
+        let (js, player_response) = self
+            .get_js(is_age_restricted, watch_html, &api_response)
+            .await?;
 
         let player_response = player_response.ok_or_else(|| Error::UnexpectedResponse(
             "Could not acquire the player response from the watch html!\n\
@@ -267,18 +276,18 @@ impl VideoFetcher {
         &self,
         is_age_restricted: bool,
         watch_html: &str,
+        api_response: &str,
     ) -> crate::Result<(String, Option<PlayerResponse>)> {
         let (js_url, player_response) = match is_age_restricted {
             true => {
                 let embed_url = self.video_id.embed_url();
                 let embed_html = self.get_html(&embed_url).await?;
-                js_url(&embed_html)?
+                js_url(&embed_html, api_response)?
             }
-            false => js_url(watch_html)?
+            false => js_url(watch_html, api_response)?,
         };
 
-        self
-            .get_html(&js_url)
+        self.get_html(&js_url)
             .await
             .map(|html| (html, player_response))
     }
@@ -303,15 +312,9 @@ impl VideoFetcher {
     #[log_derive::logfn(Trace, fmt = "get_video_info_url() => {}")]
     fn get_video_info_url(&self, is_age_restricted: bool) -> Url {
         if is_age_restricted {
-            video_info_url_age_restricted(
-                self.video_id.as_borrowed(),
-                &self.watch_url,
-            )
+            video_info_url_age_restricted(self.video_id.as_borrowed(), &self.watch_url)
         } else {
-            video_info_url(
-                self.video_id.as_borrowed(),
-                &self.watch_url,
-            )
+            video_info_url(self.video_id.as_borrowed(), &self.watch_url)
         }
     }
 
@@ -320,15 +323,22 @@ impl VideoFetcher {
     #[log_derive::logfn_inputs(Debug)]
     #[log_derive::logfn(ok = "Trace", err = "Error", fmt = "get_html() => `{}`")]
     async fn get_html(&self, url: &Url) -> crate::Result<String> {
-        Ok(
-            self.client
-                .get(url.as_str())
-                .send()
-                .await?
-                .error_for_status()?
-                .text()
-                .await?
-        )
+        Ok(self
+            .client
+            .get(url.as_str())
+            .send()
+            .await?
+            .error_for_status()?
+            .text()
+            .await?)
+    }
+
+    async fn get_api_for(&self, id: &str) -> crate::Result<String> {
+        // From pytube
+        self.client.post(format!("https://www.youtube.com/youtubei/v1/player?videoId={id}&key=AIzaSyAO_FJ2SlqU8Q4STEHLGCilw_Y9_11qcW8&contentCheckOk=true&racyCheckOk=true"))
+        .header("content-type", "application/json")
+        .body(r#"{"context":{"client":{"clientName":"ANDROID","clientVersion":"16.20"}}}"#)
+        .send().await?.text().await.map_err(Error::from)
     }
 
     /*#[inline]
@@ -396,7 +406,7 @@ fn video_info_url_age_restricted(video_id: Id<'_>, watch_url: &Url) -> Url {
 
     let sts = match PATTERN.captures(watch_url.as_str()) {
         Some(c) => c.get(1).unwrap().as_str(),
-        None => ""
+        None => "",
     };
 
     let eurl = format!("https://youtube.googleapis.com/v/{}", video_id.as_str());
@@ -414,42 +424,55 @@ fn video_info_url_age_restricted(video_id: Id<'_>, watch_url: &Url) -> Url {
 /// Helper for assembling th video info url.
 #[inline]
 fn _video_info_url(params: &[(&str, &str)]) -> Url {
-    Url::parse_with_params(
-        "https://www.youtube.com/get_video_info?",
-        params,
-    ).unwrap()
+    Url::parse_with_params("https://www.youtube.com/get_video_info?", params).unwrap()
 }
 
 /// Generates the url under which the JavaScript used for descrambling can be requested.
 #[inline]
-fn js_url(html: &str) -> crate::Result<(Url, Option<PlayerResponse>)> {
-    let player_response = get_ytplayer_config(html);
+fn js_url(html: &str, api_json: &str) -> crate::Result<(Url, Option<PlayerResponse>)> {
+    let player_response = get_ytplayer_config(html, api_json);
     let base_js = match player_response {
-        Ok(PlayerResponse { assets: Some(ref assets), .. }) => assets.js.as_str(),
-        _ => get_ytplayer_js(html)?
+        Ok(PlayerResponse {
+            assets: Some(ref assets),
+            ..
+        }) => assets.js.as_str(),
+        _ => get_ytplayer_js(html)?,
     };
 
-    Ok((Url::parse(&format!("https://youtube.com{}", base_js))?, player_response.ok()))
+    Ok((
+        Url::parse(&format!("https://youtube.com{base_js}"))?,
+        player_response.ok(),
+    ))
 }
 
 /// Extracts the [`PlayerResponse`] from the watch html.
 #[inline]
-fn get_ytplayer_config(html: &str) -> crate::Result<PlayerResponse> {
-    static CONFIG_PATTERNS: Lazy<[Regex; 3]> = Lazy::new(|| [
-        Regex::new(r"ytplayer\.config\s*=\s*").unwrap(),
-        Regex::new(r"ytInitialPlayerResponse\s*=\s*").unwrap(),
-        // fixme
-        // pytube handles `setConfig` little bit differently. It parses the entire argument
-        // to `setConfig()` and then uses load json to find `PlayerResponse` inside of it.
-        // We currently handle both the same way, and just deserialize into the `PlayerConfig` enum.
-        // This *should* have the same effect.
-        //
-        // In the future, it may be a good idea, to also handle both cases differently, so we don't
-        // loose performance on deserializing into an enum, but deserialize `CONFIG_PATTERNS` directly
-        // into `PlayerResponse`, and `SET_CONFIG_PATTERNS` into `Args`. The problem currently is, that
-        // I don't know, if CONFIG_PATTERNS can also contain `Args`.
-        Regex::new(r#"yt\.setConfig\(.*['"]PLAYER_CONFIG['"]:\s*"#).unwrap()
-    ]);
+fn get_ytplayer_config(html: &str, api_json: &str) -> crate::Result<PlayerResponse> {
+    match deserialize_ytplayer_config(api_json) {
+        Ok(e) => return Ok(e),
+        Err(err) => {
+            //TODO: improve error handling
+            log::error!("failed to deserialized player config: {err}");
+        }
+    }
+
+    static CONFIG_PATTERNS: Lazy<[Regex; 3]> = Lazy::new(|| {
+        [
+            Regex::new(r"ytplayer\.config\s*=\s*").unwrap(),
+            Regex::new(r"ytInitialPlayerResponse\s*=\s*").unwrap(),
+            // fixme
+            // pytube handles `setConfig` little bit differently. It parses the entire argument
+            // to `setConfig()` and then uses load json to find `PlayerResponse` inside of it.
+            // We currently handle both the same way, and just deserialize into the `PlayerConfig` enum.
+            // This *should* have the same effect.
+            //
+            // In the future, it may be a good idea, to also handle both cases differently, so we don't
+            // loose performance on deserializing into an enum, but deserialize `CONFIG_PATTERNS` directly
+            // into `PlayerResponse`, and `SET_CONFIG_PATTERNS` into `Args`. The problem currently is, that
+            // I don't know, if CONFIG_PATTERNS can also contain `Args`.
+            Regex::new(r#"yt\.setConfig\(.*['"]PLAYER_CONFIG['"]:\s*"#).unwrap(),
+        ]
+    });
 
     CONFIG_PATTERNS
         .iter()
@@ -457,9 +480,9 @@ fn get_ytplayer_config(html: &str) -> crate::Result<PlayerResponse> {
             let json = parse_for_object(html, pattern).ok()?;
             deserialize_ytplayer_config(json).ok()
         })
-        .ok_or_else(|| Error::UnexpectedResponse(
-            "Could not find ytplayer_config in the watch html.".into()
-        ))
+        .ok_or_else(|| {
+            Error::UnexpectedResponse("Could not find ytplayer_config in the watch html.".into())
+        })
 }
 
 /// Extracts a json object from a string starting after a pattern.
@@ -471,9 +494,8 @@ fn parse_for_object<'a>(html: &'a str, regex: &Regex) -> crate::Result<&'a str>
         .end();
 
     json_object(
-        html
-            .get(json_obj_start..)
-            .ok_or(Error::Internal("The regex does not match meaningful"))?
+        html.get(json_obj_start..)
+            .ok_or(Error::Internal("The regex does not match meaningful"))?,
     )
 }
 
@@ -511,24 +533,24 @@ fn deserialize_ytplayer_config(json: &str) -> crate::Result<PlayerResponse> {
         Err(err) => err,
     };
 
-    Err(crate::Error::JsonDeserialization(serde::de::Error::custom(format_args!(
-        "data did not match any variant of untagged enum PlayerConfig:\n\tArgs:{}\n\tPlayerResponse:{}",
-        args_err, pr_err,
+    Err(Error::JsonDeserialization(serde::de::Error::custom(format_args!(
+        "data did not match any variant of untagged enum PlayerConfig:\n\
+        \tArgs:{args_err}\n\
+        \tPlayerResponse:{pr_err}",
     ))))
 }
 
 /// Extracts the JavaScript used for descrambling from the watch html.
 #[inline]
 fn get_ytplayer_js(html: &str) -> crate::Result<&str> {
-    static JS_URL_PATTERNS: Lazy<Regex> = Lazy::new(||
-        Regex::new(r"(/s/player/[\w\d]+/[\w\d_/.]+/base\.js)").unwrap()
-    );
+    static JS_URL_PATTERNS: Lazy<Regex> =
+        Lazy::new(|| Regex::new(r"(/s/player/[\w\d]+/[\w\d_/.]+/base\.js)").unwrap());
 
     match JS_URL_PATTERNS.captures(html) {
         Some(function_match) => Ok(function_match.get(1).unwrap().as_str()),
         None => Err(Error::UnexpectedResponse(
-            "could not extract the ytplayer-javascript url from the watch html".into()
-        ))
+            "could not extract the ytplayer-javascript url from the watch html".into(),
+        )),
     }
 }
 
@@ -537,7 +559,9 @@ fn get_ytplayer_js(html: &str) -> crate::Result<&str> {
 fn json_object(mut html: &str) -> crate::Result<&str> {
     html = html.trim_start_matches(|c| c != '{');
     if html.is_empty() {
-        return Err(Error::Internal("cannot parse a json object from an empty string"));
+        return Err(Error::Internal(
+            "cannot parse a json object from an empty string",
+        ));
     }
 
     let mut stack = vec![b'{'];
@@ -548,9 +572,7 @@ fn json_object(mut html: &str) -> crate::Result<&str> {
         .iter()
         .enumerate()
         .skip(1)
-        .find(
-            |(_i, &curr_char)| is_json_object_end(curr_char, &mut skip, &mut stack)
-        )
+        .find(|(_i, &curr_char)| is_json_object_end(curr_char, &mut skip, &mut stack))
         .ok_or(Error::Internal("could not find a closing delimiter"))?;
 
     let full_obj = html
@@ -573,11 +595,19 @@ fn is_json_object_end(curr_char: u8, skip: &mut bool, stack: &mut Vec<u8>) -> bo
         .expect("stack must start with len == 1, and search must end, when len == 0");
 
     match curr_char {
-        b'}' if context == b'{' => { stack.pop(); }
-        b']' if context == b'[' => { stack.pop(); }
-        b'"' if context == b'"' => { stack.pop(); }
+        b'}' if context == b'{' => {
+            stack.pop();
+        }
+        b']' if context == b'[' => {
+            stack.pop();
+        }
+        b'"' if context == b'"' => {
+            stack.pop();
+        }
 
-        b'\\' if context == b'"' => { *skip = true; }
+        b'\\' if context == b'"' => {
+            *skip = true;
+        }
 
         b'{' if context != b'"' => stack.push(b'{'),
         b'[' if context != b'"' => stack.push(b'['),
@@ -590,7 +620,8 @@ fn is_json_object_end(curr_char: u8, skip: &mut bool, stack: &mut Vec<u8>) -> bo
 }
 
 pub fn recommended_cookies() -> reqwest::cookie::Jar {
-    let cookie = "CONSENT=YES+; Path=/; Domain=youtube.com; Secure; Expires=Fri, 01 Jan 2038 00:00:00 GMT;";
+    let cookie =
+        "CONSENT=YES+; Path=/; Domain=youtube.com; Secure; Expires=Fri, 01 Jan 2038 00:00:00 GMT;";
     let url = "https://youtube.com".parse().unwrap();
 
     let jar = reqwest::cookie::Jar::default();
@@ -601,7 +632,10 @@ pub fn recommended_cookies() -> reqwest::cookie::Jar {
 pub fn recommended_headers() -> reqwest::header::HeaderMap {
     let mut headers = reqwest::header::HeaderMap::new();
 
-    headers.insert(reqwest::header::ACCEPT_LANGUAGE, "en-US,en".parse().unwrap());
+    headers.insert(
+        reqwest::header::ACCEPT_LANGUAGE,
+        "en-US,en".parse().unwrap(),
+    );
     headers.insert(reqwest::header::USER_AGENT, "Mozilla/5.0".parse().unwrap());
 
     headers
diff --git a/src/stream/callback.rs b/src/stream/callback.rs
index 0c4ff56..60c5fa6 100644
--- a/src/stream/callback.rs
+++ b/src/stream/callback.rs
@@ -9,10 +9,10 @@ use tokio::sync::mpsc;
 
 use crate::Result;
 
-pub type OnProgressClosure = Box<dyn Fn(CallbackArguments) + Send>;
-pub type OnProgressAsyncClosure = Box<dyn Fn(CallbackArguments) -> Pin<Box<dyn Future<Output=()> + Send>> + Send + Sync>;
-pub type OnCompleteClosure = Box<dyn Fn(Option<PathBuf>) + Send>;
-pub type OnCompleteAsyncClosure = Box<dyn Fn(Option<PathBuf>) -> Pin<Box<dyn Future<Output=()> + Send>> + Send + Sync>;
+pub type OnProgressClosure<'a> = Box<dyn FnMut(CallbackArguments) + Send + 'a>;
+pub type OnProgressAsyncClosure<'a> = Box<dyn FnMut(CallbackArguments) -> Pin<Box<dyn Future<Output=()> + Send + 'a>> + Send + Sync + 'a>;
+pub type OnCompleteClosure<'a> = Box<dyn FnMut(Option<PathBuf>) + Send + 'a>;
+pub type OnCompleteAsyncClosure<'a> = Box<dyn FnMut(Option<PathBuf>) -> Pin<Box<dyn Future<Output=()> + Send + 'a>> + Send + Sync + 'a>;
 
 #[derive(Debug)]
 pub(crate) enum InternalSignal {
@@ -33,20 +33,20 @@ pub struct CallbackArguments {
 }
 
 /// Type to process on_progress
-pub enum OnProgressType {
+pub enum OnProgressType<'a> {
     /// Box containing a closure to execute on progress
-    Closure(OnProgressClosure),
+    Closure(OnProgressClosure<'a>),
     /// Box containing a async closure to execute on progress
-    AsyncClosure(OnProgressAsyncClosure),
+    AsyncClosure(OnProgressAsyncClosure<'a>),
     /// Channel to send a message to on progress,
     /// bool indicates whether or not to cancel on a closed channel
     Channel(Sender<CallbackArguments>, bool),
     /// Box containing a closure to execute on progress
     /// Will get executed for every MB downloaded
-    SlowClosure(OnProgressClosure),
+    SlowClosure(OnProgressClosure<'a>),
     /// Box containing a async closure to execute on progress
     /// Will get executed for every MB downloaded
-    SlowAsyncClosure(OnProgressAsyncClosure),
+    SlowAsyncClosure(OnProgressAsyncClosure<'a>),
     /// Channel to send a message to on progress,
     /// bool indicates whether or not to cancel on a closed channel
     /// Will get executed for every MB downloaded
@@ -54,7 +54,7 @@ pub enum OnProgressType {
     None,
 }
 
-impl fmt::Debug for OnProgressType {
+impl<'a> fmt::Debug for OnProgressType<'a> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let name = match self {
             OnProgressType::AsyncClosure(_) => "AsyncClosure(async Fn)",
@@ -69,22 +69,22 @@ impl fmt::Debug for OnProgressType {
     }
 }
 
-impl Default for OnProgressType {
+impl<'a> Default for OnProgressType<'a> {
     fn default() -> Self {
         OnProgressType::None
     }
 }
 
 /// Type to process on_progress
-pub enum OnCompleteType {
+pub enum OnCompleteType<'a> {
     /// Box containing a closure to execute on complete
-    Closure(OnCompleteClosure),
+    Closure(OnCompleteClosure<'a>),
     /// Box containing a async closure to execute on complete
-    AsyncClosure(OnCompleteAsyncClosure),
+    AsyncClosure(OnCompleteAsyncClosure<'a>),
     None,
 }
 
-impl fmt::Debug for OnCompleteType {
+impl<'a> fmt::Debug for OnCompleteType<'a> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let name = match self {
             OnCompleteType::AsyncClosure(_) => "AsyncClosure(async Fn)",
@@ -95,7 +95,7 @@ impl fmt::Debug for OnCompleteType {
     }
 }
 
-impl Default for OnCompleteType {
+impl<'a> Default for OnCompleteType<'a> {
     fn default() -> Self {
         OnCompleteType::None
     }
@@ -103,14 +103,14 @@ impl Default for OnCompleteType {
 
 /// Methods and streams to process either on_progress or on_complete
 #[derive(Debug)]
-pub struct Callback {
-    pub on_progress: OnProgressType,
-    pub on_complete: OnCompleteType,
+pub struct Callback<'a> {
+    pub on_progress: OnProgressType<'a>,
+    pub on_complete: OnCompleteType<'a>,
     pub(crate) internal_sender: InternalSender,
     pub(crate) internal_receiver: Option<Receiver<InternalSignal>>,
 }
 
-impl Callback {
+impl<'a> Callback<'a> {
     /// Create a new callback struct without actual callbacks
     pub fn new() -> Self {
         let (tx, rx) = mpsc::channel(100);
@@ -131,7 +131,7 @@ impl Callback {
     /// [Callback::connect_on_progress_closure_slow](crate::stream::callback::Callback::connect_on_progress_closure_slow)
     #[inline]
     #[must_use]
-    pub fn connect_on_progress_closure(mut self, closure: impl Fn(CallbackArguments) + Send + 'static) -> Self {
+    pub fn connect_on_progress_closure(mut self, closure: impl FnMut(CallbackArguments) + Send + 'a) -> Self {
         self.on_progress = OnProgressType::Closure(Box::new(closure));
         self
     }
@@ -140,7 +140,7 @@ impl Callback {
     /// more seldom, around once for every MB downloaded.
     #[inline]
     #[must_use]
-    pub fn connect_on_progress_closure_slow(mut self, closure: impl Fn(CallbackArguments) + Send + 'static) -> Self {
+    pub fn connect_on_progress_closure_slow(mut self, closure: impl FnMut(CallbackArguments) + Send + 'a) -> Self {
         self.on_progress = OnProgressType::SlowClosure(Box::new(closure));
         self
     }
@@ -154,7 +154,7 @@ impl Callback {
     /// [Callback::connect_on_progress_closure_async_slow](crate::stream::callback::Callback::connect_on_progress_closure_async_slow)
     #[inline]
     #[must_use]
-    pub fn connect_on_progress_closure_async<Fut: Future<Output=()> + Send + 'static, F: Fn(CallbackArguments) -> Fut + Send + Sync + 'static>(mut self, closure: F) -> Self {
+    pub fn connect_on_progress_closure_async<Fut: Future<Output=()> + Send + 'a, F: Fn(CallbackArguments) -> Fut + Send + Sync + 'a>(mut self, closure: F) -> Self {
         self.on_progress = OnProgressType::AsyncClosure(Box::new(move |arg| closure(arg).boxed()));
         self
     }
@@ -163,7 +163,7 @@ impl Callback {
     /// more seldom, around once for every MB downloaded.
     #[inline]
     #[must_use]
-    pub fn connect_on_progress_closure_async_slow<Fut: Future<Output=()> + Send + 'static, F: Fn(CallbackArguments) -> Fut + Send + Sync + 'static>(mut self, closure: F) -> Self {
+    pub fn connect_on_progress_closure_async_slow<Fut: Future<Output=()> + Send + 'a, F: Fn(CallbackArguments) -> Fut + Send + Sync + 'a>(mut self, closure: F) -> Self {
         self.on_progress = OnProgressType::SlowAsyncClosure(Box::new(move |arg| closure(arg).boxed()));
         self
     }
@@ -203,7 +203,7 @@ impl Callback {
     /// Attach a closure to be executed on complete
     #[inline]
     #[must_use]
-    pub fn connect_on_complete_closure(mut self, closure: impl Fn(Option<PathBuf>) + Send + 'static) -> Self {
+    pub fn connect_on_complete_closure(mut self, closure: impl FnMut(Option<PathBuf>) + Send + 'a) -> Self {
         self.on_complete = OnCompleteType::Closure(Box::new(closure));
         self
     }
@@ -211,13 +211,13 @@ impl Callback {
     /// Attach a async closure to be executed on complete
     #[inline]
     #[must_use]
-    pub fn connect_on_complete_closure_async<Fut: Future<Output=()> + Send + 'static, F: Fn(Option<PathBuf>) -> Fut + Send + Sync + 'static>(mut self, closure: F) -> Self {
+    pub fn connect_on_complete_closure_async<Fut: Future<Output=()> + Send + 'a, F: Fn(Option<PathBuf>) -> Fut + Send + Sync + 'a>(mut self, closure: F) -> Self {
         self.on_complete = OnCompleteType::AsyncClosure(Box::new(move |arg| closure(arg).boxed()));
         self
     }
 }
 
-impl Default for Callback {
+impl<'a> Default for Callback<'a> {
     fn default() -> Self {
         Self::new()
     }
@@ -228,7 +228,7 @@ impl super::Stream {
     /// This will download the video to <video_id>.mp4 in the current working directory.
     /// Takes an [`Callback`](crate::stream::callback::Callback)
     #[inline]
-    pub async fn download_with_callback(&self, callback: Callback) -> Result<PathBuf> {
+    pub async fn download_with_callback<'a>(&'a self, callback: Callback<'a>) -> Result<PathBuf> {
         self.wrap_callback(|channel| {
             self.internal_download(channel)
         }, callback).await
@@ -238,10 +238,10 @@ impl super::Stream {
     /// This will download the video to <video_id>.mp4 in the provided directory.
     /// Takes an [`Callback`](crate::stream::callback::Callback)
     #[inline]
-    pub async fn download_to_dir_with_callback<P: AsRef<Path>>(
-        &self,
+    pub async fn download_to_dir_with_callback<'a, P: AsRef<Path>>(
+        &'a self,
         dir: P,
-        callback: Callback,
+        callback: Callback<'a>,
     ) -> Result<PathBuf> {
         self.wrap_callback(|channel| {
             self.internal_download_to_dir(dir, channel)
@@ -252,17 +252,17 @@ impl super::Stream {
     /// This will download the video to the provided file path.
     /// Takes an [`Callback`](crate::stream::callback::Callback)
     #[inline]
-    pub async fn download_to_with_callback<P: AsRef<Path>>(&self, path: P, callback: Callback) -> Result<()> {
+    pub async fn download_to_with_callback<'a, P: AsRef<Path>>(&'a self, path: P, callback: Callback<'a>) -> Result<()> {
         let _ = self.wrap_callback(|channel| {
             self.internal_download_to(path, channel)
         }, callback).await?;
         Ok(())
     }
 
-    async fn wrap_callback<F: Future<Output=Result<PathBuf>>>(
-        &self,
+    async fn wrap_callback<'a, F: Future<Output=Result<PathBuf>>>(
+        &'a self,
         to_wrap: impl FnOnce(Option<InternalSender>) -> F,
-        mut callback: Callback,
+        mut callback: Callback<'a>,
     ) -> Result<PathBuf> {
         let wrap_fut = to_wrap(Some(callback.internal_sender.clone()));
         let aid_fut = self.on_progress(
@@ -279,12 +279,12 @@ impl super::Stream {
     }
 
     #[inline]
-    async fn on_progress(&self, mut receiver: Receiver<InternalSignal>, on_progress: OnProgressType) {
+    async fn on_progress<'a>(&'a self, mut receiver: Receiver<InternalSignal>, on_progress: OnProgressType<'a>) {
         let last_trigger = Mutex::new(0);
         let content_length = self.content_length().await.ok();
         match on_progress {
             OnProgressType::None => {}
-            OnProgressType::Closure(closure) => {
+            OnProgressType::Closure(mut closure) => {
                 while let Some(data) = receiver.recv().await {
                     match data {
                         InternalSignal::Value(data) => {
@@ -298,7 +298,7 @@ impl super::Stream {
                     }
                 }
             }
-            OnProgressType::AsyncClosure(closure) => {
+            OnProgressType::AsyncClosure(mut closure) => {
                 while let Some(data) = receiver.recv().await {
                     match data {
                         InternalSignal::Value(data) => {
@@ -329,7 +329,7 @@ impl super::Stream {
                     }
                 }
             }
-            OnProgressType::SlowClosure(closure) => {
+            OnProgressType::SlowClosure(mut closure) => {
                 while let Some(data) = receiver.recv().await {
                     match data {
                         InternalSignal::Value(data) => {
@@ -350,7 +350,7 @@ impl super::Stream {
                     }
                 }
             }
-            OnProgressType::SlowAsyncClosure(closure) => {
+            OnProgressType::SlowAsyncClosure(mut closure) => {
                 while let Some(data) = receiver.recv().await {
                     match data {
                         InternalSignal::Value(data) => {
@@ -398,13 +398,13 @@ impl super::Stream {
     }
 
     #[inline]
-    async fn on_complete(on_complete: OnCompleteType, path: Option<PathBuf>) {
+    async fn on_complete(on_complete: OnCompleteType<'_>, path: Option<PathBuf>) {
         match on_complete {
             OnCompleteType::None => {}
-            OnCompleteType::Closure(closure) => {
+            OnCompleteType::Closure(mut closure) => {
                 closure(path)
             }
-            OnCompleteType::AsyncClosure(closure) => {
+            OnCompleteType::AsyncClosure(mut closure) => {
                 closure(path).await
             }
         }
diff --git a/src/stream/mod.rs b/src/stream/mod.rs
index ff04d07..043293d 100644
--- a/src/stream/mod.rs
+++ b/src/stream/mod.rs
@@ -1,37 +1,34 @@
 use std::ops::Range;
 #[cfg(feature = "download")]
 use std::path::{Path, PathBuf};
-use std::sync::Arc;
 use std::sync::atomic::{AtomicU64, Ordering};
+use std::sync::Arc;
 
 use chrono::{DateTime, Utc};
 use mime::Mime;
 use reqwest::Client;
-use serde_with::{DisplayFromStr, serde_as};
-#[cfg(feature = "download")]
-use tokio::{
-    fs::File,
-    io::AsyncWriteExt,
-};
+use serde_with::{serde_as, DisplayFromStr};
 #[cfg(feature = "callback")]
 use tokio::sync::mpsc::error::TrySendError;
 #[cfg(feature = "download")]
+use tokio::{fs::File, io::AsyncWriteExt};
+#[cfg(feature = "download")]
 use tokio_stream::StreamExt;
 
-#[cfg(feature = "callback")]
-use callback::{InternalSender, InternalSignal};
 #[cfg(all(feature = "callback", feature = "stream", feature = "blocking"))]
 use callback::Callback;
+#[cfg(feature = "callback")]
+use callback::{InternalSender, InternalSignal};
 
-#[cfg(feature = "download")]
-use crate::{Error, Result};
 use crate::{
     video_info::player_response::streaming_data::{
-        AudioQuality, ColorInfo, FormatType, ProjectionType,
-        Quality, QualityLabel, RawFormat, SignatureCipher,
+        AudioQuality, ColorInfo, FormatType, ProjectionType, Quality, QualityLabel, RawFormat,
+        SignatureCipher,
     },
     VideoDetails,
 };
+#[cfg(feature = "download")]
+use crate::{Error, Result};
 
 #[cfg(feature = "callback")]
 pub mod callback;
@@ -85,14 +82,23 @@ pub struct Stream {
     client: Client,
 }
 
-
 impl Stream {
     // maybe deserialize RawFormat seeded with client and VideoDetails
-    pub(crate) fn from_raw_format(raw_format: RawFormat, client: Client, video_details: Arc<VideoDetails>) -> Self {
+    pub(crate) fn from_raw_format(
+        raw_format: RawFormat,
+        client: Client,
+        video_details: Arc<VideoDetails>,
+    ) -> Self {
         Self {
             is_progressive: is_progressive(&raw_format.mime_type.codecs),
-            includes_video_track: includes_video_track(&raw_format.mime_type.codecs, &raw_format.mime_type.mime),
-            includes_audio_track: includes_audio_track(&raw_format.mime_type.codecs, &raw_format.mime_type.mime),
+            includes_video_track: includes_video_track(
+                &raw_format.mime_type.codecs,
+                &raw_format.mime_type.mime,
+            ),
+            includes_audio_track: includes_audio_track(
+                &raw_format.mime_type.codecs,
+                &raw_format.mime_type.mime,
+            ),
             mime: raw_format.mime_type.mime,
             codecs: raw_format.mime_type.codecs,
             format_type: raw_format.format_type,
@@ -138,7 +144,9 @@ impl Stream {
     #[inline]
     pub async fn content_length(&self) -> Result<u64> {
         let cl = self.content_length.load(Ordering::SeqCst);
-        if cl != 0 { return Ok(cl); }
+        if cl != 0 {
+            return Ok(cl);
+        }
 
         self.client
             .head(self.signature_cipher.url.as_str())
@@ -154,9 +162,11 @@ impl Stream {
                 self.content_length.store(cl, Ordering::SeqCst);
                 cl
             })
-            .ok_or_else(|| Error::UnexpectedResponse(
-                "the response did not contain a valid content-length field".into()
-            ))
+            .ok_or_else(|| {
+                Error::UnexpectedResponse(
+                    "the response did not contain a valid content-length field".into(),
+                )
+            })
     }
 
     /// Attempts to downloads the [`Stream`]s resource.
@@ -170,8 +180,7 @@ impl Stream {
     async fn internal_download(&self, channel: Option<InternalSender>) -> Result<PathBuf> {
         let path = Path::new(self.video_details.video_id.as_str())
             .with_extension(self.mime.subtype().as_str());
-        self.internal_download_to(&path, channel)
-            .await
+        self.internal_download_to(&path, channel).await
     }
 
     /// Attempts to downloads the [`Stream`]s resource.
@@ -187,12 +196,9 @@ impl Stream {
         dir: P,
         channel: Option<InternalSender>,
     ) -> Result<PathBuf> {
-        let mut path = dir
-            .as_ref()
-            .join(self.video_details.video_id.as_str());
+        let mut path = dir.as_ref().join(self.video_details.video_id.as_str());
         path.set_extension(self.mime.subtype().as_str());
-        self.internal_download_to(&path, channel)
-            .await
+        self.internal_download_to(&path, channel).await
     }
 
     /// Attempts to downloads the [`Stream`]s resource.
@@ -204,41 +210,70 @@ impl Stream {
     }
 
     #[allow(unused_mut, clippy::let_and_return)]
-    async fn internal_download_to<P: AsRef<Path>>(&self, path: P, channel: Option<InternalSender>) -> Result<PathBuf> {
+    async fn internal_download_to<P: AsRef<Path>>(
+        &self,
+        path: P,
+        channel: Option<InternalSender>,
+    ) -> Result<PathBuf> {
         log::trace!("download_to: {:?}", path.as_ref());
         log::debug!("start downloading {}", self.video_details.video_id);
         let mut file = File::create(&path).await?;
 
-        let result = match self.download_full(&self.signature_cipher.url, &mut file, &channel, 0).await {
+        let result = match self
+            .download_full(
+                &self.signature_cipher.url,
+                &mut file,
+                &channel,
+                0,
+                Some(self.content_length.load(Ordering::SeqCst)),
+            )
+            .await
+        {
             Ok(_) => {
                 log::info!(
                     "downloaded {} successfully to {:?}",
-                    self.video_details.video_id, path.as_ref()
+                    self.video_details.video_id,
+                    path.as_ref()
                 );
                 log::debug!("downloaded stream {:?}", &self);
                 Ok(())
             }
-            Err(Error::Request(e)) if matches!(e.status(), Some(reqwest::StatusCode::NOT_FOUND)) => {
-                log::error!("failed to download {}: {:?}", self.video_details.video_id, e);
-                log::info!("try to download {} using sequenced download", self.video_details.video_id);
+            Err(Error::Request(e))
+                if matches!(e.status(), Some(reqwest::StatusCode::NOT_FOUND)) =>
+            {
+                log::error!(
+                    "failed to download {}: {:?}",
+                    self.video_details.video_id,
+                    e
+                );
+                log::info!(
+                    "try to download {} using sequenced download",
+                    self.video_details.video_id
+                );
                 // Some adaptive streams need to be requested with sequence numbers
                 self.download_full_seq(&mut file, &channel)
                     .await
                     .map_err(|e| {
                         log::error!(
                             "failed to download {} using sequenced download: {:?}",
-                            self.video_details.video_id, e
+                            self.video_details.video_id,
+                            e
                         );
                         e
                     })
             }
             Err(e) => {
-                log::error!("failed to download {}: {:?}", self.video_details.video_id, e);
+                log::error!(
+                    "failed to download {}: {:?}",
+                    self.video_details.video_id,
+                    e
+                );
                 drop(file);
                 tokio::fs::remove_file(path.as_ref()).await?;
                 Err(e)
             }
-        }.map(|_| path.as_ref().to_path_buf());
+        }
+        .map(|_| path.as_ref().to_path_buf());
 
         #[cfg(feature = "callback")]
         if let Some(channel) = channel {
@@ -248,7 +283,11 @@ impl Stream {
         result
     }
 
-    async fn download_full_seq(&self, file: &mut File, channel: &Option<InternalSender>) -> Result<()> {
+    async fn download_full_seq(
+        &self,
+        file: &mut File,
+        channel: &Option<InternalSender>,
+    ) -> Result<()> {
         // fixme: this implementation is **not** tested yet!
         // To test it, I would need an url of a video, which does require sequenced downloading.
         log::warn!(
@@ -262,23 +301,21 @@ impl Stream {
         );
 
         let mut url = self.signature_cipher.url.clone();
-        let base_query = url
-            .query()
-            .map(str::to_owned)
-            .unwrap_or_else(String::new);
+        let base_query = url.query().map(str::to_owned).unwrap_or_else(String::new);
 
         // The 0th sequential request provides the file headers, which tell us
         // information about how the file is segmented.
         Self::set_url_seq_query(&mut url, &base_query, 0);
-        let res = self.get(&url).await?;
+        let res = self.get(&url, None).await?;
         let segment_count = Stream::extract_segment_count(&res)?;
         // No callback action since this is not really part of the progress
-        self.write_stream_to_file(res.bytes_stream(), file, &None, 0).await?;
+        self.write_stream_to_file(res.bytes_stream(), file, &None, 0)
+            .await?;
         let mut count = 0;
 
         for i in 1..segment_count {
             Self::set_url_seq_query(&mut url, &base_query, i);
-            count = self.download_full(&url, file, channel, count).await?;
+            count = self.download_full(&url, file, channel, count, None).await?;
         }
 
         Ok(())
@@ -291,28 +328,34 @@ impl Stream {
         file: &mut File,
         channel: &Option<InternalSender>,
         count: usize,
+        content_length: Option<u64>,
     ) -> Result<usize> {
-        let res = self.get(url).await?;
-        self.write_stream_to_file(res.bytes_stream(), file, channel, count).await
+        let res = self.get(url, content_length).await?;
+        self.write_stream_to_file(res.bytes_stream(), file, channel, count)
+            .await
     }
 
     #[inline]
-    async fn get(&self, url: &url::Url) -> Result<reqwest::Response> {
+    async fn get(&self, url: &url::Url, content_length: Option<u64>) -> Result<reqwest::Response> {
         log::trace!("get: {}", url.as_str());
-        Ok(
+        let k = self.client.get(url.as_str());
+        Ok(if let Some(content_length) = content_length {
+            let k = k.header("Range", format!("bytes=0-{content_length}"));
+            k.send().await?.error_for_status()?
+        } else {
             self.client
                 .get(url.as_str())
                 .send()
                 .await?
                 .error_for_status()?
-        )
+        })
     }
 
     #[inline]
     #[allow(unused_variables, unused_mut)]
     async fn write_stream_to_file(
         &self,
-        mut stream: impl tokio_stream::Stream<Item=reqwest::Result<bytes::Bytes>> + Unpin,
+        mut stream: impl tokio_stream::Stream<Item = reqwest::Result<bytes::Bytes>> + Unpin,
         file: &mut File,
         channel: &Option<InternalSender>,
         mut counter: usize,
@@ -320,18 +363,19 @@ impl Stream {
         // Counter will be 0 if callback is not enabled
         while let Some(chunk) = stream.next().await {
             let chunk = chunk?;
-            log::trace!("received {} byte chunk ", chunk.len());
+            let len = chunk.len();
+            log::trace!("received {len} byte chunk ");
 
-            file
-                .write_all(&chunk)
-                .await?;
+            file.write_all(&chunk).await?;
             #[cfg(feature = "callback")]
             if let Some(channel) = &channel {
                 // network chunks of ~10kb size
-                counter += chunk.len();
+                counter += len;
                 // Will abort if the receiver is closed
                 // Will ignore if the channel is full and thus not slow down the download
-                if let Err(TrySendError::Closed(_)) = channel.try_send(InternalSignal::Value(counter)) {
+                if let Err(TrySendError::Closed(_)) =
+                    channel.try_send(InternalSignal::Value(counter))
+                {
                     return Err(Error::ChannelClosed);
                 }
             }
@@ -342,27 +386,26 @@ impl Stream {
     #[inline]
     fn set_url_seq_query(url: &mut url::Url, base_query: &str, sq: u64) {
         url.set_query(Some(base_query));
-        url
-            .query_pairs_mut()
-            .append_pair("sq", &sq.to_string());
+        url.query_pairs_mut().append_pair("sq", &sq.to_string());
     }
 
     #[inline]
     fn extract_segment_count(res: &reqwest::Response) -> Result<u64> {
-        res
-            .headers()
+        res.headers()
             .get("Segment-Count")
-            .ok_or_else(|| Error::UnexpectedResponse(
-                "sequence download request did not contain a Segment-Count".into()
-            ))?
+            .ok_or_else(|| {
+                Error::UnexpectedResponse(
+                    "sequence download request did not contain a Segment-Count".into(),
+                )
+            })?
             .to_str()
-            .map_err(|_| Error::UnexpectedResponse(
-                "Segment-Count is not valid utf-8".into()
-            ))?
+            .map_err(|_| Error::UnexpectedResponse("Segment-Count is not valid utf-8".into()))?
             .parse::<u64>()
-            .map_err(|_| Error::UnexpectedResponse(
-                "Segment-Count could not be parsed into an integer".into()
-            ))
+            .map_err(|_| {
+                Error::UnexpectedResponse(
+                    "Segment-Count could not be parsed into an integer".into(),
+                )
+            })
     }
 }
 
@@ -377,7 +420,7 @@ impl Stream {
     /// A synchronous wrapper around [`Stream::download_with_callback`](crate::Stream::download_with_callback).
     #[cfg(feature = "callback")]
     #[inline]
-    pub fn blocking_download_with_callback(&self, callback: Callback) -> Result<PathBuf> {
+    pub fn blocking_download_with_callback<'a>(&'a self, callback: Callback<'a>) -> Result<PathBuf> {
         crate::block!(self.download_with_callback(callback))
     }
 
@@ -390,10 +433,10 @@ impl Stream {
     /// A synchronous wrapper around [`Stream::download_to_dir_with_callback`](crate::Stream::download_to_dir_with_callback).
     #[cfg(feature = "callback")]
     #[inline]
-    pub fn blocking_download_to_dir_with_callback<P: AsRef<Path>>(
-        &self,
+    pub fn blocking_download_to_dir_with_callback<'a, P: AsRef<Path>>(
+        &'a self,
         dir: P,
-        callback: Callback,
+        callback: Callback<'a>,
     ) -> Result<PathBuf> {
         crate::block!(self.download_to_dir_with_callback(dir, callback))
     }
@@ -405,7 +448,11 @@ impl Stream {
 
     /// A synchronous wrapper around [`Stream::download_to_with_callback`](crate::Stream::download_to_with_callback).
     #[cfg(feature = "callback")]
-    pub fn blocking_download_to_with_callback<P: AsRef<Path>>(&self, path: P, callback: Callback) -> Result<()> {
+    pub fn blocking_download_to_with_callback<'a, P: AsRef<Path>>(
+        &'a self,
+        path: P,
+        callback: Callback<'a>,
+    ) -> Result<()> {
         crate::block!(self.download_to_with_callback(path, callback))
     }