YouTube AnyCaption Summarizer

The YouTube summarizer that still works when captions are broken, missing, or inconsistent.

Outputs: raw markdown transcript + polished markdown summary + session-ready result block.

Unlike caption-only tools, this skill still works when subtitles are missing by falling back to local Whisper transcription.

Generate a raw transcript markdown file and a polished summary markdown file from one or more YouTube videos.

This skill is self-contained. It does not require any other YouTube summarizer skill or prior workflow context.

Best for

• founder videos, operator walkthroughs, and technical explainers
• long tutorial videos that need transcript + implementation summary
• private/internal YouTube uploads that may require cookies
• mixed-caption environments where some videos have CC, some only have auto-captions, and some have no usable subtitles
• batch research workflows where many YouTube links need standardized markdown outputs
• users who want reliable markdown artifacts, not just a one-off chat summary

Why choose this over simpler transcript skills?

• manual CC first, auto-captions second, local Whisper fallback last
• keeps working when subtitle coverage is weak or missing
• supports private/restricted YouTube videos via cookies
• returns durable markdown artifacts, not just chat text
• supports batch processing and session-ready completion reporting

Install dependencies

For a fresh macOS setup, new users should be able to copy-paste the following exactly:

brew install yt-dlp ffmpeg whisper-cpp
MODELS_DIR="$HOME/.openclaw/workspace"
MODEL_PATH="$MODELS_DIR/ggml-medium.bin"
mkdir -p "$MODELS_DIR"
if [ ! -f "$MODEL_PATH" ]; then
  curl -L https://huggingface.co/ggerganov/whisper.cpp/resolve/main/ggml-medium.bin \
    -o "$MODEL_PATH.part" && mv "$MODEL_PATH.part" "$MODEL_PATH"
else
  echo "Model already exists at $MODEL_PATH — leaving it unchanged."
fi
command -v python3 yt-dlp ffmpeg whisper-cli
ls -lh "$MODEL_PATH"

What this does:

• installs

  yt-dlp

  ,

  ffmpeg

  , and

  whisper-cli

• creates the default models directory used by this skill if it does not already exist:

  ~/.openclaw/workspace

• downloads the default Whisper model file only if it is missing
• avoids touching

  ~/.openclaw/openclaw.json

  or any other OpenClaw config file
• does not delete, replace, or overwrite other files in your existing workspace folder
• verifies that the required binaries and model file are present

If you want to store models elsewhere, pass

--models-dir /path/to/models

when running the workflow.

Example requests

• “Summarize this YouTube video into markdown.”
• “Generate a transcript and polished summary for this YouTube link.”
• “Process this private YouTube video with my browser cookies.”
• “Batch summarize these YouTube links and give me transcript + summary files.”
• “Use subtitles when available, otherwise transcribe locally.”
• “Create a Chinese summary from this English YouTube video.”

Quick start

Single video

python3 scripts/run_youtube_workflow.py "https://www.youtube.com/watch?v=VIDEO_ID"

This creates a dedicated per-video folder, writes the raw transcript markdown, creates the summary placeholder markdown, and prints JSON describing the outputs plus the exact follow-up commands/prompts needed to finish the summary step.

Important: the workflow script alone is not the finished deliverable. The current OpenClaw session must still:

1. infer/backfill the language if the workflow left it as

   unknown

2. overwrite the placeholder

   Summary.md

   with a real polished summary
3. run

   scripts/complete_youtube_summary.py

   to validate/finalize the result

Force simplified Chinese summary

python3 scripts/run_youtube_workflow.py "https://www.youtube.com/watch?v=VIDEO_ID" \
  --summary-language zh-CN

Restricted video with cookies

python3 scripts/run_youtube_workflow.py "https://www.youtube.com/watch?v=VIDEO_ID" \
  --cookies /path/to/cookies.txt

or

python3 scripts/run_youtube_workflow.py "https://www.youtube.com/watch?v=VIDEO_ID" \
  --cookies-from-browser chrome

Batch / queue mode

See

references/batch-input-format.md

.

Safe invocation rule for batch mode:

• if you have exactly one URL, use

  run_youtube_workflow.py <url>

• if you have more than one URL, first create a plain-text batch file with one URL per line, then pass only

  --batch-file

  to the batch runner
• do not pass multiple positional URLs directly to

  run_youtube_batch_end_to_end.py

Recommended end-to-end batch mode:

cat > ./youtube-urls.txt <<'EOF'
https://www.youtube.com/watch?v=VIDEO_ID_1
https://www.youtube.com/watch?v=VIDEO_ID_2
EOF
python3 scripts/run_youtube_batch_end_to_end.py --batch-file ./youtube-urls.txt

When launched from an OpenClaw session, the batch orchestrator can now post best-effort milestone updates back into that same launching session automatically. It only forwards high-signal events like started, summary ready, failed, and batch complete.

Low-level extraction-only batch mode still exists:

python3 scripts/run_youtube_workflow.py --batch-file ./youtube-urls.txt

Why this skill stands out

This skill is designed to keep working across the messy reality of YouTube:

