Allmd

Convert Anything to Markdown

A CLI tool that converts web pages, Google Docs, PDFs, images, video/audio files, YouTube videos, Word docs, EPUBs, CSVs, PowerPoints, tweets, and RSS feeds into clean markdown. Most converters use AI formatting; web pages use Firecrawl markdown directly.

Reference Files

Dispatch Table

Shared Workflow

Most converters follow this pattern:

1. Validate input (URL format or file existence/extension) 2. Extract content (fetch HTML, parse PDF, read image, transcribe audio, fetch captions) 3. AI format — restructures into clean markdown via OpenAI GPT-5-mini 4. Add frontmatter — YAML header with title, source, date, type, and type-specific fields 5. Output — write to file (-o), directory (-d), clipboard (--copy), or stdout

Web page conversion differs at step 3: allmd web uses Firecrawl markdown directly and only applies optional frontmatter.

CLI Quick Reference

Gotchas

• Do not use WebFetch or call the Firecrawl API directly when the user wants markdown output — always use allmd web <url> which wraps Firecrawl with proper frontmatter and output handling
• Auto-detection handles most inputs: allmd <url> dispatches correctly for http/https URLs, YouTube, Google Docs, Twitter/X, and RSS feeds — no need to specify the subcommand
• Web conversion skips AI formatting: allmd web uses Firecrawl markdown directly; other converters (PDF, image, video, etc.) run an OpenAI post-processing pass
• FIRECRAWL_API_KEY required for web: if not set, allmd web fails with a clear error
• OPENAI_API_KEY required for non-web converters: PDF, image, video, gdoc, youtube, tweet, docx, epub, csv, pptx, rss all use AI formatting

Conversion Options and Output Format

TypeScript Types

interface ConversionOptions {
  output?: string;      // Output file path (undefined = stdout)
  verbose?: boolean;    // Enable verbose logging
  frontmatter?: boolean; // Add YAML frontmatter (default: true)
}

interface ConversionResult {
  title: string;
  markdown: string;       // Final markdown with YAML frontmatter
  rawContent?: string;    // Raw extracted content before post-processing
  metadata: Record<string, unknown>;
}

CLI Global Flags

All allmd commands accept:

Auto-Detection

allmd <input> automatically detects the input type:

• URLs: Classified as YouTube, Google Doc, tweet, RSS feed, or generic web page
• Files: Classified by extension (pdf, image, video, audio, docx, epub, csv, pptx)
• Unknown: Falls back to interactive mode

YAML Frontmatter

Every output includes frontmatter by default (via gray-matter). Disable with --no-frontmatter.

---
title: "Document title"
source: "URL or file path"
date: "2026-02-16T10:00:00.000Z"
type: web | youtube | video | image | gdoc | pdf | docx | epub | csv | pptx | tweet | rss
# ...plus type-specific fields
---

AI Formatting

Most converters use AI formatting. Raw extracted text is sent to OpenAI GPT-5-mini. The model:

• Restructures text into clean markdown with headings, lists, and code blocks
• Preserves all factual content without adding information
• Uses ATX-style headings, fenced code blocks, dash bullet markers

Web page conversion is the exception: allmd web uses Firecrawl markdown directly and only applies optional frontmatter.

Configuration

Supports .allmdrc, .allmdrc.json, .allmdrc.yaml, allmd.config.js, or allmd key in package.json via cosmiconfig.

{
  "output": "docs/",
  "verbose": true,
  "frontmatter": true,
  "openai": {
    "model": "gpt-5-mini"
  }
}

Batch Processing

File commands support glob patterns for batch conversion:

allmd pdf "docs/*.pdf" -d output/
allmd image "screenshots/**/*.png" -d output/ --parallel 5

Clipboard and Stdin

# Read URL from clipboard
allmd web -c

# Copy output to clipboard
allmd web https://example.com --copy

# Pipe input via stdin
echo "https://example.com" | allmd web -

Environment Variables

Output Handling

• With `-o output.md`: Writes to the specified file, creates parent directories if needed
• With `-d output/`: Auto-generates filenames from document titles in the specified directory
• With `--copy`: Copies markdown to system clipboard
• Without flags: Writes markdown to stdout (pipeable to other commands)

Convert CSV/TSV to Markdown

Reads a .csv or .tsv file, converts to a markdown table, and applies AI formatting.

Conversion Workflow

