# Whop Video Downloader (`serpdownloaders/whop-video-downloader`) Actor

Browser extension for saving Whop course and member-only videos as MP4 using your active session for offline viewing.

- **URL**: https://apify.com/serpdownloaders/whop-video-downloader.md
- **Developed by:** [SERP Downloaders](https://apify.com/serpdownloaders) (community)
- **Categories:** Videos, Automation, Social media
- **Stats:** 4 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

## 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

## Whop Downloader  (Browser Extension)

> Browser extension that lets you download Whop videos, images, and text posts directly to your computer — detects every piece of downloadable content on the page and organizes it by type, no extra software required.

SERP Whop Downloader is a browser extension built specifically for saving content from Whop — videos, images, and text posts — as standard files you can keep.

- Save course videos, images, and text posts from any Whop page for offline viewing and study
- Download all visible content from a course or lesson page in one click with "Download Visible" bulk action
- Skip generic tools that fail on Whop's layered page structure — this extension finds content other tools miss entirely
- In-page overlay buttons appear directly on video players so you can save without opening a popup

If you have purchased a course or joined a community on Whop and want to keep the content on your device, this extension handles it all directly in your browser.

### Links

- :rocket: Get it here: [Whop Downloader](https://serp.ly/whop-video-downloader)
- :new: Latest release: [GitHub Releases](https://github.com/serpapps/whop-video-downloader/releases/latest)
- :question: Help center: [SERP Help](https://help.serp.co/en/)
- :beetle: Report bugs: [GitHub Issues](https://github.com/serpapps/whop-video-downloader/issues)
- :bulb: Request features: [Feature Requests](https://github.com/serpapps/whop-video-downloader/discussions)

### Why Whop Downloader

Whop streams course videos in a format that blocks right-click saving, and there is no built-in export for the images or text posts on the platform. Buying a course does not mean you can easily keep the files. Generic browser extensions fail because Whop nests its media inside deeply layered page structures that standard tools cannot reach. They miss videos, skip images, and ignore text content entirely.

SERP Whop Downloader was purpose-built for Whop. It understands the platform's page structure, finds content that other tools overlook, and handles video, image, and text downloads from a single extension — no desktop software and no command line.

### Features

- **Video downloads** — Detects Whop-hosted course and lesson videos and saves them as standard MP4 files
- **Image downloads** — Finds images embedded in posts, lessons, and community pages in their original format
- **Text post export** — Saves text-based lesson content and community posts as readable .txt files with metadata
- **Bulk download** — "Download Visible" grabs all detected items in the active tab with one click
- **In-page overlay buttons** — Download buttons appear directly on video players so you can save without opening the popup
- **Download queue** — Handles up to 3 simultaneous downloads with real-time progress tracking
- **Tabbed popup** — Videos, Images, and Text organized in separate tabs with asset counts and previews
- **Cross-browser support** — Works on Chrome, Edge, Brave, Opera, Whale, Yandex, and Firefox

### How It Works

1. **Install** — Add SERP Whop Downloader to your browser from the [product page](https://serp.ly/whop-video-downloader), or download the latest version from [GitHub Releases](https://github.com/serpapps/whop-video-downloader/releases/latest) and load it manually
2. **Open your Whop content** — Head to Whop and navigate to any course, lesson, or community post you want to save
3. **Let it detect everything** — Click the extension icon. The popup scans the page and shows all found videos, images, and text posts sorted into tabs.
4. **Save what you need** — Download items individually, use the overlay button on a video player, or hit "Download Visible" to save everything in the active tab at once

### Supported Formats

- **Video:** MP4 (standard format, plays everywhere)
- **Images:** Original format preserved (JPG, PNG, WebP, and others)
- **Text:** Plain .txt files with post metadata
- **Quality:** Highest available from the source

### Step-by-Step Tutorial: How to Download Videos From Whop

Downloading from Whop is tricky because the platform streams video in a way that blocks normal saving, and media is embedded inside layered page components. This Whop course downloader Chrome extension handles all of that automatically. Here is how to get started.

**What you need:** A supported browser — Chrome, Edge, Brave, Firefox, or Opera — an internet connection, and a Whop account with purchased content.

**Step 1 — Install the extension.** Visit the extension store for your browser and add SERP Whop Downloader. Alternatively, download the latest release from [GitHub](https://github.com/serpapps/whop-video-downloader/releases/latest) and load it manually in your browser's extension settings. The icon appears in your toolbar once installed.

**Step 2 — Sign in.** Click the extension icon and enter your email. You will receive a one-time verification code — enter it to activate your 3 free trial downloads. No credit card required.

**Step 3 — Open your content on Whop.** Navigate to the course, lesson, or community post you want to save. For videos, press play at least once so the video stream becomes available to the extension.

**Step 4 — Download.** Click the extension icon to open the popup. Switch between the Videos, Images, and Text tabs to see what was found. Download items one at a time, use the overlay button on the video player, or click "Download Visible" to save Whop videos offline in bulk. Videos are converted to MP4 automatically.

**Tips:** After scrolling to load more content, click Rescan to pick up new items. Use Shift+Click on Rescan for a full page refresh. The download queue processes up to 3 files at the same time, so bulk downloads finish quickly.

**Troubleshooting:** If a video is not detected, press play on it first, then click Rescan. Make sure the extension is enabled and you are on a Whop page. Check that your browser is up to date for best compatibility.

### Who It's For

- **Course buyers** who want to save purchased Whop lessons for offline study
- **Community members** who need to revisit video and image posts without an internet connection
- **Content creators** looking to archive their own Whop-hosted material
- **Non-technical users** who want a simple, browser-based solution without extra software or scripts

### Common Use Cases

- Save course videos from Whop for offline viewing on any device
- Download images from Whop posts and lessons for personal reference
- Export text-based lesson notes as files for study or review
- Bulk download all visible content from a Whop course page in one click
- Use in-page overlay buttons for quick, one-click saves while browsing
- Archive purchased content as a personal backup

### What Makes Whop Downloader Different

Most download extensions only look for basic video links on a page. Whop Downloader goes further:

- **Multi-content detection** — Videos, images, and text posts are all found and organized automatically. You do not need a separate tool for each content type.
- **Built for Whop's page structure** — Finds media buried inside nested page components that generic tools cannot access.
- **In-page overlay buttons** — Download directly from the video player without opening any popup or menu.
- **Concurrent download queue** — Multiple files download at the same time instead of one by one.
- **No extra software** — Everything runs in your browser. No desktop apps, no command-line tools, no technical setup.
- **Free trial** — 3 downloads included with no credit card required, so you can verify it works before committing

### Trial & Pricing

3 free downloads are included — no credit card required. Sign in with your email, verify with a one-time code, and your trial is ready immediately. Upgrade to a license for unlimited downloads at the [product page](https://serp.ly/whop-video-downloader).

- Works on Chrome, Edge, Brave, Opera, Firefox, Whale, and Yandex
- Secure one-time-passcode sign-in — no passwords stored
- All processing happens locally in your browser
- Automatic update notifications for new versions

### FAQ

#### Q: How do I download a video from Whop?

Go to any page on Whop that contains video content. Click the extension icon, switch to the Videos tab, and click Download on any video. You can also use the overlay button that appears directly on the video player.

#### Q: Can I download images and text too?

Yes. The extension detects videos, images, and text posts. Use the tabs in the popup to switch between content types and download what you need.

#### Q: What about streaming videos on Whop?

The extension automatically detects streaming video players and converts them to standard MP4 files saved to your computer.

#### Q: Can I download everything at once?

Yes. Click "Download Visible" to start downloading all detected items in the active tab — Videos, Images, or Text.

#### Q: Where are my downloads saved?

Files save to your browser's default Downloads directory.

#### Q: How many free downloads do I get?

You get 3 free trial downloads after signing in with your email. After that, purchase a license for unlimited downloads.

#### Q: Does this work on Firefox?

Yes — supports Chrome, Edge, Brave, Opera, Whale, Yandex, and Firefox.

#### Q: Why isn't the extension finding my content?

Make sure you are on a Whop page with visible content. Click Rescan in the popup to re-detect. For videos, press play first so the stream becomes available.

#### Q: Is my data safe?

Yes. All processing happens entirely in your browser. Authentication uses a secure one-time code — no passwords stored.

### Watch the Video

<a href="https://www.youtube.com/watch?v=oWmu4MOS2HE" target="_blank">
<img src="https://raw.githubusercontent.com/devinschumacher/uploads/refs/heads/main/images/how-to-download-whop-videos-for-free-step-by-step-guide-to-downloading-videos-from-whopcom.jpg" width="700px">
</a>

### License

This repository is distributed under the proprietary SERP Apps license in the [LICENSE](LICENSE) file. Review that file before copying, modifying, or redistributing any part of this project.

# Actor input Schema

## `listingNotice` (type: `string`):

Optional informational field only. This actor currently serves as the public listing surface for the browser extension and does not yet expose a finalized runtime API contract.

## Actor input object example

```json
{
  "listingNotice": "No runtime input is required yet. See the README and product page for the current extension workflow."
}
````

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {};

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Whop Video Downloader",
        "description": "Browser extension for saving Whop course and member-only videos as MP4 using your active session for offline viewing.",
        "version": "0.0",
        "x-build-id": "KGq1FSggdJafPNn9c"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/serpdownloaders~whop-video-downloader/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-serpdownloaders-whop-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/serpdownloaders~whop-video-downloader/runs": {
            "post": {
                "operationId": "runs-sync-serpdownloaders-whop-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/serpdownloaders~whop-video-downloader/run-sync": {
            "post": {
                "operationId": "run-sync-serpdownloaders-whop-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": {
                    "listingNotice": {
                        "title": "Listing notice",
                        "type": "string",
                        "description": "Optional informational field only. This actor currently serves as the public listing surface for the browser extension and does not yet expose a finalized runtime API contract.",
                        "default": "No runtime input is required yet. See the README and product page for the current extension workflow."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
