# Foxtube Video Downloader | How to Download Foxtube Videos (`videodownloaders/foxtube-video-downloader-how-to-download-foxtube-videos`) Actor

- **URL**: https://apify.com/videodownloaders/foxtube-video-downloader-how-to-download-foxtube-videos.md
- **Developed by:** [videodownloaders](https://apify.com/videodownloaders) (community)
- **Categories:** Videos, Automation, Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 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

## Foxtube Video Downloader | How to Download Foxtube Videos

> Save FoxTube videos in your browser. Finds playable media, adds a download button, and includes 3 free downloads.

### Get it Here

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

![Foxtube Downloader](https://apps.serp.co/media/optimized-products/foxtube-downloader-homescreen-adult-2c5703dcf7.webp)

FoxTube Downloader is a browser extension that helps you save videos from FoxTube directly through your browser. Instead of hunting through page source code or using separate downloader sites, this extension detects playable media on the page and gives you a simple button to download it.

- Detects playable media from FoxTube video pages without manual inspection
- Adds a download button directly on the video player area
- Works through the extension popup or right-click context menu
- Includes 3 free trial downloads to test the workflow
- Saves files as MP4 for easy playback and archiving
### Table of Contents

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

### Why FoxTube Downloader

FoxTube video pages often expose media through player scripts rather than simple file links you can right-click and save. Generic browser tools may show you ad assets or non-video content instead of the actual stream you want to download. This makes saving a video feel like a technical chore rather than a normal browsing action.

FoxTube Downloader changes that by looking at the page for real media candidates and filtering out noise. It checks video tags, metadata, scripts, and resource activity to find playable content. The result is a straightforward download button on the player area, a popup with detected formats, and a right-click shortcut — all without leaving the FoxTube page.

### Features

- Download button attached to the FoxTube video player area
- Media detection from page video tags, metadata, scripts, and resource entries
- Direct MP4 and HLS candidate handling through the shared pipeline
- Format labels sorted by inferred quality where possible
- Right-click context menu for page and video contexts
- In-page download progress UI during file saving
- Organized FoxTube download folder for saved files
- OTP email activation with 3 free trial downloads

### How It Works

1. Install the extension from the latest release.
2. Open FoxTube and go to a supported video page.
3. Start playback so the extension can detect the media.
4. Open the popup or use the on-page controls.
5. Choose the quality option you want.
6. Start the download and wait for the MP4 export to finish.
7. Save the final file locally.

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

1. Install the FoxTube Downloader extension from the latest release.
2. Open a new tab and navigate to a FoxTube video page you want to save.
3. Press play on the video player so the page loads the media stream.
4. Look for the download button that appears on the video player area.
5. Click the download button to see the available format options.
6. Select the quality you prefer from the list.
7. Wait for the download to process and finish.
8. Save the MP4 file to your preferred location.

### Supported Formats

- Input: Direct MP4 URLs and HLS/M3U8-style media candidates detected from FoxTube pages
- Output: MP4

Saved files use MP4 so they are easier to replay on standard media players, move between devices, or archive locally.

### Who It's For

- FoxTube viewers who want offline access to videos
- Users who prefer a button-driven extension over copy-and-paste downloader sites
- People who want format choices without digging through developer tools
- Anyone looking for a simple browser workflow instead of command-line tools

### Common Use Cases

- Save a FoxTube video for offline viewing when you do not have internet access
- Detect playable media already exposed on a FoxTube page without manual inspection
- Choose from detected MP4 or HLS candidates where multiple formats are available
- Trigger downloads from the player UI instead of inspecting page source
- Use the extension popup or right-click menu for a faster workflow

### Troubleshooting

**No download button appears on the video player**
Refresh the page, press play on the video, and wait a few seconds for the extension to detect the media.

**The popup shows no media detected**
Make sure you are on a supported FoxTube video page and that the video has started playing.

**Download does not start after clicking**
Check your browser download permissions and ensure the extension has the necessary access to the FoxTube domain.

**The quality options look limited**
The extension can only show formats that the page exposes. Some videos may only have one available quality.

**Download fails partway through**
Try again with a stable internet connection. If the issue persists, refresh the page and restart the download.

### Trial & 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/foxtube-downloader](https://serp.ly/foxtube-downloader)

### Installation Instructions

1. Open the latest release page: [GitHub Releases](https://github.com/serpcompany/foxtube-downloader/releases/latest)
2. Download the correct build for your browser.
3. Install the extension.
4. Open a supported FoxTube page.
5. Use the popup to detect and download the media.

### FAQ

**How do I download a FoxTube video?**
Open a supported FoxTube page, play the video if needed, then use the player download button, the extension popup, or the right-click menu.

**What formats can it detect?**
The extension is designed to normalize direct MP4 URLs and HLS/M3U8-style media candidates when the page exposes them.

**Will it show different quality options?**
If the page exposes multiple variants, the extension attempts to infer quality from labels or URLs and sorts formats by detected height where possible.

**Where are downloads saved?**
The extension uses an organized FoxTube download folder for your saved files.

**Do I need to press play first?**
Often yes. Some pages only surface the actual media request after player scripts run or playback starts.

### Notes

- Only download content you own or have explicit permission to save
- An internet connection is required for downloads
- Press play on the video first to help the extension detect the media stream
- Available quality options depend on what the FoxTube page exposes

### License

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

### About FoxTube

FoxTube is a video hosting platform that offers a wide range of adult content. FoxTube Downloader makes it easier to save videos from the platform directly through your browser without needing separate tools or software.

# Actor input Schema



## Actor input object example

```json
{}
````

# 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("videodownloaders/foxtube-video-downloader-how-to-download-foxtube-videos").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("videodownloaders/foxtube-video-downloader-how-to-download-foxtube-videos").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 videodownloaders/foxtube-video-downloader-how-to-download-foxtube-videos --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Foxtube Video Downloader | How to Download Foxtube Videos",
        "version": "0.0",
        "x-build-id": "m0OiSd0lY1fx1gGMF"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/videodownloaders~foxtube-video-downloader-how-to-download-foxtube-videos/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-videodownloaders-foxtube-video-downloader-how-to-download-foxtube-videos",
                "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/videodownloaders~foxtube-video-downloader-how-to-download-foxtube-videos/runs": {
            "post": {
                "operationId": "runs-sync-videodownloaders-foxtube-video-downloader-how-to-download-foxtube-videos",
                "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/videodownloaders~foxtube-video-downloader-how-to-download-foxtube-videos/run-sync": {
            "post": {
                "operationId": "run-sync-videodownloaders-foxtube-video-downloader-how-to-download-foxtube-videos",
                "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": {}
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
