All Video Scraper

Download one public video or read metadata only, from YouTube, TikTok, Instagram, X, Twitch and 1000+ more sites. All Video Scraper brings source links, titles, creator details, duration and engagement into one place for research, editing and content planning. Paste one video link and choose Metadata Only or request an MP4 download; open the Dataset for the result.

Open input | Integrations | Pricing

Why Choose All Video Scraper

• One library across sources. Keep video titles, source links and author details under the same field names when your research spans different sites.
• A file or a catalog entry. Request an MP4 for an editing workflow, or choose Metadata Only when you only need the video facts.
• Keep the original in view. Retain source_url beside the saved file link so an editor or researcher can return to the original page.
• Compare snapshots with context. Use available engagement counts and processed_at in your own reporting, keeping missing counts distinct from zero.

Quick Start Guide

1. Open this Actor's input form and use the public link below. Keep Video Quality on Metadata Only for the first lookup.
2. Click Start once. Keep the run ID so you can return to that same run if your client stops waiting.
3. Open the run's Dataset. Export JSON for complete nested data or CSV for spreadsheet work. A file request also places its saved MP4 link in video when successful.

Use the prefilled link below for a first metadata request. The integration examples use this same input:

{
  "video_url": "https://www.youtube.com/watch?v=jNQXAC9IVRw",
  "video_quality": "metadata",
  "max_comments": 0
}

A metadata record contains the source identity and video facts; video is reserved for a saved MP4. At the FREE tier, one metadata row costs $0.1 plus Actor Usage. This includes $0.01 Actor Start and $0.09 Metadata. A zero-row run still has the startup charge and any accrued usage. The FREE pricing tier is not a free-run offer.

Input Configuration

Use one individual public video page. On supported pages containing several videos, the Actor selects the first video. For multiple links, start one run per video.

Input key	Type	Required / default	Unit and effect
video_url	string	Required; no omitted-input default	One public individual-video permalink.
video_quality	string	Default metadata	Select metadata, low, medium or high; controls whether a file is requested and its quality preference.
max_comments	integer, minimum 0	Default 0	Requested number of comments. Zero skips comment requests. Positive values have no configured maximum; available comments, order, replies and returned count vary by source.

Quality modes

Value	Behavior	How to interpret the result
metadata	Read information without downloading media.	video is null. Video details describe the source video when known.
low	Prefer the best available height up to 480 pixels.	The delivered file's actual height and width identify its resolution.
medium	Prefer the best available height up to 720 pixels.	The available video may have a lower resolution.
high	Prefer the highest available height.	Read height and width for the delivered resolution.

If no available video meets the Low or Medium height target, you receive the lowest available height. Saved downloads are MP4 files. Check the dimensions for your viewing or editing needs. Source watermarks remain in the video.

Examples for every mode

Each example below extends the same Quick Start link. Download modes deliver a row and incur the Download event only if the requested file is saved. If a requested file cannot be saved, no row or Metadata/Download result fee is produced; read the final run message.

Low file request

{
  "video_url": "https://www.youtube.com/watch?v=jNQXAC9IVRw",
  "video_quality": "low",
  "max_comments": 0
}

Medium file request

{
  "video_url": "https://www.youtube.com/watch?v=jNQXAC9IVRw",
  "video_quality": "medium",
  "max_comments": 0
}

High file request

{
  "video_url": "https://www.youtube.com/watch?v=jNQXAC9IVRw",
  "video_quality": "high",
  "max_comments": 0
}

Optional comment request. This changes the comment selection, while keeping metadata mode. Availability and the returned count remain source-dependent.

{
  "video_url": "https://www.youtube.com/watch?v=jNQXAC9IVRw",
  "video_quality": "metadata",
  "max_comments": 3
}

max_comments selects a source-dependent comment sample. Keep comment_count as the source total and comments as returned bodies; comments share the video row and have no separate billed event.

Output Data Schema

The Dataset has 43 top-level fields. Types below describe populated values; every field is nullable when unrequested or unavailable. Preserve genuine zero and false values. [] means an observed empty list.

