Automated YouTube Transcript Extraction: Building a Python Solution with API Integration#

1
from youtube_transcript_api import YouTubeTranscriptApi
2
from youtube_transcript_api.formatters import TextFormatter
3

4
def download_transcript(video_id, output_format="text", lang='en'):
5
    """
6
    Downloads the transcript for a given YouTube video ID.
7

8
    Args:
9
        video_id (str): The ID of the YouTube video.
10
        output_format (str): The desired output format ('text' or 'srt').
11
        lang (str): The preferred language code (e.g., 'en', 'es').
12

13
    Returns:
14
        str or None: The formatted transcript text, or None if no transcript found.
15
    """
16
    try:
17
        # Attempt to get the transcript for the specified language
18
        transcript_list = YouTubeTranscriptApi.list_transcripts(video_id)
19

20
        # Find a suitable transcript: try specified lang, then auto-generated in lang, then fallback
21
        transcript = None
22
        try:
23
            # Prioritize the specified language first
24
            transcript = transcript_list.find_transcript([lang])
25
        except Exception:
26
             # If not found, try finding an auto-generated one in that language
27
            try:
28
                transcript = transcript_list.find_generated_transcript([lang])
29
            except Exception:
30
                 # As a last resort, get the first available transcript (might not be in requested lang)
31
                 if transcript_list:
32
                     transcript = transcript_list[0]
33
                     print(f"Warning: Specific language '{lang}' not found for {video_id}. Using '{transcript.language_code}' transcript instead.")
34
                 else:
35
                    print(f"No transcripts found for video ID: {video_id}")
36
                    return None
37

38

39
        # Fetch the actual transcript content
40
        transcript_content = transcript.fetch()
41

42
        # Format the transcript
43
        if output_format == "text":
44
            formatter = TextFormatter()
45
            formatted_transcript = formatter.format_transcript(transcript_content)
46
            return formatted_transcript
47
        elif output_format == "srt":
48
             # Note: youtube-transcript-api itself can return list of dicts,
49
             # for SRT formatting, you might need a different approach or library,
50
             # or manually format the list of dicts. Let's return list of dicts for srt for simplicity here
51
            # and the user can format it. Or demonstrate simple text join.
52
            # A full SRT formatter is beyond this basic example using TextFormatter only.
53
            # For this example, sticking to plain text output primarily.
54
             print("SRT formatting requires a different approach or library.")
55
             return None # Or return transcript_content (list of dicts)
56

57
        else:
58
            print(f"Unsupported output format: {output_format}")
59
            return None
60

61
    except Exception as e:
62
        print(f"An error occurred for video ID {video_id}: {e}")
63
        # Handle specific exceptions like TranscriptsDisabled, NoTranscriptFound manually if needed
64
        return None
65

66
# Example Usage:
67
# video_id = "dQw4w9WgXcQ" # Replace with a real video ID
68
# transcript_text = download_transcript(video_id, output_format="text", lang='en')
69
#
70
# if transcript_text:
71
#     # Save the transcript to a file
72
#     file_name = f"{video_id}_transcript.txt"
73
#     with open(file_name, "w", encoding="utf-8") as f:
74
#         f.write(transcript_text)
75
#     print(f"Transcript saved to {file_name}")

1
import googleapiclient.discovery
2

3
def get_video_metadata(api_key, video_id):
4
    """
5
    Fetches basic metadata for a YouTube video using the official API.
6

7
    Args:
8
        api_key (str): Your YouTube Data API v3 key.
9
        video_id (str): The ID of the YouTube video.
10

11
    Returns:
12
        dict or None: A dictionary containing video metadata, or None on error.
13
    """
14
    try:
15
        api_service_name = "youtube"
16
        api_version = "v3"
17

18
        youtube = googleapiclient.discovery.build(
19
            api_service_name, api_version, developerKey=api_key)
20

21
        request = youtube.videos().list(
22
            part="snippet,captions",
23
            id=video_id
24
        )
25
        response = request.execute()
26

27
        if response and response.get('items'):
28
            # Return the first item (assuming video ID is unique)
29
            return response['items'][0]
30
        else:
31
            print(f"No metadata found for video ID: {video_id}")
32
            return None
33

34
    except Exception as e:
35
        print(f"An error occurred fetching metadata for video ID {video_id}: {e}")
36
        return None
37

