Using yt-dlp to download youtube transcript

I was having a bit of trouble with yt and decided to convert to yt-dlp

Here is a prompt I wrote for Gemini:

write a python script cli script that execute this subprocess
yt-dlp --write-subs --sub-format vtt  --skip-download <youtube video url>  -o /tmp/trans1.out
then find the output in the /tmp directory ( linux obviously )
then parse with vtt module.
output should be send to stdout.

Okay, here's a Python CLI script that does what you've requested.
First, you'll need to install the `webvtt-py` library if you haven't already:
```bash
pip install webvtt-py
```
And ensure `yt-dlp` is installed and in your system's PATH.
Now, here's the script:
```python
#!/usr/bin/env python3
import subprocess
import argparse
import sys
from pathlib import Path
import webvtt # For parsing VTT files (pip install webvtt-py)
import os
def main():
    parser = argpwrite a python script cli script that execute this subprocessarse.ArgumentParser(
        description="Download YouTube video subtitles using yt-dlp, parse the VTT, and print to stdout."
    )
    parser.add_argument("youtube_url", help="The URL of the YouTube video.")
    parser.add_argument(
        "--output-base",
        default="/tmp/trans1.out",
        help="Base path for the temporary subtitle file (defwrite a python script cli script that execute this subprocessault: /tmp/trans1.out). "
             "yt-dlp will append language and .vtt extension to this base."
    )
    parser.add_argument(
        "--keep-file",
        action="store_true",
        help="Keep the downloaded .vtt file in /tmp instead of deleting it."
    )
args = parser.parse_args()
# The -o option for yt-dlp is an output *template*.
    # If you specify -o /tmp/trans1.out and --sub-format vtt,
    # yt-dlp will likely create something like /tmp/trans1.out.en.vtt
    output_base_path_template = Path(args.output_base)
    output_directory = output_base_path_template.parent
    # This is the part before yt-dlp adds ".lang.vtt"
    output_filename_stem_for_glob = output_base_path_template.name 
# Ensure the output directory exists (though /tmp usuallywrite a python script cli script that execute this subprocess does)
    try:
        output_directory.mkdir(parents=True, exist_ok=True)
    except OSError as e:
        print(f"Error creating output directory {output_directory}: {e}", file=sys.stderr)
        sys.exit(1)
# Construct yt-dlp command
    command = [
        "yt-dlp",
        "--write-subs",
        "--sub-format", "vtt",
        "--skip-download",
        args.youtube_url,
        "-o", str(output_base_path_template) # Pass the template path
    ]
print(f"Executing: {' '.join(command)}", file=sys.stderr)
    try:
        # Run the command. Capture output for better error repwrite a python script cli script that execute this subprocessorting.
        process = subprocess.run(command, check=True, capture_output=True, text=True)
        # Print yt-dlp's own output to stderr for diagnosis
        if process.stdout:
            print(f"yt-dlp STDOUT:\n{process.stdout.strip()}", file=sys.stderr)
        if process.stderr:
            print(f"yt-dlp STDERR:\n{process.stderr.strip()}", file=sys.stderr)
except subprocess.CalledProcessError as e:
        print(f"Error executing yt-dlp. Return code: {e.returncode}", file=sys.stderr)
        if e.stdout:
            print(f"yt-dlp STDOUT:\n{e.stdout.strip()}", file=sys.stderr)
        if e.stderr:
            print(f"yt-dlp STDERR:\n{e.stderr.strip()}", file=sys.stderr)
        sys.exit(1)
    except FileNotFoundError:
        print("Error: yt-dlp command not found. Please ensure it's installed and in your PATH.", file=sys.stderr)
        sys.exit(1)
# Find the downloaded VTT file(s)
    # yt-dlp will name it like <output_filename_stem_for_glob>.LANG.vtt
    # e.g., if output_base_path_template was /tmp/trans1.out, it might be /tmp/trans1.out.en.vtt
# We search in the directory part of output_base_path_templawrite a python script cli script that execute this subprocesste
    # for files starting with the filename part, followed by anything, ending with .vtt
    glob_pattern = f"{output_filename_stem_for_glob}.*.vtt"
    vtt_files_found = list(output_directory.glob(glob_pattern))
if not vtt_files_found:
        print(f"Error: No .vtt file found in {output_directory} matching pattern '{glob_pattern}'", file=sys.stderr)
        print("This could be because no subtitles were available or yt-dlp had an issue.", file=sys.stderr)
        sys.exit(1)
# For simplicity, use the first VTT file found.
    # A more robust script might handle multiple languages or let the user choose.
    vtt_file_path = vtt_files_found[0]
    print(f"Found VTT file: {vtt_file_path}", file=sys.stderr)
if len(vtt_files_found) > 1:
        print(f"Warning: Multiple VTT files found ({[str(f.name) for f in vtt_files_found]}). Processing the first one: {vtt_file_path.name}", file=sys.stderr)
# Parse the VTT file
    try:
        vtt_contewrite a python script cli script that execute this subprocessnt = webvtt.read(str(vtt_file_path))
    except Exception as e:
        print(f"Error parsing VTT file {vtt_file_path}: {e}", file=sys.stderr)
        # Clean up before exiting on parse error
        if not args.keep_file:
            try:
                os.remove(vtt_file_path)
            except OSError as del_e:
                print(f"Error deleting {vtt_file_path} after parse error: {del_e}", file=sys.stderr)
        sys.exit(1)
# Output parsed content to stdout
    print(f"\n--- Parsed Subtitles from {vtt_file_path.name} ---", file=sys.stderr) # Info to stderr
    for caption in vtt_content:
        # Output actual data to stdout
        print(f"{caption.start} --> {caption.end}")
        # VTT text can have newlines within a single cue.
        # Replace internal newlines with spaces for a cleaner single-line output per cue segment,
        # or print caption.text as is if multiline output for a single cue is desired.
        cleaned_text = caption.text.replace('\n', ' ').strip()
        print(cleaned_text)
        print() # Extra newline for readability between cues
# Clean up the VTT file unless asked to keep it
    if not args.keep_file:
        try:
            os.remove(vtt_file_path)
            print(f"Cleaned up {vtt_file_path}", file=sys.stderr)
        except OSError as e:
            print(f"Error deleting {vtt_file_path}: {e}", file=sys.stderr)
    else:
        print(f"Kept VTT file: {vtt_file_path}", file=sys.stderr)
if __name__ == "__main__":
    main()
```
**How to use it:**write a python script cli script that execute this subprocess
1.  Save the code above as a Python file (e.g., `get_subs.py`).
2.  Make it executable: `chmod +x get_subs.py`
3.  Run it with a YouTube video URL:
    ```bash
    ./get_subs.py "https://www.youtube.com/watch?v=dQw4w9WgXcQ"
    ```
    (Replace with a video URL that actually has subtitles for best results).