Field	JSON type	Meaning and unit
id	string	Unique video identifier from the source platform
source_url	string	Canonical source page returned for the individual video; for a definitive missing answer, the queried link. It is separate from the saved MP4 URL.
thumbnail	string	Direct link to the source platform thumbnail image
platform	string	Source platform name in lowercase.
media_type	string	Kind of media the source reports, such as video or audio.
live_status	string	Whether the item is a normal recording, currently live, or a finished live stream.
availability	string	Source visibility of the item, such as public, unlisted, subscriber_only, or needs_auth.
age_limit	number	Minimum viewer age the source enforces. Zero means no restriction.
language	string	Primary language of the item as reported by the source.
title	string	Video title
description	string	Full video description or caption
duration	number	Video length in seconds
published_at	string	Source publication instant in UTC ISO 8601, retaining source precision. A date-only or separate creation time does not become an invented midnight timestamp.
author	string	Source channel or uploader name. For Kick and Twitch clips, channel attribution is retained when provided.
author_id	string	Stable channel or uploader identifier on the source platform.
author_url	string	Direct link to the creator's profile page
followers	number	Follower or subscriber count of the author's channel at processing time.
is_verified	boolean	Whether the author's channel carries a verified badge.
categories	array	List of categories assigned to the video
tags	array	Hashtags and keywords associated with the video
view_count	number	Total number of video views
like_count	number	Total number of likes or favorites
shares_count	number	Number of times the video has been shared or reposted
saves_count	number	Number of times viewers saved or bookmarked the item, on sources that expose it.
dislike_count	number	Total number of dislikes (if available)
comment_count	number	Total number of comments on the video
width	number	Video resolution width in pixels
height	number	Video resolution height in pixels
fps	number	Video frame rate (frames per second)
video_codec	string	Video format name reported for the video.
audio_codec	string	Audio format name reported for the video.
bitrate	number	Combined video and audio data rate, in kbit/s.
dynamic_range	string	Colour range the source reports for the video, such as SDR or HDR10.
file_ext	string	File extension, such as mp4 or webm. Saved downloads use mp4; a metadata lookup may leave this value empty.
file_size	number	Exact bytes of the saved file in download mode; an exact source size in metadata mode.
audio_title	string	Title of the audio track or background music
audio_artist	string	Artist name of the audio track or background music
subtitles	array	Array of published subtitle language codes. This field contains no caption text or file links; automatic captions are excluded.
chapters	array	Chapter markers with title and start and end time in seconds, when the source defines them.
comments	array	Returned comment text in source order, with replies where available. Treat this as a sample rather than a complete discussion.
video	string	Saved MP4 URL after successful file delivery. Null in metadata mode. If a requested download cannot be retrieved or saved, no row is returned; the run status keeps the warning.
processor	string	Canonical Store URL of this Actor.
processed_at	string	Time this Actor prepared the public row, in UTC ISO 8601 with a Z suffix. This is the collection timestamp.

Nested objects

Path	Type	Meaning
chapters[].title	string	Source chapter title.
chapters[].start_time	number	Offset from the beginning, in seconds.
chapters[].end_time	number	Chapter end offset, in seconds.
comments[].author	string	Public source author name when supplied.
comments[].text	string	Returned comment body, separate from the video description.
comments[].like_count	number	Source comment likes.
comments[].published_at	string	Source comment publication instant, UTC ISO 8601 when supplied.

comment_count is a source total, not the length of comments. subtitles lists language codes and does not contain transcript text. processed_at is generated when the row is prepared and is not evidence of the video's age.

Complete specimen

Illustrative metadata record for the Quick Start link (abbreviated; the tables above list the complete contract):

{
  "id": "source-video-id",
  "source_url": "https://www.youtube.com/watch?v=jNQXAC9IVRw",
  "platform": "youtube",
  "title": "Illustrative video title",
  "duration": 19,
  "video": null,
  "processor": "https://apify.com/agentx/all-video-scraper",
  "processed_at": "2026-11-06T22:00:00Z"
}

Success, partial data, no result and unavailable

• Success: a video record is saved. In metadata mode, video: null is expected. In download mode, a non-null video identifies the stored MP4.
• Partial requested data: a saved row can retain available video facts when optional requested comments are missing. A failed requested download returns no row and incurs neither a Metadata nor a Download fee; the run status keeps the warning.
• Definitive no video: when the source explicitly confirms an absent, deleted or supported private result, a sparse identity row can answer the supplied source_url, with no video ID or business facts. That row has no Metadata or Download event. Startup and usage still apply.
• Unavailable: a source refusal or unresolved retrieval failure can leave zero rows. Zero rows do not prove deletion or that the URL contains no video. The run status provides the supported explanation.

