ytmusicapi

https://docs.rs/ytmusicapi/latest
Admin
An async Rust client for the YouTube Music internal API (YouTubei), focused on playlist and library...
Tokens:58,305
Snippets:515
Trust Score:9.1
Update:4 months ago
Show doc for...
Tokens:
Raw
### Get Library Playlists Example

Source: https://docs.rs/ytmusicapi/latest/ytmusicapi/struct.YTMusicClient.html

Fetches a list of playlists from the user's library, with an optional limit on the number of playlists returned. Requires authentication.

```rust
let playlists = client.get_library_playlists(Some(10)).await?;
for playlist in playlists {
    println!("{}", playlist.title);
}
```

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

### Handling File Metadata Operations with Result

Source: https://docs.rs/ytmusicapi/latest/ytmusicapi/type.Result.html

Shows how to use `and_then` to chain fallible operations like getting file metadata and modified time. Includes examples for both successful and failed path lookups, demonstrating error kind checking.

```rust
use std::{io::ErrorKind, path::Path};

// Note: on Windows "/" maps to "C:\"
let root_modified_time = Path::new("/").metadata().and_then(|md| md.modified());
assert!(root_modified_time.is_ok());

let should_fail = Path::new("/bad/path").metadata().and_then(|md| md.modified());
assert!(should_fail.is_err());
assert_eq!(should_fail.unwrap_err().kind(), ErrorKind::NotFound);
```

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

### Quick Start: Authenticated Client Usage

Source: https://docs.rs/ytmusicapi/latest/src/ytmusicapi/lib.rs.html

Initialize the YTMusicClient with browser authentication and fetch library playlists.

```rust
use ytmusicapi::{BrowserAuth, YTMusicClient};

#[tokio::main]
async fn main() -> ytmusicapi::Result<()> {
    let auth = BrowserAuth::from_file("headers.json")?;
    let client = YTMusicClient::builder()
        .with_browser_auth(auth)
        .build()?;

    let playlists = client.get_library_playlists(Some(10)).await?;
    for playlist in playlists {
        println!("{} ({})", playlist.title, playlist.count.unwrap_or(0));
    }
    Ok(())
}

```

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

### Get Playlist with Tracks Example

Source: https://docs.rs/ytmusicapi/latest/ytmusicapi/struct.YTMusicClient.html

Retrieves a specific playlist by its ID, including its tracks. Supports an optional limit for the number of tracks. The client does not enforce authentication, but private playlists may be rejected. If no limit is set, it fetches up to 5,000 tracks.

```rust
let playlist = client.get_playlist("PL123456789", None).await?;
println!("Title: {}", playlist.title);
for track in playlist.tracks {
    println!(" - {} by {:?}", track.title.unwrap_or_default(), track.artists);
}
```

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

### Quick Start: Authenticated API Usage

Source: https://docs.rs/ytmusicapi/latest/index.html

Initialize the YTMusicClient with browser authentication and fetch the user's library playlists.

```rust
use ytmusicapi::{BrowserAuth, YTMusicClient};

#[tokio::main] async fn main() -> ytmusicapi::Result<()> {
    let auth = BrowserAuth::from_file("headers.json")?;
    let client = YTMusicClient::builder()
        .with_browser_auth(auth)
        .build()?;

    let playlists = client.get_library_playlists(Some(10)).await?;
    for playlist in playlists {
        println!("{} ({})", playlist.title, playlist.count.unwrap_or(0));
    }
    Ok(())
}
```

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

### Example: Navigating Nested JSON Data

Source: https://docs.rs/ytmusicapi/latest/src/ytmusicapi/nav.rs.html

Demonstrates how to use the `nav` function and `path!` macro to extract a specific string value from a nested JSON structure. This example shows accessing a string within an array of objects.

```Rust
use serde_json::json;
use ytmusicapi::{nav::nav, path};

let data = json!({
    "contents": [
        { "title": { "text": "Hello" } }
    ]
});
let title = nav(&data, &path!["contents", 0, "title", "text"])
    .and_then(|v| v.as_str());
assert_eq!(title, Some("Hello"));
```

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

### Install ytmusicapi

Source: https://docs.rs/ytmusicapi/latest/index.html

Add the ytmusicapi crate to your project's Cargo.toml file to include it as a dependency.

```toml
[dependencies]
ytmusicapi = "0.4"
```

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

### Quick Start: Authenticated Client

Source: https://docs.rs/ytmusicapi/latest/ytmusicapi/index.html

Initialize an authenticated YTMusicClient using browser cookies loaded from a file and fetch your library playlists.

```rust
use ytmusicapi::{BrowserAuth, YTMusicClient};

#[tokio::main]
async fn main() -> ytmusicapi::Result<()> {
    let auth = BrowserAuth::from_file("headers.json")?;
    let client = YTMusicClient::builder()
        .with_browser_auth(auth)
        .build()?;

    let playlists = client.get_library_playlists(Some(10)).await?;
    for playlist in playlists {
        println!("{} ({})", playlist.title, playlist.count.unwrap_or(0));
    }
    Ok(())
}
```

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

### Get song details

Source: https://docs.rs/ytmusicapi/latest/src/ytmusicapi/client.rs.html

Fetches detailed information about a song. Does not require authentication.

```rust
pub async fn get_song(&self, song_id: &str) -> Result<Song> {
        let body = json!({
            "video_id": song_id,
        });

        let response = self.send_request("get_video", body).await?;
        Ok(serde_json::from_value(response)?)
    }
```

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

### Get album details

Source: https://docs.rs/ytmusicapi/latest/src/ytmusicapi/client.rs.html

Fetches detailed information about an album. Does not require authentication.

```rust
pub async fn get_album(&self, album_id: &str) -> Result<Value> {
        let body = json!({
            "browseId": album_id,
        });

        self.send_request("browse", body).await
    }
```

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

### Get artist details

Source: https://docs.rs/ytmusicapi/latest/src/ytmusicapi/client.rs.html