1. Validate file exists and has .csv or .tsv extension 2. Detect delimiter — tabs vs commas (auto-detected for .csv, forced tab for .tsv) 3. Parse CSV with RFC 4180-compliant parser (handles quoted fields, escaped quotes) 4. Build markdown pipe table with header and separator rows 5. AI format — restructures into clean markdown via GPT-5-mini 6. Add frontmatter and output

Key Details

• Custom CSV parser handles RFC 4180 edge cases (quoted fields, embedded commas, escaped double quotes)
• Auto-detects delimiter by comparing tab vs comma count in first line
• Title derived from filename via titleFromFilename()
• Rows are padded to match header column count

Frontmatter Fields

type: csv
title: "Data File"
source: "/path/to/data.csv"
rows: 150
delimiter: comma | tab

CLI Usage

allmd csv data.csv
allmd csv data.csv -o data.md
allmd csv spreadsheet.tsv -o table.md
allmd csv "data/*.csv" -d output/

Edge Cases

• Large files: Very large CSVs may exceed AI token limits
• Mixed delimiters: Auto-detection uses first line only; inconsistent delimiters may cause issues
• Binary data: Non-text content in cells will be included as-is

Convert Word Document to Markdown

Reads a .docx or .doc file, converts HTML content via mammoth, then converts to markdown using Turndown with GFM support.

Conversion Workflow

1. Validate file exists and has .docx or .doc extension 2. Extract HTML content using mammoth 3. Convert HTML to markdown via Turndown (same engine as web converter) 4. AI format — restructures into clean markdown via GPT-5-mini 5. Add frontmatter and output

Key Details

• Uses mammoth library for DOCX → HTML conversion
• Reuses htmlToMarkdown() from the web converter for HTML → markdown
• Title derived from filename via titleFromFilename()
• Mammoth warnings (e.g., unsupported styles) logged in verbose mode

Frontmatter Fields

type: docx
title: "Document Title"
source: "/path/to/document.docx"

CLI Usage

allmd docx document.docx
allmd docx document.docx -o output.md
allmd docx "docs/*.docx" -d output/

Edge Cases

• `.doc` files: mammoth has limited support for legacy .doc format; results may vary
• Complex formatting: Tables, images, and advanced layouts may not convert perfectly
• Embedded images: Not extracted; only text content is converted

Convert EPUB to Markdown

Reads an .epub file, extracts chapter HTML content via epub2, converts each chapter to markdown, and joins them with horizontal rules.

Conversion Workflow

1. Validate file exists and has .epub extension 2. Parse EPUB structure using epub2 library 3. Extract each chapter's HTML and convert to markdown via Turndown 4. Join chapters with --- separators, adding chapter headings where available 5. AI format — restructures into clean markdown via GPT-5-mini 6. Add frontmatter and output

Key Details

• Uses epub2 library (EPub.createAsync()) for EPUB parsing
• Reuses htmlToMarkdown() from the web converter for HTML → markdown
• Title and author extracted from EPUB metadata
• Chapters with empty content are skipped
• Corrupt EPUB files are caught with a descriptive error message

Frontmatter Fields

type: epub
title: "Book Title"
source: "/path/to/book.epub"
author: "Author Name"
chapters: 12

CLI Usage

allmd epub book.epub
allmd epub book.epub -o book.md
allmd epub "books/*.epub" -d output/

Edge Cases

• DRM-protected EPUBs: Will fail to parse
• Image-heavy EPUBs: Only text content is extracted
• Corrupt files: Caught with Failed to parse EPUB file error

Convert Google Doc to Markdown

Exports a public Google Doc directly as markdown using Google's native format=markdown export. No HTML parsing or conversion needed.

Conversion Workflow

- [ ] Step 1: Validate URL and extract document ID
- [ ] Step 2: Fetch markdown export
- [ ] Step 3: Extract title and apply AI formatting
- [ ] Step 4: Add frontmatter and output

Step 1: Validate URL and extract document ID

Expects a Google Docs URL matching: docs.google.com/document/d/<docId>

The document ID is extracted via regex. Any URL variant (edit, preview, published) works as long as it contains the /d/<docId> segment.

Step 2: Fetch markdown export

Constructs the export URL: https://docs.google.com/document/d/<docId>/export?format=markdown

The document must be publicly shared ("Anyone with the link"). Private documents return a 404 with a helpful error message.