**Explanation:**
1.  **`#!/usr/bin/env python3`**: Shebang line to make the script executable.
2.  **`import ...`**: Imports necessary modules:
    *   `subprocess`: To run the `yt-dlp` command.
    *   `argparse`: To create a user-friendly command-line interface.
    *   `sys`: For `sys.exit()` and writing to `sys.stderr`.
    *   `pathlib.Path`: For modern, object-oriented path manipulationwrite a python script cli script that execute this subprocess.
    *   `webvtt`: The library for parsing `.vtt` files.
    *   `os`: For removing the temporary file.
3.  **`argparse` Setup**:
    *   Defines a positional argument `youtube_url`.
    *   Adds an optional `--output-base` argument, defaulting to `/tmp/trans1.out`. This is important because `yt-dlp` uses its `-o` option as an *output template*, not a final filename. It will append the language code (e.g., `.en`) and the extension (`.vtt`) to this base.
    *   Adds an optional `--keep-file` flag to prevent deletion of the downloaded `.vtt` file.
4.  **`yt-dlp` Command Execution**:
    *   The `yt-dlp` command is constructed as a list of strwrite a python script cli script that execute this subprocessings.
    *   `output_base_path_template` is passed to `yt-dlp`'s `-o` option.
    *   `subprocess.run()` executes the command.
        *   `check=True`: Raises a `CalledProcessError` if `yt-dlp` exits with a non-zero status.
        *   `capture_output=True, text=True`: Captures stdout and stderr from `yt-dlp` as text, which is useful for debugging.
    *   Error handling is included for `CalledProcessError` (if `yt-dlp` fails) and `FileNotFoundError` (if `yt-dlp` isn't installed).
5.  **Finding the Output File**:
    *   `yt-dlp` typically names subtitle files like `<output_template>.LANG.vtt` (e.g., `/tmp/trans1.out.en.vtt`).
    *   `output_diwrite a python script cli script that execute this subprocessrectory.glob(f"{output_filename_stem_for_glob}.*.vtt")` is used to find files matching this pattern. `output_filename_stem_for_glob` would be `trans1.out` in the default case.
    *   The script takes the first file found. If a video has subtitles in multiple languages and `yt-dlp` downloads them all, this will pick one.
6.  **Parsing with `webvtt`**:
    *   `webvtt.read(str(vtt_file_path))` parses the found VTT file.
    *   It then iterates through `vtt_content.captions` (or just `vtt_content` as it's iterable).
    *   `caption.stwrite a python script cli script that execute this subprocessart`, `caption.end`, and `caption.text` provide the timing and content of each subtitle cue.
    *   The parsed information is printed to `stdout`. Diagnostic messages (like "Executing...", "Found VTT file...", etc.) are printed to `stderr` to keep `stdout` clean for potential piping.
7.  **Cleanup**:
    *   Unless `--keep-file` is specified, `os.remove(vtt_file_path)` deletes the downloaded VTT file from `/tmp`.
This script provideswrite a python script cli script that execute this subprocess a robust way to achieve your goal, including error handling and clear feedback.

This didn’t give what I wanted. The output had the time stamps

can we eliminate time stamps
00:43:56.840 --> 00:44:00.080
so at least I've got some snacks for the road.

what it came up with was the following:

KEY CHANGE:
The loop for printing parsed content now looks like this:
# Output parsed content (text only) to stdout
    print(f"\n--- Subtitle Text from {vtt_file_path.name} (timestamps omitted) ---", file=sys.stderr) # Info to stderr
    for caption in vtt_content:
        # VTT text can have newlines within a single cue.
        # Replace internal newlines with spaces for a cleaner single-line output per cue segment.
        cleaned_text = caption.text.replace('\n', ' ').strip()
        if cleaned_text: # Only print if there's actual text
            print(cleaned_text) # Output actual data (text only) to stdout
IGNORE_WHEN_COPYING_START
Use code with caution. Python
IGNORE_WHEN_COPYING_END
This will produce output like:
First line of subtitles.
Second line of subtitles, perhaps originally on multiple lines in VTT.
And so on.ey change:
The loop for printing parsed content now looks like this:
# Output parsed content (text only) to stdout
    print(f"\n--- Subtitle Text from {vtt_file_path.name} (timestamps omitted) ---", file=sys.stderr) # Info to stderr
    for caption in vtt_content:
        # VTT text can have newlines within a single cue.
        # Replace internal newlines with spaces for a cleaner single-line output per cue segment.
        cleaned_text = caption.text.replace('\n', ' ').strip()
        if cleaned_text: # Only print if there's actual text
            print(cleaned_text) # Output actual data (text only) to stdout
IGNORE_WHEN_COPYING_START
Use code with caution. Python
IGNORE_WHEN_COPYING_END
This will produce output like:
First line of subtitles.
Second line of subtitles, perhaps originally on multiple lines in VTT.
And so on.
IGNORE_WHEN_COPYING_START
Use code with caution.
IGNORE_WHEN_COPYING_END
All diagnostic information will still go to stderr, so stdout will contain only the extracted subtitle text, with each caption's text on a new line.
IGNORE_WHEN_COPYING_START
Use code with caution.
IGNORE_WHEN_COPYING_END
All diagnostic information will still go to stderr, so stdout will contain only the extracted subtitle text, with each caption's text on a new line.

the output is like the original yt — but there is a bit of noise from yt-dlp, but that is going to stderr. stdout is the transcript.

[jon2allen@jons-bad-ass-fedora-server-37 python]$ ./yt_trans_dlp.py https://www.youtube.com/watch?v=XmD1eGuX4GU
Executing: yt-dlp --write-subs --sub-format vtt --skip-download https://www.youtube.com/watch?v=XmD1eGuX4GU -o /tmp/trans1.out
yt-dlp STDOUT:
[youtube] Extracting URL: https://www.youtube.com/watch?v=XmD1eGuX4GU
[youtube] XmD1eGuX4GU: Downloading webpage
[youtube] XmD1eGuX4GU: Downloading tv client config
[youtube] XmD1eGuX4GU: Downloading tv player API JSON
[youtube] XmD1eGuX4GU: Downloading ios player API JSON
[youtube] XmD1eGuX4GU: Downloading player fc2a56a5-main
[youtube] XmD1eGuX4GU: Downloading m3u8 information
[info] XmD1eGuX4GU: Downloading subtitles: en-GB
[info] XmD1eGuX4GU: Downloading 1 format(s): 625+234
[info] Writing video subtitles to: /tmp/trans1.out.en-GB.vtt
[download] Destination: /tmp/trans1.out.en-GB.vtt
[download]    1.00KiB at  Unknown B/s (00:00:00)
[download]    3.00KiB at    2.79MiB/s (00:00:00)
[download]    7.00KiB at    4.58MiB/s (00:00:00)
[download]   15.00KiB at    7.42MiB/s (00:00:00)
[download]   31.00KiB at    5.13MiB/s (00:00:00)
[download]   63.00KiB at    7.00MiB/s (00:00:00)
[download]   75.50KiB at    7.54MiB/s (00:00:00)
[download] 100% of   75.50KiB in 00:00:00 at 1001.12KiB/s
yt-dlp STDERR:
WARNING: [youtube] Falling back to generic n function search
         player = https://www.youtube.com/s/player/fc2a56a5/player_ias.vflset/en_US/base.js
WARNING: [youtube] XmD1eGuX4GU: nsig extraction failed: Some formats may be missing
         n = yR01YPe3cSkdGq- ; player = https://www.youtube.com/s/player/fc2a56a5/player_ias.vflset/en_US/base.js
         Please report this issue on  https://github.com/yt-dlp/yt-dlp/issues?q= , filling out the appropriate issue template. Confirm you are on the latest version using  yt-dlp -U
WARNING: [youtube] XmD1eGuX4GU: nsig extraction failed: Some formats may be missing
         n = fpjqJn25cjVvz0a ; player = https://www.youtube.com/s/player/fc2a56a5/player_ias.vflset/en_US/base.js
         Please report this issue on  https://github.com/yt-dlp/yt-dlp/issues?q= , filling out the appropriate issue template. Confirm you are on the latest version using  yt-dlp -U
WARNING: [youtube] XmD1eGuX4GU: nsig extraction failed: Some formats may be missing
         n = t6eAKIAlX74Ovj9 ; player = https://www.youtube.com/s/player/fc2a56a5/player_ias.vflset/en_US/base.js
         Please report this issue on  https://github.com/yt-dlp/yt-dlp/issues?q= , filling out the appropriate issue template. Confirm you are on the latest version using  yt-dlp -U
WARNING: [youtube] XmD1eGuX4GU: Some web client https formats have been skipped as they are missing a url. YouTube is forcing SABR streaming for this client. See  https://github.com/yt-dlp/yt-dlp/issues/12482  for more details
Found VTT file: /tmp/trans1.out.en-GB.vtt
--- Subtitle Text from trans1.out.en-GB.vtt (timestamps omitted) ---
In a land far, far away.
For the fifth time, I embarked on a journey of a lifetime,alias yt='/home/jon2allen/python/yt_trans_dlp.py'

you can alias the yt command in Linux:

alias yt='/home/jon2allen/python/yt_trans_dlp.py'alias yt='/home/jon2allen/python/yt_trans_dlp.py'

and there you have a complete replacement for yt. there could be some minor enhancements such as using pid for the output to support concurrent running of the script.

Here is the final code:

#!/usr/bin/env python3
import subprocess
import argparse
import sys
from pathlib import Path
import webvtt # For parsing VTT files (pip install webvtt-py)
import os
def main():
    parser = argparse.ArgumentParser(
        description="Download YouTube video subtitles using yt-dlp, parse the VTT, and print only the text to stdout."
    )
    parser.add_argument("youtube_url", help="The URL of the YouTube video.")
    parser.add_argument(
        "--output-base",
        default="/tmp/trans1.out",
        help="Base path for the temporary subtitle file (default: /tmp/trans1.out). "
             "yt-dlp will append language and .vtt extension to this base."
    )
    parser.add_argument(
        "--keep-file",
        action="store_true",
        help="Keep the downloaded .vtt file in /tmp instead of deleting it."
    )
args = parser.parse_args()
output_base_path_template = Path(args.output_base)
    output_directory = output_base_path_template.parent
    output_filename_stem_for_glob = output_base_path_template.name
try:
        output_directory.mkdir(parents=True, exist_ok=True)
    except OSError as e:
        print(f"Error creating output directory {output_directory}: {e}", file=sys.stderr)
        sys.exit(1)
command = [
        "yt-dlp",
        "--write-subs",
        "--sub-format", "vtt",
        "--skip-download",
        args.youtube_url,
        "-o", str(output_base_path_template)
    ]
print(f"Executing: {' '.join(command)}", file=sys.stderr)
    try:
        process = subprocess.run(command, check=True, capture_output=True, text=True)
        if process.stdout:
            print(f"yt-dlp STDOUT:\n{process.stdout.strip()}", file=sys.stderr)
        if process.stderr:
            print(f"yt-dlp STDERR:\n{process.stderr.strip()}", file=sys.stderr)
except subprocess.CalledProcessError as e:
        print(f"Error executing yt-dlp. Return code: {e.returncode}", file=sys.stderr)
        if e.stdout:
            print(f"yt-dlp STDOUT:\n{e.stdout.strip()}", file=sys.stderr)
        if e.stderr:
            print(f"yt-dlp STDERR:\n{e.stderr.strip()}", file=sys.stderr)
        sys.exit(1)
    except FileNotFoundError:
        print("Error: yt-dlp command not found. Please ensure it's installed and in your PATH.", file=sys.stderr)
        sys.exit(1)
glob_pattern = f"{output_filename_stem_for_glob}.*.vtt"
    vtt_files_found = list(output_directory.glob(glob_pattern))
if not vtt_files_found:
        print(f"Error: No .vtt file found in {output_directory} matching pattern '{glob_pattern}'", file=sys.stderr)
        print("This could be because no subtitles were available or yt-dlp had an issue.", file=sys.stderr)
        sys.exit(1)
vtt_file_path = vtt_files_found[0]
    print(f"Found VTT file: {vtt_file_path}", file=sys.stderr)
if len(vtt_files_found) > 1:
        print(f"Warning: Multiple VTT files found ({[str(f.name) for f in vtt_files_found]}). Processing the first one: {vtt_file_path.name}", file=sys.stderr)
try:
        vtt_content = webvtt.read(str(vtt_file_path))
    except Exception as e:
        print(f"Error parsing VTT file {vtt_file_path}: {e}", file=sys.stderr)
        if not args.keep_file:
            try:
                os.remove(vtt_file_path)
            except OSError as del_e:
                print(f"Error deleting {vtt_file_path} after parse error: {del_e}", file=sys.stderr)
        sys.exit(1)
# Output parsed content (text only) to stdout
    print(f"\n--- Subtitle Text from {vtt_file_path.name} (timestamps omitted) ---", file=sys.stderr) # Info to stderr
    for caption in vtt_content:
        # VTT text can have newlines within a single cue.
        # Replace internal newlines with spaces for a cleaner single-line output per cue segment.
        cleaned_text = caption.text.replace('\n', ' ').strip()
        if cleaned_text: # Only print if there's actual text
            print(cleaned_text) # Output actual data (text only) to stdout
if not args.keep_file:
        try:
            os.remove(vtt_file_path)
            print(f"Cleaned up {vtt_file_path}", file=sys.stderr)
        except OSError as e:
            print(f"Error deleting {vtt_file_path}: {e}", file=sys.stderr)
    else:
        print(f"Kept VTT file: {vtt_file_path}", file=sys.stderr)
if __name__ == "__main__":
    main()