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

{
  "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.

{
  "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:

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

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

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

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:

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:

{
  "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 for authorized public Vimeo archives.
• Twitch Public Video Downloader for public Twitch clips and bounded VOD media.
• Reddit Public Video Downloader for public Reddit post media.
• 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.