The public Dataset does not add a status field. Interpret the row together with the requested mode and final run status; do not treat an MP4 link as present because the platform run says SUCCEEDED. Do not manufacture a blank video in your application when the Dataset is empty.

Exports and file retrieval

JSON preserves the complete nested arrays and null values. CSV is useful for scalar fields, while arrays may require JSON parsing in your spreadsheet workflow. Downloaded media is stored in the run's Key-Value Store; source_url remains the original page. Read the video URL, verify the response and retain the bytes you need within your storage-retention policy. A source thumbnail is an external image URL and can expire independently of a saved MP4.

Integration Examples

The authenticated Actor ID is etzrjsBIFSOb19k5E. Each example starts once, polls that run and retrieves every default-Dataset page. Set APIFY_TOKEN in your own environment; never put a token into a shared URL, committed file or public log. The examples use the same complete metadata input as Quick Start.

A client wait ending can leave the Actor running. Poll the existing run ID; starting again can create another run and another bill. If the initial start response is lost, check your run list before submitting again. A terminal FAILED, TIMED-OUT or ABORTED run can still have saved data, so the examples read its Dataset too.

cURL and jq

Requires cURL, jq and a POSIX shell. Save the run ID printed by the script. Requests use the Authorization header rather than a token query parameter.

set -eu
: "${APIFY_TOKEN:?Set APIFY_TOKEN}"
BASE=https://api.apify.com/v2
INPUT='{"video_url":"https://www.youtube.com/watch?v=jNQXAC9IVRw","video_quality":"metadata","max_comments":0}'
RUN=$(curl --fail-with-body --silent --show-error   -H "Authorization: Bearer $APIFY_TOKEN" -H 'Content-Type: application/json'   --data "$INPUT" "$BASE/acts/etzrjsBIFSOb19k5E/runs")
RID=$(printf '%s' "$RUN" | jq -er '.data.id')
printf 'Run ID: %s
' "$RID" >&2
while :; do
  RUN=$(curl --fail-with-body --silent --show-error     -H "Authorization: Bearer $APIFY_TOKEN" "$BASE/actor-runs/$RID")
  STATUS=$(printf '%s' "$RUN" | jq -r '.data.status')
  case "$STATUS" in SUCCEEDED|FAILED|TIMED-OUT|ABORTED) break;; esac
  sleep 3
done
DID=$(printf '%s' "$RUN" | jq -r '.data.defaultDatasetId // empty')
printf 'Final status: %s
' "$STATUS" >&2
if [ -n "$DID" ]; then
  OFFSET=0
  while :; do
    PAGE=$(curl --fail-with-body --silent --show-error       -H "Authorization: Bearer $APIFY_TOKEN"       "$BASE/datasets/$DID/items?format=json&clean=false&limit=1000&offset=$OFFSET")
    printf '%s' "$PAGE" | jq -c '.[]'
    COUNT=$(printf '%s' "$PAGE" | jq 'length')
    [ "$COUNT" -lt 1000 ] && break
    OFFSET=$((OFFSET + COUNT))
  done
fi

Python

Uses Python 3 and the requests package. The start request is not automatically repeated. A later client error does not cancel the Actor; retain the printed run ID and resume polling it.

import json
import os
import time
import requests

BASE = "https://api.apify.com/v2"
session = requests.Session()
session.headers["Authorization"] = "Bearer " + os.environ["APIFY_TOKEN"]
run_input = {'video_url': 'https://www.youtube.com/watch?v=jNQXAC9IVRw', 'video_quality': 'metadata', 'max_comments': 0}

def get(path, **params):
    response = session.get(BASE + path, params=params, timeout=60)
    response.raise_for_status()
    return response.json()

response = session.post(BASE + "/acts/etzrjsBIFSOb19k5E/runs", json=run_input, timeout=60)
response.raise_for_status()
run = response.json()["data"]
run_id = run["id"]
print("Run ID:", run_id, flush=True)
terminal = {"SUCCEEDED", "FAILED", "TIMED-OUT", "ABORTED"}
while run["status"] not in terminal:
    time.sleep(3)
    run = get("/actor-runs/" + run_id)["data"]