Fetches detailed information about an artist. Does not require authentication.

```rust
pub async fn get_artist(&self, channel_id: &str) -> Result<Value> {
        let body = json!({
            "browseId": channel_id,
        });

        self.send_request("browse", body).await
    }
```

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

### Get song lyrics

Source: https://docs.rs/ytmusicapi/latest/src/ytmusicapi/client.rs.html

Fetches lyrics for a given song. Does not require authentication.

```rust
pub async fn get_lyrics(&self, video_id: &str) -> Result<String> {
        let body = json!({
            "video_id": video_id,
        });

        let response = self.send_request("getLyrics", body).await?;
        Ok(response["lyrics": response["lyrics"]].to_string())
    }
```

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

### Get Playlist

Source: https://docs.rs/ytmusicapi/latest/ytmusicapi/index.html

Fetches detailed metadata and tracks for a specific playlist.

```APIDOC
## `get_playlist`

### Description
Fetches detailed metadata and tracks for a specific playlist identified by its ID. This is useful for displaying the contents of a playlist.

### Method
`YTMusicClient::get_playlist`

### Parameters
#### Path Parameters
- **playlist_id** (str) - Required - The unique identifier of the playlist.

### Response
#### Success Response
- Returns a `Playlist` object containing detailed information about the playlist and its tracks.

### Request Example
```rust
use ytmusicapi::YTMusicClient;

#[tokio::main]
async fn main() -> ytmusicapi::Result<()> {
    let client = YTMusicClient::builder().build()?;
    let playlist = client.get_playlist("PL_some_playlist_id").await?;
    Ok(())
}
```
```

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

### Getting Mutable References with `as_mut()`

Source: https://docs.rs/ytmusicapi/latest/ytmusicapi/type.Result.html

Shows how to use `as_mut()` to get mutable references to the contained values of a Result. This allows in-place modification of Ok or Err values.

```rust
fn mutate(r: &mut Result<i32, i32>) {
    match r.as_mut() {
        Ok(v) => *v = 42,
        Err(e) => *e = 0,
    }
}

let mut x: Result<i32, i32> = Ok(2);
mutate(&mut x);
assert_eq!(x.unwrap(), 42);

let mut x: Result<i32, i32> = Err(13);
mutate(&mut x);
assert_eq!(x.unwrap_err(), 0);
```

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

### Get Library Playlists

Source: https://docs.rs/ytmusicapi/latest/index.html

Fetches a list of playlists from the user's library. An optional limit can be specified.

```APIDOC
## `YTMusicClient::get_library_playlists`

### Description
Reads library playlists for the authenticated user.

### Method
`get_library_playlists`

### Parameters
#### Query Parameters
- **limit** (Option<u32>) - Optional - The maximum number of playlists to return.

### Response
#### Success Response
- **Vec<PlaylistSummary>** - A list of playlist summaries.

### Request Example
```rust
let playlists = client.get_library_playlists(Some(10)).await?;
```
```

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

### Get charts content

Source: https://docs.rs/ytmusicapi/latest/src/ytmusicapi/client.rs.html

Fetches content for the YouTube Music charts. Does not require authentication.

```rust
pub async fn get_charts(&self) -> Result<Value> {
        let body = json!({});
        self.send_request("charts", body).await
    }
```

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

### Product Trait Example for Result

Source: https://docs.rs/ytmusicapi/latest/ytmusicapi/type.Result.html

Demonstrates using the `product` method on an iterator of `Result` types. If any element is an `Err`, the iteration stops and the `Err` is returned. Otherwise, it computes the product of all `Ok` values.

```rust
let nums = vec!["5", "10", "1", "2"];
let total: Result<usize, _> = nums.iter().map(|w| w.parse::<usize>()).product();
assert_eq!(total, Ok(100));
let nums = vec!["5", "10", "one", "2"];
let total: Result<usize, _> = nums.iter().map(|w| w.parse::<usize>()).product();
assert!(total.is_err());
```

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

### Get a playlist with its tracks

Source: https://docs.rs/ytmusicapi/latest/src/ytmusicapi/client.rs.html

Fetches metadata and tracks for a given playlist ID. The client does not enforce authentication, but private playlists may be rejected by the API. If `limit` is `None`, the client follows continuations and returns up to 5,000 tracks.

```rust
pub async fn get_playlist(&self, playlist_id: &str, limit: Option<u32>) -> Result<Playlist> {
        let validated_id = validate_playlist_id(playlist_id);
        let mut body = json!({
            "playlistId": validated_id,
        });

        let mut response = self.send_request("browse", body).await?;

        if let Some(continuation_token) = get_continuation_token(&response) {
            if limit.is_none() || limit.unwrap() > 100 {
                // Fetch remaining tracks if limit is not set or large enough
                body["continuation": continuation_token];
                body["cursor": continuation_token];
                let continuation_response = self.send_request("browse", body).await?;
                response["contents": continuation_response["contents"]];
            }
        }

        Ok(parse_playlist_response(response)?)
    }
```

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

### Get library playlists with YTMusicClient

Source: https://docs.rs/ytmusicapi/latest/src/ytmusicapi/client.rs.html

Fetches playlists from the user's library. Requires authentication. This currently fetches only the first page of playlists and does not follow continuations. Handles pagination by limiting the number of returned playlists.

```rust
pub async fn get_library_playlists(&self, limit: Option<u32>) -> Result<Vec<PlaylistSummary>> {
        self.check_auth()?;

        let body = json!({
            "browseId": "FEmusic_liked_playlists"
        });

        let response = self.send_request("browse", body).await?;
        let mut playlists = parse_library_playlists(&response);

        // Handle pagination if needed
        if let Some(lim) = limit {
            playlists.truncate(lim as usize);
        }

        // TODO: Handle continuations for large libraries

        Ok(playlists)
    }
```

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

### Get Playlist Details and Tracks

