# Reddit Video Downloader (`agentx/reddit-video-downloader`) Actor

Process one publicly accessible Reddit post containing supported video for structured metadata and an optional stored video file.

- **URL**: https://apify.com/agentx/reddit-video-downloader.md
- **Developed by:** [AgentX](https://apify.com/agentx) (community)
- **Categories:** Videos, Social media, Agents
- **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/platform/actors/running/actors-in-store#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 processes one accessible Reddit post containing supported video, returns normalized metadata, and can optionally store the media file in Apify.

- Two public inputs cover one Reddit post URL and an optional download preference.
- Four quality values provide metadata-only, low, medium, and high processing modes.
- Successful results follow a 39-field Dataset contract with the thumbnail first.
- Reddit comment retrieval is not exposed; the reserved `comments` list is normally empty.

**[Run one Reddit video test](https://apify.com/agentx/reddit-video-downloader)**

**[View the Apify API](https://apify.com/agentx/reddit-video-downloader/api)**

Publish the Actor, replace the illustrative post, and validate metadata before downloading.

### Why Choose This API

Reddit Video Downloader provides a one-post media contract. It can normalize the information returned for supported Reddit-hosted video or a supported video attached to a post into fields for ID, title, description, thumbnail, author, publication time, engagement counters, dimensions, audio labels, and run provenance.

Metadata mode avoids file transfer. A download preference asks for an available rendition and stores it only after successful delivery. The source media controls actual formats and resolution.

This is not a subreddit, user, search, feed, gallery, comment-thread, or voting scraper. Use the dedicated Reddit and SubReddit AgentX Actors for those data surfaces.

### Quick Start Guide

The documentation uses a URL-shaped placeholder:

```json
{
  "video_url": "https://www.reddit.com/r/aww/comments/qvowir/two_kittens_i_picked_up_from_the_highway_dont/",
  "video_quality": "metadata"
}
```

Replace it with a current public Reddit post containing video that you may process. Open the URL in a private browser window and confirm the media plays. Then run metadata mode and compare the returned ID, title, author, and thumbnail with the intended post.

A Reddit page can contain a link, image gallery, removed media, or external embed instead of a supported video. Do not count a rendered page as success unless the output identifies the expected video. Request a file only after metadata passes.

### Input Parameters

| Parameter | Type | Required | Purpose |
|---|---|---:|---|
| `video_url` | string | Yes | One public Reddit post containing supported video. |
| `video_quality` | string | No | `metadata`, `low`, `medium`, or `high`; metadata skips storage. |

The required URL has a matching placeholder prefill and example. The optional quality field has no prefill or example and defaults to metadata when omitted.

No subreddit, author, query, date, sort, listing, login, cookie, batch, gallery, or comment input exists. Additional properties are rejected.

### Output Data Schema

The Actor uses a 39-field cross-video record:

| Area | Fields |
|---|---|
| Video identity | `thumbnail`, `id`, `platform`, `title`, `description`, `duration`, `published_at` |
| Author | `author`, `author_id`, `author_url` |
| Labels and counters | `categories`, `tags`, `view_count`, `like_count`, `shares_count`, `dislike_count`, `comment_count` |
| Media | `width`, `height`, `fps`, `audio_title`, `audio_artist`, `video` |
| Reserved and provenance | `comments`, `processed_at`, `processor` |

Abbreviated shape for the same placeholder:

```json
{
  "id": "example",
  "platform": "Reddit",
  "title": "Example Reddit video post",
  "author": "example_author",
  "thumbnail": "https://example.com/reddit-thumbnail.jpg",
  "comments": [],
  "video": ""
}
```

This illustrates the schema, not live output. Fields may be null. `comment_count` is a possible numeric statistic, but the Actor does not retrieve the discussion as comment objects. Metadata mode intentionally returns no file.

Source-dependent fields also present in every item:

| Field | Meaning |
|---|---|
| `source_url` | Canonical page URL of the item on its own platform |
| `media_type` | Kind of media the source reports, such as video or audio |
| `live_status` | Whether the item is a recording, currently live, or a finished stream |
| `availability` | Source visibility, such as public, unlisted, or needs\_auth |
| `age_limit` | Minimum viewer age the source enforces; zero means no restriction |
| `language` | Primary language of the item as reported by the source |
| `followers` | Follower or subscriber count of the author at processing time |
| `is_verified` | Whether the author's account carries a verified badge |
| `saves_count` | Times viewers saved the item, on sources that expose it |
| `file_ext` | Container extension of the selected media, such as mp4 or webm |
| `file_size` | Size of the selected media in bytes, exact or approximate |
| `subtitles` | Language codes of published subtitle tracks; auto-captions excluded |
| `chapters` | Chapter markers with title and start and end time in seconds |

### Integration Examples

Use the same scenario through HTTP:

```bash
curl -X POST "https://api.apify.com/v2/acts/agentx~reddit-video-downloader/runs?token=$APIFY_TOKEN" \
 -H "Content-Type: application/json" \
 -d '{"video_url":"https://www.reddit.com/r/aww/comments/qvowir/two_kittens_i_picked_up_from_the_highway_dont/","video_quality":"metadata"}'
```

The matching hosted MCP configuration is:

```json
{
  "mcpServers": {
    "apify-reddit-video": {
      "url": "https://mcp.apify.com?tools=agentx/reddit-video-downloader",
      "headers": {
        "Authorization": "Bearer <APIFY_TOKEN>"
      }
    }
  },
  "exampleToolArguments": {
    "video_url": "https://www.reddit.com/r/aww/comments/qvowir/two_kittens_i_picked_up_from_the_highway_dont/",
    "video_quality": "metadata"
  }
}
```

Publication is required for discovery. Protect the token and follow the [Apify MCP documentation](https://docs.apify.com/integrations/mcp).

### Pricing & Cost Calculator

Local metadata declares these events, not a verified public offer:

| Event | Billing unit | Local price |
|---|---|---:|
| `actor_usage` | Metered runtime, proxy, and storage usage | $0.00001 |
| `metadata` | One successfully processed metadata result | $0.07 |
| `download` | One successfully processed result with stored video | $0.20 |

The smallest metadata result declares $0.07 plus metered usage. A download declares $0.20 plus metered usage.

### Use Cases & Applications

Researchers can preserve the identity and available media properties of one cited public post. Moderation or editorial teams can attach a permitted video and source URL to a review record. Developers can route the Dataset item into a webhook or asset catalog. AI teams can pass authorized files to separate transcript or classification tools.

Repeated runs can observe current counters, but the Actor does not calculate deltas or collect discussion. Keep the post URL and media ID with each result, and distinguish removed media from a runtime regression.

### Limits & Troubleshooting

Deleted posts, private or quarantined communities, age gates, authentication, unsupported external embeds, galleries, rate limits, and Reddit changes may block processing. No Reddit credential or cookie input exists.

If no item appears, replace the placeholder and confirm the post contains playable video in a private browser. Retry metadata mode. If a file is missing in download mode, inspect logs and storage and verify metadata still succeeds.

Before release, test native Reddit video, a supported external embed, a text post, a gallery, a removed post, an access-restricted post, and one download. Validate media identity, 26 keys, and an empty comment list.

### FAQ

#### Can it scrape a subreddit or user profile?

No. Use the related Reddit data Actors.

#### Does it retrieve Reddit comments?

No comment input exists; the reserved list is normally empty.

#### Does every Reddit post work?

No. The post must contain video supported by the extractor.

#### Can it process galleries?

Gallery extraction is outside the documented one-video contract.

#### Does high guarantee a resolution?

No. Source renditions determine the result.

#### Why are fields null?

The post or extractor did not expose them. Null is not zero.

#### Can I schedule it?

Yes, but the same URL is reprocessed and availability can change.

#### Does it matter whether the video is Reddit-hosted?

Yes. A `v.redd.it` post is hosted by Reddit and resolves directly. A post that links out to another platform is resolved only when that platform is itself supported, and the returned `platform` field then names the real source rather than Reddit. Check that field when you reconcile records downstream.

### Legal & Responsible Use

Process only media you are authorized to access, download, and retain. The caller is responsible for Reddit terms, community rules, copyright, privacy, applicable law, and retention policy.

### Related Tools

- [Reddit Author Scraper](https://apify.com/agentx/reddit-author-scraper) handles author information.
- [Reddit Viral Scraper](https://apify.com/agentx/reddit-viral-scraper) handles broader post discovery.
- [SubReddit Post Scraper](https://apify.com/agentx/subreddit-post-scraper) handles subreddit posts.
- [All Video Scraper](https://apify.com/agentx/all-video-scraper) accepts supported media URLs from multiple hosts.

### Support & Community

- [AgentX community](https://t.me/Apify_Actor)
- [Contact the AgentX team](https://t.me/AiAgentApi)
- [Apify Actor dashboard](https://apify.com/agentx/reddit-video-downloader)
- [Apify API reference](https://apify.com/agentx/reddit-video-downloader/api)
- [Apify MCP documentation](https://docs.apify.com/integrations/mcp)

Include the stable ID, redacted post URL, input, and run ID in support requests.

**[Run one Reddit video test](https://apify.com/agentx/reddit-video-downloader)**

**[View the Apify API](https://apify.com/agentx/reddit-video-downloader/api)**

# Actor input Schema

## `video_url` (type: `string`):

Publicly accessible Reddit post URL containing supported video.

## `video_quality` (type: `string`):

Preferred download quality, or metadata-only mode without a video file.

## Actor input object example

```json
{
  "video_url": "https://www.reddit.com/r/aww/comments/qvowir/two_kittens_i_picked_up_from_the_highway_dont/"
}
```

# Actor output Schema

## `results` (type: `string`):

All video details and optional download links with full engagement stats and comments

# 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 = {
    "video_url": "https://www.reddit.com/r/aww/comments/qvowir/two_kittens_i_picked_up_from_the_highway_dont/"
};

// Run the Actor and wait for it to finish
const run = await client.actor("agentx/reddit-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 = { "video_url": "https://www.reddit.com/r/aww/comments/qvowir/two_kittens_i_picked_up_from_the_highway_dont/" }

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

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

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

```

## CLI example

```bash
echo '{
  "video_url": "https://www.reddit.com/r/aww/comments/qvowir/two_kittens_i_picked_up_from_the_highway_dont/"
}' |
apify call agentx/reddit-video-downloader --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=agentx/reddit-video-downloader",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/0up38sfUfwN7PdW0T/builds/ShtrEfTTMK4RCDbnp/openapi.json