# JustForFans Downloader (`serpxxx/justforfans-downloader`) Actor

Justforfans Downloader gives you a fast, reliable way to save Justforfans videos for offline access. It is built for local-first downloading, preserves the best available quality, and keeps the workflow simple for people who need dependable saves without extra tooling.

- **URL**: https://apify.com/serpxxx/justforfans-downloader.md
- **Developed by:** [SERP X](https://apify.com/serpxxx) (community)
- **Categories:** Videos, Automation, Social media
- **Stats:** 6 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

## JustForFans Downloader (Browser Extension)

> Save JustForFans videos, images, galleries, and text posts from creator feeds directly in your browser.

### Links

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

JustForFans Downloader is a browser extension built specifically for saving supported JustForFans content in a cleaner, browser-native workflow. It can detect videos, images, gallery posts, and text from visible feed items, organize them by content type, and export video as MP4 for easier offline viewing.

- Save JustForFans videos, images, galleries, and text posts
- Download all visible feed content in one pass with a bulk action
- Export supported video streams as MP4 files
- Keep downloads organized in a dedicated JustForFans folder
- Skip generic tools that miss protected or feed-scoped media
### Table of Contents

- [Why JustForFans Downloader](#why-justforfans-downloader)
- [Features](#features)
- [How It Works](#how-it-works)
- [Step-by-Step Tutorial: How to Download Content from JustForFans](#step-by-step-tutorial-how-to-download-content-from-justforfans)
- [Supported Formats](#supported-formats)
- [Who It's For](#who-its-for)
- [Common Use Cases](#common-use-cases)
- [Troubleshooting](#troubleshooting)
- [Trial and Access](#trial-and-access)
- [Installation Instructions](#installation-instructions)
- [FAQ](#faq)
- [License](#license)
- [Notes](#notes)
- [About JustForFans](#about-justforfans)

### Why JustForFans Downloader

JustForFans content is not limited to one simple file type. Videos can rely on protected playback, galleries require expansion, and text posts live alongside media in the same feed. Generic downloaders usually ignore half that structure. They miss gallery images, skip feed text, or fail once the video is delivered through a protected player.

JustForFans Downloader is built for the actual feed workflow. It scans visible posts, groups content by type, and gives you direct save options for videos, images, galleries, and text from the same page.

### Features

- Feed-aware scanning for videos, images, galleries, and text
- Per-post download controls for targeted saves
- Bulk "Download Visible" action for on-screen feed content
- Converts HLS streams and DASH encrypted video to MP4 in-browser
- MP4 export for supported video playback flows
- Gallery expansion support for multi-image posts
- Quality selector with all available video resolutions
- Right-click context menu for quick video downloads
- Download organization into a JustForFans folder
- Tabbed popup UI for browsing Videos, Images, and Text Posts separately
- Cross-browser support for Chrome, Edge, Brave, Opera, Firefox, Whale, and Yandex

### How It Works

1. Install the extension from the latest release.
2. Sign in with your email and verify using a one-time code.
3. Open a JustForFans creator page and scroll through the feed.
4. Let the extension scan visible posts.
5. Open the popup to review Videos, Images, and Text tabs.
6. Save individual posts or use the bulk action to download everything currently visible.
7. Check your Downloads/JustForFans folder for saved content.

### Step-by-Step Tutorial: How to Download Content from JustForFans

1. Install JustForFans Downloader in your browser.
2. Open the extension and complete email sign-in with the one-time verification code.
3. Go to a creator page on JustForFans and scroll through the content you want to save.
4. Open the popup to review Videos, Images, and Text tabs.
5. Use the per-post download button for individual items or "Download Visible" to bulk save everything currently on screen.
6. For videos, choose the available quality if more than one option appears.
7. After scrolling to load more content, click the Rescan button to detect new posts.
8. Open the saved content from your Downloads/JustForFans folder.

### Supported Formats

- Video output: MP4
- Image output: original downloadable image files where supported
- Text output: saved text post content

Video files use MP4 so they are easier to replay on standard media players, move between devices, or archive locally. HLS and DASH streams are converted automatically.

### Who It's For

- JustForFans subscribers who want offline access to content they can already view
- Users archiving creator posts, galleries, and videos in one workflow
- Non-technical users who want a browser extension instead of scripts
- People who need feed-aware bulk download controls
- Anyone organizing personal downloads into a cleaner local library

### Common Use Cases

- Save a creator feed for offline access
- Download visible videos, images, and text in one pass
- Export supported JustForFans videos as MP4
- Archive gallery posts without opening every item manually
- Use per-post buttons for targeted saves of individual items

### Troubleshooting

**The extension is not finding posts**  
Scroll through the feed first so the content becomes visible, then rescan.

**The video download is not listed**  
Open the post and start playback so the player exposes the active media stream.

**New posts are missing after I scrolled**
Use the rescan action after more content loads into the page.

**The download failed partway through**
Check your connection and refresh the page before starting again.

**A video uses DRM or encryption**
The extension includes DASH decryption support for encrypted streams commonly used on JustForFans.

### Trial and Access

- Includes **3 free downloads** so you can test the workflow first
- Email sign-in uses secure one-time password verification
- No credit card required for the trial
- Unlimited downloads are available with a paid license

Start here: [https://serp.ly/justforfans-downloader](https://serp.ly/justforfans-downloader)

### Installation Instructions

1. Open the latest release page: [GitHub Releases](https://github.com/serpxxx/justforfans-downloader/releases/latest)
2. Download the correct build for your browser.
3. Install the extension.
4. Sign in with your email and verify the one-time code.
5. Open a JustForFans creator page and start downloading supported content.

### FAQ

**Can it download more than just videos?**  
Yes. It can also save supported images, gallery posts, and text posts.

**Can I bulk-download visible feed items?**  
Yes. Use the "Download Visible" workflow for everything currently on screen.

**Does it work without extra software?**
Yes. The full workflow runs inside the browser extension.

**Can I download gallery or carousel posts?**
Yes. The extension automatically expands gallery and carousel posts to capture all images in multi-image posts.

**Where are my downloads saved?**
Content automatically saves to a JustForFans subfolder inside your browser's default Downloads directory.

**Is my data safe?**
Yes. All processing happens entirely in your browser. Authentication uses secure OTP with no passwords stored.

### License

This repository is distributed under the proprietary SERP Apps license in the [LICENSE](https://github.com/serpxxx/justforfans-downloader/blob/main/LICENSE) file. Review that file before copying, modifying, or redistributing any part of this project.

### Notes

- Only download content you own or have explicit permission to save
- An internet connection is required for downloads
- Content must be visible on the page before it can be detected — scroll to load
- A valid JustForFans subscription is required to access creator content

### About JustForFans

JustForFans is a creator platform where videos, images, galleries, and text posts all live together in the feed. JustForFans Downloader is built to handle that mixed-content workflow more accurately than generic media download tools.

# 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/justforfans-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/justforfans-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/justforfans-downloader --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "JustForFans Downloader",
        "description": "Justforfans Downloader gives you a fast, reliable way to save Justforfans videos for offline access. It is built for local-first downloading, preserves the best available quality, and keeps the workflow simple for people who need dependable saves without extra tooling.",
        "version": "0.0",
        "x-build-id": "ADom3zFgGBAtxwggM"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/serpxxx~justforfans-downloader/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-serpxxx-justforfans-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~justforfans-downloader/runs": {
            "post": {
                "operationId": "runs-sync-serpxxx-justforfans-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~justforfans-downloader/run-sync": {
            "post": {
                "operationId": "run-sync-serpxxx-justforfans-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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
