# Reddit Video Downloader Scraper (`automation-lab/reddit-public-video-downloader`) Actor

Download authorized public Reddit-hosted MP4 video and separate M4A audio files with typed post, source, resolution, size, and retrieval metadata.

- **URL**: https://apify.com/automation-lab/reddit-public-video-downloader.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Videos, Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Reddit Video Downloader Scraper

Download video and separate audio files from supplied, anonymously reachable public Reddit video posts.
This **reddit video downloader** stores authorized Reddit-hosted MP4 and M4A files in Apify storage and exports post ID, title, author, subreddit, permalink, source media URL, format, resolution, duration, byte sizes, and retrieval status.

No Reddit login, cookies, browser, or user API key is required.
Private, deleted, quarantined, age-gated, external-hosted, DRM, and login-required media are outside scope.

### What can the Reddit Video Downloader do?

- Process exact `reddit.com` post URLs and `redd.it` short links.
- Download Reddit-hosted MP4 video into the run key-value store.
- Assemble Reddit's separate public HLS audio rendition into an M4A file.
- Save video only, audio only, both files, or metadata only.
- Export typed metadata and a clear status for every processed URL.
- Deduplicate repeated post IDs within one run.
- Apply a per-file byte limit while streaming downloads.
- Continue after one bad URL and fail clearly if every URL fails.
- Process up to 100 supplied posts per run.

This is a supplied-URL archiver. It does not search Reddit, crawl a subreddit, download comments, or retrieve private content.

### Who is this Actor for?

**Creators and rights holders** can preserve their own public Reddit uploads with source context.

**Editorial and social teams** can attach post identity and community context to authorized campaign assets.

**Researchers and journalists** can create reproducible inventories of public videos they are permitted to retain.

**Developers and data engineers** can turn approved Reddit links into JSON plus downloadable media records for a pipeline.

**Compliance teams** can schedule bounded archives of a reviewed URL list and record retrieval outcomes.

### Why use this Reddit video downloader?

A manual browser download usually provides only one file. Reddit often delivers video and audio separately.
The Actor resolves the exact post, stores the source MP4, assembles the public AAC audio rendition when available, and connects both files to a structured dataset record.

The implementation uses lightweight public structured endpoints and Reddit's `v.redd.it` CDN. It does not launch a browser or automatically enable paid proxy traffic.
Use metadata-only mode when you need an inventory rather than copied bytes.

### Supported Reddit URLs and media

Supported:

```text
https://www.reddit.com/r/<subreddit>/comments/<post-id>/<slug>/
https://old.reddit.com/r/<subreddit>/comments/<post-id>/<slug>/
https://redd.it/<post-id>
```

The post must identify an anonymously reachable video hosted by `v.redd.it`.
The Actor does not treat YouTube, Streamable, TikTok, image galleries, animated images, text posts, or arbitrary direct CDN URLs as Reddit-hosted videos.

### Extracted Reddit video data

| Field | Meaning |
| --- | --- |
| `postId` | Stable Reddit post ID |
| `title` | Public post title |
| `author` | Public Reddit author name |
| `subreddit` | Community containing the post |
| `permalink` | Canonical public Reddit post URL |
| `sourceMediaUrl` | Direct Reddit CDN MP4 URL resolved during the run |
| `format` | Video container format |
| `width`, `height` | Source video resolution in pixels |
| `durationSeconds` | Video duration |
| `hasAudio` | Whether Reddit advertises an audio rendition |
| `videoFileKey`, `videoFileUrl`, `videoSizeBytes` | Stored MP4 details |
| `audioFileKey`, `audioFileUrl`, `audioSizeBytes` | Stored M4A details |
| `retrievalStatus` | `downloaded`, `metadata_only`, or `failed` |
| `error` | Per-URL failure reason, otherwise `null` |
| `scrapedAt` | ISO 8601 retrieval time |

Missing upstream fields are returned as `null`, not guessed.

### How to download a public Reddit video

1. Confirm the video post opens while logged out and that you may archive it.
2. Copy the full post URL or `redd.it` short link.
3. Open this Actor in Apify Console.
4. Add the URL under **Public Reddit post URLs**.
5. Keep video and audio storage enabled, or disable either file type.
6. Choose a safe per-file size limit.
7. Click **Start**.
8. Open **Reddit video archives** for metadata.
9. Open **Downloaded media files** for stored MP4 and M4A records.

The prefilled URL is a real public input suitable for a first run, but Reddit content can later be removed.

### Input parameters

| Input | Type | Default | Description |
| --- | --- | --- | --- |
| `startUrls` | array | required | One to 100 exact public Reddit post URLs |
| `maxItems` | integer | URL count | Maximum unique supplied posts processed, 1–100 |
| `downloadVideo` | boolean | `true` | Store the Reddit MP4 |
| `downloadAudio` | boolean | `true` | Store separate M4A audio when available |
| `maxMediaSizeMb` | integer | `100` | Maximum size of each individual file, 1–500 MB |
| `maxRequestRetries` | integer | `2` | Transient request retries, 0–5 |