Source: https://docs.rs/ytmusicapi/latest/src/ytmusicapi/client.rs.html

Fetches details and tracks for a given playlist ID. Handles pagination for tracks and applies an optional limit. Recalculates the total duration of the playlist.

```rust
/// # use ytmusicapi::YTMusicClient;
/// # async fn example(client: &YTMusicClient) -> ytmusicapi::Result<()> {
/// let playlist = client.get_playlist("PL123456789", None).await?;
/// println!("Title: {}", playlist.title);
/// for track in playlist.tracks {
///     println!(" - {} by {:?}", track.title.unwrap_or_default(), track.artists);
/// }
/// # Ok(())
/// # }
/// ```
pub async fn get_playlist(&self, playlist_id: &str, limit: Option<u32>) -> Result<Playlist> {
    // Ensure playlist ID has VL prefix for browse endpoint
    let browse_id = if playlist_id.starts_with("VL") {
        playlist_id.to_string()
    } else {
        format!("VL{{}}", playlist_id)
    };

    let body = json!({
        "browseId": browse_id
    });

    let response = self.send_request("browse", body.clone()).await?;
    let mut playlist = parse_playlist_response(&response, playlist_id);

    // Handle pagination for tracks
    let track_limit = limit.unwrap_or(5000) as usize;

    // Get continuation token if present and we need more tracks
    let secondary_contents = nav(
        &response,
        &path![
            "contents",
            "twoColumnBrowseResultsRenderer",
            "secondaryContents",
            "sectionListRenderer",
            "contents",
            0,
            "musicPlaylistShelfRenderer"
        ],
    );

    if let Some(shelf) = secondary_contents {
        if playlist.tracks.len() < track_limit {
            if let Some(token) = get_continuation_token(shelf) {
                let more_tracks = self
                    .fetch_playlist_continuations(&token, track_limit - playlist.tracks.len())
                    .await?;
                playlist.tracks.extend(more_tracks);
            }
        }
    }

    // Apply limit
    if let Some(lim) = limit {
        playlist.tracks.truncate(lim as usize);
    }

    // Recalculate duration
    playlist.duration_seconds = Some(
        playlist
            .tracks
            .iter()
            .filter_map(|t| t.duration_seconds)
            .sum(),
    );

    Ok(playlist)
}
```

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

### Navigate JSON and Get i64

Source: https://docs.rs/ytmusicapi/latest/src/ytmusicapi/nav.rs.html

Navigates a JSON `Value` and attempts to return the value as an `i64`. Useful for integer fields in JSON data.

```Rust
pub fn nav_i64(root: &Value, path: &[PathSegment]) -> Option<i64> {
    nav(root, path).and_then(|v| v.as_i64())
}
```

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

### Get playlist tracks with YTMusicClient

Source: https://docs.rs/ytmusicapi/latest/src/ytmusicapi/client.rs.html

Fetches tracks for a given playlist ID. If `limit` is `None`, the client follows continuations and returns up to 5,000 tracks. Requires authentication if the playlist is private.

```rust
pub async fn get_playlist_tracks(&self, playlist_id: &str, limit: Option<u32>) -> Result<Vec<PlaylistTrack>> {
        let playlist = self.get_playlist(playlist_id, limit).await?;
        Ok(playlist.tracks)
    }
```

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

### Generic Implementations for Author

Source: https://docs.rs/ytmusicapi/latest/ytmusicapi/struct.Author.html

Demonstrates various blanket implementations available for the Author struct, including Any, Borrow, CloneToUninit, From, Instrument, Into, PolicyExt, Same, ToOwned, TryFrom, TryInto, and WithSubscriber.

```rust
impl<T> Any for T
where T: 'static + ?Sized,
Source
fn type_id(&self) -> TypeId
Source
impl<T> Borrow<T> for T
where T: ?Sized,
Source
fn borrow(&self) -> &T
Source
impl<T> BorrowMut<T> for T
where T: ?Sized,
Source
fn borrow_mut(&mut self) -> &mut T
Source
impl<T> CloneToUninit for T
where T: Clone,
Source
unsafe fn clone_to_uninit(&self, dest: *mut u8)
Source
impl<T> From<T> for T
Source
fn from(t: T) -> T
Source
impl<T> Instrument for T
Source
fn instrument(self, span: Span) -> Instrumented<Self>
fn in_current_span(self) -> Instrumented<Self>
Source
impl<T, U> Into<U> for T
where U: From<T>,
Source
fn into(self) -> U
Source
impl<T> PolicyExt for T
where T: ?Sized,
Source
fn and<P, B, E>(self, other: P) -> And<T, P>
where T: Policy<B, E>, P: Policy<B, E>,
fn or<P, B, E>(self, other: P) -> Or<T, P>
where T: Policy<B, E>, P: Policy<B, E>,
Source
impl<T> Same for T
Source
type Output = T
Source
impl<T> ToOwned for T
where T: Clone,
Source
type Owned = T
fn to_owned(&self) -> T
fn clone_into(&self, target: &mut T)
Source
impl<T, U> TryFrom<U> for T
where U: Into<T>,
Source
type Error = Infallible
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
Source
impl<T, U> TryInto<U> for T
where U: TryFrom<T>,
Source
type Error = <U as TryFrom<T>>::Error
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
Source
impl<T> WithSubscriber for T
Source
fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where S: Into<Dispatch>,
fn with_current_subscriber(self) -> WithDispatch<Self>
Source
impl<T> DeserializeOwned for T
where T: for<'de> Deserialize<'de>,
```

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

### Create a new YTMusicClient builder

Source: https://docs.rs/ytmusicapi/latest/src/ytmusicapi/client.rs.html

Use this builder to construct a YTMusicClient. Defaults are language: "en", location: None, user: None.

```rust
pub fn builder() -> YTMusicClientBuilder {
        YTMusicClientBuilder {
            auth: None,
            language: "en".to_string(),
            location: None,
            user: None,
        }
    }
