# Brazz Video Downloader | How to Download Brazz Videos (`serpdownloaders/brazz-video-downloader-how-to-download-brazz-videos`) Actor

- **URL**: https://apify.com/serpdownloaders/brazz-video-downloader-how-to-download-brazz-videos.md
- **Developed by:** [SERP Downloaders](https://apify.com/serpdownloaders) (community)
- **Categories:** Videos, Automation, Social media
- **Stats:** 1 total users, 0 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

## Brazz Video Downloader | How to Download Brazz Videos

> Download videos from Brazz with a browser-based workflow. Detects available media candidates, adds player controls, and saves through the extension.

### Get it Here

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

![Brazz Downloader](https://apps.serp.co/media/optimized-products/brazz-downloader-homescreen-adult-0f107b639c.webp)

Brazz Downloader is a browser extension that helps you save videos from supported Brazz pages and player surfaces. When you open a video on Brazz, the extension can detect available media candidates and give you a simple way to download them. Instead of hunting through page source code or using external downloader sites, you get player-level controls and a familiar extension workflow.

- Works on both brazz.org and brazzpw.com player pages
- Adds a download button directly in the video player area
- Detects media from video tags, source elements, and page metadata
- Uses in-browser processing with offscreen stream handling
- Includes 3 free trial downloads to test the workflow
### Table of Contents

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

### Why Brazz Downloader

Brazz videos play through a player that can open on a separate host domain from the main site. This split setup means standard browser save tools and generic downloader sites often miss the actual media stream. You end up copying URLs, trying different tools, or digging through page source to find the video file.

Brazz Downloader keeps the save workflow inside your browser. It is configured for both brazz.org and brazzpw.com, so the detection works across the main site and the player host. The extension adds a download button near the player, detects available media candidates, and processes them through an offscreen pipeline. You do not need to switch tabs or paste links into external downloaders.

### Features

- In-page player button that appears on supported Brazz video pages
- Right-click context menu with Download Brazz Video option
- Media detection from video elements, source tags, Open Graph metadata, and Twitter player stream fields
- Works across both brazz.org and brazzpw.com domains
- Offscreen stream processing with HLS concat mode for compatible sources
- Shared download manager with progress tracking
- OTP email activation with secure one-time password verification
- 3 free trial downloads before licensing

### How It Works

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

1. Install Brazz Downloader from the GitHub Releases page.
2. Open your browser and navigate to a Brazz video page on brazz.org.
3. Press play on the video player to initialize the stream.
4. Look for the download button that appears near the video player area.
5. Click the button or right-click anywhere on the page and select Download Brazz Video.
6. Review the detected media candidates in the popup that appears.
7. Select your preferred quality option if multiple are available.
8. Click download and wait for the file to be processed and saved.

### Supported Formats

- Input: Direct video URLs and HLS-style streams exposed through video tags, source elements, Open Graph video fields, and Twitter player stream metadata on supported Brazz 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

- Brazz viewers who want a simple browser-based download workflow
- Users who prefer player-level controls instead of source code inspection
- People who want to save videos for offline viewing
- Anyone who wants to avoid generic downloader sites and copy-paste workflows

### Common Use Cases

- Saving favorite Brazz videos for offline playback
- Archiving video content for personal media libraries
- Downloading videos to watch on devices without internet access
- Creating a local backup of purchased or owned content
- Transferring videos to other devices for convenient viewing

### Troubleshooting

**The download button does not appear on the video page**
Press play on the video first. Some pages only expose media metadata after the player initializes. If it still does not appear, try reloading the page and starting playback again.

**No media candidates are detected**
The video may use a stream format the extension cannot detect with its current configuration. Try refreshing the page and ensuring the video is playing before opening the popup.

**The download starts but fails partway through**
Check your internet connection. Large files may take longer to process. If the issue persists, try a lower quality option if one is available.

**The extension says I need to activate first**
You need to sign in once using email OTP verification. This is a one-time setup that enables the trial downloads.

**The context menu option is grayed out**
Make sure you are on a supported Brazz page. The context menu only activates on pages that match the configured host patterns for brazz.org and brazzpw.com.

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

### Installation Instructions

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

### FAQ

**How do I download a Brazz video?**
Open a supported Brazz page or player URL, press play if needed, then use the player button, extension popup, or right-click menu to view detected candidates.

**Which domains does it work on?**
The extension is configured for brazz.org and brazzpw.com, including their subdomain and www variants.

**What formats can it detect?**
The extension looks for direct video URLs and stream-style media exposed through video tags, source tags, Open Graph video fields, and Twitter player stream metadata.

**Will every video show multiple quality options?**
Not necessarily. Quality options depend on what the page exposes, and not all videos may offer multiple choices.

**Where are downloads saved?**
Files are saved to a Brazz folder in your browser default download location.

**Do I need an account to use it?**
You need to sign in once with email OTP verification to activate the trial. No credit card is required for the 3 free downloads.

### Notes

- Only download content you own or have explicit permission to save
- An internet connection is required for downloads
- Some Brazz pages may require pressing play before media becomes detectable
- Available formats and quality depend on what the source page exposes

### License

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

### About Brazz

Brazz is a premium adult entertainment platform featuring high-quality video content. Brazz Downloader helps viewers save videos directly from their browser, working across both the main site and the separate player host domain.

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

```

## MCP server setup

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

```

## OpenAPI specification

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