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
use anyhow::Result;
use reqwest::Client;
use yt_transcript_rs::api::YouTubeTranscriptApi;
/// This example demonstrates how to translate a YouTube transcript to a different language.
///
/// It shows:
/// 1. Creating a YouTubeTranscriptApi instance
/// 2. Listing available transcripts
/// 3. Finding a translatable transcript
/// 4. Translating the transcript to a different language
/// 5. Displaying the translated transcript
#[tokio::main]
async fn main() -> Result<()> {
// Initialize the YouTubeTranscriptApi
let api = YouTubeTranscriptApi::new(None, None, None)?;
// Ted Talk video ID (known to have multiple language transcripts)
let video_id = "arj7oStGLkU";
// Target translation language
let target_language = "fr"; // French
println!(
"Getting transcript for video ID: {} and translating to {}",
video_id, target_language
);
// Step 1: List available transcripts
match api.list_transcripts(video_id).await {
Ok(transcript_list) => {
println!("Successfully retrieved transcript list!");
// Step 2: Find a translatable transcript
let mut found_translatable = false;
for transcript in &transcript_list {
if transcript.is_translatable() {
found_translatable = true;
println!(
"Found translatable transcript: {} ({})",
transcript.language, transcript.language_code
);
// Check if the target language is available
let target_available = transcript
.translation_languages
.iter()
.any(|lang| lang.language_code == target_language);
if target_available {
println!(
"Target language {} is available for translation",
target_language
);
// Create a client for fetching the transcript
let client = Client::new();
// Step 3: Translate the transcript
match transcript.translate(target_language) {
Ok(translated_transcript) => {
println!("Successfully created translated transcript object");
// Step 4: Fetch the translated transcript content
match translated_transcript.fetch(&client, false).await {
Ok(fetched_transcript) => {
println!("Successfully fetched translated transcript!");
println!(
"Original language: {} ({})",
transcript.language, transcript.language_code
);
println!(
"Translated language: {} ({})",
fetched_transcript.language,
fetched_transcript.language_code
);
println!(
"Number of snippets: {}",
fetched_transcript.snippets.len()
);
// Display the first 5 snippets of the translated transcript
println!("\nTranslated transcript content:");
for snippet in fetched_transcript.snippets.iter().take(5) {
println!(
"[{:.1}-{:.1}s] {}",
snippet.start,
snippet.start + snippet.duration,
snippet.text
);
}
println!("... (truncated)");
return Ok(());
}
Err(e) => {
println!("Failed to fetch translated transcript: {:?}", e);
}
}
}
Err(e) => {
println!("Failed to translate transcript: {:?}", e);
}
}
} else {
println!(
"Target language {} is not available for translation",
target_language
);
println!("Available translation languages:");
for lang in &transcript.translation_languages {
println!(" {} ({})", lang.language, lang.language_code);
}
}
// Only process the first translatable transcript
break;
}
}
if !found_translatable {
println!("No translatable transcripts found for this video");
}
}
Err(e) => {
println!("Failed to list transcripts: {:?}", e);
}
}
Ok(())
}