```

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

### Sum Trait Example for Result

Source: https://docs.rs/ytmusicapi/latest/ytmusicapi/type.Result.html

Illustrates the `sum` method for iterators of `Result` types. It aggregates `Ok` values, but short-circuits and returns the first `Err` encountered. This example shows summing integers with a check for negative values.

```rust
let f = |&x: &i32| if x < 0 { Err("Negative element found") } else { Ok(x) };
let v = vec![1, 2];
let res: Result<i32, _> = v.iter().map(f).sum();
assert_eq!(res, Ok(3));
let v = vec![1, -2];
let res: Result<i32, _> = v.iter().map(f).sum();
assert_eq!(res, Err("Negative element found"));
```

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

### from_file

Source: https://docs.rs/ytmusicapi/latest/ytmusicapi/struct.BrowserAuth.html

Creates a BrowserAuth instance from a headers JSON file, simplifying credential management.

```APIDOC
## fn from_file<P: AsRef<Path>>(path: P) -> Result<Self>

### Description
Create `BrowserAuth` from a headers JSON file. The file should contain a JSON object with at least a `cookie` key. Header names are matched case-insensitively, and `x-goog-authuser` defaults to `"0"` if omitted.

### Parameters
* `path`: P - A path to the JSON file containing authentication headers.
```

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

### Create Playlist

Source: https://docs.rs/ytmusicapi/latest/index.html

Creates a new playlist for the authenticated user.

```APIDOC
## `YTMusicClient::create_playlist`

### Description
Creates a new playlist.

### Method
`create_playlist`

### Parameters
#### Request Body
- **title** (str) - Required - The title of the new playlist.
- **description** (Option<str>) - Optional - The description for the new playlist.
- **privacy** (Option<Privacy>) - Optional - The privacy setting for the new playlist.

### Response
#### Success Response (200)
- **CreatePlaylistResponse** - The response from creating the playlist.

### Request Example
```rust
let response = client.create_playlist("My New Playlist", None, None).await?;
```
```

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

### Any Trait Implementation

Source: https://docs.rs/ytmusicapi/latest/ytmusicapi/struct.Album.html

Provides the `type_id` method to get the `TypeId` of a type.

```rust
fn type_id(&self) -> TypeId
```

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

### Converting Result to Option with `ok()`

Source: https://docs.rs/ytmusicapi/latest/ytmusicapi/type.Result.html

Shows how to use the `ok()` method to convert a Result into an Option. It returns `Some(T)` if the Result is Ok, and `None` if it's Err. This consumes the Result.

```rust
let x: Result<u32, &str> = Ok(2);
assert_eq!(x.ok(), Some(2));

let x: Result<u32, &str> = Err("Nothing here");
assert_eq!(x.ok(), None);
```

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

### Create a New Playlist

Source: https://docs.rs/ytmusicapi/latest/src/ytmusicapi/client.rs.html

Creates a new playlist with a specified title, description, and privacy status. Requires authentication. An empty description is omitted from the request.

```rust
/// Create a new playlist.
///
/// Requires authentication. An empty `description` is omitted from the request.
pub async fn create_playlist(
    &self,
    title: &str,
    description: Option<&str>,
    privacy: Privacy,
) -> Result<CreatePlaylistResponse> {
    self.check_auth()?;
    if title.trim().is_empty() {
        return Err(Error::InvalidInput(
            "title must include at least one character".to_string(),
        ));
    }

    let privacy_status = match privacy {
        Privacy::Public => "PUBLIC",
        Privacy::Private => "PRIVATE",
        Privacy::Unlisted => "UNLISTED",
    };

    let mut body = json!({
        "title": title,
        "privacyStatus": privacy_status
    });

    if let Some(desc) = description {
        if !desc.trim().is_empty() {
            body["description"] = json!(desc);
        }
    }

    let response = self.send_request("playlist/create", body).await?;
    let created: CreatePlaylistResponse = serde_json::from_value(response)?;
    Ok(created)
}
```

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

### create_playlist

Source: https://docs.rs/ytmusicapi/latest/src/ytmusicapi/client.rs.html

Creates a new playlist with a specified title, description, and privacy status. Requires authentication. An empty description is omitted from the request.

```APIDOC
## create_playlist

### Description
Creates a new playlist with a specified title, description, and privacy status. Requires authentication. An empty description is omitted from the request.

### Method
POST

### Endpoint
/playlist/create

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **title** (string) - Required - The title of the playlist. Must contain at least one character.
- **description** (string) - Optional - The description of the playlist. If empty or whitespace, it's omitted.
- **privacyStatus** (string) - Required - The privacy status of the playlist. Can be "PUBLIC", "PRIVATE", or "UNLISTED".

### Request Example
```json
{
  "title": "My New Playlist",
  "description": "A collection of my favorite songs.",
  "privacyStatus": "PUBLIC"
}
```

### Response
#### Success Response (200)
- **playlistId** (string) - The ID of the newly created playlist.

#### Response Example
```json
{
  "playlistId": "PLabcdef123456789"
}
```
```

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

### Build YTMusicClient with Default Headers

Source: https://docs.rs/ytmusicapi/latest/src/ytmusicapi/client.rs.html

Constructs a `reqwest::Client` with default headers and gzip compression enabled. This is used internally by `YTMusicClientBuilder` to create the HTTP client instance.

```rust
let mut headers = HeaderMap::new();

        for (key, value) in default_headers() {
            if let Ok(header_value) = HeaderValue::from_str(&value) {
                if let Ok(header_name) = key.parse::<HeaderName>() {
                    headers.insert(header_name, header_value);
                }
            }
        }

        let http = reqwest::Client::builder()
            .default_headers(headers)
            .gzip(true)
            .build()?;

        Ok(YTMusicClient {
            http,
            auth: self.auth,
            language: self.language,
            location: self.location,
            user: self.user,
        })
