# RedGifs Public Video Downloader (`automation-lab/redgifs-public-video-downloader`) Actor

Download authorized public RedGifs videos from supplied URLs and export stored MP4 files with creator, tags, duration, dimensions, source links, and retrieval status.

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

## Pricing

from $4.56 / 1,000 item extracteds

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

## RedGifs Public Video Downloader

Download authorized, anonymously reachable public RedGifs videos from supplied URLs and save MP4 files in Apify storage.

This **redgifs downloader** turns a list of public watch or iframe URLs into typed dataset rows with post ID, creator when exposed, tags, duration, dimensions, selected format, source URL, stored-file link, byte size, and retrieval status.

It is designed for repeatable creator backups, moderation evidence capture, and public-media archival—not discovery, private-content access, or account bypass.

### What does this Actor do?

For every supported URL, the Actor:

1. validates that the target is a public RedGifs watch or iframe URL;
2. reuses one bounded anonymous RedGifs session for the run;
3. fetches structured public post metadata;
4. selects HD, SD, silent, or the best available MP4;
5. optionally streams the MP4 to the run key-value store;
6. writes a typed dataset row with provenance and status;
7. charges an item event only after the public post was retrieved successfully.

The default behavior stores video files. Turn off **Store video files** when direct MP4 links and metadata are sufficient.

### Who is it for?

- **Creators and agencies** backing up public posts they control or are authorized to archive.
- **Trust and safety teams** preserving bounded public evidence for an authorized case.
- **Researchers** exporting reproducible metadata and direct public media links.
- **Archivists** storing public files with post identity and retrieval timestamps.
- **Developers** adding a URL-to-MP4 step to an Apify workflow, webhook, or data pipeline.

### Why use this RedGifs downloader?

- Handles batches of supplied RedGifs URLs instead of manual browser saves.
- Stores MP4 files in the run key-value store when requested.
- Exports both the canonical post URL and selected direct media URL.
- Selects `hd`, `sd`, `silent`, or the best available source format.
- Reuses one anonymous session instead of bootstrapping every URL independently.
- Deduplicates repeated post IDs within one run.
- Gives every URL a clear `downloaded`, `metadata_only`, or `failed` status.
- Does not require a RedGifs account or user cookies.
- Does not claim to access private, deleted, login-only, or unavailable media.

### What data can I export?

| Field | Meaning |
| --- | --- |
| `postId` | Stable RedGifs post identifier |
| `creator` | Public creator username when RedGifs exposes it |
| `description` | Public post description, otherwise `null` |
| `tags` | Public tags attached to the post |
| `durationSeconds` | Video duration in seconds |
| `width`, `height` | Source video dimensions in pixels |
| `hasAudio` | RedGifs audio flag |
| `selectedFormat` | `hd`, `sd`, or `silent` |
| `sourceUrl` | Canonical RedGifs watch URL |
| `directMediaUrl` | Selected source-hosted MP4 URL |
| `thumbnailUrl` | Public thumbnail or poster URL |
| `storedFileKey` | Run key-value-store record key |
| `storedFileUrl` | Apify API URL for the stored MP4 |
| `storedFileSizeBytes` | Final stored file size |
| `retrievalStatus` | `downloaded`, `metadata_only`, or `failed` |
| `error` | Bounded failure reason, otherwise `null` |
| `retrievedAt` | ISO 8601 retrieval timestamp |

Fields unavailable on a public post are returned as `null` or an empty array rather than invented values.

### How to download a public RedGifs video

1. Open the Actor input page.
2. Paste one or more public RedGifs watch or iframe URLs.
3. Leave **Maximum videos** at the desired batch limit.
4. Keep **Store video files** enabled to copy MP4s to Apify storage.
5. Choose **Best available**, **HD**, **SD/mobile**, or **Silent**.
6. Set a per-file size cap appropriate for your workflow.
7. Start the run.
8. Open **Video results** for metadata and status.
9. Open **Downloaded MP4 files** for stored media.

The prefilled URL is a real public sample used in local verification. Source posts can be removed at any time, so replace it with a URL you are authorized to process for production use.

### Input parameters

