yt-transcript-rs 0.1.8

A Rust library for fetching and working with YouTube video transcripts
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147

use crate::errors::{CouldNotRetrieveTranscript, CouldNotRetrieveTranscriptReason};
use reqwest::Client;
use serde_json::{json, Value};

/// InnerTube API client for fetching YouTube transcript data
///
/// This client uses YouTube's internal InnerTube API instead of the legacy
/// transcript URLs to fetch caption data. This approach is more reliable
/// and doesn't require cookie authentication for public videos.
pub struct InnerTubeClient {
    client: Client,
}

impl InnerTubeClient {
    pub fn new(client: Client) -> Self {
        Self { client }
    }

    /// Fetch transcript data using YouTube's InnerTube API
    pub async fn get_transcript_data(
        &self,
        video_id: &str,
    ) -> Result<Value, CouldNotRetrieveTranscript> {
        let url = "https://www.youtube.com/youtubei/v1/get_transcript";

        let payload = json!({
            "context": {
                "client": {
                    "clientName": "WEB",
                    "clientVersion": "2.20231219.04.00",
                    "hl": "en",
                    "gl": "US"
                }
            },
            "params": self.encode_transcript_params(video_id)
        });

        let response = self.client
            .post(url)
            .json(&payload)
            .header("Content-Type", "application/json")
            .header("User-Agent", "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36")
            .send()
            .await
            .map_err(|e| CouldNotRetrieveTranscript {
                video_id: video_id.to_string(),
                reason: Some(CouldNotRetrieveTranscriptReason::YouTubeRequestFailed(
                    format!("InnerTube API request failed: {}", e)
                )),
            })?;

        if !response.status().is_success() {
            return Err(CouldNotRetrieveTranscript {
                video_id: video_id.to_string(),
                reason: Some(CouldNotRetrieveTranscriptReason::YouTubeRequestFailed(
                    format!("InnerTube API returned status: {}", response.status()),
                )),
            });
        }

        let data: Value = response
            .json()
            .await
            .map_err(|e| CouldNotRetrieveTranscript {
                video_id: video_id.to_string(),
                reason: Some(CouldNotRetrieveTranscriptReason::YouTubeDataUnparsable(
                    format!("Failed to parse InnerTube response: {}", e),
                )),
            })?;

        Ok(data)
    }

    /// Encode transcript parameters for InnerTube API
    /// This is a simplified version - the actual encoding may be more complex
    fn encode_transcript_params(&self, video_id: &str) -> String {
        // For now, we'll try a simple approach
        // In the real implementation, this would need proper base64 encoding
        // of the video ID and other parameters
        use base64::{engine::general_purpose, Engine as _};

        let params = json!({
            "videoId": video_id
        });

        general_purpose::STANDARD.encode(params.to_string())
    }

    /// Alternative approach: try to get transcript list first
    pub async fn get_transcript_list(
        &self,
        video_id: &str,
    ) -> Result<Value, CouldNotRetrieveTranscript> {
        // Try the player API first to get available captions
        let url = "https://www.youtube.com/youtubei/v1/player";

        let payload = json!({
            "context": {
                "client": {
                    "clientName": "WEB",
                    "clientVersion": "2.20231219.04.00",
                    "hl": "en",
                    "gl": "US"
                }
            },
            "videoId": video_id
        });

        let response = self.client
            .post(url)
            .json(&payload)
            .header("Content-Type", "application/json")
            .header("User-Agent", "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36")
            .send()
            .await
            .map_err(|e| CouldNotRetrieveTranscript {
                video_id: video_id.to_string(),
                reason: Some(CouldNotRetrieveTranscriptReason::YouTubeRequestFailed(
                    format!("InnerTube player API request failed: {}", e)
                )),
            })?;

        if !response.status().is_success() {
            return Err(CouldNotRetrieveTranscript {
                video_id: video_id.to_string(),
                reason: Some(CouldNotRetrieveTranscriptReason::YouTubeRequestFailed(
                    format!(
                        "InnerTube player API returned status: {}",
                        response.status()
                    ),
                )),
            });
        }

        let data: Value = response
            .json()
            .await
            .map_err(|e| CouldNotRetrieveTranscript {
                video_id: video_id.to_string(),
                reason: Some(CouldNotRetrieveTranscriptReason::YouTubeDataUnparsable(
                    format!("Failed to parse InnerTube player response: {}", e),
                )),
            })?;

        Ok(data)
    }
}