```

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

### Get Liked Songs

Source: https://docs.rs/ytmusicapi/latest/ytmusicapi

Fetches the user's "Liked Songs" playlist.

```APIDOC
## `get_liked_songs`

### Description
Fetches your “Liked Songs”.

### Method
`YTMusicClient::get_liked_songs`

### Parameters
None

### Request Example
```rust
use ytmusicapi::YTMusicClient;

#[tokio::main]
async fn main() -> ytmusicapi::Result<()> {
    // Assuming client is already built and authenticated
    let client = YTMusicClient::builder().build()?; // Placeholder for actual client setup
    let liked_songs = client.get_liked_songs().await?;
    Ok(())
}
```

### Response
#### Success Response
Returns the playlist containing liked songs.

#### Response Example
```json
{
  "title": "Liked Songs",
  "tracks": [
    {
      "title": "Liked Song Title",
      "artist": "Artist Name"
    }
  ]
}
```
```

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

### YTMusicClientBuilder Methods

Source: https://docs.rs/ytmusicapi/latest/ytmusicapi/struct.YTMusicClientBuilder.html

Methods for configuring and building a YTMusicClient.

```APIDOC
## YTMusicClientBuilder

Builder for constructing a `YTMusicClient`.

### Methods

#### `with_browser_auth(self, auth: BrowserAuth) -> Self`

Set browser authentication.

#### `with_language(self, language: impl Into<String>) -> Self`

Set the language for responses. This maps to the `hl` client parameter (default: `"en"`).

#### `with_location(self, location: impl Into<String>) -> Self`

Set the location for results. This maps to the `gl` client parameter and expects ISO 3166-1 alpha-2 country codes (e.g., `"US"`, `"GB"`, `"DE"`).

#### `with_user(self, user: impl Into<String>) -> Self`

Set a user ID for brand account requests. This maps to `onBehalfOfUser` in the request context.

#### `build(self) -> Result<YTMusicClient>`

Build the client. This does not validate authentication credentials.
```

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

### Get Song

Source: https://docs.rs/ytmusicapi/latest/ytmusicapi/index.html

Fetches metadata for a song using its video ID. This operation does not require authentication.

```APIDOC
## `get_song`

### Description
Fetches metadata for a song using its video ID. This operation does not require authentication and can be used for public song information.

### Method
`YTMusicClient::get_song`

### Parameters
#### Path Parameters
- **video_id** (str) - Required - The ID of the video (song) to fetch metadata for.

### Response
#### Success Response
- Returns a `Song` object containing detailed metadata about the song.

### Request Example
```rust
use ytmusicapi::YTMusicClient;

#[tokio::main]
async fn main() -> ytmusicapi::Result<()> {
    let client = YTMusicClient::builder().build()?;
    let song = client.get_song("dQw4w9WgXcQ").await?;
    println!("Song title: {}", song.video_details.title);
    Ok(())
}
```
```

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

### Clone BrowserAuth Instance

Source: https://docs.rs/ytmusicapi/latest/ytmusicapi/struct.BrowserAuth.html

Demonstrates the cloning of a BrowserAuth instance, creating a duplicate of the authentication credentials.

```rust
fn clone(&self) -> BrowserAuth
```

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

### Get home feed content

Source: https://docs.rs/ytmusicapi/latest/src/ytmusicapi/client.rs.html

Fetches content for the YouTube Music home feed. Does not require authentication.

```rust
pub async fn get_home(&self) -> Result<Value> {
        let body = json!({});
        self.send_request("home", body).await
    }
```

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

### Create BrowserAuth from JSON file

Source: https://docs.rs/ytmusicapi/latest/src/ytmusicapi/auth.rs.html

Loads browser authentication credentials from a specified JSON file. The file must contain at least a 'cookie' field.

```rust
pub fn from_file<P: AsRef<Path>>(path: P) -> Result<Self> {
    let content = std::fs::read_to_string(path)?;
    Self::from_json(&content)
}
```

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

### Get Song Metadata

Source: https://docs.rs/ytmusicapi/latest/index.html

Fetches metadata for a song using its video ID. This operation does not require authentication.

```APIDOC
## `YTMusicClient::get_song`

### Description
Fetches song metadata (no auth required).

### Method
`get_song`

### Parameters
#### Path Parameters
- **video_id** (str) - Required - The ID of the video/song.

### Response
#### Success Response
- **Song** - The song metadata object.

### Request Example
```rust
let song = client.get_song("dQw4w9WgXcQ").await?;
```
```

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

### Get Liked Songs Playlist

Source: https://docs.rs/ytmusicapi/latest/src/ytmusicapi/client.rs.html

Retrieves the user's 'Liked Songs' playlist. This operation requires authentication.

```rust
/// Get the "Liked Songs" playlist.
///
/// Requires authentication.
///
/// # Arguments
///
/// * `limit` - Maximum number of tracks to return. `None` for all.
pub async fn get_liked_songs(&self, limit: Option<u32>) -> Result<Playlist> {
    self.check_auth()?;
    self.get_playlist("LM", limit).await
}
```

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

### Test: Simple Navigation

Source: https://docs.rs/ytmusicapi/latest/src/ytmusicapi/nav.rs.html

Verifies basic navigation to a string value using a single key.

```Rust
let data = json!({"foo": "bar"});
assert_eq!(nav_str(&data, &path!["foo"]), Some("bar"));
```

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

### Create Playlist Response Struct

Source: https://docs.rs/ytmusicapi/latest/src/ytmusicapi/types/playlist.rs.html

Contains the ID of a newly created playlist. Used to confirm successful playlist creation.

```Rust
pub struct CreatePlaylistResponse {
    /// The newly created playlist ID.
    #[serde(rename = "playlistId")]
    pub playlist_id: String,
}
```

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

### Get Song Metadata

Source: https://docs.rs/ytmusicapi/latest/src/ytmusicapi/client.rs.html

Retrieves song metadata from the 'player' endpoint. This operation does not require authentication and does not return stream URLs.

```rust
/// Get song metadata from the `player` endpoint.
///
/// This does not require authentication and does not return stream URLs.

