# BitChute Video Downloader (`abuzar_saleem/bitchute-video-downloader`) Actor

Download a video from BitChute by URL. Returns the MP4 (in the key-value store) plus a dataset record with the video's title, uploader, duration and a download link.

- **URL**: https://apify.com/abuzar\_saleem/bitchute-video-downloader.md
- **Developed by:** [scrape-by-abuzar](https://apify.com/abuzar_saleem) (community)
- **Categories:** Videos, Social media
- **Stats:** 3 total users, 1 monthly users, 14.3% 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

## BitChute Video Downloader — Apify Actor

A headless [Apify](https://apify.com) Actor that downloads a single
[BitChute](https://www.bitchute.com) video by URL. It wraps
[yt-dlp](https://github.com/yt-dlp/yt-dlp) with browser impersonation and merges
audio/video to a single `.mp4` with ffmpeg.

### Input

| Field | Type | Required | Default | Description |
|-------|------|----------|---------|-------------|
| `url` | string | ✅ | — | Full `bitchute.com` video link, e.g. `https://www.bitchute.com/video/<id>/` |
| `quality` | string | — | `best` | `best`, `1080`, `720`, `480`, `360`, `240`, or `180`. Numeric values cap the resolution. |

Example:

```json
{
  "url": "https://www.bitchute.com/video/CLrgGuxoacGr/",
  "quality": "720"
}
````

### Output

- **Key-value store** — the downloaded video is saved to the run's default
  key-value store under the key `<videoId>.mp4` (content-type `video/mp4`).
- **Dataset** — one record with metadata and a direct download link:

```json
{
  "url": "https://www.bitchute.com/video/<id>/",
  "id": "<id>",
  "title": "Some Video",
  "uploader": "Channel Name",
  "duration": 213,
  "thumbnail": "https://...",
  "viewCount": 345,
  "quality": "720",
  "ext": "mp4",
  "fileSizeBytes": 5407040,
  "storageKey": "<id>.mp4",
  "videoUrl": "https://api.apify.com/v2/key-value-stores/<storeId>/records/<id>.mp4"
}
```

**Getting the file.** The video lives in the run's default key-value store,
which is private to your account, so `videoUrl` needs authentication:

- **Easiest:** open the run in **Apify Console → Storage → Key-value store** and
  click the record to download it.
- **Direct link / API:** append your token — `…/records/<id>.mp4?token=YOUR_APIFY_TOKEN`
  (or open `videoUrl` while logged into Apify in the same browser).

`videoUrl` is stored token-free on purpose so your API token is never written
into the dataset.

### How it works

```
input { url, quality }
   │
   ├── validate it's a bitchute.com URL
   ├── yt-dlp  --impersonate chrome  -f <height-based selector>  --merge-output-format mp4
   ├── store the mp4 in the key-value store
   └── push a dataset record (metadata + download URL)
```

The download logic lives in [`src/downloader.py`](src/downloader.py) (pure, no
Apify dependency, so it's easy to test); [`src/main.py`](src/main.py) is the
Actor wrapper.

### Run / deploy

Requires the [Apify CLI](https://docs.apify.com/cli) and an Apify account.

```bash
## from this folder
apify login          ## paste your Apify API token when prompted
apify push           ## builds the Docker image on Apify and creates the Actor
```

To test locally first (needs Docker running):

```bash
apify run --input '{"url":"https://www.bitchute.com/video/<id>/","quality":"480"}'
```

### Notes

- **curl\_cffi must be `>=0.10,<0.15`** (pinned in `requirements.txt`). yt-dlp's
  `--impersonate` does not support curl\_cffi `0.15+`.
- Very large videos may approach key-value store record size limits; prefer a
  capped `quality` for big files.
- Only download content you own or have the rights to. Respect BitChute's Terms
  of Service and applicable copyright law.

# Actor input Schema

## `url` (type: `string`):

Full bitchute.com video link, e.g. https://www.bitchute.com/video/<id>/

## `quality` (type: `string`):

Maximum video resolution. 'Best available' downloads the highest quality; a numeric value caps the resolution and still merges the best audio.

## Actor input object example

```json
{
  "url": "https://www.bitchute.com/video/",
  "quality": "best"
}
```

# 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 = {
    "url": "https://www.bitchute.com/video/"
};

// Run the Actor and wait for it to finish
const run = await client.actor("abuzar_saleem/bitchute-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 = { "url": "https://www.bitchute.com/video/" }

# Run the Actor and wait for it to finish
run = client.actor("abuzar_saleem/bitchute-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 '{
  "url": "https://www.bitchute.com/video/"
}' |
apify call abuzar_saleem/bitchute-video-downloader --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "BitChute Video Downloader",
        "description": "Download a video from BitChute by URL. Returns the MP4 (in the key-value store) plus a dataset record with the video's title, uploader, duration and a download link.",
        "version": "0.1",
        "x-build-id": "gaDVydUnzVIJVxsQe"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/abuzar_saleem~bitchute-video-downloader/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-abuzar_saleem-bitchute-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/abuzar_saleem~bitchute-video-downloader/runs": {
            "post": {
                "operationId": "runs-sync-abuzar_saleem-bitchute-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/abuzar_saleem~bitchute-video-downloader/run-sync": {
            "post": {
                "operationId": "run-sync-abuzar_saleem-bitchute-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",
                "required": [
                    "url"
                ],
                "properties": {
                    "url": {
                        "title": "BitChute video URL",
                        "pattern": "^https?://(www\\.)?bitchute\\.com/(video|embed)/",
                        "type": "string",
                        "description": "Full bitchute.com video link, e.g. https://www.bitchute.com/video/<id>/"
                    },
                    "quality": {
                        "title": "Quality",
                        "enum": [
                            "best",
                            "1080",
                            "720",
                            "480",
                            "360",
                            "240",
                            "180"
                        ],
                        "type": "string",
                        "description": "Maximum video resolution. 'Best available' downloads the highest quality; a numeric value caps the resolution and still merges the best audio.",
                        "default": "best"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
