{"id":32,"date":"2026-11-11T14:42:26","date_gmt":"2026-11-11T14:42:26","guid":{"rendered":"https:\/\/globalcorpora.com\/blog\/yt-dlp-extract-youtube-metadata-json\/"},"modified":"2026-11-11T14:42:26","modified_gmt":"2026-11-11T14:42:26","slug":"yt-dlp-extract-youtube-metadata-json","status":"publish","type":"post","link":"https:\/\/globalcorpora.com\/blog\/yt-dlp-extract-youtube-metadata-json\/","title":{"rendered":"yt-dlp Metadata: Extract YouTube JSON Without Downloading Video"},"content":{"rendered":"<p>Before you spend bandwidth on video bytes, you want a table of every candidate video with its duration, license, language and caption tracks. yt-dlp can build that table without downloading any media, but the flags overlap in confusing ways: <code>-j<\/code> vs <code>-J<\/code>, flat vs full extraction, <code>--print<\/code> vs <code>--write-info-json<\/code>. This guide maps each yt-dlp metadata option to the job it does, lists the info.json fields worth keeping, and shows how to store them as JSONL and Parquet and filter before downloading. Flags were checked against the <a href=\"https:\/\/github.com\/yt-dlp\/yt-dlp\">yt-dlp README<\/a> and source at release <a href=\"https:\/\/github.com\/yt-dlp\/yt-dlp\/releases\/tag\/2026.10.26\">2026.10.26<\/a>.<\/p>\n<h2>TL;DR<\/h2>\n<ul>\n<li><strong>Two passes.<\/strong> First enumerate channels and playlists with <code>--flat-playlist<\/code>, which makes no per-video requests and returns thin records. Then run full extraction per video with <code>-j<\/code> or <code>--skip-download --write-info-json<\/code>.<\/li>\n<li><strong>Use <code>-j<\/code>, not <code>-J<\/code>, at scale.<\/strong> <code>-j<\/code> prints one JSON line per video. <code>-J<\/code> prints a whole playlist as a single line.<\/li>\n<li><strong>Use <code>-O<\/code>\/<code>--print<\/code> with <code>%(.{field,field})j<\/code><\/strong> to emit only the fields you need as compact JSON.<\/li>\n<li><strong>Pace extraction with <code>--sleep-requests<\/code>.<\/strong> <code>--sleep-interval<\/code> sleeps before each <em>download<\/em>, and a metadata-only run has none.<\/li>\n<li><strong>Filter on metadata<\/strong> (<code>duration<\/code>, <code>license<\/code>, <code>language<\/code>, <code>live_status<\/code>) in DuckDB or with <code>--match-filters<\/code>, then download only the IDs that pass.<\/li>\n<\/ul>\n<h2>The yt-dlp metadata flags at a glance<\/h2>\n<table>\n<thead>\n<tr>\n<th>Flag<\/th>\n<th>What it does (per the README)<\/th>\n<th>Use it for<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td><code>-j<\/code>, <code>--dump-json<\/code><\/td>\n<td>\"Quiet, but print JSON information for each video. Simulate unless <code>--no-simulate<\/code> is used.\"<\/td>\n<td>Streaming one record per video into a JSONL file<\/td>\n<\/tr>\n<tr>\n<td><code>-J<\/code>, <code>--dump-single-json<\/code><\/td>\n<td>One JSON per URL. For a playlist, \"the whole playlist information is dumped in a single line\".<\/td>\n<td>Small playlists, or when you need the playlist object itself<\/td>\n<\/tr>\n<tr>\n<td><code>--flat-playlist<\/code><\/td>\n<td>\"Do not extract a playlist's URL result entries; some entry metadata may be missing\"<\/td>\n<td>Cheap enumeration of channels and playlists<\/td>\n<\/tr>\n<tr>\n<td><code>--skip-download<\/code><\/td>\n<td>\"Do not download the video but write all related files\"<\/td>\n<td>Writing <code>.info.json<\/code>, subtitles and thumbnails without media<\/td>\n<\/tr>\n<tr>\n<td><code>--write-info-json<\/code><\/td>\n<td>Writes video metadata to a <code>.info.json<\/code> file<\/td>\n<td>One file per video, kept as raw provenance<\/td>\n<\/tr>\n<tr>\n<td><code>-O<\/code>, <code>--print [WHEN:]TEMPLATE<\/code><\/td>\n<td>Prints a field or output template. Implies <code>--quiet<\/code> and <code>--simulate<\/code>.<\/td>\n<td>Slim, custom records<\/td>\n<\/tr>\n<tr>\n<td><code>--print-to-file [WHEN:]TEMPLATE FILE<\/code><\/td>\n<td>Appends the template to a file<\/td>\n<td>Writing a side file (e.g. a URL list) during another run<\/td>\n<\/tr>\n<tr>\n<td><code>--ignore-no-formats-error<\/code><\/td>\n<td>Ignores \"No video formats\" errors. The README calls it useful \"for extracting metadata even if the videos are not actually available for download\" (experimental).<\/td>\n<td>Keeping metadata for videos whose formats fail<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<p>Because <code>-j<\/code> and <code>-O<\/code> imply simulate mode, nothing is written to disk except what you redirect. <code>--skip-download<\/code> is different: it still writes the side files you ask for (<code>.info.json<\/code>, subtitles, thumbnails), just not the media.<\/p>\n<h2>Step 1: Enumerate channels and playlists with <code>--flat-playlist<\/code><\/h2>\n<p>A flat run reads the channel or playlist pages and returns one stub per entry. It doesn't open any watch pages. In the YouTube tab extractor (<a href=\"https:\/\/github.com\/yt-dlp\/yt-dlp\/blob\/master\/yt_dlp\/extractor\/youtube\/_tab.py\"><code>extractor\/youtube\/_tab.py<\/code><\/a>), each stub is a <code>_type: \"url\"<\/code> result with <code>id<\/code>, <code>url<\/code>, <code>title<\/code> and, when the page shows them, <code>duration<\/code>, <code>view_count<\/code>, <code>channel_id<\/code>, <code>live_status<\/code> and <code>availability<\/code>. There is no license, language, tags or category at this stage.<\/p>\n<pre><code># one compact JSON object per upload on the channel's Videos tab\nyt-dlp --flat-playlist --lazy-playlist \\\n  -O \"%(.{id,url,title,duration,view_count,live_status,availability,channel_id})j\" \\\n  \"https:\/\/www.youtube.com\/@CHANNEL\/videos\" &gt; seeds\/CHANNEL_videos.jsonl\n\n# a playlist\nyt-dlp --flat-playlist -j \"https:\/\/www.youtube.com\/playlist?list=PLAYLIST_ID\" &gt; seeds\/PLAYLIST_ID.jsonl<\/code><\/pre>\n<p>Practical notes:<\/p>\n<ul>\n<li><strong>Pick the tab.<\/strong> A bare channel URL returns nested playlists, one per tab. The extractor's own test expects \"three playlists for videos, shorts and streams tabs\". Point at <code>\/videos<\/code>, <code>\/shorts<\/code> or <code>\/streams<\/code> explicitly so you know what you're counting.<\/li>\n<li><strong><code>--lazy-playlist<\/code><\/strong> processes entries as they arrive, so output starts streaming before the whole channel is paged. It disables <code>n_entries<\/code>, <code>--playlist-random<\/code> and <code>--playlist-reverse<\/code>.<\/li>\n<li><strong>Sampling.<\/strong> <code>-I 1:500<\/code> (<code>--playlist-items<\/code>) limits the run to the first 500 entries, which helps when you're sizing a channel before committing.<\/li>\n<li><strong>Dates.<\/strong> Flat entries have no <code>upload_date<\/code> by default. <code>--extractor-args \"youtubetab:approximate_date\"<\/code> parses the \"3 weeks ago\" text into a timestamp. The README warns it \"may cause date-based filters to be slightly off\", so use it for ordering and coarse cuts only.<\/li>\n<\/ul>\n<p>The <code>%(.{a,b,c})j<\/code> syntax comes from the README's output template section: an empty field name refers to the whole info dict, <code>{}<\/code> selects keys, and the <code>j<\/code> conversion emits JSON. It gives you a slim JSONL without a <code>jq<\/code> step.<\/p>\n<h2>Step 2: Full metadata per video, without media<\/h2>\n<p>Full extraction opens each watch page and player response. That's where <code>license<\/code>, <code>categories<\/code>, <code>tags<\/code>, <code>chapters<\/code>, captions and formats come from. You have two output styles.<\/p>\n<h3>Option A: stream JSONL with <code>-j<\/code><\/h3>\n<pre><code>yt-dlp -a urls.txt -j \\\n  --ignore-no-formats-error \\\n  --sleep-requests 1 \\\n  --retry-sleep extractor:exp=1:120 \\\n  &gt;&gt; meta\/full.jsonl 2&gt;&gt; meta\/errors.log<\/code><\/pre>\n<p>One line per video, appended. The default <code>--no-abort-on-error<\/code> keeps going after unavailable videos, and the errors land in the log for a retry pass. <code>--retry-sleep<\/code> accepts a type prefix (<code>http<\/code>, <code>fragment<\/code>, <code>file_access<\/code>, <code>extractor<\/code>) and <code>linear=<\/code>\/<code>exp=<\/code> expressions.<\/p>\n<h3>Option B: one <code>.info.json<\/code> per video<\/h3>\n<pre><code>yt-dlp -a urls.txt --skip-download --write-info-json \\\n  --no-write-playlist-metafiles \\\n  -o \"meta\/%(id).2s\/%(id)s.%(ext)s\" \\\n  --sleep-requests 1 \\\n  --download-archive meta_archive.txt --force-write-archive<\/code><\/pre>\n<ul>\n<li><code>%(id).2s<\/code> shards files into subdirectories by the first two characters of the ID. Nobody wants a million files in one directory.<\/li>\n<li><code>--clean-info-json<\/code> is the default and strips internal fields such as filenames. <code>--no-clean-info-json<\/code> keeps everything.<\/li>\n<li><code>--no-write-playlist-metafiles<\/code> skips the extra playlist-level <code>.info.json<\/code> when your input is a playlist URL.<\/li>\n<li><strong>Archive gotcha:<\/strong> in simulate or skip-download mode, archive entries are only written with <code>--force-write-archive<\/code>. Also, yt-dlp records <em>flat<\/em> entries in the archive too when that flag is on (see <code>process_ie_result<\/code> in <a href=\"https:\/\/github.com\/yt-dlp\/yt-dlp\/blob\/master\/yt_dlp\/YoutubeDL.py\"><code>YoutubeDL.py<\/code><\/a>). Keep a separate archive file per stage, or your enumeration run will mark every ID as already done.<\/li>\n<\/ul>\n<p>Option A is easier to ingest. Option B gives you an immutable per-video record you can hash and keep as lineage. Many teams do B and derive a slim JSONL from it.<\/p>\n<h2>Which info.json fields matter<\/h2>\n<p>Field names below come from the README's output template list and the info dict spec in <a href=\"https:\/\/github.com\/yt-dlp\/yt-dlp\/blob\/master\/yt_dlp\/extractor\/common.py\"><code>extractor\/common.py<\/code><\/a>. Example values come from the YouTube extractor's tests. Any field can be missing, and <code>None<\/code> means \"unknown\".<\/p>\n<table>\n<thead>\n<tr>\n<th>Field<\/th>\n<th>Type \/ example<\/th>\n<th>Notes<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td><code>id<\/code>, <code>title<\/code>, <code>description<\/code><\/td>\n<td>string<\/td>\n<td>The 11-character video ID is your primary key.<\/td>\n<\/tr>\n<tr>\n<td><code>duration<\/code><\/td>\n<td>seconds (int or float)<\/td>\n<td>Also available as <code>duration_string<\/code> (HH:mm:ss).<\/td>\n<\/tr>\n<tr>\n<td><code>upload_date<\/code>, <code>timestamp<\/code><\/td>\n<td><code>\"20080529\"<\/code>, Unix time<\/td>\n<td><code>upload_date<\/code> is UTC, <code>YYYYMMDD<\/code>.<\/td>\n<\/tr>\n<tr>\n<td><code>channel<\/code>, <code>channel_id<\/code>, <code>uploader_id<\/code><\/td>\n<td><code>\"UCSMOQeBJ2RAnuFungnQOxLg\"<\/code>, <code>\"@BlenderOfficial\"<\/code><\/td>\n<td>Use <code>channel_id<\/code> for joins. Handles can change.<\/td>\n<\/tr>\n<tr>\n<td><code>license<\/code><\/td>\n<td><code>\"Creative Commons Attribution license (reuse allowed)\"<\/code> or <code>\"Standard YouTube License\"<\/code><\/td>\n<td>Treat a missing value as unknown, not as CC.<\/td>\n<\/tr>\n<tr>\n<td><code>categories<\/code><\/td>\n<td>list, e.g. <code>[\"Film &amp; Animation\"]<\/code><\/td>\n<td>One YouTube category per video, wrapped in a list.<\/td>\n<\/tr>\n<tr>\n<td><code>tags<\/code><\/td>\n<td>list of strings<\/td>\n<td>Uploader-supplied and noisy, but useful for topic balancing.<\/td>\n<\/tr>\n<tr>\n<td><code>language<\/code><\/td>\n<td><code>\"en\"<\/code><\/td>\n<td>Not in the generic spec. For YouTube it is a format-level field (the audio track's language, or inferred from the original-language auto-caption track) that ends up on the info dict from the selected format. Often absent.<\/td>\n<\/tr>\n<tr>\n<td><code>view_count<\/code>, <code>like_count<\/code>, <code>comment_count<\/code><\/td>\n<td>int<\/td>\n<td>A snapshot, so store <code>epoch<\/code> (extraction time) next to it.<\/td>\n<\/tr>\n<tr>\n<td><code>live_status<\/code><\/td>\n<td><code>not_live<\/code>, <code>is_live<\/code>, <code>is_upcoming<\/code>, <code>was_live<\/code>, <code>post_live<\/code><\/td>\n<td>Drop <code>is_live<\/code>\/<code>is_upcoming<\/code>. Decide whether <code>was_live<\/code> streams fit your data.<\/td>\n<\/tr>\n<tr>\n<td><code>availability<\/code>, <code>age_limit<\/code><\/td>\n<td><code>\"public\"<\/code>, <code>0<\/code><\/td>\n<td>Skip anything needing sign-in.<\/td>\n<\/tr>\n<tr>\n<td><code>chapters<\/code><\/td>\n<td>list of <code>{start_time, end_time, title}<\/code><\/td>\n<td>Free, creator-made segmentation, useful for clip boundaries.<\/td>\n<\/tr>\n<tr>\n<td><code>heatmap<\/code><\/td>\n<td>list of <code>{start_time, end_time, value}<\/code><\/td>\n<td>Normalized \"most replayed\" curve, values 0\u20131.<\/td>\n<\/tr>\n<tr>\n<td><code>subtitles<\/code>, <code>automatic_captions<\/code><\/td>\n<td><code>{lang: [{ext, url, name}]}<\/code><\/td>\n<td>Manual vs ASR tracks. Keep the key lists, drop the URLs.<\/td>\n<\/tr>\n<tr>\n<td><code>formats<\/code>, <code>thumbnails<\/code><\/td>\n<td>lists of dicts<\/td>\n<td>Most of the file's size. Stream URLs are short-lived, so store the format properties you filter on (<code>height<\/code>, <code>fps<\/code>, <code>vcodec<\/code>), not the URLs.<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<p>The caption keys are the cheapest language signal you have. A video with manual <code>en<\/code> subtitles, or an <code>en-orig<\/code> key in <code>automatic_captions<\/code>, very likely has English speech. The details of manual, ASR and translated tracks are in our <a href=\"https:\/\/globalcorpora.com\/blog\/yt-dlp-download-subtitles-auto-captions\/\">yt-dlp subtitles guide<\/a>.<\/p>\n<h2>Storing metadata as JSONL and Parquet<\/h2>\n<p>Raw <code>-j<\/code> lines are wide and nested, and the <code>formats<\/code> list varies from video to video. That makes schema inference messy. A pattern that works: keep the raw JSON compressed as provenance, and project a flat row for analytics.<\/p>\n<pre><code>import gzip\nimport json\nimport sys\n\nfrom yt_dlp.version import __version__ as YTDLP_VERSION\n\nKEEP = [\"id\", \"title\", \"duration\", \"upload_date\", \"timestamp\", \"channel_id\",\n        \"channel\", \"license\", \"language\", \"categories\", \"tags\", \"view_count\",\n        \"like_count\", \"comment_count\", \"age_limit\", \"availability\",\n        \"live_status\", \"webpage_url\", \"epoch\"]\n\n\ndef project(info):\n    row = {k: info.get(k) for k in KEEP}\n    row[\"chapters\"] = [\n        {\"start\": c.get(\"start_time\"), \"end\": c.get(\"end_time\"), \"title\": c.get(\"title\")}\n        for c in info.get(\"chapters\") or []\n    ]\n    row[\"manual_sub_langs\"] = sorted(info.get(\"subtitles\") or {})\n    row[\"asr_orig_langs\"] = sorted(\n        k for k in (info.get(\"automatic_captions\") or {}) if k.endswith(\"-orig\"))\n    row[\"max_height\"] = max(\n        (f.get(\"height\") or 0 for f in info.get(\"formats\") or []), default=0)\n    row[\"ytdlp_version\"] = YTDLP_VERSION\n    return row\n\n\n# usage: python project.py meta\/full.jsonl meta\/raw.jsonl.gz &gt; meta\/slim.jsonl\nwith open(sys.argv[1], encoding=\"utf-8\") as src, \\\n        gzip.open(sys.argv[2], \"at\", encoding=\"utf-8\") as raw:\n    for line in src:\n        info = json.loads(line)\n        raw.write(line)\n        print(json.dumps(project(info), ensure_ascii=False))<\/code><\/pre>\n<p>Then convert to Parquet with <a href=\"https:\/\/duckdb.org\/docs\/2.0\/data\/json\/overview.html\">DuckDB's JSON reader<\/a> and query it directly:<\/p>\n<pre><code>duckdb -c \"COPY (SELECT * FROM read_json('meta\/slim.jsonl', format = 'newline_delimited'))\n           TO 'meta\/slim.parquet' (FORMAT parquet)\"<\/code><\/pre>\n<p>Record <code>epoch<\/code> and <code>ytdlp_version<\/code> on every row. Counts drift, and extractor behavior changes between releases. When a field looks wrong six months later, you'll want to know which version produced it. For the wider pipeline (sharding, checksums, lineage), see <a href=\"https:\/\/globalcorpora.com\/blog\/build-youtube-video-dataset-for-multimodal-training\/\">building a YouTube video dataset for multimodal training<\/a>.<\/p>\n<h2>Pre-filter before downloading<\/h2>\n<p>This is where metadata pays for itself. Two places to filter:<\/p>\n<h3>In SQL, on the Parquet table<\/h3>\n<pre><code>COPY (\n  SELECT 'https:\/\/www.youtube.com\/watch?v=' || id\n  FROM 'meta\/slim.parquet'\n  WHERE duration BETWEEN 60 AND 3600\n    AND live_status = 'not_live'\n    AND availability = 'public'\n    AND license LIKE 'Creative Commons%'\n    AND (language LIKE 'en%' OR list_contains(asr_orig_langs, 'en-orig'))\n    AND max_height &gt;= 720\n) TO 'download_urls.txt' (FORMAT csv, HEADER false);<\/code><\/pre>\n<p>SQL lets you rerun with different thresholds without touching YouTube again, check how many hours each filter removes, and balance categories before you commit bandwidth. To turn the surviving durations into a bandwidth estimate, see <a href=\"https:\/\/globalcorpora.com\/blog\/bandwidth-for-large-scale-video-downloads\/\">bandwidth for large-scale video downloads<\/a>.<\/p>\n<h3>Inline, with <code>--match-filters<\/code><\/h3>\n<pre><code>yt-dlp -a urls.txt -j \\\n  --match-filters \"duration&gt;=60 &amp; duration&lt;=3600 &amp; !is_live &amp; license*='Creative Commons' &amp; language^=en\" \\\n  --sleep-requests 1 &gt;&gt; meta\/filtered.jsonl<\/code><\/pre>\n<p>Rules from the README: any output-template field can be compared, <code>!field<\/code> checks that a field is not present, <code>&amp;<\/code> joins conditions, and passing <code>--match-filters<\/code> twice ORs them. A comparison on a missing field fails unless you add <code>?<\/code> (e.g. <code>like_count&gt;?100<\/code>). For <code>license<\/code> that strict default is what you want. For <code>language<\/code> it can drop good videos that simply lack the field, which is one more reason to filter in SQL, where you can fall back to caption keys. More on license filtering in <a href=\"https:\/\/globalcorpora.com\/blog\/creative-commons-youtube-videos-for-ai-training\/\">our Creative Commons guide<\/a>. For speech-specific language rules, see the <a href=\"https:\/\/globalcorpora.com\/blog\/yt-dlp-audio-only-download-for-speech-datasets\/\">audio-only download guide<\/a>.<\/p>\n<h2>Rate limiting and failure handling<\/h2>\n<ul>\n<li><strong><code>--sleep-requests SECONDS<\/code><\/strong>: \"sleep between requests during data extraction\". This is the main throttle for metadata runs.<\/li>\n<li><strong><code>--sleep-interval<\/code> \/ <code>--max-sleep-interval<\/code><\/strong>: a randomized sleep \"before each download\". With <code>-j<\/code> or <code>--skip-download<\/code> there is no media download, so these do little here. Use them in the download stage.<\/li>\n<li><strong><code>-t sleep<\/code><\/strong> expands to <code>--sleep-subtitles 5 --sleep-requests 0.75 --sleep-interval 10 --max-sleep-interval 20<\/code>. That's a reasonable starting point when you also fetch captions.<\/li>\n<li><strong>Parallelism.<\/strong> Throughput comes from running several workers on disjoint ID shards, each with its own sleep settings and egress. A single process with a short sleep tends to get you blocked. If you see \"Sign in to confirm you're not a bot\", read <a href=\"https:\/\/globalcorpora.com\/blog\/yt-dlp-sign-in-to-confirm-not-a-bot\/\">our fix guide<\/a>. For per-worker egress, see <a href=\"https:\/\/globalcorpora.com\/blog\/yt-dlp-proxy-guide\/\">the yt-dlp proxy guide<\/a>.<\/li>\n<li><strong>Dependencies.<\/strong> The README lists <code>yt-dlp-ejs<\/code> plus a JavaScript runtime (deno recommended) as required for full YouTube support. A <code>-j<\/code> run still resolves formats, so install them for metadata jobs too, and stay on a current release.<\/li>\n<li><strong>Resumability.<\/strong> Use <code>--download-archive<\/code> with <code>--force-write-archive<\/code>, or dedupe on <code>id<\/code> against your JSONL before each run.<\/li>\n<\/ul>\n<h2>Compliance<\/h2>\n<p>YouTube's Terms of Service restrict automated access and downloading, and that applies to metadata collection as well as media. Copyright and licensing determine what you can train on and redistribute. Filtering on <code>license<\/code> helps, but record it per sample. The README notes that info.json \"may contain personal information\", and titles, descriptions and channel names can be personal data under GDPR. So can faces and voices in any media you fetch later. Honor takedown and opt-out requests, and keep the lineage (ID, channel, extraction time) you need to act on them. Get legal review for your jurisdiction and use case.<\/p>\n<h2>If you'd rather not run this yourself<\/h2>\n<p>Corpora offers <a href=\"https:\/\/globalcorpora.com\/#pricing\">dedicated 1\u201340 Gbps unmetered proxy capacity<\/a> (HTTP(S) and SOCKS5, compatible with yt-dlp) for teams running their own metadata and download workers. There's also a fully managed option that delivers YouTube metadata, video, audio and subtitles as JSONL\/Parquet with sha256 checksums and manifests to S3, GCS or Azure Blob, starting with a free sample batch. <a href=\"https:\/\/globalcorpora.com\/#contact\">Contact us<\/a> to scope it.<\/p>\n<h2>FAQ<\/h2>\n<h3>How do I get YouTube video metadata with yt-dlp without downloading the video?<\/h3>\n<p>Run <code>yt-dlp -j URL<\/code>. It prints the full info dict as JSON and simulates, so no media is downloaded. Use <code>--skip-download --write-info-json<\/code> instead if you want a <code>.info.json<\/code> file per video.<\/p>\n<h3>What's the difference between <code>-j<\/code> and <code>-J<\/code>?<\/h3>\n<p><code>-j<\/code> (<code>--dump-json<\/code>) prints one JSON object per video. <code>-J<\/code> (<code>--dump-single-json<\/code>) prints one object per input URL, so a playlist becomes a single line containing every entry. For large channels, <code>-j<\/code> streams better and fails per video instead of per playlist.<\/p>\n<h3>How do I list all video IDs on a channel quickly?<\/h3>\n<p><code>yt-dlp --flat-playlist -O \"%(id)s\" \"https:\/\/www.youtube.com\/@CHANNEL\/videos\"<\/code>. Flat mode doesn't open each video, so it's fast, but entries lack license, tags and exact dates.<\/p>\n<h3>Why is <code>language<\/code> missing from my yt-dlp JSON?<\/h3>\n<p>For YouTube, <code>language<\/code> comes from the selected format's audio track metadata or from the original-language auto-caption track. Many videos expose neither. Fall back to the <code>subtitles<\/code> and <code>automatic_captions<\/code> keys, and confirm with audio language ID after download.<\/p>\n<h3>Does <code>--sleep-interval<\/code> slow down metadata extraction?<\/h3>\n<p>Not meaningfully. It applies before each media download. For <code>-j<\/code> and <code>--skip-download<\/code> runs, use <code>--sleep-requests<\/code>.<\/p>\n","protected":false},"excerpt":{"rendered":"<p>Extract yt-dlp metadata at scale without downloading media: -j vs -J, --flat-playlist, info.json fields, JSONL\/Parquet storage and pre-filtering by license.<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[1],"tags":[82,81,77,80,7],"class_list":["post-32","post","type-post","status-publish","format-standard","hentry","category-guides","tag-data-pipelines","tag-info-json","tag-parquet","tag-youtube-metadata","tag-yt-dlp"],"_links":{"self":[{"href":"https:\/\/globalcorpora.com\/blog\/wp-json\/wp\/v2\/posts\/32","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/globalcorpora.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/globalcorpora.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/globalcorpora.com\/blog\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/globalcorpora.com\/blog\/wp-json\/wp\/v2\/comments?post=32"}],"version-history":[{"count":0,"href":"https:\/\/globalcorpora.com\/blog\/wp-json\/wp\/v2\/posts\/32\/revisions"}],"wp:attachment":[{"href":"https:\/\/globalcorpora.com\/blog\/wp-json\/wp\/v2\/media?parent=32"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/globalcorpora.com\/blog\/wp-json\/wp\/v2\/categories?post=32"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/globalcorpora.com\/blog\/wp-json\/wp\/v2\/tags?post=32"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}