```

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

### into_ok

Source: https://docs.rs/ytmusicapi/latest/ytmusicapi/type.Result.html

Returns the contained Ok value, but never panics. This is an experimental API.

```APIDOC
## into_ok

### Description
Returns the contained `Ok` value, but never panics. Unlike `unwrap`, this method is known to never panic on the result types it is implemented for. Therefore, it can be used instead of `unwrap` as a maintainability safeguard that will fail to compile if the error type of the `Result` is later changed to an error that can actually occur.

### Method
`into_ok()`

### Parameters
None

### Response
#### Success Response
- `T`: The contained `Ok` value.

### Response Example
```rust
fn only_good_news() -> Result<String, !> {
    Ok("this is fine".into())
}

let s: String = only_good_news().into_ok();
println!("{s}");
```

### Note
This is a nightly-only experimental API.
```

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

### Create a playlist with YTMusicClient

Source: https://docs.rs/ytmusicapi/latest/src/ytmusicapi/client.rs.html

Creates a new playlist. Requires authentication. The playlist can be public, private, or unlisted.

```rust
pub async fn create_playlist(&self, title: &str, privacy: Privacy, ids: Option<Vec<String>>) -> Result<CreatePlaylistResponse> {
        self.check_auth()?;

        let mut body = json!({
            "title": title,
            "privacy": privacy.to_string(),
        });

        if let Some(video_ids) = ids {
            body["videoIds": video_ids];
        }

        let response = self.send_request("playlist/create", body).await?;
        Ok(serde_json::from_value(response)?)
    }
```

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

### Navigate JSON and Get u64

Source: https://docs.rs/ytmusicapi/latest/src/ytmusicapi/nav.rs.html

Navigates a JSON `Value` and attempts to return the value as a `u64`. Suitable for unsigned integer fields.

```Rust
pub fn nav_u64(root: &Value, path: &[PathSegment]) -> Option<u64> {
    nav(root, path).and_then(|v| v.as_u64())
}
```

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

### Create Navigation Path Macro

Source: https://docs.rs/ytmusicapi/latest/src/ytmusicapi/nav.rs.html

The `path!` macro simplifies creating a `Vec<PathSegment>` from a list of string keys and usize indices. It automatically converts the provided arguments into the correct `PathSegment` variants.

```Rust
macro_rules! path {
    ($($segment:expr),* $(,)?) => {
        vec![$($crate::nav::PathSegment::from($segment)),*]
    };
}
```

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

### YTMusicClientBuilder::build

Source: https://docs.rs/ytmusicapi/latest/src/ytmusicapi/client.rs.html

Builds and returns a new `YTMusicClient` instance with the configured options. Does not validate authentication.

```APIDOC
## build

### Description
Builds the `YTMusicClient` instance with the current builder configuration. Authentication credentials are not validated at this stage.

### Method
`pub fn build(self) -> Result<YTMusicClient>`

### Parameters
None

### Response
#### Success Response
- `Ok(YTMusicClient)`: A new instance of `YTMusicClient` configured with the specified options.

#### Error Response
- `Err(Error)`: If there is an issue building the HTTP client (e.g., invalid headers).
```

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

### Get Continuation Token

Source: https://docs.rs/ytmusicapi/latest/src/ytmusicapi/parsers/playlist.rs.html

Extracts the continuation token from the results, which is used for paginating through playlist items. It navigates through the 'contents' array to find the token.

```Rust
pub fn get_continuation_token(results: &Value) -> Option<String> {
    let contents = results.get("contents")?.as_array()?;
    let last = contents.last()?;
    nav_str(last, paths::CONTINUATION_TOKEN).map(|s| s.to_string())
}

```

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

### Navigate JSON and Get Boolean

Source: https://docs.rs/ytmusicapi/latest/src/ytmusicapi/nav.rs.html

Navigates a JSON `Value` and attempts to return the value as a boolean. Use this for boolean flags or fields in your JSON.

```Rust
pub fn nav_bool(root: &Value, path: &[PathSegment]) -> Option<bool> {
    nav(root, path).and_then(|v| v.as_bool())
}
```

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

### Clone From BrowserAuth Instance

Source: https://docs.rs/ytmusicapi/latest/ytmusicapi/struct.BrowserAuth.html

Shows how to perform copy-assignment from one BrowserAuth instance to another.

```rust
fn clone_from(&mut self, source: &Self)
```

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

### Navigate JSON and Get Array

Source: https://docs.rs/ytmusicapi/latest/src/ytmusicapi/nav.rs.html

Navigates a JSON `Value` and attempts to return it as a reference to a `Vec<Value>`. Useful for accessing JSON arrays.

```Rust
pub fn nav_array<'a>(root: &'a Value, path: &[PathSegment]) -> Option<&'a Vec<Value>> {
    nav(root, path).and_then(|v| v.as_array())
}
```

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

### Into Ok Value (Nightly)

Source: https://docs.rs/ytmusicapi/latest/ytmusicapi/type.Result.html

Returns the contained `Ok` value, guaranteed not to panic. This is a nightly-only experimental API.

```rust
fn only_good_news() -> Result<String, !> {
    Ok("this is fine".into())
}

let s: String = only_good_news().into_ok();
println!("{s}");
```

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

### Get Song Metadata

Source: https://docs.rs/ytmusicapi/latest/src/ytmusicapi/client.rs.html

Retrieves detailed metadata for a given song using its video ID. A `signatureTimestamp` of 0 is often sufficient for metadata retrieval.

```rust
pub async fn get_song(&self, video_id: &str) -> Result<Song> {
        let body = json!({
            "video_id": video_id,
            "playbackContext": {
                "contentPlaybackContext": {
                    "signatureTimestamp": 0 // We might need a real timestamp for streaming, but 0 often works for metadata
                }
            }
        });

        let response = self.send_request("player", body).await?;
        let song: Song = serde_json::from_value(response)?;
        Ok(song)
    }
