# Tube8 Video Downloader | How to Download Tube8 Videos (`serpxxx/tube8-video-downloader-how-to-download-tube8-videos`) Actor

Tube8 Video Downloader | How to Download Tube8 Videos Apify actor.

- **URL**: https://apify.com/serpxxx/tube8-video-downloader-how-to-download-tube8-videos.md
- **Developed by:** [SERP XXX](https://apify.com/serpxxx) (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/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## Tube8 Video Downloader | How to Download Tube8 Videos

> A browser extension for downloading videos from Tube8 as MP4 files.

### Get it Here

Get it here: https://serp.ly/tube8-downloader?via=apify

Tube8 Downloader is a browser extension that lets you save videos from Tube8 directly to your computer. When you play a video on Tube8, the extension detects the media stream and lets you choose a quality option before downloading. The saved file comes out as an MP4 that works on any standard media player.

- Save Tube8 videos as MP4 files directly from your browser
- Choose from available quality options when multiple resolutions are present
- Works with Chrome, Edge, Brave, Firefox, and other Chromium browsers
- Simple popup interface that activates when you visit a supported video page
- Designed for personal offline use with content you own or have permission to save
### Table of Contents

- [Why Tube8 Downloader](#why-tube8-downloader)
- [Features](#features)
- [How It Works](#how-it-works)
- [Step-by-Step Tutorial: How to Download Videos from Tube8](#step-by-step-tutorial-how-to-download-videos-from-tube8)
- [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 Tube8](#about-tube8)

### Why Tube8 Downloader

Tube8 hosts a large library of adult video content, but like most streaming platforms, it does not provide a native download button. If you want to save a video for offline viewing, you are left searching for third-party tools that often come with confusing interfaces, intrusive ads, or security risks.

Tube8 Downloader solves this by working directly inside your browser. When you play a video on Tube8, the extension detects the media stream the player is using and presents you with a simple download option. There is no need to copy URLs, visit external websites, or install separate software. The entire process happens within the browser window you already have open.

### Features

- Detects video streams during playback on Tube8 video pages
- Offers quality selection when the platform exposes multiple resolutions
- Saves videos as MP4 files for broad media player compatibility
- Works on Chrome, Edge, Brave, Firefox, and other Chromium-based browsers
- Clean popup interface that shows available download options
- Sequential download queue for saving multiple videos without conflict
- Desktop notifications when a download completes
- No external software or account creation required to use the extension

### How It Works

1. Install the extension from the latest release.
2. Open Tube8 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 Tube8

1. Navigate to Tube8 and find the video you want to save.
2. Click the video thumbnail to open the full video page.
3. Press play and let the video buffer for a few seconds.
4. Click the Tube8 Downloader icon in your browser toolbar.
5. The popup will display the detected video title and available quality options.
6. Select your preferred resolution from the list.
7. Click the download button to start saving the MP4 file.
8. Wait for the download to finish and check your browser's default downloads folder.

### Supported Formats

- Input: HLS or MPEG-DASH stream segments exposed by the Tube8 player, typically containing H.264 video with AAC audio
- 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

- Adults who want to save Tube8 videos for personal offline viewing
- Users who prefer browser extensions over standalone download software
- People who need to archive content they have permission to save
- Anyone looking for a straightforward download workflow without extra steps

### Common Use Cases

- Saving a video to watch later when you do not have an internet connection
- Archiving content you own or have explicit permission to keep
- Building a personal offline library of videos you enjoy
- Moving video files between devices without relying on streaming
- Keeping a backup copy of content that might be removed from the platform

### Troubleshooting

**The extension does not detect any video**
Make sure the video is playing and has loaded enough content. Try refreshing the page and starting playback again.

**The download starts but fails partway through**
Check your internet connection and make sure you have enough free disk space. Try downloading a lower quality option if available.

**The popup shows no quality options**
The platform may only expose a single stream. The extension will use whatever quality the player is currently serving.

**The extension icon is grayed out on Tube8**
This usually means you are on a page that does not contain a supported video player. Navigate to a specific video page and try again.

**Downloads are slow**
Download speed depends on your internet connection and the Tube8 server response. Try pausing other downloads or streaming activities.

### 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/tube8-downloader?via=apify](https://serp.ly/tube8-downloader?via=apify)

### Installation Instructions

1. Open the latest release page: GitHub Releases
2. Download the correct build for your browser.
3. Install the extension.
4. Open a supported Tube8 page.
5. Use the popup to detect and download the media.

### FAQ

**Is Tube8 Downloader free?**
The extension includes 3 free downloads so you can test it. Unlimited downloads require a paid license.

**Which browsers are supported?**
The extension works on Chrome, Edge, Brave, Firefox, and other Chromium-based browsers.

**Do I need an account to use it?**
You need to sign in with your email using a one-time password to activate the trial or paid license.

**Can I download multiple videos at once?**
The extension queues downloads sequentially to avoid conflicts. You can start a new download after the current one finishes.

**What if a video does not appear in the popup?**
Make sure the video is playing and the page is fully loaded. If the issue persists, try refreshing the page or restarting your browser.

### Notes

- Only download content you own or have explicit permission to save
- An internet connection is required for downloads
- Tube8 video pages use route patterns like `/porn-video/{numeric-id}/`
- The extension is designed for standard video pages, not live streams or VR content

### License

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

### About Tube8

Tube8 is an adult video streaming platform that hosts a wide variety of user-uploaded and studio-produced content. This extension helps users save videos they have permission to download directly from their browser, making offline access simpler and more convenient.

# 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("serpxxx/tube8-video-downloader-how-to-download-tube8-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("serpxxx/tube8-video-downloader-how-to-download-tube8-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 serpxxx/tube8-video-downloader-how-to-download-tube8-videos --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

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