Example:

```json
{
  "startUrls": [{"url": "https://www.reddit.com/r/videos/comments/REAL_POST_ID/example/"}],
  "maxItems": 1,
  "downloadVideo": true,
  "downloadAudio": true,
  "maxMediaSizeMb": 100
}
```

Use the real prefilled URL in Console instead of the anonymized documentation ID.

### Output example

```json
{
  "postId": "abc123",
  "title": "An example public video",
  "author": "exampleuser",
  "subreddit": "videos",
  "permalink": "https://www.reddit.com/r/videos/comments/abc123/example/",
  "sourceMediaUrl": "https://v.redd.it/example/CMAF_720.mp4",
  "format": "mp4",
  "width": 720,
  "height": 1280,
  "durationSeconds": 10,
  "hasAudio": true,
  "videoFileKey": "video-abc123.mp4",
  "videoFileUrl": "https://api.apify.com/v2/key-value-stores/example/records/video-abc123.mp4",
  "videoSizeBytes": 1448462,
  "audioFileKey": "audio-abc123.m4a",
  "audioFileUrl": "https://api.apify.com/v2/key-value-stores/example/records/audio-abc123.m4a",
  "audioSizeBytes": 659120,
  "retrievalStatus": "downloaded",
  "error": null,
  "scrapedAt": "2025-01-15T12:00:00.000Z"
}
```

Default run storage is private. Authenticate when opening API file URLs, or copy files to your own storage.

### Where are video and audio files stored?

The default key-value store uses:

```text
video-<post-id>.mp4
audio-<post-id>.m4a
```

The audio file contains the AAC rendition Reddit publishes separately from its MP4 video.
The Actor does not re-encode, normalize, watermark, or combine the tracks.
Set both download switches to `false` for metadata-only output.

### How much does it cost to download Reddit videos?

The Actor uses pay-per-event pricing: one **$0.015** start event and one `item` event for each successfully resolved public Reddit video.
Failed and duplicate URLs have no item charge. Video and audio files do not create separate events.

The current per-item tiers are:

| Tier | Successful video record |
| --- | ---: |
| FREE | $0.015488 |
| BRONZE | $0.013468 |
| SILVER | $0.010505 |
| GOLD | $0.0080808 |
| PLATINUM | $0.0053872 |
| DIAMOND | $0.003771 |

At BRONZE, one successful video is about **$0.028468**, 10 are about **$0.14968**, and 100 are about **$1.3618** before ordinary Apify storage and transfer usage.
Final cost is the start event plus successful records at your tier. Large files increase normal platform transfer and storage usage.

### Metadata-only and transfer-saving workflows

Set `downloadVideo: false` and `downloadAudio: false` to export a post and media inventory without copying bytes.
The item event is unchanged because the Actor still resolves and emits the complete typed video record.

For video-only processing, disable audio. For audio-only processing, disable video; the M4A is produced only when Reddit advertises an audio rendition.

### Batch and scheduled archives

Supply a bounded list of approved public post URLs and schedule the task when recurring snapshots are required.
Deduplicate across runs in your destination using `postId`.
Export files before your Apify storage retention expires.
A later failed status can mean removal, access changes, or a temporary source failure; the Actor does not infer the cause.

The Actor does not discover new posts or compare historical runs automatically.

### Integrations and export workflows

Send dataset rows and stored files to:

- Amazon S3, Google Cloud Storage, or Azure Blob Storage;
- Airtable, Notion, or Google Sheets for an archive index;
- a webhook for transcription, moderation, or classification;
- a database keyed by `postId`;
- an approved media asset management system.

Copy the bytes or pass authenticated storage access when the destination cannot read private Apify run storage.

### Run with the Apify API

#### cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~reddit-public-video-downloader/runs?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"startUrls":[{"url":"https://www.reddit.com/r/videos/comments/REAL_ID/example/"}],"maxItems":1,"downloadVideo":true,"downloadAudio":true}'
```

#### JavaScript

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/reddit-public-video-downloader').call({
  startUrls: [{ url: 'https://www.reddit.com/r/videos/comments/REAL_ID/example/' }],
  maxItems: 1,
  downloadVideo: true,
  downloadAudio: true,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
from apify_client import ApifyClient
client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("automation-lab/reddit-public-video-downloader").call(run_input={
    "startUrls": [{"url": "https://www.reddit.com/r/videos/comments/REAL_ID/example/"}],
    "maxItems": 1,
    "downloadVideo": True,
    "downloadAudio": True,
})
print(client.dataset(run["defaultDatasetId"]).list_items().items)
```

Keep API tokens in environment variables or a secret manager.

### Use with Apify MCP

Add the Actor to Claude Code:

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/reddit-public-video-downloader"
```

#### Claude Desktop setup

Add this configuration to Claude Desktop:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/reddit-public-video-downloader"
    }
  }
}
```

#### Cursor setup

Add the same MCP server URL in **Cursor Settings → MCP**.