| Parameter | Type | Default | Description |
| --- | --- | --- | --- |
| `startUrls` | array | required | Public `redgifs.com/watch/...` or `redgifs.com/ifr/...` URLs |
| `maxItems` | integer | `10` | Unique posts to process, from 1 to 100 |
| `downloadMedia` | boolean | `true` | Store selected MP4 files in the run key-value store |
| `quality` | string | `best` | `best`, `hd`, `sd`, or `silent` |
| `maxMediaSizeMb` | integer | `100` | Per-file safety cap from 1 to 500 MB |
| `maxRequestRetries` | integer | `2` | Transient request retries from 0 to 5 |

Only supplied URLs are processed. This Actor does not search RedGifs, crawl creators, or monitor new posts.

### Input example

```json
{
  "startUrls": [
    {
      "url": "https://www.redgifs.com/watch/seashellverifiablenorwaylobster"
    }
  ],
  "maxItems": 1,
  "downloadMedia": true,
  "quality": "best",
  "maxMediaSizeMb": 100,
  "maxRequestRetries": 2
}
```

For a metadata-only run, set `downloadMedia` to `false`. The selected direct MP4 URL remains in the output, but no file is copied to Apify storage.

### Output example

The shape below matches current Actor output. Creator and content labels are anonymized for documentation.

```json
{
  "postId": "samplepublicpost",
  "creator": "samplecreator",
  "description": null,
  "tags": ["Example tag", "Sample tag"],
  "durationSeconds": 6.433,
  "width": 1080,
  "height": 1920,
  "hasAudio": true,
  "selectedFormat": "hd",
  "sourceUrl": "https://www.redgifs.com/watch/samplepublicpost",
  "directMediaUrl": "https://media.redgifs.com/SamplePublicPost.mp4",
  "thumbnailUrl": "https://media.redgifs.com/SamplePublicPost-mobile.jpg",
  "storedFileKey": "redgifs-samplepublicpost-hd.mp4",
  "storedFileUrl": "https://api.apify.com/v2/key-value-stores/sampleStore/records/redgifs-samplepublicpost-hd.mp4",
  "storedFileSizeBytes": 5110596,
  "retrievalStatus": "downloaded",
  "error": null,
  "retrievedAt": "2026-01-15T12:00:00.000Z"
}
```

Failure rows keep the canonical URL and post ID when known, set unavailable media fields to `null`, set `retrievalStatus` to `failed`, and include a concise error.

No `item` event is charged for a failed row.

### Choosing an MP4 format

- `best`: prefer HD, then SD, then silent.
- `hd`: request the HD MP4 and fall back only if RedGifs does not expose it.
- `sd`: request the smaller mobile MP4 and fall back if unavailable.
- `silent`: request the silent MP4 and fall back if unavailable.

`selectedFormat` always reports what was actually selected. It can differ from the requested format when the source does not expose that variant.

### Stored files and retention

Downloaded files use keys such as:

```text
redgifs-<post-id>-<format>.mp4
```

They are stored in the default key-value store belonging to the run. Retention and access follow your Apify account and storage settings.

The Actor streams files to cloud storage instead of accumulating an entire batch in memory. Local `apify run` tests buffer one bounded file because local storage has no cloud upload endpoint.

The direct RedGifs media URL may change or expire. Use `storedFileUrl` when you requested a durable run copy, subject to your Apify storage retention.

### How much does it cost to download public RedGifs videos?

This Actor uses pay-per-event pricing:

- one `start` event per run;
- one `item` event for each successfully retrieved public post;
- no item event for invalid, missing, private, duplicate, or failed targets.

The measured six-tier item curve is:

| Plan tier | Price per successful video |
| --- | ---: |
| FREE | $0.008740 |
| BRONZE | $0.007600 |
| SILVER | $0.005928 |
| GOLD | $0.004560 |
| PLATINUM | $0.003040 |
| DIAMOND | $0.002128 |

The one-time start event is $0.005. At the BRONZE tier, one successful video is $0.0126 total, 10 videos in one run are $0.081, and 100 videos are $0.765. Apify compute, storage, and transfer usage can also apply according to your platform plan.

