# OnlyFans Video Downloader | How to Download OnlyFans Videos (`serpxxx/onlyfans-downloader`) Actor

OnlyFans Downloader helps users save accessible OnlyFans content they own or have permission to download.

- **URL**: https://apify.com/serpxxx/onlyfans-downloader.md
- **Developed by:** [SERP XXX](https://apify.com/serpxxx) (community)
- **Categories:** Videos, Automation, Social media
- **Stats:** 2 total users, 1 monthly users, 0.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

## OnlyFans Video Downloader | How to Download OnlyFans Videos

> Browser extension built specifically for saving OnlyFans content — videos, images, GIFs, and text posts — with in-page overlay buttons, bulk gallery scanning, and automatic MP4 conversion, all without leaving your browser.

### Get it Here

Get it here: https://serp.ly/onlyfans-downloader

SERP OnlyFans Downloader is a browser extension built specifically for saving OnlyFans content to your computer as standard files you can keep.

- Save videos, images, GIFs, and text posts from any creator's OnlyFans page for offline viewing
- Bulk download an entire creator's gallery with auto-scroll scanning — no clicking through posts one by one
- Skip generic tools that fail on OnlyFans' authenticated streaming — this extension handles it natively
- Downloads auto-organize into per-creator folders so your files stay sorted without any manual effort

<a href="https://www.youtube.com/@devinschumacher1/videos" target="_blank">
<img src="https://raw.githubusercontent.com/devinschumacher/uploads/main/images/how-to-bulk-download-onlyfans-profile-content-onlyfans-bulk-downloader.jpg" width="700px">
</a>

If you have paid for a subscription and want to keep the content on your device, this extension handles it all directly in your browser.
### Why OnlyFans Downloader

OnlyFans does not offer a built-in way to save videos or images. Videos on the platform are delivered through a streaming format that prevents you from right-clicking and saving them like a normal file. On top of that, the site uses authenticated requests that block generic download tools from accessing your content at all.

That means even if you have paid for a subscription, saving a single video requires workarounds that most people do not want to deal with — desktop software, command-line utilities, or copy-pasting URLs into third-party sites. And if a creator has posted hundreds of images, downloading them one at a time is not realistic.

This extension was designed to solve all of that directly inside your browser, with no extra software required.

### Features

- **In-page download overlays** — Hover over any image or video on a creator's page and a download button appears right on top of the media. One click saves it.
- **Bulk gallery scanner** — Auto-scrolls through a creator's entire media page, collects every photo and video, and downloads them all. Filter by media type to grab only what you need.
- **Automatic MP4 conversion** — Videos are converted from their streaming format to standard MP4 files that play on any device.
- **Per-creator folder organization** — Downloads are sorted into folders by creator name, so you always know where to find your files.
- **Side panel UI** — A tabbed panel organizes detected content into Videos, Images/GIFs, Text, and Bulk sections for easy navigation.
- **Download manager** — Track progress in real time with speed indicators and cancel controls for every active download.
- **DRM detection** — Protected content is flagged before you attempt a download, so you never waste time on files that cannot be saved.
- **Cross-browser support** — Works on Chrome, Edge, Brave, Opera, Whale, Yandex, and Firefox

### How It Works

1. **Install** — Add SERP OnlyFans Downloader to your browser from the [product page](https://serp.ly/onlyfans-downloader), or download the latest version from [GitHub Releases](https://github.com/serpxxx/onlyfans-downloader/releases/latest) and load it manually
2. **Visit a creator's page** — Log in to OnlyFans and navigate to any creator you are subscribed to
3. **Pick what to save** — Use the overlay buttons that appear on each photo and video, or open the side panel to see all detected media organized by type
4. **Files land in organized folders** — Videos are saved as MP4, images keep their original format, and everything is sorted into per-creator directories

### Supported Formats

- **Video output:** MP4 (converted automatically from streaming sources)
- **Video quality:** 720p, 1080p, source, and original depending on availability
- **Images:** JPG, PNG, GIF, WebP, AVIF in original quality
- **Text posts:** Saved as-is

### Step-by-Step Tutorial: How to Download Videos from OnlyFans

Downloading from OnlyFans is tricky because the platform streams video rather than serving direct files, and all requests must be authenticated. This extension handles both problems automatically.

**What you need:** A supported browser — Chrome, Edge, Brave, Firefox, or Opera — an internet connection, and an active OnlyFans subscription to the creator whose content you want to save.

**Step 1 — Install the extension.** Add SERP OnlyFans Downloader from your browser's extension store. Alternatively, download the latest release from [GitHub](https://github.com/serpxxx/onlyfans-downloader/releases/latest) and load it manually in your browser's extension settings.

**Step 2 — Sign in.** Open the extension, enter your email, and complete the one-time verification code to activate your account. This unlocks your free trial downloads. No credit card required.

**Step 3 — Browse OnlyFans.** Log in to OnlyFans and go to any creator's profile, feed, or media page. The extension begins detecting content as soon as the page loads.

**Step 4 — Download individual items.** Hover over any image or video to reveal the overlay download button. Click it to save that item directly to your computer.

**Step 5 — Bulk download an entire gallery.** Open the side panel and switch to the Bulk tab. The scanner will auto-scroll through the creator's media, collect every item, and let you download everything at once. Filter by photos, videos, or all media types.

**Tips:** Downloads are automatically organized into per-creator folders. Use the file picker to choose a custom save location for bulk operations. Check for DRM flags before starting large downloads to avoid interruptions. If media is not detected, refresh the page and let it fully load.

**Troubleshooting:** If content is not showing up, make sure you are logged in to OnlyFans and the page has fully loaded. Click Rescan in the side panel to re-detect. For DRM-protected videos, the extension will flag them so you know before attempting a download.

### Who It's For

- **OnlyFans subscribers** who want to save content they have paid for
- **Offline viewers** who want to archive creator media so it is available without an internet connection
- **Non-technical users** who want a simple, reliable solution without installing desktop apps or running scripts
- **Bulk savers** who want to download an entire creator's gallery rather than saving items one at a time

### Common Use Cases

- Save a video from an OnlyFans post for offline viewing
- Download all images from a creator's media gallery in one batch
- Archive an entire creator's content library using the bulk scanner
- Use overlay buttons to quickly grab individual photos or clips
- Organize downloads by creator into automatically named subfolders

### What Makes OnlyFans Downloader Different

Most generic download tools cannot handle OnlyFans because the platform requires authenticated, signed requests for every piece of media. This extension handles that natively, so it works where other approaches fail.

Beyond compatibility, the extension is built for the specific workflow of saving OnlyFans content:

- **Multi-media support** — Videos, images, GIFs, and text posts. Everything from a creator's page, not just one media type.
- **Bulk tools** — Auto-scroll scanning and batch downloads let you save an entire gallery without clicking through posts one by one.
- **Overlay simplicity** — Hover over any item, click the button, and it downloads. No popups, no extra steps.
- **DRM detection** — Protected content is flagged before you attempt a download, so you never waste time on files that cannot be saved.
- **No external software** — Everything runs inside your browser. No desktop apps, no command-line tools, no configuration files.
- **Automatic organization** — Per-creator folders keep your downloads sorted without any manual effort.
- **Free trial** — Trial downloads included with no credit card required, so you can verify it works before committing

### Trial & Pricing

Trial downloads are included when you sign in with your email — no credit card required. Upgrade to a license for unlimited downloads at the [product page](https://serp.ly/onlyfans-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
- DRM detection protects you from failed downloads
- Downloads auto-save to organized per-creator folders
- Automatic update notifications for new versions

### FAQ

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

Go to any OnlyFans page with video content. Hover over the video and click the download overlay button, or open the extension's side panel and select the video from the list.

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

Yes. The extension detects videos, images, GIFs, and text posts. Each media item gets a download overlay button. The side panel organizes content by type.

#### Q: How does bulk download work?

Open the Bulk tab in the side panel. The extension auto-scrolls through the creator's media page, detects all content, and downloads everything. You can filter by media type (all, photos, or videos).

#### Q: What quality options are available?

The extension detects all available qualities from the source. For videos, common options include 720p, 1080p, source, and original. Quality is parsed from the video URL.

#### Q: What format are downloaded videos?

All videos are saved as standard MP4 files that play on any device or media player. Streaming formats are automatically converted.

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

Videos save to an OnlyFans/Videos/ or OnlyFans/{creator}/Videos/ subfolder inside your Downloads directory. For bulk operations, you can choose a custom folder.

#### Q: Why does a video show "DRM Protected"?

Some OnlyFans content uses DRM encryption. The extension detects this and notifies you. DRM-protected videos cannot be downloaded at this time.

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

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

#### Q: Is my data safe?

Yes. Video processing happens entirely in your browser. Authentication uses secure one-time codes — no passwords stored. The extension accesses OnlyFans using your existing logged-in session cookies.

### License

This repository is distributed under the proprietary SERP Apps license in the [LICENSE](https://github.com/serpxxx/onlyfans-downloader/blob/main/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("serpxxx/onlyfans-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("serpxxx/onlyfans-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 serpxxx/onlyfans-downloader --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "OnlyFans Video Downloader | How to Download OnlyFans Videos",
        "description": "OnlyFans Downloader helps users save accessible OnlyFans content they own or have permission to download.",
        "version": "0.0",
        "x-build-id": "VTJ9NDVFcQcGTKovd"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/serpxxx~onlyfans-downloader/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-serpxxx-onlyfans-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~onlyfans-downloader/runs": {
            "post": {
                "operationId": "runs-sync-serpxxx-onlyfans-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~onlyfans-downloader/run-sync": {
            "post": {
                "operationId": "run-sync-serpxxx-onlyfans-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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
