You open a YouTube page. The video is public. You need that video - or its transcript, or its metadata, or just a clean download link you can pass to the next step in your workflow.
So you search for a YouTube video downloader. You find a browser extension, a sketchy website, maybe a command-line tool. You paste the URL. It works - once. But you have twenty more URLs to process. Or you need to run this same task every Monday morning. Or three people on your team need to do the same thing without using three different methods and getting three different outputs.
That is where every basic downloader starts to fall apart.
YouTube Video Downloader is an Apify Actor built to solve exactly this problem. It processes public YouTube watch URLs, YouTube Shorts, and live replay links in a structured, repeatable, automatable way. You get download format URLs, video metadata, thumbnails, channel data, and optional transcript text - all in one clean dataset output per run.
This guide will show you exactly how it works, how to configure it, and why it is a better fit than generic one-off tools if your workflow involves more than one video or one person.
What the YouTube Video Downloader Actor does
Most downloader tools treat the task as simple: give them a URL and they give you a file. That is fine if that is truly all you need.
But most teams need a bit more. They need the title and description to track what they downloaded. They need the thumbnail to display in a content board. They need the transcript to feed into a summarization or search tool. And they need all of this in a format that works with the rest of their stack - not a browser download that lands in someone's desktop folder.
YouTube Video Downloader handles all of that in one run. Here is what it can return for each URL you give it:
- Direct download URLs for available MP4 and WebM formats
- Progressive (video + audio combined) and adaptive (video-only or audio-only) stream metadata
- Video title, description, tags, and view count
- Channel name and channel ID
- Duration in seconds
- Thumbnail URL (including the high-resolution version when available)
- Media type - regular video, Short, or live replay
- Public transcript text when available and enabled
- A saved file in the run's key-value store when you use file export mode
The Actor runs on the Apify platform, which means you are not limited to a single manual session. You can run it from Apify Console, call it via API from your own application, schedule it on a recurring basis, or trigger it with a webhook. The output lands in a structured dataset you can export in JSON, CSV, or Excel.
Who this Actor is actually useful for
Before you decide whether this tool is worth using, it helps to know whether your situation matches how it was designed.
Content and editorial teams are a natural fit. If your team regularly works with public video assets - for clipping, repurposing, archiving, or editorial reference - you likely need more than the video file itself. You need the metadata alongside it. The Actor gives you both in a consistent format, run after run.
Agencies and operations teams benefit most from the repeatability. When different people handle different requests manually, the output is inconsistent. One person uses one site, another uses a different tool. The Actor standardizes the intake: one input format, one output structure, every time.
Developers and product teams often want a YouTube video downloader API - something they can call from inside their application or automation, not something they have to operate manually. The Actor exposes a full REST API and is also available through the JavaScript and Python client libraries. You can integrate it into any stack in a few lines of code.
Researchers and analysts who work with transcripts, topic metadata, or structured video data will find the Actor useful for building consistent datasets from public YouTube content. Instead of scraping each video manually, you can pass a list of URLs and get back a single structured export.
Why browser-based downloaders are not enough
It is worth being direct about this, because plenty of people reading this article have already tried the obvious alternatives.
Browser-based YouTube downloader sites work for one-off tasks. You paste a link, download a file, and you are done. But they are built for individual, manual use. They do not give you metadata. They do not store transcripts. They do not support API access. They do not let you schedule a run or trigger one programmatically. And they definitely do not output a structured dataset you can hand to the next step in a pipeline.
There is also the reliability issue. Many of these sites change frequently, break without warning, or quietly stop working after YouTube updates. If you build a team process around one of them, you are building on unstable ground.
The YouTube Video Downloader Actor approaches the problem differently. Direct format URLs returned by YouTube are time-limited - they expire. The Actor solves this by giving you two options: use the expiring URL for immediate access, or switch to save-best-progressive mode and have the Actor store a durable copy in Apify's key-value store. From there, you can fetch it via a stable URL for as long as you need it.
Step-by-step: how to download public YouTube videos with Apify
Here is exactly how to run the Actor and get results.
Step 1: Open the Actor in Apify Console
Go to the YouTube Video Downloader page in Apify Store. If you do not have an Apify account yet, you can sign up for free - no credit card required to start.
Once you are in, click Try for free to open the Actor in Apify Console. You will land on the Input tab, which is where you configure everything before running.
Step 2: Add your YouTube URLs
In the YouTube video URLs field, paste one or more public YouTube links. The Actor supports:
- Standard watch links:
https://www.youtube.com/watch?v=... - YouTube Shorts:
https://www.youtube.com/shorts/... - Live replay links for completed live streams
You can add up to 100 URLs per run (controlled by the Max videos input field, which defaults to 10). If you have a longer list, you can run multiple jobs or call the Actor programmatically in batches.
Step 3: Choose your download mode
This is where the Actor becomes more powerful than a generic downloader. Under Download mode, you have two options:
- metadata-only - The Actor returns format URLs, metadata, and optional transcript data. No file is saved. This is the default mode and the fastest way to get structured output. Use this when you only need the download link or metadata to pass downstream.
- save-best-progressive - The Actor selects the best available progressive format (video + audio combined), downloads it, and stores the file in the run's default key-value store. You can then fetch it via a stable Apify URL.
Set your preferred quality (best, 720p, 1080p, etc.) and container (mp4, webm, or any) to guide which format gets selected when saving.
Step 4: Configure the rest of your input
A few more fields worth knowing:
- Include transcript - Toggle this on if you need the public transcript text. When available, it gets included in the dataset output for each video. Useful for search indexing, summarization, and AI enrichment.
- Include progressive formats - Returns combined video + audio formats in the output. On by default.
- Include adaptive formats - Returns video-only and audio-only streams separately. On by default. Useful if you are working with adaptive streaming workflows.
- Max formats per video - Limits how many format entries appear in the output. Default is 8. Increase this if you want to see the full list of available streams.
-
Max saved file size (MB) - A safety cap when using
save-best-progressivemode. Defaults to 150 MB. Increase if you are working with longer videos and have confirmed the file will fit.
Here is an example input that covers most use cases:
{
"startUrls": [
{ "url": "https://www.youtube.com/watch?v=dQw4w9WgXcQ" },
{ "url": "https://www.youtube.com/shorts/abc123" }
],
"maxVideos": 10,
"preferredQuality": "720p",
"preferredContainer": "mp4",
"includeProgressiveFormats": true,
"includeAdaptiveFormats": false,
"downloadMode": "metadata-only",
"includeTranscript": true,
"maxDownloadSizeMb": 150
}
Step 5: Start the run
Click Start in Apify Console. The Actor processes each URL in sequence, resolves the available formats, collects the metadata, and pushes one item to the dataset for each URL it handles.
You do not need to keep the browser open. Apify Console shows run status in real time, and you can come back when it is done. For large batches or scheduled runs, you will not be watching at all - the output will just be there when you need it.
Step 6: Review and use the output
Once the run finishes, open the Dataset tab. You will see one row per input URL. Each row has:
| Field | What it gives you |
|---|---|
status |
ready, downloaded, or error
|
videoId |
The normalized YouTube video ID |
title |
The video title from YouTube |
mediaType |
Video, Short, or live replay |
durationSeconds |
Runtime in seconds |
viewCount |
Public view count at the time of the run |
thumbnailUrl |
High-resolution thumbnail URL |
formats |
All returned format entries with stream URLs and quality labels |
transcript |
Public transcript text (if enabled and available) |
selectedDownload |
Key-value store key and public URL of saved file (if applicable) |
You can export the dataset from the Export button as JSON, CSV, or Excel. If you saved files using save-best-progressive mode, they appear in the Storage tab under the run's key-value store.
How to integrate the Actor into your own code
If you want to call the Actor programmatically - for example, from an internal tool, a script, or a larger automation - the easiest way is through the official Apify client libraries.
JavaScript / TypeScript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });
const run = await client.actor('eunit/youtube-video-downloader').call({
startUrls: [{ url: 'https://www.youtube.com/watch?v=dQw4w9WgXcQ' }],
downloadMode: 'metadata-only',
includeTranscript: true,
preferredQuality: '720p',
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
Python
from apify_client import ApifyClient
client = ApifyClient("YOUR_API_TOKEN")
run = client.actor("eunit/youtube-video-downloader").call(run_input={
"startUrls": [{"url": "https://www.youtube.com/watch?v=dQw4w9WgXcQ"}],
"downloadMode": "metadata-only",
"includeTranscript": True,
"preferredQuality": "720p",
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
print(item)
Install the client with pip install apify-client (Python) or npm install apify-client (JavaScript/TypeScript). Your API token is in Apify Console under Settings > Integrations.
A note on legal and responsible use
Any good guide on YouTube video downloading should address this clearly.
The YouTube Video Downloader Actor is built for public YouTube content - videos that are publicly visible without login. That does not automatically mean every public video is fair game to download, archive, or redistribute.
YouTube's terms of service generally prohibit downloading videos without explicit permission from the platform or the content owner. There are exceptions for content you own, content licensed for download, and content in the public domain - but those are the exceptions, not the default.
If you are asking how to download YouTube videos legally, the clearest answer is: work with content you own, content you have been licensed to use, or content in the public domain. If you are unsure about a specific piece of content, check with a qualified legal advisor, not a downloader tool's FAQ.
For teams, this matters even more. A repeatable workflow that processes video at scale creates a larger footprint. Good compliance means having clear answers to: what content are we allowed to process, where does the output go, and who approved it.
The Actor helps you build a consistent, auditable workflow. The permissions question is something you need to answer before you run it.
Common use cases where the Actor earns its cost
If you are comparing this Actor against free browser-based tools, the question is not whether the free tool works for one video. It usually does. The question is what your workflow actually costs.
Content repurposing pipelines. If your team regularly turns public video into clips, summaries, or knowledge-base articles, you need the transcript and metadata alongside the media file. The Actor gives you all three in one run, in a structured format that fits your next tool.
Approved asset management. Agencies and media teams that manage approved public video assets across campaigns or clients need consistency. The Actor standardizes the output, so every URL processed the same way, by anyone on the team, gives the same fields.
AI and research workflows. Transcripts combined with metadata - title, tags, description, view count, duration - are a useful input for classification, topic modeling, or AI summarization pipelines. The Actor gives you a clean starting point for that kind of enrichment.
Product integration. If you are building an internal tool or product feature that involves YouTube video data, the Actor is a faster path than building and maintaining your own downloader infrastructure. You call an API, you get structured output, and you handle the hard part (your product logic) rather than YouTube format resolution.
Why automation changes the value equation
Here is a way to think about whether the Actor is worth paying for.
If you download five YouTube videos a month manually, the cost of manual work is low. A free tool is probably fine.
If you process fifty URLs every week across a team of three people, the math changes. Manual work is time, and time is money. If each URL takes five minutes to process by hand (finding the right tool, pasting the link, downloading the file, renaming it, noting the metadata, passing it to the next step), that is over four hours of manual work per week. At scale, or across a team, that adds up fast.
The real cost of manual tools is not the tool's price. It is the time spent, the inconsistency in output, and the fragility when the tool breaks or the website changes.
For teams that process video data regularly, the automation pays for itself quickly. And for teams that need scheduled or API-triggered runs - the kind of workflow that simply cannot be done with a manual tool - the comparison is not really about price at all.
Frequently asked questions
Can this Actor download YouTube Shorts?
Yes. The Actor supports public YouTube Shorts URLs. They are handled as a supported media type and included in the dataset output with the mediaType field set to Short.
Does it return direct download links?
Yes. When available, the Actor returns direct format URLs in the formats array. These URLs are time-limited, so use them promptly or switch to save-best-progressive mode to get a durable stored copy.
Can it save the video file, not just the URL?
Yes. Set downloadMode to save-best-progressive and the Actor will select the best available progressive format, download it, and store it in the run's key-value store. You can then access it via a stable public URL from the selectedDownload field.
Can it extract transcripts?
Yes, when the video has a public transcript and you enable the includeTranscript option. Not all videos have public transcripts, and in those cases the Actor returns a structured item without transcript data rather than failing the run.
Does it work for live replays?
Yes. Completed live streams that are publicly available on YouTube are supported as a media type. The Actor handles them the same way as regular videos.
Can I run this on a schedule or trigger it with a webhook?
Yes. Scheduled runs and webhook triggers are both available from Apify Console. You can also call the Actor via the REST API or the official client libraries to integrate it into any external system.
Why use this instead of a free downloader?
Because free downloaders are built for one-off, manual, single-user tasks. They do not return structured metadata. They do not support transcripts. They do not give you API access, scheduled runs, or structured exports. And they break without warning. If your workflow involves more than one video, more than one person, or more than a one-time task, a structured Actor on a stable platform is a significantly better fit.
Wrapping Up
If you have a workflow that involves downloading public YouTube videos - or extracting metadata, transcripts, thumbnails, or stream format data from them - YouTube Video Downloader is built for exactly that.
You can start with a single public URL, review the dataset output, and see in one run how much cleaner and more useful the output is compared to what you get from a browser-based tool.
From there, you can scale up to batches, schedule recurring runs, or connect it to your own code using the Apify JavaScript or Python clients.
Top comments (0)