Google handles the document-to-markdown conversion natively, including headings, lists, tables, links, and formatting.

Step 3: Extract title and apply AI formatting

1. Extracts title from the first # heading in the markdown, with fallback to "Untitled Google Doc" 2. AI restructures the content into clean, well-formatted markdown

Step 4: Add frontmatter and output

• Frontmatter fields: title, source, date, type ("gdoc"), docId

CLI Usage

allmd gdoc <url>
allmd gdoc "https://docs.google.com/document/d/abc123/edit" -o doc.md

Best Practices

• The document must be shared publicly before conversion; check sharing settings first
• Images in Google Docs are exported as external URLs by the markdown exporter

Edge Cases

• Private documents: Return 404; the doc must be shared as "Anyone with the link"
• Complex formatting: Text boxes, columns, and drawing elements may not convert cleanly to markdown
• Comments and suggestions: Not included in the export — only accepted content appears

Troubleshooting

• "Google Doc not found" — verify the document is publicly shared (not just "anyone in your org")
• "Could not extract document ID" — the URL must contain docs.google.com/document/d/<id>; spreadsheets, slides, and forms are not supported

Convert Image to Markdown

Reads an image file and sends it to OpenAI GPT-4o for analysis. Produces a markdown description that transcribes visible text or describes visual content.

Conversion Workflow

- [ ] Step 1: Validate file and format
- [ ] Step 2: Read image to buffer
- [ ] Step 3: AI vision analysis
- [ ] Step 4: Add frontmatter and output

Step 1: Validate file and format

Supported extensions: .jpg, .jpeg, .png, .gif, .webp

The file must exist and have a supported extension. Unsupported formats throw an error listing valid options.

Step 2: Read image to buffer

The image file is read as a binary buffer and base64-encoded for the OpenAI Vision API.

Step 3: AI vision analysis

The base64 image is sent to OpenAI GPT-4o with a prompt that handles multiple image types:

• Text documents / screenshots: Transcribes all visible text
• Photographs: Provides a detailed scene description
• Diagrams / illustrations: Describes structure and relationships
• Charts / graphs: Extracts data and labels

The output is structured as clean markdown with appropriate headings.

Vision AI is the only extraction method for images.

Step 4: Add frontmatter and output

Frontmatter fields: title (filename), source (file path), date, type ("image"), mimeType, fileSize (bytes)

CLI Usage

allmd image <file>
allmd image screenshot.png -o notes.md
allmd image diagram.jpg
allmd image photo.webp -o description.md

Best Practices

• Higher resolution images produce better OCR and descriptions
• For multi-page documents, use the allmd pdf command instead — image only processes a single file
• Screenshots with clear text and minimal noise transcribe most accurately
• For complex diagrams, the AI will describe the structure rather than recreate it in markdown

Edge Cases

• Low-resolution text: OCR quality degrades with smaller or blurry text
• Handwritten text: Results vary depending on legibility
• Very large images: Buffer size can become significant; no explicit size limit but API has token constraints
• Multi-page documents: Only single images are processed; use PDF converter for multi-page
• Complex layouts: Multi-column text or overlapping elements may not transcribe in correct reading order

Troubleshooting

• "Unsupported image format" — check the extension is one of: jpg, jpeg, png, gif, webp
• "File not found" — verify the file path; quotes may be needed for paths with spaces
• Poor transcription quality — try a higher resolution source image
• Empty or minimal output — the image may contain very little recognizable content

Convert PDF to Markdown

Extracts text from a PDF file using pdf-parse, detects scanned documents, and optionally formats the content with AI.

Conversion Workflow

- [ ] Step 1: Validate file
- [ ] Step 2: Extract text with pdf-parse
- [ ] Step 3: Detect scanned PDFs
- [ ] Step 4: Apply AI formatting (optional)
- [ ] Step 5: Add frontmatter and output

Step 1: Validate file

The file must exist and be readable. The command validates file access before attempting to parse.

Step 2: Extract text with pdf-parse

• Reads the PDF as a binary buffer
• Uses pdf-parse to extract plain text and metadata
• Available metadata: page count, PDF info dict (Title, Author, Creator, Producer, PDF version)

Step 3: Detect scanned PDFs

If the extracted text is fewer than 100 characters, the PDF is likely scanned or image-based. A warning blockquote is prepended:

This PDF appears to be scanned/image-based. Text extraction may be incomplete.

