# RedGifs Bulk Video Downloader (`serpxxx/redgifs-bulk-video-downloader`) Actor

Bulk RedGifs downloader for extracting video metadata, direct MP4 URLs, and optional Apify-hosted download links from RedGifs links.

- **URL**: https://apify.com/serpxxx/redgifs-bulk-video-downloader.md
- **Developed by:** [SERP XXX](https://apify.com/serpxxx) (community)
- **Categories:** Videos, Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $10.00 / 1,000 results

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 Video Downloader

RedGifs Bulk Video Downloader

### RedGifs Downloader Built for Bulk Video Workflows

This actor is designed for people who need more than a single manual download button. It turns RedGifs pages into clean dataset rows that can be exported, filtered, automated, scheduled, or connected to other Apify workflows.

Use it to process individual RedGifs URLs, bulk URL lists, iframe URLs, raw IDs, or search results. By default, it keeps runs lightweight by extracting metadata and direct downloadable MP4 links. When you need files stored by Apify, enable file downloads and the actor can save selected videos to Apify key-value storage and return clickable `storedFileUrl` links.

### Features

- Bulk process RedGifs watch URLs, iframe URLs, and raw RedGifs IDs
- Search RedGifs and return matching video results
- Extract direct MP4 URLs from RedGifs API responses
- Select preferred quality: best, HD, SD, or silent
- Return normalized metadata including title, description, tags, dimensions, duration, thumbnails, and canonical URL
- Generate clickable download links in the Apify dataset
- Optional Apify-hosted file storage with `storedFileUrl`
- Optional ZIP creation for smaller RedGifs batches when file downloads are enabled
- Works as a no-code Apify actor, scheduled job, API endpoint, or automation step

### Benefits

- Save time compared with opening RedGifs pages one by one
- Turn RedGifs video pages into structured rows for export or automation
- Extract direct video links without maintaining your own RedGifs integration
- Keep costs lower by using direct-link extraction as the default mode
- Store videos in Apify only when you actually need hosted file downloads
- Use the same actor from the Apify UI, API clients, webhooks, or scheduled runs

### Web Browser Extension Alternative

Need a simpler one-click downloader instead of a bulk Apify workflow? Use the RedGifs web browser extension alternative for normal browser-based downloading.

👉 Get the browser extension alternative here: https://serp.ly/redgifs-downloader

### Screenshots

Suggested screenshots for this lander:

- Apify input form with URL list and quality selector
- Dataset output showing `directVideoUrl`, `thumbnailUrl`, and `status`
- Optional file-download output showing `storedFileUrl`
- Example exported CSV or JSON dataset row

### Common Use Cases

- Build a RedGifs video dataset from a list of URLs
- Extract direct MP4 download links from RedGifs pages
- Convert RedGifs iframe URLs into canonical watch URLs and media links
- Archive publicly accessible RedGifs clips into Apify key-value storage
- Feed RedGifs metadata into content research, moderation, cataloging, or internal tools
- Schedule recurring RedGifs searches and collect new matching results

### Output Fields

Each successful dataset item can include:

- `inputUrl`
- `sourceUrl`
- `canonicalUrl`
- `id`
- `title`
- `description`
- `duration`
- `width`
- `height`
- `tags`
- `thumbnailUrl`
- `availableFormats`
- `selectedFormat`
- `directVideoUrl`
- `status`
- `errorMessage`
- `storedFileKey`, `storedFileUrl`, and `fileSizeBytes` when file downloads are enabled
- `zipFileKey`, `zipFileUrl`, and `zipFileSizeBytes` when ZIP export is enabled and succeeds

### Download Options

Default mode returns direct RedGifs MP4 links. This is the fastest and cheapest workflow for most users.

If `downloadFiles` is enabled, the actor downloads selected videos into Apify key-value storage and returns a clickable `storedFileUrl` for each file. For RedGifs, ZIP export can also be useful for small batches, but individual file links are the primary download path.

### FAQ

#### Can I download multiple RedGifs videos at once?

Yes. Paste multiple RedGifs URLs, iframe URLs, or IDs into the input and the actor returns one structured result per processed item.

#### Does this return direct MP4 links?

Yes. The actor extracts direct RedGifs media URLs where available and includes the selected URL in `directVideoUrl`.

#### Can Apify host the downloaded files for me?

Yes. Enable `downloadFiles` to save selected videos into Apify key-value storage and receive clickable `storedFileUrl` links.

#### Is ZIP supported?

Yes for smaller RedGifs batches when file downloads are enabled. For most workflows, per-file download links are simpler and more reliable.

#### Is this affiliated with RedGifs?

No. This actor is an independent tool and is not affiliated with, endorsed by, or sponsored by RedGifs.

### How to Use

1. Open the bulk downloader here: https://serp.ly/redgifs-bulk-video-downloader
2. Paste one or more RedGifs watch URLs, iframe URLs, or raw IDs.
3. Choose your preferred quality: best, HD, SD, or silent.
4. Run the actor.
5. Open the dataset results and use `directVideoUrl` for the source MP4 link.
6. If file downloads are enabled, use `storedFileUrl` as the clickable Apify-hosted download link.

### Links

- Run it here: https://serp.ly/redgifs-bulk-video-downloader
- Browser extension alternative: https://serp.ly/redgifs-downloader

# Actor input Schema

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

RedGifs watch URLs, iframe URLs, or raw IDs to process.
## `urlText` (type: `string`):

Optional textarea input with one RedGifs URL or raw ID per line.
## `searchQuery` (type: `string`):

Optional RedGifs API search query.
## `maxItems` (type: `integer`):

Maximum number of discovered URLs to process.
## `downloadFiles` (type: `boolean`):

Download selected media into the default key-value store. Keep false for smoke tests.
## `createZip` (type: `boolean`):

When downloadFiles is enabled, also create a ZIP archive containing all downloaded videos.
## `preferredQuality` (type: `string`):

Requested quality: best, hd, sd, or silent. best prefers hd, then sd, then silent.
## `useApifyProxy` (type: `boolean`):

Route page/media requests through Apify Proxy. Recommended for cloud runs.
## `proxyGroups` (type: `array`):

Optional Apify Proxy groups, for example RESIDENTIAL if enabled on the account.

## Actor input object example

```json
{
  "urlText": "https://www.redgifs.com/watch/seashellverifiablenorwaylobster\nhttps://www.redgifs.com/watch/welllitfavorablefulmar",
  "maxItems": 2,
  "downloadFiles": false,
  "createZip": true,
  "preferredQuality": "best",
  "useApifyProxy": false
}
````

# 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 = {
    "urlText": `https://www.redgifs.com/watch/seashellverifiablenorwaylobster
https://www.redgifs.com/watch/welllitfavorablefulmar`,
    "maxItems": 2,
    "downloadFiles": false,
    "createZip": false,
    "preferredQuality": "best",
    "useApifyProxy": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("serpxxx/redgifs-bulk-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 = {
    "urlText": """https://www.redgifs.com/watch/seashellverifiablenorwaylobster
https://www.redgifs.com/watch/welllitfavorablefulmar""",
    "maxItems": 2,
    "downloadFiles": False,
    "createZip": False,
    "preferredQuality": "best",
    "useApifyProxy": False,
}

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

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

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

```

## CLI example

```bash
echo '{
  "urlText": "https://www.redgifs.com/watch/seashellverifiablenorwaylobster\\nhttps://www.redgifs.com/watch/welllitfavorablefulmar",
  "maxItems": 2,
  "downloadFiles": false,
  "createZip": false,
  "preferredQuality": "best",
  "useApifyProxy": false
}' |
apify call serpxxx/redgifs-bulk-video-downloader --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "RedGifs Bulk Video Downloader",
        "description": "Bulk RedGifs downloader for extracting video metadata, direct MP4 URLs, and optional Apify-hosted download links from RedGifs links.",
        "version": "0.1",
        "x-build-id": "LDzqYbmQqdw4oDmCH"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/serpxxx~redgifs-bulk-video-downloader/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-serpxxx-redgifs-bulk-video-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/serpxxx~redgifs-bulk-video-downloader/runs": {
            "post": {
                "operationId": "runs-sync-serpxxx-redgifs-bulk-video-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/serpxxx~redgifs-bulk-video-downloader/run-sync": {
            "post": {
                "operationId": "run-sync-serpxxx-redgifs-bulk-video-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": {
                    "urls": {
                        "title": "Video URLs",
                        "type": "array",
                        "description": "RedGifs watch URLs, iframe URLs, or raw IDs to process.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "urlText": {
                        "title": "Video URLs, one per line",
                        "type": "string",
                        "description": "Optional textarea input with one RedGifs URL or raw ID per line."
                    },
                    "searchQuery": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Optional RedGifs API search query."
                    },
                    "maxItems": {
                        "title": "Maximum items",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum number of discovered URLs to process.",
                        "default": 20
                    },
                    "downloadFiles": {
                        "title": "Download files",
                        "type": "boolean",
                        "description": "Download selected media into the default key-value store. Keep false for smoke tests.",
                        "default": false
                    },
                    "createZip": {
                        "title": "Create ZIP archive",
                        "type": "boolean",
                        "description": "When downloadFiles is enabled, also create a ZIP archive containing all downloaded videos.",
                        "default": true
                    },
                    "preferredQuality": {
                        "title": "Preferred quality",
                        "enum": [
                            "best",
                            "hd",
                            "sd",
                            "silent"
                        ],
                        "type": "string",
                        "description": "Requested quality: best, hd, sd, or silent. best prefers hd, then sd, then silent.",
                        "default": "best"
                    },
                    "useApifyProxy": {
                        "title": "Use Apify Proxy",
                        "type": "boolean",
                        "description": "Route page/media requests through Apify Proxy. Recommended for cloud runs.",
                        "default": false
                    },
                    "proxyGroups": {
                        "title": "Apify Proxy groups",
                        "type": "array",
                        "description": "Optional Apify Proxy groups, for example RESIDENTIAL if enabled on the account.",
                        "items": {
                            "type": "string"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