```

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

### path! Macro

Source: https://docs.rs/ytmusicapi/latest/src/ytmusicapi/nav.rs.html

A macro for creating a `Vec<PathSegment>` from a list of keys and indices, simplifying path construction for navigation functions.

```APIDOC
## path! Macro

### Description
This macro provides a convenient way to construct a `Vec<PathSegment>` which is used as the path argument for navigation functions like `nav`.

### Syntax
```rust
path![segment1, segment2, ...]
```

### Arguments
* `segment`: Can be a string literal (for object keys) or a numeric literal (for array indices).

### Returns
* `Vec<PathSegment>`: A vector of `PathSegment` enums representing the navigation path.

### Example
```rust
use ytmusicapi::path;

// Creates a path to navigate an object key "contents", then the first element (index 0), then the key "title", then the key "text".
let my_path = path!["contents", 0, "title", "text"];
```
```

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

### CloneToUninit Trait Implementation (Nightly)

Source: https://docs.rs/ytmusicapi/latest/ytmusicapi/struct.Album.html

Nightly-only experimental API for copy-assignment to uninitialized memory.

```rust
unsafe fn clone_to_uninit(&self, dest: *mut u8)
```

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

### Navigate JSON and Get String

Source: https://docs.rs/ytmusicapi/latest/src/ytmusicapi/nav.rs.html

A convenience function to navigate a JSON `Value` and attempt to retrieve the value as a string slice. It combines `nav` with `as_str`.

```Rust
pub fn nav_str<'a>(root: &'a Value, path: &[PathSegment]) -> Option<&'a str> {
    nav(root, path).and_then(|v| v.as_str())
}
```

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

### Get liked songs with YTMusicClient

Source: https://docs.rs/ytmusicapi/latest/src/ytmusicapi/client.rs.html

Fetches songs that the user has liked. Requires authentication. This currently fetches only the first page of liked songs and does not follow continuations.

```rust
pub async fn get_liked_songs(&self, limit: Option<u32>) -> Result<Vec<Song>> {
        self.check_auth()?;

        let body = json!({
            "browseId": "FEmusic_liked_songs",
            "sortBy": "DATE"
        });

        let response = self.send_request("browse", body).await?;
        let mut songs = parse_library_playlists(&response);

        if let Some(lim) = limit {
            songs.truncate(lim as usize);
        }

        // TODO: Handle continuations for large liked songs lists

        Ok(songs)
    }
```

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

### Serialize BrowserAuth to Serde

Source: https://docs.rs/ytmusicapi/latest/ytmusicapi/struct.BrowserAuth.html

Demonstrates the implementation of the Serialize trait for BrowserAuth, allowing it to be serialized into Serde data formats.

```rust
fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>
where __S: Serializer,
```

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

### Providing a Default Value with unwrap_or

Source: https://docs.rs/ytmusicapi/latest/ytmusicapi/type.Result.html

Shows how to use `unwrap_or` to get the `Ok` value or a default value if the `Result` is an `Err`. Note that the default value is eagerly evaluated.

```rust
let default = 2;
let x: Result<u32, &str> = Ok(9);
assert_eq!(x.unwrap_or(default), 9);

let x: Result<u32, &str> = Err("error");
assert_eq!(x.unwrap_or(default), default);
```

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

### Copying Result<&mut T, E> to Result<T, E>

Source: https://docs.rs/ytmusicapi/latest/ytmusicapi/type.Result.html

Demonstrates how to map a `Result<&mut T, E>` to a `Result<T, E>` by copying the value if it's `Ok` and `T` implements `Copy`.

```rust
let mut val = 12;
let x: Result<&mut i32, i32> = Ok(&mut val);
assert_eq!(x, Ok(&mut 12));
let copied = x.copied();
assert_eq!(copied, Ok(12));
```

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

### Getting References to Result Contents with `as_ref()`

Source: https://docs.rs/ytmusicapi/latest/ytmusicapi/type.Result.html

Illustrates using `as_ref()` to obtain references to the contained values of a Result without consuming it. Useful for inspecting values immutably.

```rust
let x: Result<u32, &str> = Ok(2);
assert_eq!(x.as_ref(), Ok(&2));

let x: Result<u32, &str> = Err("Error");
assert_eq!(x.as_ref(), Err(&"Error"));
```

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

### Build YTMusicClient

Source: https://docs.rs/ytmusicapi/latest/ytmusicapi/struct.YTMusicClientBuilder.html

Constructs and returns a YTMusicClient instance using the configured builder. Authentication credentials are not validated by this method.

```rust
pub fn build(self) -> Result<YTMusicClient>
```

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

### Get Text from Item at Specific Flex Column Index

Source: https://docs.rs/ytmusicapi/latest/src/ytmusicapi/parsers/track.rs.html

A convenience function to extract text content from a flex column item at a given index. It uses `get_flex_column_item` and `nav_str` internally.

```rust
use ytmusicapi::parsers::track::get_item_text;
use serde_json::Value;

// Assuming 'item' is a Value representing a list item and 'index' is the column index.
// let text = get_item_text(&item, index);
```

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

### TryInto Implementation

Source: https://docs.rs/ytmusicapi/latest/ytmusicapi/enum.Error.html

Provides the try_into method for types that implement TryFrom.

```APIDOC
### impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

#### type Error = <U as TryFrom<T>>::Error

### Description
The type returned in the event of a conversion error.

#### fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

### Description
Performs the conversion.

```

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

### Get Fixed Column Item from Music Responsive List Item

Source: https://docs.rs/ytmusicapi/latest/src/ytmusicapi/parsers/track.rs.html

Retrieves a fixed column item from a music responsive list item, returning None if not found or if the structure is unexpected.

```rust
use ytmusicapi::parsers::track::get_fixed_column_item;
use serde_json::Value;