#### VS Code setup

Add the same MCP server URL through your VS Code MCP extension or workspace MCP configuration.

Example prompts:

- "Download this authorized public Reddit video and return its MP4, separate audio, and post metadata."
- "Resolve these approved Reddit video URLs in metadata-only mode for a CSV archive index."
- "Archive this bounded list of public Reddit videos with a 50 MB per-file limit."

### Reliability, limits, and failure behavior

The Actor retries bounded transient request, rate-limit, and server failures.
It validates Reddit post IDs, requires `v.redd.it` media, enforces the per-file byte limit, and does not enable a residential proxy fallback.

A failed URL produces an uncharged `failed` status record and a log message. Successful URLs are preserved when another URL fails. The run fails with a non-zero status when no URL succeeds.

Source media URLs can expire. Enable storage when you need a run-owned copy.

### Troubleshooting

#### Why was my Reddit post rejected?

Open it in a logged-out browser and confirm it is one specific Reddit-hosted video. External embeds, GIFs, galleries, text posts, private posts, removed posts, and restricted media are unsupported.

#### Why is the audio file null?

The post may have no public audio rendition, or `downloadAudio` was disabled. Some Reddit videos are intentionally silent.

#### Why is the stored-file URL unauthorized?

Run storage is private by default. Open it while authenticated in Console or make an authorized API request with your token.

#### Why did an oversized file fail?

It exceeded `maxMediaSizeMb`. Raise the limit only when you have budgeted the additional transfer and storage.

### Responsible and legal use

Use this Actor only for public media you are legally allowed to access, download, retain, and process.
Respect copyright, privacy, publicity rights, contractual restrictions, Reddit's terms, and applicable law.
Do not use the Actor to bypass access controls, collect private content, or redistribute media without permission.

Minimize retained personal data, restrict file access, choose an appropriate retention period, and honor valid deletion requests. This tool does not grant rights to third-party content.

### Related automation-lab Actors

- [Reddit Posts Search Scraper](https://apify.com/automation-lab/reddit-posts-search-scraper) — discover and export normalized public post records when your job starts from a subreddit, keyword, author, or URL.
- [Reddit Scraper](https://apify.com/automation-lab/reddit-scraper) — collect broader public Reddit listing data.
- [Video to Text Transcriber](https://apify.com/automation-lab/video-to-text-transcriber) — transcribe an authorized saved video in a separate workflow.

These products do not replace this Actor's supplied-URL video-and-audio storage workflow.

### FAQ

#### Does it require a Reddit account?

No. It supports only anonymously reachable public Reddit-hosted video posts.

#### Can it search a subreddit or keyword?

No. Supply exact post URLs. Use a related Reddit discovery Actor first when appropriate.

#### Does it merge audio into the MP4?

No. It preserves Reddit's separate source renditions as MP4 video and M4A audio without re-encoding.

#### Are failed or duplicate URLs charged as items?

No. Only successfully resolved public Reddit video records create the `item` event. The start event still applies once per run.

#### Can I keep files permanently?

Apify retention depends on your plan. Copy files to durable storage when you need longer retention.

# Actor input Schema

## `startUrls` (type: `array`):

HTTPS reddit.com post URLs or redd.it short links. Private, deleted, quarantined, age-gated, external-embed, and login-required posts are not supported.

## `maxItems` (type: `integer`):

Maximum number of unique supplied posts to process.

## `downloadVideo` (type: `boolean`):

Download each Reddit-hosted MP4 into the run key-value store.

## `downloadAudio` (type: `boolean`):

When Reddit provides audio, assemble its public HLS audio rendition into a separate M4A file.

## `maxMediaSizeMb` (type: `integer`):

Stop an individual video or audio download when it exceeds this many megabytes.

## `maxRequestRetries` (type: `integer`):

Retries for transient network, rate-limit, and server errors.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.reddit.com/r/funny/comments/1vqld5b/it_is_monday_again/"
    }
  ],
  "maxItems": 10,
  "downloadVideo": true,
  "downloadAudio": true,
  "maxMediaSizeMb": 100,
  "maxRequestRetries": 2
}
```

# Actor output Schema

## `dataset` (type: `string`):

Dataset containing one retrieval record per processed unique Reddit post.

## `files` (type: `string`):

Key-value store containing saved MP4 video and M4A audio records.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "startUrls": [
        {
            "url": "https://www.reddit.com/r/funny/comments/1vqld5b/it_is_monday_again/"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/reddit-public-video-downloader").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "startUrls": [{ "url": "https://www.reddit.com/r/funny/comments/1vqld5b/it_is_monday_again/" }] }

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/reddit-public-video-downloader").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "startUrls": [
    {
      "url": "https://www.reddit.com/r/funny/comments/1vqld5b/it_is_monday_again/"
    }
  ]
}' |
apify call automation-lab/reddit-public-video-downloader --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/reddit-public-video-downloader"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/enfgdvLgiqv0wJkol/builds/O0wcPzqA4xuur7OHp/openapi.json