Reddit Video Downloader

Request a Reddit video download as MP4 from one public video-post permalink. Reddit Video Downloader helps researchers and moderators review selected posts and build a video research collection with original permalinks. Choose a download mode or request metadata without a file, then check the run message and Dataset for the outcome.

Open input | Integrations | Pricing

Why Choose Reddit Video Downloader

• Start from the discussion's video post. Use a Reddit post permalink to keep a chosen video tied to its original page.
• Request the file you need to review. Low, Medium and High request an MP4; use a returned video link only after the file is saved.
• Keep a research reference. Metadata Only requests the available post and video facts for your own source-linked collection.
• See the outcome before repeating work. The final message and Dataset let you review an unsuccessful request without assuming a video was downloaded.

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.reddit.com/r/videos/comments/6rrwyj/that_small_heart_attack/",
  "video_quality": "metadata"
}

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.08 plus Actor Usage. This includes $0.01 Actor Start and $0.07 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 a permalink to a Reddit post containing a video. Text-only posts, galleries and community listings are outside this workflow. Links must be publicly accessible; the input has no Reddit sign-in field. 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.

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.reddit.com/r/videos/comments/6rrwyj/that_small_heart_attack/",
  "video_quality": "low"
}

Medium file request

{
  "video_url": "https://www.reddit.com/r/videos/comments/6rrwyj/that_small_heart_attack/",
  "video_quality": "medium"
}

High file request

{
  "video_url": "https://www.reddit.com/r/videos/comments/6rrwyj/that_small_heart_attack/",
  "video_quality": "high"
}

This edition uses video_url and video_quality. A source comment total describes the video; it does not indicate that comment bodies were collected.

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	Reddit author name as provided on the video post.
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.reddit.com/r/videos/comments/6rrwyj/that_small_heart_attack/",
  "platform": "reddit",
  "title": "Illustrative video title",
  "duration": 19,
  "video": null,
  "processor": "https://apify.com/agentx/reddit-video-downloader",
  "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 0up38sfUfwN7PdW0T. 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.reddit.com/r/videos/comments/6rrwyj/that_small_heart_attack/","video_quality":"metadata"}'
RUN=$(curl --fail-with-body --silent --show-error   -H "Authorization: Bearer $APIFY_TOKEN" -H 'Content-Type: application/json'   --data "$INPUT" "$BASE/acts/0up38sfUfwN7PdW0T/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.reddit.com/r/videos/comments/6rrwyj/that_small_heart_attack/', 'video_quality': 'metadata'}

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/0up38sfUfwN7PdW0T/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.reddit.com/r/videos/comments/6rrwyj/that_small_heart_attack/",
  "video_quality": "metadata"
};
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/0up38sfUfwN7PdW0T/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.07	$0.2
BRONZE	$0.063	$0.18
SILVER	$0.056	$0.16
GOLD	$0.0525	$0.15
PLATINUM	$0.0525	$0.15
DIAMOND	$0.0525	$0.15

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.08 + U x $0.00001
Low, Medium or High, one saved MP4	Start 1, Download 1, Usage U	$0.21 + 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.081 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

• Selected-post research (Metadata Only): Request facts for a chosen Reddit video post and add any returned record to a collection of post permalinks.
• Moderation review (Metadata Only): Request a record for a public video post you already identified; review the outcome before using returned facts in your own case notes.
• Authorized video retention (Low, Medium or High): Request an MP4 from a public post and retain a returned file with its discussion link only after successful saving.

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 video links from several sources, use All Video Scraper.

Limits and Troubleshooting

Use a permalink to a Reddit post containing a video. Text-only posts, galleries and community listings are outside this workflow. Links must be publicly accessible; the input has no Reddit sign-in field.

• 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

How do I request a Reddit video download?

Use the public video-post permalink in video_url and choose Low, Medium or High. Inspect the final run message and Dataset; a saved MP4 is linked in video only after successful saving.

Which Reddit links belong in this downloader?

Use a permalink to a post containing a video. Text-only posts, image galleries and subreddit listings are outside this workflow.

Is this a Reddit scraper for posts and comments?

This edition handles one selected video post per run. It does not discover subreddit posts or export a discussion's comment bodies; a source comment total does not mean comments were collected.

Can I inspect the post without requesting a video file?

Choose Metadata Only, the default. Check the returned record for available post and video facts; this mode does not save an MP4.

How do I export or revisit my video research references?

Export any returned Dataset records as JSON or CSV. Save a post input as an Apify Task and add a Schedule for later requests; each post link has its own run.

What does the video quality choice mean?

Low prefers a height up to 480 pixels, Medium up to 720 pixels, and High the highest available quality. The source determines the actual dimensions and any watermark remains.

What is charged if Reddit returns no downloadable video?

Startup and accrued usage apply. A file request that cannot be retrieved or saved delivers no row and has no Metadata or Download result fee. Pricing lists the whole bill for each outcome.

Does an empty result mean the post was deleted?

No. Check the public post link and that run's final message. Keep the run ID if your client stops waiting and inspect the same Dataset before retrying. For help, send support the run ID, permalink and mode through the Issues tab.

Related AgentX Actors

• All Video Scraper - use the returned Reddit source URL in the broader video metadata and download workflow.
• SubReddit Info Scraper - take the r/community path from the returned post URL to look up its community.

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