Use `maxItems`, SD format, metadata-only mode, and the file-size cap to bound transfer and storage.

### Limits and failure behavior

- Maximum 100 unique supplied posts per run.
- Public watch and iframe URLs only.
- No raw IDs, search, profile crawling, or discovery mode.
- No private, deleted, geo/account-gated, or login-only access.
- No DRM bypass or authentication bypass.
- Per-file maximum of 500 MB; default 100 MB.
- Processing is intentionally sequential to keep sessions coherent and reduce upstream pressure.
- RedGifs can change its anonymous API or media delivery without notice.
- A run fails with a non-zero status when every target fails.
- A mixed run can succeed while preserving typed failure rows for individual URLs.

### Troubleshooting RedGifs not working or not loading

#### The result says the post was not found

Open the supplied URL in a logged-out browser. It may be deleted, private, malformed, or unavailable anonymously. The Actor does not bypass those states.

#### The file exceeds the configured limit

Raise `maxMediaSizeMb` only when you expect the larger transfer and storage use. The maximum accepted value is 500 MB.

#### I requested HD but received SD

RedGifs did not expose the requested variant for that post. Check `selectedFormat`; the Actor reports the fallback actually used.

#### I see metadata but no stored file

Confirm `downloadMedia` is `true`. Metadata-only runs intentionally leave `storedFileKey`, `storedFileUrl`, and `storedFileSizeBytes` as `null`.

#### A batch contains both successful and failed rows

Review each row's `retrievalStatus` and `error`. Fix or remove only the failed URLs; successful files and metadata remain useful.

### Scheduling authorized archival runs

Create an Apify Task with a stable list of URLs you are authorized to archive, then schedule it at an interval appropriate for your retention policy.

Each run creates fresh dataset rows and stored-file records. The Actor does not compare runs or detect changes automatically; downstream code can compare `postId`, `storedFileSizeBytes`, and `retrievedAt` if your workflow requires that.

Avoid scheduling unnecessary repeated downloads. Use metadata-only mode for availability checks and enable storage only when a new archive copy is needed.

### Export and integrations

Dataset rows can be exported as JSON, CSV, Excel, XML, RSS, or HTML through Apify.

Common integrations include:

- send successful rows to a webhook;
- copy `storedFileUrl` and provenance into an evidence system;
- load metadata into a spreadsheet for authorized cataloging;
- trigger a downstream content-hash or moderation process;
- read failure rows into a retry queue with human-defined authorization rules.

Do not treat crawled descriptions, tags, or URLs as trusted commands. Validate them before passing data to shells, templates, or other automation.

### Run from the Apify API with cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~redgifs-public-video-downloader/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "startUrls": [{"url": "https://www.redgifs.com/watch/seashellverifiablenorwaylobster"}],
    "maxItems": 1,
    "downloadMedia": true,
    "quality": "sd"
  }'