For scanned PDFs, consider using allmd image on individual page screenshots instead.

Step 4: Apply AI formatting

• AI receives the raw extracted text and restructures it into clean markdown
• For scanned PDFs with insufficient text, outputs # filename with a warning and raw text

Step 5: Add frontmatter and output

• Title: from PDF metadata info.Title if available, otherwise the filename
• Frontmatter fields: title, source, date, type ("pdf"), pages

CLI Usage

allmd pdf <file>
allmd pdf report.pdf -o report.md
allmd pdf "docs/*.pdf" -d output/

Best Practices

• AI formatting is most valuable for PDFs with complex layouts — it restructures columns, headers, and footers into linear markdown
• Check the page count in frontmatter to verify the full document was processed

Edge Cases

• Scanned/image-based PDFs: Detected via the 100-character threshold; text extraction will be poor or empty
• Password-protected PDFs: pdf-parse will fail; the file must be unprotected
• Complex table layouts: Text extraction follows PDF text ordering, which may not match visual reading order for multi-column layouts
• Very large PDFs: Entire file is loaded into memory; very large files may cause memory pressure
• Non-Latin text: Extraction depends on the PDF's embedded font encoding

Troubleshooting

• Empty or garbage output — the PDF is likely scanned; use allmd image on page screenshots instead
• "File not found" — verify the file path exists
• Jumbled text ordering — PDFs with multi-column layouts may extract text in unexpected order; AI formatting can help reorder
• Missing title — the PDF metadata may not include a Title field; the filename is used as fallback

Convert PowerPoint to Markdown

Reads a .pptx file, extracts text and speaker notes from slide XML using adm-zip, and formats as markdown sections.

Conversion Workflow

1. Validate file exists and has .pptx extension 2. Unzip PPTX (which is a ZIP archive) using adm-zip 3. Extract slides — parse ppt/slides/slide*.xml files, sorted by slide number 4. Extract notes — parse ppt/notesSlides/notesSlide*.xml files 5. Build markdown — each slide becomes a ## Slide N section with text and optional speaker notes 6. AI format — restructures into clean markdown via GPT-5-mini 7. Add frontmatter and output

Key Details

• Text extracted by parsing <a:p> (paragraph) and <a:t> (text run) XML elements
• Speaker notes included as blockquotes: > Speaker notes: ...
• Slides separated by --- horizontal rules
• XML entities (&, <, etc.) properly decoded
• Slide number placeholders filtered from notes

Frontmatter Fields

type: pptx
title: "Presentation Title"
source: "/path/to/slides.pptx"
slides: 15

CLI Usage

allmd pptx presentation.pptx
allmd pptx presentation.pptx -o slides.md
allmd pptx "decks/*.pptx" -d output/

Edge Cases

• Image-only slides: Show as (no text content)
• SmartArt/charts: Text within SmartArt XML may not be fully extracted
• Legacy `.ppt` format: Not supported (only .pptx)

Convert RSS/Atom Feed to Markdown

Fetches an RSS or Atom feed URL, parses it with rss-parser, and converts all items to markdown sections.

Conversion Workflow

1. Validate URL (auto-detected for URLs containing /feed, /rss, .xml, .atom) 2. Fetch and parse feed using rss-parser library 3. Build markdown — feed description as blockquote, each item as a ## Heading section 4. AI format — restructures into clean markdown via GPT-5-mini 5. Add frontmatter and output

Key Details

• Uses rss-parser library for RSS 2.0 and Atom feed parsing
• Each feed item includes: title, metadata (author, date, link), content, and categories/tags
• Item content rendered as markdown via htmlToMarkdown() (same Turndown engine as web converter)
• Falls back to contentSnippet or summary if full content is unavailable
• Markdown links in feed URLs are escaped to prevent injection (] → %5D, ) → %29)
• Items separated by --- horizontal rules

Frontmatter Fields

type: rss
title: "Feed Title"
source: "https://blog.example.com/feed"
items: 25
feedUrl: "https://blog.example.com/feed.xml"

CLI Usage

allmd rss https://blog.example.com/feed
allmd rss https://blog.example.com/feed.xml -o feed.md

Edge Cases

• Private feeds: Feeds requiring authentication will fail
• Large feeds: Feeds with hundreds of items may produce very long output
• Malformed feeds: rss-parser handles most variations but truly broken XML will fail
• HTML in content: Converted to markdown; complex layouts may lose formatting