• if a video has manual closed captions (CC), use them first
• if it only has auto-generated subtitles, use those next
• if it has no usable subtitles at all, fall back to local Whisper transcription

That makes it materially more reliable than caption-only workflows. It works well for caption-rich videos, caption-poor videos, and private/internal uploads where subtitle coverage is inconsistent.

For multi-video requests, prefer the end-to-end batch orchestrator so each video is processed to completion when possible, failures do not block the whole batch, failed items are retried up to 3 times, and the final batch result includes both successful outputs and failed-video reasons. For stability, multi-video requests should always be converted into a batch file first and then run via

run_youtube_batch_end_to_end.py --batch-file ...

.

Core capabilities:

• fetch YouTube metadata first and derive safe output paths
• support single-video mode and batch / queue mode
• handle manual CC, auto-generated subtitles, or no subtitles via subtitle-first extraction with local Whisper fallback
• support restricted/private videos via cookies or browser-cookie extraction
• normalize noisy transcript text before summarization
• create a placeholder summary file, overwrite it with the final summary, and finalize end-to-end timing
• clean up only known intermediates created by the workflow unless explicitly told otherwise

What this skill produces

For each video, create exactly one dedicated output folder containing these final deliverables:

• SANITIZED_VIDEO_NAME_transcript_raw.md

• SANITIZED_VIDEO_NAME_Summary.md

By default, delete only the known intermediate media, subtitle, and WAV files created by the workflow. Do not wipe unrelated files that may already exist in the per-video folder.

Required local tools

Verify these tools exist before running the workflow:

• yt-dlp

• ffmpeg

• whisper-cli

• python3

The workflow also requires a supported Whisper ggml model file in the configured models directory.

Bundled scripts

Use these scripts directly:

• scripts/run_youtube_workflow.py

  — main deterministic workflow for metadata, download/subtitles, transcription, placeholder summary creation, cleanup, and workflow metadata emission

• scripts/run_youtube_batch_end_to_end.py

  — recommended batch orchestrator for multiple URLs; processes videos sequentially to completion when possible, retries failed items up to 3 times, and returns final success/failure results including failed-video reasons and successful-item

  end_to_end_total_seconds

• scripts/backfill_detected_language.py

  — update

  transcript_raw.md

  ,

  Summary.md

  , and workflow metadata after the current session LLM decides the major transcript language

• scripts/complete_youtube_summary.py

  — validate that

  Summary.md

  is no longer a placeholder, optionally backfill language, compute the final end-to-end timing report for one item, and emit a session-ready result block

• scripts/normalize_transcript_text.py

  — convert raw timestamped transcript text into cleaner summary input without modifying the raw transcript file

• scripts/finalize_youtube_summary.py

  — lower-level timing helper used by the completion flow

• scripts/prepare_video_paths.py

  — derive sanitized folder and output file paths from a title and video ID

Useful references:

• references/detailed-workflow.md

  — full operational workflow, completion rules, batch guidance, naming rules, and practical notes

• references/summary-template.md

  — required structure and writing rules for the final

  Summary.md

• references/session-output-template.md

  — required user-facing output format to return to the current OpenClaw session after completion

• references/batch-input-format.md

  — input format for queue / batch processing

Defaults

• Default parent output folder:

  ~/Downloads

• Default whisper model:

  ggml-medium

• Supported whisper models:

  ggml-base

  ,

  ggml-small

  ,

  ggml-medium

• Default media mode: audio-only
• Default transcript language: auto-detect if transcription is needed
• Default summary language:

  source

• Raw transcript keeps timestamps

Public workflow overview

At a high level, the skill does this:

1. fetch metadata first and create safe output paths
2. try manual subtitles, then auto-captions, then local Whisper fallback
3. write

   SANITIZED_VIDEO_NAME_transcript_raw.md

4. create

   SANITIZED_VIDEO_NAME_Summary.md

   as a placeholder
5. have the current OpenClaw session overwrite the placeholder with a real summary
6. run

   scripts/complete_youtube_summary.py

   to validate completion, backfill language if needed, and emit a session-ready result block

What counts as completion

For a normal end-to-end request, completion means all of the following are true:

1. the workflow script succeeded
2. if language was initially

   unknown

   , the language was backfilled into both markdown files
3. the placeholder summary file was overwritten with a real summary

4. scripts/complete_youtube_summary.py

   was run successfully
5. the user received the resulting output paths and timing/result status

If the workflow script succeeded but the summary/completion step did not happen yet, describe the state as partial/in-progress rather than complete.

When to read the deeper references

Read these as needed:

• references/detailed-workflow.md

  when you need the full implementation contract, batch guidance, naming rules, cleanup rules, timing flow, or debugging details

• references/summary-template.md

  before writing the final polished

  Summary.md

• references/session-output-template.md

  before returning the final user-facing per-video result block

• references/batch-input-format.md

  when handling

  --batch-file

• references/batch-end-to-end-behavior.md

  when handling multi-video end-to-end completion with retry and final success/failure reporting

Practical public promise

This skill is optimized for dependable end-to-end output, not just quick transcript extraction:

• raw transcript markdown
• polished summary markdown
• session-ready completion report