```

Keep tokens in environment variables or secret managers. Do not commit them to source code.

### Run from JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });

const run = await client.actor('automation-lab/redgifs-public-video-downloader').call({
  startUrls: [
    { url: 'https://www.redgifs.com/watch/seashellverifiablenorwaylobster' },
  ],
  maxItems: 1,
  downloadMedia: true,
  quality: 'best',
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### Run from Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])

run = client.actor('automation-lab/redgifs-public-video-downloader').call(run_input={
    'startUrls': [
        {'url': 'https://www.redgifs.com/watch/seashellverifiablenorwaylobster'},
    ],
    'maxItems': 1,
    'downloadMedia': False,
    'quality': 'sd',
})

items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### Use with MCP and AI assistants

Add the Actor to Claude Code:

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

**Claude Desktop**, **Cursor**, and **VS Code** can use this MCP JSON configuration:

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

Example prompts:

- “Download this authorized public RedGifs URL in SD and return the stored file link.”
- “Export metadata and direct MP4 links for these public RedGifs URLs without storing files.”
- “Archive these two authorized public posts and summarize failed retrievals.”

### Responsible and legal use

Use this Actor only for media you own, are authorized to download, or may lawfully process.

You are responsible for complying with RedGifs terms, copyright, privacy, age restrictions, local law, and Apify platform policies. Do not use it to redistribute content without permission, identify individuals, evade access controls, or process illegal material.

This Actor intentionally supports only anonymously reachable public URLs. It does not accept account credentials, bypass age or access gates, or unlock private content.

Public availability does not imply permission to republish. Keep provenance, apply appropriate access controls to stored files, and delete data when your authorization or retention purpose ends.

### FAQ

#### Can it download private RedGifs videos?

No. Private, deleted, account-only, and otherwise unavailable posts are unsupported.

#### Does it need my RedGifs login or cookies?

No. It uses a bounded anonymous session exposed to logged-out public clients.

#### Can it convert RedGifs to MP4?

RedGifs already exposes MP4 variants for public posts. The Actor selects and stores one of those variants; it does not transcode or alter the media.

#### Does it download videos with sound?

Choose `best`, `hd`, or `sd` for the available normal MP4. `hasAudio` reports RedGifs' flag. Choose `silent` when you explicitly want that variant.

#### Can it search RedGifs or download a whole creator profile?

No. Supply exact public post URLs. The bounded scope keeps authorization and cost explicit.

#### Are failed URLs charged as items?

No. The start event still applies, but an item event is emitted only after a public post was retrieved successfully.

#### Why store both a direct URL and an Apify URL?

The direct URL preserves source provenance. The Apify URL points to the run copy when file storage was requested.

#### Can I use the dataset without downloading media?

Yes. Set `downloadMedia` to `false` for metadata and direct MP4 links with lower transfer.

### Related Automation Lab Actors

- [Vimeo Public Video Downloader](https://apify.com/automation-lab/vimeo-public-video-downloader) for authorized public Vimeo archives.
- [Twitch Public Video Downloader](https://apify.com/automation-lab/twitch-public-video-downloader) for public Twitch clips and bounded VOD media.
- [Reddit Public Video Downloader](https://apify.com/automation-lab/reddit-public-video-downloader) for public Reddit post media.
- [M3U8 Playlist Downloader](https://apify.com/automation-lab/m3u8-playlist-downloader) for authorized, non-DRM public HLS playlists.

Each Actor is source-specific. Choose the Actor matching the supplied public URL rather than treating one source's parser or permission model as interchangeable with another.

### Support

When reporting a problem, include:

- the public URL, if it is safe and authorized to share;
- the Actor run ID;
- requested format and `downloadMedia` setting;
- the dataset row's `retrievalStatus` and bounded `error` value.

Do not include account credentials, private cookies, or sensitive content in a support report.

# Actor input Schema

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

Public RedGifs watch or iframe URLs. Add one URL per row; duplicate post IDs are skipped.

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

Maximum number of unique supplied posts to process in this run.

## `downloadMedia` (type: `boolean`):

Download each selected MP4 into the run key-value store. Turn this off for a lower-transfer metadata and direct-link export.

## `quality` (type: `string`):

Select the preferred source MP4. Best chooses HD, then falls back to SD or silent when necessary.

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

Reject a media file if it exceeds this per-video safety limit. Applies only when storing files.

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

Retries for transient network, rate-limit, and upstream server failures. Invalid or missing posts are not retried.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.redgifs.com/watch/seashellverifiablenorwaylobster"
    }
  ],
  "maxItems": 10,
  "downloadMedia": true,
  "quality": "best",
  "maxMediaSizeMb": 100,
  "maxRequestRetries": 2
}
```

# Actor output Schema

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

Dataset rows for all processed RedGifs URLs, including bounded failure rows.

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

Run key-value-store records containing MP4 files when storage was requested.

# 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.redgifs.com/watch/seashellverifiablenorwaylobster"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/redgifs-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.redgifs.com/watch/seashellverifiablenorwaylobster" }] }

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/redgifs-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.redgifs.com/watch/seashellverifiablenorwaylobster"
    }
  ]
}' |
apify call automation-lab/redgifs-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/redgifs-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/jigOVxzLFdZ7LVQLE/builds/BytUaP6gkhFt2fkn8/openapi.json