# Reddit Media Downloader (`scraperoka/reddit-media-downloader`) Actor

🎬 Reddit Media Downloader lets you save posts & videos from Reddit fast and in HD. ⚡ Simple, reliable, and SEO-friendly—perfect for creators, researchers, and social media teams. Download with confidence and enjoy offline anytime!

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

## Pricing

from $1.99 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use 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 Media Downloader 🚀

Manually downloading video and image assets from Reddit posts one by one wastes hours you don’t have. **Reddit Media Downloader** extracts high-quality Reddit media in bulk so you can use it in campaigns, reviews, and research faster. This Reddit media downloader online is ideal for marketers, recruiters, and growth teams who need a Reddit post media downloader that scales to thousands of items in minutes.

---

### What You Get: Sample Output

Here's a sample record from a single run:

```json
{
  "url": "https://www.reddit.com/r/ChatGPT/comments/1t99m84/the_spaghetti_benchmark/",
  "result": {
    "url": "https://v.redd.it/unknown",
    "source": "reddit",
    "title": "The spaghetti benchmark",
    "thumbnail": "https://preview.redd.it/example.jpg",
    "medias": [
      {
        "type": "video",
        "maxquality": false,
        "quality": "720p",
        "url": "https://v.redd.it/unknown/DASH_1280.mp4",
        "info": {
          "bandwidth": "1234567",
          "codecs": "avc1.4d401f",
          "frameRate": "30",
          "height": "720",
          "id": "1280",
          "mimeType": "video/mp4",
          "width": "1280"
        },
        "extension": "mp4"
      },
      {
        "type": "audio",
        "url": "https://v.redd.it/unknown/DASH_AUDIO_128.mp4",
        "quality": "audio",
        "info": {
          "contentType": "audio",
          "id": "AUDIO_128",
          "segmentAlignment": "true",
          "startWithSAP": "1",
          "subsegmentAlignment": "true",
          "subsegmentStartsWithSAP": "1"
        },
        "extension": "mp3"
      }
    ],
    "type": "multiple",
    "error": false,
    "time_end": 1456
  }
}
````

| Field | Type | What It Tells You |
|---|---|---|
| `url` | string | The Reddit post URL you submitted for scraping |
| `result` | object | The full extracted payload (media + metadata) for that post |
| `result.url` | string | The underlying media base URL on `v.redd.it` for the extracted post |
| `result.source` | string | Where the media came from (`reddit`) |
| `result.title` | string | The Reddit post title (useful for naming your downloads and assets) |
| `result.thumbnail` | string | Best-available thumbnail image URL (falls back to preview image URL when needed) |
| `result.type` | string | Media type summary for the record (for videos/audio, it returns `"multiple"`) |
| `result.error` | boolean | Whether the extraction succeeded (`false` on success) |
| `result.time_end` | number | A time marker value included in the returned payload |
| `result.medias` | array | List of extracted media items (videos and audio) for the post |
| `result.medias[].type` | string | Whether the media item is `"video"` or `"audio"` |
| `result.medias[].quality` | string | Video quality label (for example, `720p`) or `"audio"` |
| `result.medias[].url` | string | Direct downloadable media URL you can fetch or store |
| `result.medias[].extension` | string | File extension (`mp4` for videos, `mp3` for audio entries) |
| `result.error_message` | string | Included when the actor returns a failure payload (see “What happens if the actor hits an error?”) |

Export your dataset as JSON, CSV, or Excel — straight from the Apify dashboard.

***

### Why Reddit Media Downloader?

There are a lot of ways to pull data from Reddit — here’s what sets **Reddit Media Downloader** (and related Reddit video downloader workflows like “download Reddit videos” and “Reddit post media downloader”) apart.

#### Video and audio media URLs in one structured result

This Reddit media downloader online returns direct media URLs plus metadata like the post `title` and `thumbnail`. It’s built for use cases where you need “Reddit MP4 downloader”-style outputs without manual copying.

#### Output includes a clear media list (`medias`)

Instead of returning a single link, the actor returns a `medias` array so you can pick the quality you want (useful for “Reddit video url downloader” and “Reddit GIF downloader” style asset workflows—even when the post includes multiple renditions).

#### Thumbnail handling for better usability

When a thumbnail is missing or not directly usable, it falls back to the preview image URL from the post payload. This makes the output more practical for thumbnails, galleries, and review flows (e.g., “Reddit thumbnail downloader”).

#### Built for batch extraction from multiple post URLs

Feed a list of Reddit post URLs and get results per link. This supports workflows like “download Reddit videos” at scale for research, content curation, and archiving.

***

### Configuring Your Run

Drop this into your `input.json` to get started:

```json
{
  "urls": [
    "https://www.reddit.com/r/ChatGPT/comments/1t99m84/the_spaghetti_benchmark/"
  ]
}
```

| Parameter | Required | What It Does |
|---|---|---|
| `urls` | ✅ | A list of Reddit post URLs to scrape for media extraction |

***

### Core Capabilities

#### Bulk post URL support

You provide multiple Reddit post URLs via `urls`, and the actor processes them one by one with a short delay between requests. This makes it straightforward to run repeated “Reddit media extractor” jobs for different campaigns and research batches.

#### Structured media extraction output

For each submitted post, you get a consistent payload that includes `title`, `thumbnail`, and a `medias` list with direct download URLs and quality metadata. This is designed to support “save Reddit videos to phone” workflows and media cataloging without extra parsing.

#### Resilience and error handling

If it can’t extract media for a specific post, it returns a clear failure result with an error flag and message. If the actor encounters a request or parsing issue, it pushes an error payload for that URL instead of stopping the entire run.

#### Proxy support for more reliable scraping

The actor supports proxy configuration to improve reliability for bulk runs. This is especially helpful when you’re processing many posts in one execution.

#### Dataset-first results for automation

Each post’s extracted data is pushed to the dataset as results become available. That makes it easy to automate downstream steps (like importing “Reddit MP4 downloader” links into your storage or CMS pipelines).

***

### Who Gets the Most Out of This

**Content and Social Media Teams**—Use Reddit Media Downloader to collect video and image assets from relevant posts, so you can move from discovery to publishing faster without manual downloading and link copying.

**Digital Marketers and Creators**—When you need a Reddit post media downloader for campaign research, this actor helps you build a media shortlist with titles and thumbnails, then export links for later editing.

**Researchers and Data Analysts**—If your work involves cataloging public web media, the structured `medias` list (with quality and URLs) makes it easier to analyze what media types and renditions show up across posts.

**Automation and Integration Specialists**—If you want a repeatable pipeline, Reddit Media Downloader produces clean JSON records you can feed into your automation workflow via the Apify dataset output.

***

### Step-by-Step: How to Use It

No coding needed. Here's how to run Reddit Media Downloader from start to finish:

1. **Open the actor on Apify** — go to [console.apify.com](https://console.apify.com) and find **Reddit Media Downloader**.
2. **Enter your inputs** — add one or more Reddit post URLs in the `urls` field (the actor requires `urls`).
3. **Configure proxy settings (optional)** — if your run needs improved reliability, enable proxy configuration in the actor UI.
4. **Hit Run and watch the live log** — monitor progress as each Reddit post URL is processed.
5. **View results in the dataset tab** — for each input URL, you’ll see an output record with the extracted `result` payload.
6. **Export as JSON, CSV, or Excel** — download the dataset for use in spreadsheets, dashboards, or media management.

The whole process takes under 5 minutes to set up.

***

### Integrations & Export Options

Once your data is collected, Reddit Media Downloader plugs directly into your existing workflow. You can export results from the Apify dataset tab in common formats such as JSON, CSV, and Excel.

You can also connect your run to other tools using Apify’s automation options like Zapier and Make (Integromat), and push results into downstream systems. For developers, you can access run outputs programmatically via the Apify API and build triggers (including webhooks) to run the next step automatically when a run completes.

For full details on scheduling, API usage, and automation integrations, refer to the Apify docs at https://apify.com/docs/api.

***

### Pricing & Free Trial

Reddit Media Downloader runs on the Apify platform, which offers a **free tier** — no credit card required to get started. That typically covers several test runs so you can validate your exact “Reddit video downloader” workflow.

After the free tier, pricing is pay-as-you-go based on Apify platform compute units (CU), with scaling options available for heavier usage. Start for free at [apify.com](https://apify.com) and scale when you're ready.

***

### Reliability & Performance

| What We Handle | How |
|---|---|
| Rate limits | Uses built-in request management and spacing between items |
| Proxy support | Lets you route requests through proxy configuration for better reliability |
| Failure-state handling | Pushes a per-URL error result when media can’t be extracted |
| Resilience during parsing | Includes handling around parsing the extracted media metadata |
| Output completeness | Returns a structured `result` object including `medias` when available |

Limitations: The actor extracts media only when the post payload contains the expected video media structure; other post types (for example, posts without the relevant media data) may return an error payload. Private or login-gated content is out of scope.

For enterprise-scale runs, contact us to discuss custom configurations.

***

### Frequently Asked Questions

#### Is there a free plan or trial?

Yes. Apify offers a **free tier** on the platform so you can run Reddit Media Downloader with no credit card required before scaling up.

#### Do I need to log in to Reddit to use this?

No. This actor works on publicly available sources and focuses on extracting media assets from the post payloads it can access without login.

#### How accurate is the data?

The output is as accurate as the media metadata and URLs available in the publicly accessible post data. If a post doesn’t expose the expected media fields, the actor returns a failure result for that URL.

#### How many results can I get per run?

Your results correspond to how many Reddit post URLs you include in `urls`. The actor processes each provided URL and pushes one `result` payload per input link.

#### How often is the data updated / how fresh is it?

The actor fetches media details at run time for each post URL. If you need fresh media renditions, re-run the actor on the same URLs.

#### Is this legal? Does it comply with GDPR / CCPA?

You should treat this as collecting **publicly available data** only. It’s your responsibility to comply with GDPR, CCPA, platform Terms of Service, and any applicable regulations for your use and storage.

#### Can I export results to Google Sheets or Excel?

Yes. You can export your dataset from the Apify dashboard, including formats like JSON and CSV/Excel-compatible exports, and then load the data into Google Sheets or your spreadsheet tool.

#### Can I run this on a schedule automatically?

Yes. You can schedule runs using Apify’s scheduling capabilities so the actor runs automatically at the cadence you choose.

#### Can I access this via API?

Yes. You can trigger runs programmatically and retrieve outputs via the Apify API.

#### What happens if the actor hits an error?

If the actor can’t extract media for a specific URL, it returns a failure payload for that URL with an error flag and message. If there’s an unexpected exception, it also pushes an error result per URL so the run continues without silently dropping records.

***

### Need Help or Have a Request?

Got a question about Reddit Media Downloader or want a new feature added? Reach out at <dataforleads@gmail.com>. Share your use case and feedback—this actor is actively maintained based on user requests. If you want enhancements like improved asset handling or additional output fields for media review workflows (including Reddit video downloader needs), tell us what you’re building.

***

### Disclaimer & Responsible Use

*Reddit Media Downloader is the fastest, most reliable way to extract public Reddit media links — start your free run today.*

This actor collects **publicly available data** from Reddit posts. It does not access private accounts, login-gated content, or password-protected pages. You are responsible for GDPR, CCPA, and platform Terms of Service compliance for how you use and store the extracted content. For data removal requests, contact <dataforleads@gmail.com>. Use responsibly, ethically, and only for lawful purposes.

# Actor input Schema

## `urls` (type: `array`):

List of Reddit post URLs to scrape.

## Actor input object example

```json
{
  "urls": [
    "https://www.reddit.com/r/ChatGPT/comments/1t99m84/the_spaghetti_benchmark/"
  ]
}
```

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("scraperoka/reddit-media-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("scraperoka/reddit-media-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 '{}' |
apify call scraperoka/reddit-media-downloader --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Reddit Media Downloader",
        "description": "🎬 Reddit Media Downloader lets you save posts & videos from Reddit fast and in HD. ⚡ Simple, reliable, and SEO-friendly—perfect for creators, researchers, and social media teams. Download with confidence and enjoy offline anytime!",
        "version": "0.1",
        "x-build-id": "s2Zkn6IedkDwiT6iJ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraperoka~reddit-media-downloader/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraperoka-reddit-media-downloader",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/scraperoka~reddit-media-downloader/runs": {
            "post": {
                "operationId": "runs-sync-scraperoka-reddit-media-downloader",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/scraperoka~reddit-media-downloader/run-sync": {
            "post": {
                "operationId": "run-sync-scraperoka-reddit-media-downloader",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "urls"
                ],
                "properties": {
                    "urls": {
                        "title": "Reddit Post URLs",
                        "type": "array",
                        "description": "List of Reddit post URLs to scrape.",
                        "items": {
                            "type": "string"
                        },
                        "default": [
                            "https://www.reddit.com/r/ChatGPT/comments/1t99m84/the_spaghetti_benchmark/"
                        ]
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
