# Facebook Video Downloader (`truefetch/facebook-video-downloader`) Actor

Process one public Facebook video page for structured metadata and an optional stored video file. Choose metadata-only mode or a download quality preference for an Apify workflow.

- **URL**: https://apify.com/truefetch/facebook-video-downloader.md
- **Developed by:** [TrueFetch](https://apify.com/truefetch) (community)
- **Categories:** Videos, Social media, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

Facebook Video Downloader is a one-URL Actor for collecting available public video metadata and, when requested, storing the accessible video file in an Apify run.

- The public schema exposes two fields and requires only `video_url`.
- The quality control has four values: one metadata-only mode and three download preferences.
- The Dataset contract defines 39 fields covering the page, publisher, engagement, media, processing context, and stored file.
- Individual Facebook comment retrieval is not exposed; the reserved `comments` field is normally empty.

**[Run a one-result test](https://apify.com/truefetch/facebook-video-downloader)**

**[View API](https://apify.com/truefetch/facebook-video-downloader/api)**

Publish the Actor and verify its identity before using one public video in metadata mode as the first paid test.

### What does Facebook Video Downloader do?

Facebook Video Downloader accepts one Facebook video-page URL. It converts the values available on that page into a normalized Dataset record containing an ID, thumbnail, title or description, duration, publication time, publisher identity, available engagement totals, media dimensions, audio labels, and the time and Actor reference associated with processing.

When a download mode is selected, the Actor can store an available media file and expose its URL through the `video` field. The quality choice is a preference among source formats. It is not a promise of a particular resolution, container, watermark state, or permanent file availability.

The Actor does not log into Facebook, search posts, expand a Page or profile, collect a feed, accept multiple URLs, or return individual comments. Facebook privacy, account, region, deletion, and sharing settings can make a URL visible in one browser context but unavailable to a public Actor run.

### How do I run Facebook Video Downloader?

Confirm that its name and input form say Facebook Video Downloader and show only **Video URL** and **Video Quality**.

Use the same public-page scenario throughout this README:

```json
{
  "video_url": "https://www.facebook.com/facebook/videos/10153231379946729/",
  "video_quality": "metadata"
}
```

Start the run, open **Results**, and inspect the Dataset item. A metadata result demonstrates that the URL is accessible and that the output shape is correct without adding file transfer. Only then rerun with `low`, `medium`, or `high` when the stored media is actually required.

Test from the Actor rather than relying on an authenticated browser. Use content only when your organization has the rights and authority required for processing, storage, and downstream use.

### What data does Facebook Video Downloader return?

The effective Dataset has 39 named fields:

| Data area | Fields |
|---|---|
| Run context | `processor`, `processed_at` |
| Page and video | `id`, `thumbnail`, `platform`, `title`, `description`, `duration`, `published_at` |
| Publisher | `author`, `author_id`, `author_url` |
| Classification | `categories`, `tags` |
| Engagement | `view_count`, `like_count`, `shares_count`, `dislike_count`, `comment_count` |
| Media properties | `width`, `height`, `fps`, `audio_title`, `audio_artist` |
| Reserved and stored values | `comments`, `video` |

An abbreviated illustrative response for the shared Facebook URL is:

```json
{
  "id": "10153231379946729",
  "platform": "Facebook",
  "title": "Example public Facebook video",
  "author": "Facebook",
  "thumbnail": "https://example.com/facebook-thumbnail.jpg",
  "view_count": null,
  "comments": [],
  "video": ""
}
```

The example documents keys and types rather than current values. Facebook can withhold or change fields, so null is not the same as zero. The public input does not request comment objects. Metadata mode intentionally leaves `video` empty.

Source-dependent fields also present in every item:

| Field | Meaning |
|---|---|
| `source_url` | Canonical page URL of the item on its own platform |
| `media_type` | Kind of media the source reports, such as video or audio |
| `live_status` | Whether the item is a recording, currently live, or a finished stream |
| `availability` | Source visibility, such as public, unlisted, or needs\_auth |
| `age_limit` | Minimum viewer age the source enforces; zero means no restriction |
| `language` | Primary language of the item as reported by the source |
| `followers` | Follower or subscriber count of the author at processing time |
| `is_verified` | Whether the author's account carries a verified badge |
| `saves_count` | Times viewers saved the item, on sources that expose it |
| `file_ext` | Container extension of the selected media, such as mp4 or webm |
| `file_size` | Size of the selected media in bytes, exact or approximate |
| `subtitles` | Language codes of published subtitle tracks; auto-captions excluded |
| `chapters` | Chapter markers with title and start and end time in seconds |

### What inputs can I configure?

The public input contract contains:

| Input | Required | Effect |
|---|---:|---|
| `video_url` | Yes | Supplies one public Facebook video page. |
| `video_quality` | No | Accepts `metadata`, `low`, `medium`, or `high`; metadata mode skips the stored file. |

The required URL includes a consistent example. The optional quality field has no prefill or example, so omission remains distinct from an explicit user choice. There is no `max_comments` property. Do not send undocumented fields in an attempt to enable comments or authentication.

### What platforms and markets does Facebook Video Downloader cover?

The intended scope is a publicly reachable Facebook video page. The schema has no country, language, Page, group, profile, date, keyword, feed, or market control. It does not discover URLs; the caller supplies the exact page.

Facebook uses several URL styles for videos, watch pages, shared posts, and Reels. Do not infer universal coverage across those surfaces. Resolve redirected links when practical and test every page family your application expects to receive.

Privacy and login state are central limits. A post may be public to a logged-in user, restricted to an audience, unavailable in a region, or removed after the first run. Preserve the submitted URL and handle access failures as data outcomes rather than converting them into empty successful records.

### Why use Facebook Video Downloader?

For an accessible public URL, the Actor offers a consistent response contract rather than a manual save-and-copy process. A developer can read a Dataset item through Apify APIs, trigger a webhook, or connect the result to an internal review queue. A stored file remains associated with the page metadata and run context.

Metadata mode supports low-risk qualification. The thumbnail-first overview helps a reviewer recognize the item. Nullable fields make source gaps visible, and the absence of a comment input prevents a workflow from promising data the public contract does not offer.

This local project is being prepared for publication. Store usage, ratings, reviews, and Actor identity cannot be claimed before the public route exists. The README therefore prioritizes a reproducible release test over marketing proof.

### Who is Facebook Video Downloader for?

Developers can add one-video handling to a submission tool. Research teams can record available public metadata for an approved sample. Content operations teams can review campaign or brand videos they are authorized to process. Archivists can preserve permitted media together with the source URL and processing time. AI teams can send stored media to a separate transcription or classification service.

Apify Console users can perform the same one-URL workflow without writing code after the Actor draft is available to their account.

It is not suitable for private posts, account automation, Page crawling, group monitoring, feed scraping, comment analysis, batch discovery, rights verification, or guaranteed media recovery. Those goals require different inputs, permissions, and controls.

### How can I use Facebook Video Downloader through the API or MCP?

Record and publish the real ID before release.

This HTTP example is syntactically valid and uses the shared scenario:

```bash
curl -X POST "https://api.apify.com/v2/acts/truefetch~facebook-video-downloader/runs?token=$APIFY_TOKEN" \
 -H "Content-Type: application/json" \
 -d '{"video_url":"https://www.facebook.com/facebook/videos/10153231379946729/","video_quality":"metadata"}'
```

A focused hosted MCP entry follows the same publication dependency:

```json
{
  "mcpServers": {
    "apify-facebook-video": {
      "url": "https://mcp.apify.com?tools=truefetch/facebook-video-downloader",
      "headers": {
        "Authorization": "Bearer <APIFY_TOKEN>"
      }
    }
  }
}
```

Call the tool with the same JSON input. Keep the token secret. The [official Apify MCP documentation](https://docs.apify.com/integrations/mcp) covers OAuth, bearer authentication, and tool selection.

### How much does Facebook Video Downloader cost?

The local metadata declares flat pay-per-event prices. These are not a verified public Store offer:

| Declared event | Unit | Local price |
|---|---|---:|
| `apify-actor-start` | Actor start | $0.01 |
| `actor_usage` | Metered usage event | $0.00001 |
| `metadata` | One processed page without file download | $0.12 |
| `download` | One processed page with file download and storage | $0.28 |

The smallest metadata test declares $0.13 in fixed start and metadata events, before metered usage or platform-related costs. A download path uses the $0.28 event instead of the metadata event.

Verify the published pricing setup and completed-run charges after release. No FREE, BRONZE, SILVER, GOLD, PLATINUM, or DIAMOND amounts are defined locally.

### How does Facebook Video Downloader compare with alternatives?

| Option | Appropriate when | Trade-off |
|---|---|---|
| Facebook Video Downloader | One known public Facebook video needs metadata or a stored file | Public publication and representative access tests are still pending. |
| Best Video Downloader | Inputs come from several supported video sites | Wider scope offers less Facebook-specific expectation setting. |
| Video To Text | The required artifact is speech text | It solves transcription rather than page metadata. |
| Manual browser workflow | A person handles an occasional authorized video | Hard to normalize, audit, schedule, or connect to APIs. |

A Facebook video URL, a Page feed, comment threads, and a transcript are separate data products. Choose the narrowest tool whose public inputs and outputs match the requested job.

### What are the limits and troubleshooting steps?

The Actor takes one URL and no credentials. It does not expose batch, Page, profile, feed, comments, locale, or date controls. Quality is a preference, fields are nullable, and repeated runs do not deduplicate previous results.

When a draft run fails, verify that all public surfaces use Facebook branding, then check whether the URL opens to the intended video without a private session. Retry in metadata mode. If metadata succeeds, test the stored file. An empty `video` in metadata mode is normal; an empty value in a download run requires log and storage inspection.

The Store, API, and Issues pages were unavailable at the verification checkpoint. Public issue history and live behavior therefore remain release blockers, not evidence of error-free operation.

### Frequently asked questions

#### Which Facebook URL forms are accepted?

Use a permalink that points at one video: a `/videos/<id>/` address, a `watch` link, or a post URL whose primary attachment is the video. A Page root, a group listing, or a profile URL has no single media target, so the run ends without a Dataset item.

#### Can it download private Facebook videos?

No private-content or login input is exposed. The documented scope is public video pages.

#### Can I collect comments?

No. The public schema has no comments control, and the reserved output is normally empty.

#### Does high quality guarantee a resolution?

No. The source formats available for that page determine the result.

#### Why are engagement fields null?

Facebook did not expose a usable value in that processing context. Null does not mean zero.

#### Does metadata mode create a file?

No. It intentionally skips file storage.

#### Can I submit a Page URL?

No. The contract is one video page, not Page discovery or feed crawling.

#### Why do engagement counters vary between runs?

Facebook exposes reaction, share, and view counts inconsistently depending on the surface that serves the page. The Actor writes what the source returns at that moment and leaves the rest null rather than substituting zero. Treat repeated runs as separate observations and compare them downstream.

#### Does the stored file keep the original audio track?

The downloader merges the best available video and audio renditions into a single MP4 container. When Facebook publishes only a muxed low-bitrate rendition, that rendition is stored instead, and `width`, `height`, and `fps` describe the file you actually received.

#### How should I structure a repeatable Facebook workflow?

Keep resolution and processing separate. Collect permalinks in your own system, then call this Actor once per permalink so each run maps to one Dataset item and one billed result event. That layout keeps retries cheap, because a failed source lookup charges no result event, and it keeps your audit trail simple: one input URL, one run, one record. Store the returned `id` alongside your own key so a later re-run can be reconciled against the original observation rather than creating an unexplained duplicate.

### Related TrueFetch Actors

- [Best Video Downloader](https://apify.com/truefetch/best-video-downloader) handles a mixed-source video queue.
- [Video To Text](https://apify.com/truefetch/video-to-text) produces speech text from authorized media.
- [Video Subtitles Downloader](https://apify.com/truefetch/video-subtitles-downloader) retrieves caption tracks when available.

### Support

- [Apify Actor dashboard](https://apify.com/truefetch/facebook-video-downloader)
- [Apify Actor API reference](https://apify.com/truefetch/facebook-video-downloader/api)
- [Apify MCP documentation](https://docs.apify.com/integrations/mcp)
- [TrueFetch community](https://t.me/TrueFetch)
- [Direct support](https://t.me/AiAgentApi)

After release, include the public Actor URL, stable ID, redacted input, run ID, and expected and observed results in support requests.

**[Run a one-result test](https://apify.com/truefetch/facebook-video-downloader)**

**[View API](https://apify.com/truefetch/facebook-video-downloader/api)**

# Actor input Schema

## `video_url` (type: `string`):

Public Facebook video page URL to process.

## `video_quality` (type: `string`):

Preferred download quality, or metadata-only mode without a video file.

## Actor input object example

```json
{
  "video_url": "https://www.facebook.com/facebook/videos/10153231379946729/"
}
```

# Actor output Schema

## `results` (type: `string`):

All video details and optional download links with full engagement stats and comments

# 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 = {
    "video_url": "https://www.facebook.com/facebook/videos/10153231379946729/"
};

// Run the Actor and wait for it to finish
const run = await client.actor("truefetch/facebook-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 = { "video_url": "https://www.facebook.com/facebook/videos/10153231379946729/" }

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

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/ah2rWOa9dFXoFDSIa/builds/w0fHHDw3Ag10dpNnA/openapi.json