38
# Example Usage:
39
# youtube_api_key = "YOUR_API_KEY" # Replace with your actual API key
40
# video_id = "dQw4w9WgXcQ" # Replace with a real video ID
41
# video_metadata = get_video_metadata(youtube_api_key, video_id)
42
#
43
# if video_metadata:
44
#     title = video_metadata['snippet']['title']
45
#     print(f"Video Title: {title}")
46
#     captions_info = video_metadata.get('captions')
47
#     if captions_info:
48
#         print("Captions are likely available.")
49
#     else:
50
#         print("Captions metadata not found (may still have auto-generated).")

1
from youtube_transcript_api import YouTubeTranscriptApi
2
from youtube_transcript_api.formatters import TextFormatter
3
import googleapiclient.discovery
4
import sys # To handle API key input safely
5

6
def get_safe_api_key():
7
    """Placeholder for securely getting the API key."""
8
    # In a real application, use environment variables or a config file
9
    # For this example, a simple input might suffice, but it's not secure
10
    return input("Enter your YouTube Data API key: ") # Use with caution!
11

12
def download_transcript_with_metadata(api_key, video_id, output_format="text", lang='en'):
13
    """
14
    Fetches metadata and downloads transcript for a video ID.
15
    """
16
    # 1. Fetch Metadata using Official API
17
    video_metadata = get_video_metadata(api_key, video_id)
18
    title = "Unknown_Title"
19
    if video_metadata and 'snippet' in video_metadata:
20
        title = video_metadata['snippet']['title']
21
        print(f"Processing video: '{title}'")
22
        # The 'captions' part in metadata only confirms if *any* caption tracks are listed,
23
        # not whether a *specific* auto-generated or manual one in the target language exists.
24
        # Still rely on youtube-transcript-api to find/fetch the desired transcript.
25

26
    # 2. Download Transcript using youtube-transcript-api
27
    transcript_content = download_transcript(video_id, output_format=output_format, lang=lang)
28

29
    # 3. Save Transcript
30
    if transcript_content:
31
        # Sanitize title for filename (remove invalid characters)
32
        safe_title = "".join([c for c in title if c.isalnum() or c in (' ', '-', '_')]).rstrip()
33
        file_name = f"{safe_title}_{video_id}.{output_format}"
34

35
        try:
36
            if output_format == "text":
37
                 with open(file_name, "w", encoding="utf-8") as f:
38
                     f.write(transcript_content)
39
                 print(f"Transcript saved successfully to {file_name}")
40
            # Add logic here for other formats like SRT if supported by formatter or manual method
41
            # else:
42
            #    print(f"Could not save transcript in {output_format} format.")
43

44
        except Exception as e:
45
            print(f"Error saving file {file_name}: {e}")
46

47
# Main execution flow (example)
48
if __name__ == "__main__":
49
    # Example video IDs (replace with actual IDs)
50
    # A video known to have auto-generated English captions
51
    example_video_id_1 = "dQw4w9WgXcQ" # Rick Astley - Never Gonna Give You Up
52
    # A video potentially with manual captions or different languages
53
    example_video_id_2 = "M7lc1UVf-VE" # Kurzgesagt - In a Nutshell (often has many translations)
54

55
    # WARNING: Hardcoding API key in source is NOT recommended for security.
56
    # Use environment variables or a config file in production.
57
    # For demonstration, prompt for key or use a placeholder.
58
    # youtube_api_key = get_safe_api_key() # Uncomment this line in a real application
59

60
    # --- Using a placeholder for demonstration, replace with your key ---
61
    # To run this code, you MUST replace this with a valid API key that
62
    # has access to the YouTube Data API v3.
63
    youtube_api_key = "YOUR_YOUTUBE_API_KEY" # <<<--- REPLACE THIS!!!
64
    # --- End of Placeholder ---
65

66
    if youtube_api_key == "YOUR_YOUTUBE_API_KEY":
67
        print("\n!!! WARNING: Please replace 'YOUR_YOUTUBE_API_KEY' with your actual API key to fetch metadata. !!!")
68
        print("Running without API key for now, only transcript download will function.")
69
        # Set key to None or handle error if API key is strictly required
70
        youtube_api_key = None # Set to None if API key is not provided
71

72
    print("-" * 30)
73
    print(f"Attempting to download transcript for video ID: {example_video_id_1}")
74
    download_transcript_with_metadata(youtube_api_key, example_video_id_1, output_format="text", lang='en')
75

76
    print("-" * 30)
77
    print(f"Attempting to download transcript for video ID: {example_video_id_2}")
78
    # Try downloading in a different language (e.g., Spanish 'es')
79
    download_transcript_with_metadata(youtube_api_key, example_video_id_2, output_format="text", lang='es')