print("Final status:", run["status"])
dataset_id = run.get("defaultDatasetId")
if dataset_id:
    offset = 0
    while True:
        page = get("/datasets/" + dataset_id + "/items", format="json",
                   clean="false", offset=offset, limit=1000)
        for item in page:
            print(json.dumps(item, ensure_ascii=False))
        if len(page) < 1000:
            break
        offset += len(page)

JavaScript

Uses Node.js 18 or later with built-in fetch. Save as an ES module (.mjs) and set APIFY_TOKEN. It does not need an additional SDK package. A failed HTTP request ends this client, not necessarily the remote run.

const base = 'https://api.apify.com/v2';
const token = process.env.APIFY_TOKEN;
if (!token) throw new Error('Set APIFY_TOKEN');
const input = {
  "video_url": "https://www.youtube.com/watch?v=jNQXAC9IVRw",
  "video_quality": "metadata",
  "max_comments": 0
};
async function api(path, options = {}) {
  const response = await fetch(base + path, {
    ...options,
    headers: { Authorization: `Bearer ${token}`, 'Content-Type': 'application/json' },
  });
  if (!response.ok) throw new Error(`Apify HTTP ${response.status}`);
  return response.json();
}
let { data: run } = await api('/acts/etzrjsBIFSOb19k5E/runs', {
  method: 'POST', body: JSON.stringify(input),
});
const runId = run.id;
console.log('Run ID:', runId);
const terminal = new Set(['SUCCEEDED', 'FAILED', 'TIMED-OUT', 'ABORTED']);
while (!terminal.has(run.status)) {
  await new Promise(resolve => setTimeout(resolve, 3000));
  ({ data: run } = await api(`/actor-runs/${runId}`));
}
console.log('Final status:', run.status);
if (run.defaultDatasetId) {
  for (let offset = 0; ; ) {
    const page = await api(`/datasets/${run.defaultDatasetId}/items?format=json&clean=false&limit=1000&offset=${offset}`);
    for (const item of page) console.log(JSON.stringify(item));
    if (page.length < 1000) break;
    offset += page.length;
  }
}

Make, n8n and downstream tools

In Make, select Apify's Run an Actor, use the Actor ID above, map the same JSON input and retain the returned run ID. Wait for that run to finish, then use Get Dataset Items with its defaultDatasetId; configure pagination rather than assuming the first page is the whole result. In n8n, use the Apify Actor action and pass the same input; retain the run and Dataset IDs between nodes. If the workflow stops waiting, resume polling the existing run.

For a media archive, fetch the saved video URL. For analytics, ingest Dataset JSON with its source links and collection timestamp. Caption text requires a separate transcript workflow.

Pricing

This Actor uses pay-per-event pricing. The account's effective pricing tier determines result prices. Check this Actor's Pricing tab before a production workload. Startup and variable usage are separate from the mutually exclusive Metadata or Download result event.

Event key	Billed unit	Trigger	Price
apify-actor-start	One run	Starting a run, including a zero-row run	$0.01 per run
actor_usage	Usage unit	Usage accumulated while handling your request	$0.00001 per unit
metadata	One saved metadata record	Successful metadata delivery without a saved MP4	See tier table
download	One saved video record with MP4	Successful file delivery	See tier table

Tier	Metadata	Download
FREE	$0.09	$0.28
BRONZE	$0.081	$0.252
SILVER	$0.072	$0.224
GOLD	$0.0675	$0.21
PLATINUM	$0.0675	$0.21
DIAMOND	$0.0675	$0.21

Whole-bill examples

Let U be the usage units actually billed for the run. At the FREE tier:

Scenario	Event quantities	Complete event bill
Quick Start, one metadata row	Start 1, Metadata 1, Usage U	$0.1 + U x $0.00001
Low, Medium or High, one saved MP4	Start 1, Download 1, Usage U	$0.29 + U x $0.00001
Requested download could not be retrieved or saved; no row	Start 1, Metadata 0, Download 0, Usage U	$0.01 + U x $0.00001
Explicit no-video identity row	Start 1, result events 0, Usage U	$0.01 + U x $0.00001
No row after source retrieval failure	Start 1, result events 0, Usage U	$0.01 + U x $0.00001