Convert Tweet to Markdown

Fetches a tweet/X post via the Twitter oEmbed API and converts it to markdown.

Conversion Workflow

1. Validate URL is from twitter.com or x.com 2. Normalize URL to twitter.com format for oEmbed API 3. Fetch tweet content via Twitter oEmbed API (publish.twitter.com/oembed) 4. Fallback to web extraction via Readability if oEmbed fails 5. AI format — restructures into clean markdown via GPT-5-mini 6. Add frontmatter and output

Key Details

• Primary method: Twitter oEmbed API (no authentication required)
• Fallback: Web extraction using the same Readability engine as the web converter
• Author name and URL extracted from oEmbed response
• HTML entities in tweet text properly decoded
• pic.twitter.com links stripped from text

Frontmatter Fields

type: tweet
title: "Tweet by Author Name"
source: "https://x.com/user/status/123456"
author: "Author Name"

CLI Usage

allmd tweet https://x.com/user/status/123456
allmd tweet https://twitter.com/user/status/123456 -o tweet.md

Edge Cases

• Private/deleted tweets: Both oEmbed and web extraction will fail
• Threads: Only the linked tweet is extracted, not the full thread
• Media-only tweets: Text may be empty or minimal
• Rate limiting: oEmbed API may rate-limit with many requests

Convert Video/Audio to Markdown

Extracts audio from video files using ffmpeg, transcribes it with OpenAI Whisper via the Vercel AI Gateway, and formats the transcript as markdown.

Conversion Workflow

- [ ] Step 1: Validate file and format
- [ ] Step 2: Extract audio (video files only)
- [ ] Step 3: Transcribe with Whisper
- [ ] Step 4: Format transcript
- [ ] Step 5: Add frontmatter and output
- [ ] Step 6: Cleanup temp files

Step 1: Validate file and format

Video formats: .mp4, .mkv, .avi, .mov, .webm, .flv, .wmv, .m4v Audio formats: .mp3, .wav, .m4a, .ogg, .flac, .aac, .wma

Audio files skip the extraction step and go directly to transcription.

Step 2: Extract audio (video files only)

• Creates a temporary directory in the system temp folder
• Uses ffmpeg-extract-audio (with bundled ffmpeg-static) to extract audio as MP3
• Audio files bypass this step entirely

Step 3: Transcribe with Whisper

• Reads the audio file into a buffer
• Sends to OpenAI Whisper (whisper-1 model) via Vercel AI Gateway
• Returns: full text + timestamped segments (start time and text for each segment)

Step 4: Format transcript

Raw transcript text is sent to AI for structured prose formatting with paragraph breaks and structure.

Step 5: Add frontmatter and output

Frontmatter fields: title (filename), source (file path), date, type ("video")

Step 6: Cleanup temp files

Temporary audio files are always deleted, even if transcription fails (uses finally block).

CLI Usage

allmd video <file>
allmd video recording.mp4 -o transcript.md
allmd video podcast.mp3 -o podcast.md
allmd video interview.wav -o transcript.md

Best Practices

• Audio files (mp3, wav, etc.) are fully supported — not just video
• AI formatting works best for talks and interviews — it adds paragraph breaks and structure
• For best transcription quality, use source files with clear audio and minimal background noise

Edge Cases

• Very long recordings: Whisper has file size limits; large files may need to be split
• Multiple speakers: No speaker diarization — all speech is merged into a single stream
• Background music or noise: Degrades transcription accuracy significantly
• Non-English audio: Whisper auto-detects language but defaults may vary
• Corrupted media files: ffmpeg extraction may fail; check the source file plays correctly
• Files with no audio track: Some video files (e.g., screen recordings) may have no audio

Troubleshooting

• "Unsupported format" — check the file extension is in the supported list above
• ffmpeg errors — ensure ffmpeg is available; the ffmpeg-static npm package bundles it, but system-level issues can interfere
• Empty transcription — the audio may be silent, corrupted, or contain only music
• Garbled output — audio quality is too low; try a higher bitrate source

Convert Web Page to Markdown

Fetches a URL, renders and extracts the main page content with Firecrawl, then uses Firecrawl's markdown directly as the final allmd output with optional frontmatter.

Conversion Workflow

