# RedGifs Bulk Downloader (`maximedupre/redgifs-bulk-downloader`) Actor

Download RedGifs videos in bulk from links, IDs, or search. Export direct MP4 links, thumbnails, tags, duration, views, likes, and optional hosted files or ZIP archives.

- **URL**: https://apify.com/maximedupre/redgifs-bulk-downloader.md
- **Developed by:** [Maxime Dupré](https://apify.com/maximedupre) (community)
- **Categories:** Social media, Developer tools, Automation
- **Stats:** 4 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$9.00 / 1,000 saved videos

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.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/platform/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

### 📥 RedGifs bulk downloader for public videos

RedGifs Bulk Downloader saves public [RedGifs](https://www.redgifs.com/) video metadata and direct MP4 links from watch URLs, iframe URLs, raw video IDs, or a RedGifs search query. Use it when you need repeatable RedGifs video downloads for content review, research, archiving, moderation support, cataloging, or an API workflow.

For a quick first run, keep the prefilled RedGifs targets and search query, leave **Maximum results** at `25`, leave **Download files** off, and start the Actor. The run will save public video rows with RedGifs page URLs, selected MP4 URLs, thumbnails, duration, dimensions, tags, profile details, engagement counts when available, and scrape time. Once the output shape fits your workflow, paste your own video links or IDs, change the search query, adjust the result limit, and enable hosted downloads only when you need files stored in Apify storage.

### ✅ What this Actor does

- Accepts public RedGifs watch URLs.
- Accepts RedGifs iframe URLs when they contain a public video ID.
- Accepts raw RedGifs video IDs.
- Accepts a RedGifs search query and saves matching public videos.
- Saves one dataset row per unique video.
- Returns the selected direct MP4 link plus available video formats.
- Lets you choose `best`, `hd`, `sd`, or `silent` quality.
- Can save MP4 files to Apify key-value storage.
- Can create one ZIP archive for downloaded videos in the run.
- Stops at your maximum result limit so run size and spend stay predictable.

This Actor is built for public RedGifs videos. It does not fetch private, deleted, unavailable, or login-only content, and it does not use a RedGifs account.

### 📊 Data you can export

Each saved video row can include:

- `id` - RedGifs video ID.
- `canonicalUrl` and `sourceUrl` - source links for tracing the result back to RedGifs.
- `rowOrigin` - whether the row came from a direct target or search.
- `input`, `inputIndex`, `searchQuery`, and `searchPosition` - useful context for batch runs.
- `description`, `durationSeconds`, `width`, `height`, and `hasAudio`.
- `tags`, `niches`, and `sexuality` when RedGifs exposes them.
- `thumbnailUrl` and `posterUrl`.
- `selectedQuality`, `requestedQuality`, and `selectedQualityReason`.
- `directVideoUrl` - the selected MP4 link from RedGifs.
- `availableFormats` - other video URLs and quality labels found for the same video.
- `userName`, `verified`, `views`, `likes`, `published`, and `createdAt` when available.
- `scrapedAt` - timestamp for the extraction run.
- `file` and `zipFile` when hosted downloads and ZIP creation are enabled.

You can open the dataset in Apify, export it as JSON, CSV, Excel, XML, RSS, or HTML, call it from the Apify API, schedule recurring runs, or connect the results to webhooks and integrations.

### 🚀 How to run

1. Add RedGifs links or IDs in **RedGifs URLs or IDs**, enter a **Search query**, or use both.
2. Choose **Preferred quality**: `best`, `hd`, `sd`, or `silent`.
3. Keep **Download files** off if direct RedGifs MP4 links are enough.
4. Turn on **Download files** when you want hosted Apify storage links.
5. Turn on **Create ZIP archive** only when **Download files** is also enabled.
6. Set **Maximum results** to control the total number of saved videos.
7. Start the Actor and open the dataset.

Example targets:

```text
https://www.redgifs.com/watch/seashellverifiablenorwaylobster
welllitfavorablefulmar
````

Example search:

```text
funny
```

### 🔧 Input options

| Field | What to enter |
| ----- | ------------- |
| `targets` | Public RedGifs watch URLs, iframe URLs, or raw video IDs. |
| `searchQuery` | Optional RedGifs search text for finding matching public videos. |
| `preferredQuality` | `best`, `hd`, `sd`, or `silent`. Default is `best`. |
| `downloadFiles` | Save selected MP4 files to Apify storage and add hosted links. Default is `false`. |
| `createZip` | Create one ZIP archive for downloaded videos. Requires `downloadFiles`. Default is `false`. |
| `maxItems` | Maximum videos to save across direct targets and search. Default is `25`; maximum is `500`. |

### 📄 Output example

```json
{
	"rowOrigin": "search",
	"input": null,
	"searchQuery": "funny",
	"searchPosition": 1,
	"targetType": "searchResult",
	"id": "examplevideoid",
	"canonicalUrl": "https://www.redgifs.com/watch/examplevideoid",
	"sourceUrl": "https://www.redgifs.com/watch/examplevideoid",
	"description": "Public RedGifs description",
	"durationSeconds": 12.34,
	"width": 1280,
	"height": 720,
	"hasAudio": true,
	"tags": ["tag-one", "tag-two"],
	"thumbnailUrl": "https://thumbs.example/example.jpg",
	"posterUrl": "https://thumbs.example/poster.jpg",
	"selectedQuality": "hd",
	"requestedQuality": "best",
	"selectedQualityReason": "Best available format selected.",
	"directVideoUrl": "https://media.example/example.mp4",
	"availableFormats": [
		{
			"quality": "hd",
			"url": "https://media.example/example.mp4"
		}
	],
	"userName": "creator",
	"verified": false,
	"views": 12345,
	"likes": 678,
	"published": "2026-06-01T12:00:00.000Z",
	"createdAt": "2026-06-01T12:00:00.000Z",
	"scrapedAt": "2026-06-13T10:00:00.000Z"
}
```

When **Download files** is enabled, rows also include `file.downloadUrl`, `file.storageKey`, `file.contentType`, and `file.fileSizeBytes`. When **Create ZIP archive** is enabled and files were downloaded, rows include `zipFile.downloadUrl` for the run archive.

### 💾 Direct links, hosted files, and ZIPs

By default, the Actor returns direct RedGifs MP4 links. This is the lightest option and is usually enough when your next step is a script, spreadsheet, database import, or manual review.

Enable **Download files** when you want the selected MP4 copied into the run's Apify key-value store. This gives you a hosted `downloadUrl` tied to the run. Enable **Create ZIP archive** when you want one ZIP file containing the downloaded videos from that run.

### 💸 Pricing

This Actor uses pay-per-event pricing. You are charged `$0.009` for each public RedGifs video saved by the Actor. Skipped, missing, duplicate, or unsupported targets do not create saved-video events.

Use **Maximum results** to keep a test run small or to cap production spend. A run with hosted file downloads can also use more storage and bandwidth than a metadata-only run.

### ⚖️ Limits and caveats

The Actor works with public RedGifs data that RedGifs exposes for the requested videos or search results. Some videos may have fewer metadata fields, missing engagement counts, or fewer video formats. In those cases, the Actor saves the available fields and leaves unavailable values empty.

Direct MP4 links are source links and may depend on RedGifs availability after your run. If you need run artifacts instead of source-hosted links, enable **Download files** and optionally **Create ZIP archive**.

Search results are saved until the Actor reaches **Maximum results** or RedGifs stops returning matching videos for the query.

### ❓ FAQ

#### Can I download private RedGifs videos?

No. This Actor is for public RedGifs videos only. It does not use a RedGifs account and does not bypass private, deleted, unavailable, or login-only content.

#### Can I use raw RedGifs IDs instead of full URLs?

Yes. Paste one raw video ID per row in **RedGifs URLs or IDs**. You can mix IDs and full RedGifs links in the same run.

#### Does the Actor always download video files?

No. By default, it saves metadata and direct MP4 links only. Turn on **Download files** when you want MP4 files copied to Apify storage.

#### Can I search RedGifs and download the matching videos?

Yes. Enter a **Search query** and set **Maximum results** to the number of public videos you want to save. If **Download files** is enabled, the Actor downloads the selected MP4 for each saved result.

### 📝 Changelog

- 0.1: Initial release.

### 🆘 Support

For issues, questions, or feature requests, [file a ticket](https://console.apify.com/actors/maximedupre~redgifs-bulk-downloader/issues) and I'll fix or implement it in less than 24h 🫡

### 🔗 Other actors

- [Facebook Media Downloader ↗](https://apify.com/maximedupre/facebook-media-downloader) - Download public Facebook videos and reels with media links and metadata.
- [TikTok Video Downloader ↗](https://apify.com/maximedupre/tiktok-video-downloader) - Save public TikTok video or audio files from known video URLs.
- [Twitter Media Scraper ↗](https://apify.com/maximedupre/twitter-media-scraper) - Extract images, videos, and GIFs from public Twitter/X posts and searches.
- [Pinterest Video Downloader ↗](https://apify.com/maximedupre/pinterest-video-downloader) - Export public Pinterest pin videos, images, thumbnails, and media variants.
- [Instagram Downloader API ↗](https://apify.com/maximedupre/instagram-downloader-api) - Collect public Instagram post and reel media links with source metadata.

**Made with ❤️ by Maxime Dupré**

# Actor input Schema

## `targets` (type: `array`):

Add one RedGifs video link or video ID per row.

## `searchQuery` (type: `string`):

Optional RedGifs search text for finding matching public videos.

## `preferredQuality` (type: `string`):

Choose the video quality to save for each result.

## `downloadFiles` (type: `boolean`):

Save videos to Apify storage and add hosted download links to the output.

## `createZip` (type: `boolean`):

Create one ZIP file for downloaded videos in this run.

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

Maximum RedGifs videos to save across direct targets and search results.

## Actor input object example

```json
{
  "targets": [
    "https://www.redgifs.com/watch/seashellverifiablenorwaylobster",
    "welllitfavorablefulmar"
  ],
  "searchQuery": "funny",
  "preferredQuality": "best",
  "downloadFiles": false,
  "createZip": false,
  "maxItems": 25
}
```

# Actor output Schema

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

Open video rows with direct MP4 links, thumbnails, tags, duration, source URLs, and hosted file links when 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 = {
    "targets": [
        "https://www.redgifs.com/watch/seashellverifiablenorwaylobster",
        "welllitfavorablefulmar"
    ],
    "searchQuery": "funny",
    "maxItems": 25
};

// Run the Actor and wait for it to finish
const run = await client.actor("maximedupre/redgifs-bulk-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 = {
    "targets": [
        "https://www.redgifs.com/watch/seashellverifiablenorwaylobster",
        "welllitfavorablefulmar",
    ],
    "searchQuery": "funny",
    "maxItems": 25,
}

# Run the Actor and wait for it to finish
run = client.actor("maximedupre/redgifs-bulk-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 '{
  "targets": [
    "https://www.redgifs.com/watch/seashellverifiablenorwaylobster",
    "welllitfavorablefulmar"
  ],
  "searchQuery": "funny",
  "maxItems": 25
}' |
apify call maximedupre/redgifs-bulk-downloader --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "RedGifs Bulk Downloader",
        "description": "Download RedGifs videos in bulk from links, IDs, or search. Export direct MP4 links, thumbnails, tags, duration, views, likes, and optional hosted files or ZIP archives.",
        "version": "0.1",
        "x-build-id": "HTCS9F7MVZQ27tEXC"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/maximedupre~redgifs-bulk-downloader/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-maximedupre-redgifs-bulk-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/maximedupre~redgifs-bulk-downloader/runs": {
            "post": {
                "operationId": "runs-sync-maximedupre-redgifs-bulk-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/maximedupre~redgifs-bulk-downloader/run-sync": {
            "post": {
                "operationId": "run-sync-maximedupre-redgifs-bulk-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",
                "properties": {
                    "targets": {
                        "title": "RedGifs URLs or IDs",
                        "maxItems": 500,
                        "type": "array",
                        "description": "Add one RedGifs video link or video ID per row.",
                        "items": {
                            "type": "string",
                            "minLength": 1
                        }
                    },
                    "searchQuery": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Optional RedGifs search text for finding matching public videos."
                    },
                    "preferredQuality": {
                        "title": "Preferred quality",
                        "enum": [
                            "best",
                            "hd",
                            "sd",
                            "silent"
                        ],
                        "type": "string",
                        "description": "Choose the video quality to save for each result.",
                        "default": "best"
                    },
                    "downloadFiles": {
                        "title": "Download files",
                        "type": "boolean",
                        "description": "Save videos to Apify storage and add hosted download links to the output.",
                        "default": false
                    },
                    "createZip": {
                        "title": "Create ZIP archive",
                        "type": "boolean",
                        "description": "Create one ZIP file for downloaded videos in this run.",
                        "default": false
                    },
                    "maxItems": {
                        "title": "Maximum results",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum RedGifs videos to save across direct targets and search results.",
                        "default": 25
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
