# Bootychristmas Video Downloader (`serpdownloaders/bootychristmas-video-downloader`) Actor

- **URL**: https://apify.com/serpdownloaders/bootychristmas-video-downloader.md
- **Developed by:** [SERP Downloaders](https://apify.com/serpdownloaders) (community)
- **Categories:** Videos, Automation, Social media
- **Stats:** 2 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

## Bootychristmas Video Downloader | How to Download Bootychristmas Videos

> Save available Booty Christmas videos from themed page URLs with a browser-based player-button workflow.

### Get it Here

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

![Bootychristmas Downloader](https://apps.serp.co/media/optimized-products/bootychristmas-downloader-homescreen-adult-25a2ab1ca5.webp)

Downloader for Booty Christmas is a browser-extension candidate for detecting and saving video candidates on booty-christmas.com. The strongest fit is the site's themed, day-numbered page flow, with download entry points kept close to the player. Built for a single seasonal brand with exact site matches, a configured player wrapper, and direct page-level selectors for titles, streams, and thumbnails.

- Purpose-built identity for Booty Christmas video detection and saving
- Supports booty-christmas.com, subdomains, and www domain variations
- Adds a player-button workflow around the configured video player wrapper
- Reads video candidates from page media tags plus Open Graph and Twitter stream metadata
- Leans into the site's advent-style page cadence instead of generic cross-site promises
### Table of Contents

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

### Why Bootychristmas Downloader

Themed clip pages on Booty Christmas are easy to browse but not always easy to save from. Right-click save often misses the actual playable media URL, and generic downloader tools can surface noise instead of the real page video. Some media activity may appear only after the page and player finish loading, which makes manual extraction frustrating.

Bootychristmas Downloader solves this by staying close to the player and the page instead of the source code. It detects direct video candidates exposed by the page player or metadata, adds an in-player button for quick access, and keeps the workflow focused on one seasonal site instead of making broad unsupported claims. You review available candidates in-browser before saving, and the entire process feels lighter than manual extraction.

### Features

- Exact site matches for booty-christmas.com, subdomains, and www domain
- Generic static-media adapter preset for video detection
- Title lookup from og:title, h1, .title, and page title elements
- Video lookup from video[src], video source[src], source[src], og:video, og:video:secure_url, and twitter:player:stream
- Thumbnail lookup from og:image and video[poster] elements
- In-page player button with dedicated class prefix for visual consistency
- Offscreen folder and referer/origin defaults set to Booty Christmas
- Download manager with in-page download status UI

### How It Works

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

1. Install Bootychristmas Downloader from the latest GitHub release.
2. Navigate to a supported Booty Christmas video page, such as a day-numbered advent-style URL.
3. Let the page load completely and start the video player if needed.
4. Look for the player button that appears near the video wrapper.
5. Click the button or open the extension popup to inspect detected video candidates.
6. Review the available quality options shown by the extension.
7. Select the desired quality and confirm the download.
8. Wait for the MP4 export to finish, then save the file locally.

### Supported Formats

- Input: Video candidates detected from page media selectors, Open Graph video tags, and Twitter player stream metadata
- 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

- Booty Christmas viewers who want a simple browser workflow instead of manual source hunting on themed clip pages
- Users who prefer an in-player button instead of inspecting page source
- People who want to review available candidates in-browser before saving
- Users looking for a page-level workflow that feels lighter than manual extraction

### Common Use Cases

- Save an available Booty Christmas video from a day-numbered page
- Detect direct video candidates exposed by the page player or metadata
- Use an in-player button instead of inspecting page source
- Keep the workflow focused on one seasonal site instead of a broad unsupported claim
- Review available candidates in-browser before saving

### Troubleshooting

**The player button does not appear**
Make sure the page has fully loaded and the video player is visible. Try refreshing the page and starting playback.

**No video candidates are detected**
Not every page may expose usable video candidates through the configured selectors. Try a different Booty Christmas page.

**The download does not start**
Check your internet connection and ensure the video is still available on the page. Try restarting the player and attempting the download again.

**The extension does not work on a specific page**
The extension is designed for Booty Christmas pages with the configured player wrapper. Some pages may use different player setups.

**Quality options are limited**
The extension can only offer quality options that the page exposes. If only one candidate is detected, only one quality will be available.

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

### Installation Instructions

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

### FAQ

**How do I download a Booty Christmas video?**
Open a supported Booty Christmas page, let the player load, and use the extension workflow to inspect any detected video candidates.

**What pages is this aimed at?**
The clearest fit is Booty Christmas's themed, day-numbered page pattern, like advent-style calendar URLs.

**What formats can it detect?**
The configuration checks direct page-media selectors plus og:video, og:video:secure_url, and twitter:player:stream metadata when those values are exposed.

**Does it work on every page?**
That is not proven by the available facts. The targeting signals are strong, but real extraction review is still required for full validation.

**Is it released?**
This extension is available as a release candidate. The target fit is strong, but users should review the readiness status before relying on it for production use.

### Notes

- Only download content you own or have explicit permission to save
- An internet connection is required for downloads
- The extension is designed for Booty Christmas's themed, day-numbered page structure
- Real extraction review is still required before full release claims can be made

### License

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

### About Bootychristmas

Booty Christmas is a seasonal adult entertainment brand that features themed, day-numbered video pages in an advent-style calendar format. This extension helps viewers save available video candidates from those pages using a browser-based workflow that stays close to the player and the page.

# 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/bootychristmas-video-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("serpdownloaders/bootychristmas-video-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 serpdownloaders/bootychristmas-video-downloader --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

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