- [ ] Step 1: Validate URL
- [ ] Step 2: Extract markdown with Firecrawl
- [ ] Step 3: Use Firecrawl markdown directly
- [ ] Step 4: Add frontmatter and output

Step 1: Validate URL

• Must be a valid HTTP or HTTPS URL
• The page must be publicly accessible (no authentication)
• Uses Firecrawl, which can render JavaScript before extracting content

Step 2: Extract readable content

• Requires FIRECRAWL_API_KEY
• Uses Firecrawl's markdown extraction with onlyMainContent: true
• Supports JavaScript-rendered pages and harder sites better than a local HTML parser
• Extracts: title, content (markdown), excerpt, siteName
• Uses an explicit timeout for the Firecrawl scrape request

Step 3: Convert HTML to markdown

Firecrawl returns markdown directly, so the web converter no longer runs a separate HTML-to-markdown pass.

Step 4: Add frontmatter and output

Frontmatter fields: title, source, date, type ("web"), excerpt, siteName

CLI Usage

allmd web <url>
allmd web <url> -o article.md
allmd web <url> --no-frontmatter

Best Practices

• Set FIRECRAWL_API_KEY before using allmd web
• Use -v when debugging extraction latency or page-specific failures
• Use -o article.md when converting long pages so output is saved to disk instead of dumped to stdout
• Use Ctrl+C to interrupt a slow Firecrawl run

Edge Cases

• Paywalled content: Firecrawl can only extract what the service can access; paywalled output may still be partial
• Very dynamic pages: Some sites may still require longer render time or site-specific handling
• Large pages: Output can still be large even without an AI post-processing pass
• Hosted dependency: Web conversion now depends on Firecrawl availability and your API quota

Troubleshooting

• "Web conversion requires FIRECRAWL_API_KEY" — set FIRECRAWL_API_KEY in your environment or .env
• "Firecrawl timed out" — the page may need more render time or Firecrawl may be under load
• Need to stop a long-running conversion — press Ctrl+C to cancel the active Firecrawl request
• Empty or very short output — inspect the raw page in Firecrawl directly and retry with -v

Convert YouTube Video to Markdown

Extracts captions from a YouTube video, fetches video metadata via oEmbed, and formats the transcript as clean markdown.

Conversion Workflow

- [ ] Step 1: Validate YouTube URL
- [ ] Step 2: Extract video ID
- [ ] Step 3: Fetch metadata and captions
- [ ] Step 4: Format transcript
- [ ] Step 5: Add frontmatter and output

Step 1: Validate YouTube URL

Supported URL formats:

• https://www.youtube.com/watch?v=VIDEO_ID (standard)
• https://youtu.be/VIDEO_ID (short)
• https://www.youtube.com/embed/VIDEO_ID (embed)
• https://www.youtube.com/shorts/VIDEO_ID (shorts)

Step 2: Extract video ID

Regex extraction of the 11-character video ID from any of the 4 URL patterns above.

Step 3: Fetch metadata and captions

• Fetches video title and author via YouTube oEmbed API (no auth needed)
• Fetches transcript segments via youtube-transcript package (English captions, lang: 'en')
• Both requests run in parallel via Promise.all
• HTML entities in caption text are decoded (& → &, etc.)
• If no captions exist, throws "No captions available"

Step 4: Format transcript

Raw transcript text is sent to AI for structured prose formatting with paragraph breaks at topic changes.

Step 5: Add frontmatter and output

Frontmatter fields: title, source, date, type ("youtube"), videoId, author

CLI Usage

allmd youtube <url>
allmd yt <url>                    # alias
allmd youtube <url> -o transcript.md

Best Practices

• AI formatting works best for talks and lectures — it adds paragraph breaks at topic changes
• The oEmbed metadata provides the video title and channel name without any API key

Edge Cases

• No captions available: Video may be too new, have captions disabled, or be region-locked
• Auto-generated captions: No punctuation, potential word errors — AI formatting helps significantly
• Non-English videos: Defaults to lang: 'en'; non-English captions may not be fetched
• Live stream transcripts: May have gaps or lower quality auto-captions
• Music videos: Lyrics may be available as captions, but instrumental sections have no text

Troubleshooting

• "No captions available" — check if the video has captions enabled; very new uploads may not have them yet
• "Could not extract video ID" — verify the URL matches one of the 4 supported patterns
• Garbled or incorrect text — auto-generated captions have known accuracy issues; AI formatting can help clean them up