// Assuming 'data' is a Value representing the API response and 'index' is the column index.
// let fixed_item = get_fixed_column_item(&data, index);
```

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

### Cloning Result<&mut T, E> to Result<T, E>

Source: https://docs.rs/ytmusicapi/latest/ytmusicapi/type.Result.html

Demonstrates how to map a `Result<&mut T, E>` to a `Result<T, E>` by cloning the value if it's `Ok` and `T` implements `Clone`.

```rust
let mut val = 12;
let x: Result<&mut i32, i32> = Ok(&mut val);
assert_eq!(x, Ok(&mut 12));
let cloned = x.cloned();
assert_eq!(cloned, Ok(12));
```

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

### Generate SAPISIDHASH authorization header

Source: https://docs.rs/ytmusicapi/latest/src/ytmusicapi/auth.rs.html

Computes the time-based 'SAPISIDHASH' authorization header required for browser authentication with YouTube Music.

```rust
pub fn get_authorization(&self) -> Result<String> {
    let sapisid = self.sapisid()?;
    let timestamp = SystemTime::now()
        .duration_since(UNIX_EPOCH)
        .unwrap()
        .as_secs();

    let auth_string = format!("{} {} {}", timestamp, sapisid, self.origin);

    let mut hasher = Sha1::new();
    hasher.update(auth_string.as_bytes());

```

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

### Copying Result<&T, E> to Result<T, E>

Source: https://docs.rs/ytmusicapi/latest/ytmusicapi/type.Result.html

Demonstrates how to map a `Result<&T, E>` to a `Result<T, E>` by copying the value if it's `Ok` and `T` implements `Copy`.

```rust
let val = 12;
let x: Result<&i32, i32> = Ok(&val);
assert_eq!(x, Ok(&12));
let copied = x.copied();
assert_eq!(copied, Ok(12));
```

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

### YTMusicClient::create_playlist

Source: https://docs.rs/ytmusicapi/latest/src/ytmusicapi/lib.rs.html

Creates a new playlist for the authenticated user.

```APIDOC
## YTMusicClient::create_playlist

### Description
Creates a new playlist for the authenticated user.

### Method
(Implied async method call)

### Endpoint
(Internal API endpoint, not directly exposed)

### Parameters
#### Request Body
- **title** (str) - Required - The title of the new playlist.
- **description** (Option<str>) - Optional - A description for the playlist.
- **privacy** (Option<PlaylistPrivacy>) - Optional - The privacy setting for the playlist (e.g., public, private).

### Response
#### Success Response (200)
- (Playlist) - The newly created playlist's metadata.

### Response Example
```json
{
  "playlistId": "new_playlist_id",
  "title": "My New Playlist",
  "privacy": "PRIVATE"
}
```
```

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

### Get Flex Column Item from Music Responsive List Item

Source: https://docs.rs/ytmusicapi/latest/src/ytmusicapi/parsers/track.rs.html

Safely retrieves a specific flex column item from a music responsive list item structure in the JSON response. It validates the presence of 'text' and 'runs'.

```rust
use ytmusicapi::parsers::track::get_flex_column_item;
use serde_json::Value;

// Assuming 'data' is a Value representing the API response and 'index' is the column index.
// let flex_item = get_flex_column_item(&data, index);
```

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

### fetch_playlist_continuations

Source: https://docs.rs/ytmusicapi/latest/src/ytmusicapi/client.rs.html

Fetches additional tracks from a playlist using a continuation token. It iteratively requests more tracks until the maximum number of items is reached or no further continuation is available.

```APIDOC
## fetch_playlist_continuations

### Description
Fetches additional tracks from a playlist using a continuation token. It iteratively requests more tracks until the maximum number of items is reached or no further continuation is available.

### Method
`async fn`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```json
{
  "continuation": "initial_token"
}
```

### Response
#### Success Response (200)
- **Vec<PlaylistTrack>** - A vector containing playlist tracks.

#### Response Example
```json
[
  {
    "title": "Song Title",
    "artist": "Artist Name",
    "duration": "3:45"
  }
]
```
```

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

### TryInto<U> for T

Source: https://docs.rs/ytmusicapi/latest/ytmusicapi/struct.MicroformatDataRenderer.html

Provides methods for attempting conversions between types, returning a Result to handle potential errors.

```APIDOC
## impl<T, U> TryInto<U> for T

### Description
Provides methods for attempting conversions between types, returning a Result to handle potential errors.

### Type Alias
#### type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

### Method
#### fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
```

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

### Cloning Result<&T, E> to Result<T, E>

Source: https://docs.rs/ytmusicapi/latest/ytmusicapi/type.Result.html

Demonstrates how to map a `Result<&T, E>` to a `Result<T, E>` by cloning the value if it's `Ok` and `T` implements `Clone`.

```rust
let val = 12;
let x: Result<&i32, i32> = Ok(&val);
assert_eq!(x, Ok(&12));
let cloned = x.cloned();
assert_eq!(cloned, Ok(12));
```

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

### Serialize Implementation for Album

Source: https://docs.rs/ytmusicapi/latest/ytmusicapi/struct.Album.html

Enables serialization of an Album instance to a Serde serializer.

```rust
fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>
where __S: Serializer
```

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

### Clone Implementation for PlaylistSummary

Source: https://docs.rs/ytmusicapi/latest/ytmusicapi/struct.PlaylistSummary.html

Provides methods to duplicate or copy-assign a PlaylistSummary instance.

```rust
fn clone(&self) -> PlaylistSummary
```

```rust
fn clone_from(&mut self, source: &Self)
```

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

### Clone Implementation for Microformat

Source: https://docs.rs/ytmusicapi/latest/ytmusicapi/struct.Microformat.html

Provides methods for cloning a `Microformat` instance, including returning a duplicate and performing copy-assignment.

```rust
fn clone(&self) -> Microformat
```

```rust
fn clone_from(&mut self, source: &Self)
```
Tokens:
Raw