pip install youtube-transcript-api

Here is the complete script. You can save this as `get_transcript.py` and use it right away. Below, I’ll walk through exactly how it works.

import sys
from urllib.parse import urlparse, parse_qs
from youtube_transcript_api import YouTubeTranscriptApi, NoTranscriptFound, TranscriptsDisabled

def get_video_id(url):
    """Extracts the YouTube video ID from a URL."""
    if not url:
        return None
    
    # Standard URL: https://www.youtube.com/watch?v=VIDEO_ID
    # Shortened URL: https://youtu.be/VIDEO_ID
    parsed_url = urlparse(url)
    if 'youtube.com' in parsed_url.netloc:
        query_params = parse_qs(parsed_url.query)
        return query_params.get('v', [None])[0]
    elif 'youtu.be' in parsed_url.netloc:
        return parsed_url.path[1:]
    return None

def fetch_transcript(video_id):
    """Fetches and formats the transcript for a given video ID."""
    try:
        # Fetches a list of transcript objects
        transcript_list = YouTubeTranscriptApi.get_transcript(video_id)
        
        # Formats the transcript into a single string
        full_transcript = " ".join([item['text'] for item in transcript_list])
        return full_transcript

    except NoTranscriptFound:
        print(f"Error: No transcript found for video ID '{video_id}'. The owner may have disabled it.")
        return None
    except TranscriptsDisabled:
        print(f"Error: Transcripts are disabled for video ID '{video_id}'.")
        return None
    except Exception as e:
        print(f"An unexpected error occurred: {e}")
        return None

def main():
    """Main function to run the script from the command line."""
    if len(sys.argv) != 2:
        print("Usage: python get_transcript.py \"<YOUTUBE_URL>\"")
        sys.exit(1)

    youtube_url = sys.argv[1]
    video_id = get_video_id(youtube_url)

    if not video_id:
        print("Error: Invalid YouTube URL provided.")
        sys.exit(1)

    print(f"Fetching transcript for video ID: {video_id}...")
    transcript = fetch_transcript(video_id)

    if transcript:
        filename = f"{video_id}_transcript.txt"
        with open(filename, 'w', encoding='utf-8') as f:
            f.write(transcript)
        print(f"\nSuccess! Transcript saved to {filename}")

if __name__ == "__main__":
    main()

Step 1: Imports and Setup

We start by importing the necessary libraries. `sys` lets us read command-line arguments (the YouTube URL we'll provide). `urlparse` and `parse_qs` are handy tools for reliably extracting the video ID from different types of YouTube links. And, of course, we import our hero, `YouTubeTranscriptApi`, along with its specific error classes.

Step 2: A Robust Function to Get the Video ID

A YouTube video can be linked in several ways (e.g., `youtube.com/watch?v=...` or `youtu.be/...`). Instead of manually copying the ID, our `get_video_id` function intelligently parses the URL you give it and extracts the ID. This makes the script much more user-friendly.

Step 3: Fetching and Formatting the Transcript

This is where the magic happens. The `fetch_transcript` function does two key things:

1. It calls `YouTubeTranscriptApi.get_transcript(video_id)`. This returns a list of dictionaries, where each dictionary contains a chunk of text and its timing information.
2. We then use a simple list comprehension (`" ".join([item['text'] for item in transcript_list])`) to pull out just the text from each chunk and join it all together into one clean, continuous block of text.

Crucially, this is wrapped in a `try...except` block. This handles cases where a video has no transcript or has disabled them, preventing the script from crashing and instead printing a helpful error message.

Step 4: Putting It All Together in `main()`

The `main` function is the script's entry point. It orchestrates everything:

• It checks if a URL was provided when the script was run.
• It calls `get_video_id` to extract the ID.
• It calls `fetch_transcript` to get the text.
• If successful, it creates a unique filename (e.g., `dQw4w9WgXcQ_transcript.txt`) and saves the transcript to a new text file in the same directory.

How to Use the Script in 3 Simple Steps

Ready to try it? Here’s how.

1. Save the code above into a file named `get_transcript.py`.
2. Open your terminal or command prompt and navigate to the directory where you saved the file.
3. Run the script, passing the YouTube video's URL in quotes as an argument:

python get_transcript.py "https://www.youtube.com/watch?v=your_video_id_here"

After a moment, you’ll see a success message, and a new `.txt` file will appear in the folder, ready for you to search, read, and study from!

Going Further: Ideas for Improvement

This script is a fantastic starting point, but you can easily extend it. Here are a few ideas to get you thinking:

• Add Timestamps: Modify the formatting loop to include the `start` time for each text chunk. This lets you jump to the exact moment in the video.
• Automatic Translation: The `youtube-transcript-api` library can also fetch translated transcripts! You could add an argument to specify a language code (e.g., `'de'`, `'es'`).
• AI Summarization: Pipe the output transcript into an API like OpenAI's GPT or Google's Gemini to automatically generate a summary, key bullet points, or even flashcards.
• Build a GUI: For a less technical user, you could wrap this logic in a simple graphical interface using a library like Tkinter or PySimpleGUI.

Conclusion: Study Smarter, Not Harder

This simple Python script has genuinely changed how I engage with educational content online. It's a small piece of automation that saves a significant amount of time and removes a major point of friction from the learning process.

By transforming passive video-watching into an active, searchable experience, you can absorb information more effectively and efficiently. Give the script a try on your next YouTube deep-dive. I’d love to hear how it works for you or what improvements you come up with!