For a numerical arithmetic example, if U were 100, usage would be $0.001 and Quick Start would cost $0.101 in Actor events. This is an illustration, not a measured usage prediction. The actual bill is sum(event quantity x your tier price), plus any separately applicable platform/account costs. The fixed-event amount alone is not an all-inclusive quote.

One video row does not receive both Metadata and Download. Comment objects and chapter markers are part of the same row, with no separate comment/chapters event. Re-running one URL ten times means ten starts and ten independently delivered results; it is not one free lookup with retries. A spending limit can stop later work while retaining already saved data. Check the run's charged-event counts and final charge rather than inferring a bill from platform success.

Use Cases

• Mixed-source media library (Low, Medium or High): Request authorized MP4 files from selected public video links and organize saved files with their original pages.
• Cross-platform content inventory (Metadata Only): Export titles, descriptions, author details and duration into one catalog for a team researching several video sites.
• Recurring engagement review (Metadata Only): Schedule selected links and compare available counters with their observation times.
• Editing handoff (Low, Medium or High): Give an editor a saved MP4 link, its dimensions and its source reference after successful delivery.

Alternatives

Use the source website for a one-off visual check or its own download/export feature for your content. Choose this Actor when you need a Dataset record and a repeatable single-link workflow. For caption text, choose a transcript product.

For source-specific input guidance, see the focused video editions below.

Limits and Troubleshooting

Use one individual public video page. On supported pages containing several videos, the Actor selects the first video.

• No rows: check the final run message and verify the individual link. Source access can prevent retrieval; zero rows alone do not mean the video was deleted.
• File request: read video for a saved MP4. If retrieval or saving fails, no row or Metadata/Download fee is produced; startup and accrued usage still apply.
• Missing details: use the shared missing-value meanings in Output Data Schema. Source engagement totals and the returned comment sample describe different things.
• Interrupted client or pending billing: retain the run ID, inspect its Dataset and charged events, and contact support before starting a replacement.
• File retention: save the media you need before removing its run storage.

Trust and Reliability

Source URLs, creator identifiers and processed_at keep each record attributable and useful for repeat snapshots. Saved-file links are separate from source pages, and download rows describe the file actually saved. Review the final run message alongside the Dataset for any missing requested data.

Legal and Compliance

Use content you are authorized to access, store and reuse. Follow source-platform terms, copyright and privacy requirements, and apply retention and access controls to exported records and media. Public visibility alone does not grant redistribution rights.

Frequently Asked Questions

When should I use All Video Scraper?

Use it for individual public video links across supported sites when you want one output format for a mixed-source library. For a workflow focused on one platform, the matching downloader edition gives more focused guidance.

How do I download a video instead of collecting metadata?

Choose Low, Medium or High in video_quality. A successful file request puts the saved MP4 URL in video. Metadata Only returns video facts without a file; availability depends on the link.

Can I submit a playlist, profile or several links?

Use an individual video page and start one run per link. On a supported page with several videos, only the first video is selected. This workflow does not promise a complete playlist or profile export.

Will every site return the same details?

The field names stay the same, but available titles, author facts, engagement and other values vary by source. Read the shared missing-value meanings in Output Data Schema; a missing count is not zero.

Can I export the library and refresh it on a schedule?

Export the Dataset as JSON for complete nested records or CSV for scalar fields. Save each input as an Apify Task and add a Schedule; use source_url and processed_at when comparing snapshots.

What do Low, Medium and High mean?

Low prefers a height up to 480 pixels, Medium up to 720 pixels, and High the highest available quality. Check the saved file dimensions for the actual result. Source watermarks remain.

What happens to the bill when a download fails?

Startup and accrued usage still apply. A requested file that cannot be retrieved or saved produces no row and no Metadata or Download result fee. See Pricing for all events and whole-bill examples.

What should I do if a link returns no result or my client stops waiting?

Keep the run ID and check that run's final message and Dataset before starting again. Verify the public video link; if you need help, send support the run ID, link and requested mode through the Issues tab.

Related AgentX Actors

• Video Transcript - paste the saved video URL into Video File to transcribe its speech.
• Video Captions Downloader - use the source video URL to download captions when the source provides them.

Support and Community

Use this Actor's Issues tab for product support, with a run ID and a clear description of the missing result. You can also find AgentX's published Actors on the AgentX Store profile. Keep credentials and private inputs out of public messages.

AgentX is an Arcyton brand. Arcyton