# Facebook Page Videos Scraper — Plays, Reactions, No Login (`foxlabs/facebook-page-videos-scraper`) Actor

Videos and reels of public Facebook Pages, newest first: title, the post's text, exact time, plays, duration, thumbnail, address, reactions in total and by kind, comment and share counts, plays per hour. Many Pages a run, only-new mode for recurring runs. No login.

- **URL**: https://apify.com/foxlabs/facebook-page-videos-scraper.md
- **Developed by:** [Berkan Kaplan](https://apify.com/foxlabs) (community)
- **Categories:** Social media, Videos
- **Stats:** 2 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$2.00 / 1,000 videos

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Facebook Page Videos Scraper — Plays, Reactions, No Login 🚀

**foXLabs Facebook series:** [Page Posts](https://apify.com/foxlabs/facebook-page-posts-scraper) · [Page Profile](https://apify.com/foxlabs/facebook-page-profile-scraper) · [Post Comments](https://apify.com/foxlabs/facebook-post-comments-scraper) · [Page Reviews](https://apify.com/foxlabs/facebook-page-reviews-scraper) · [Page Events](https://apify.com/foxlabs/facebook-page-events-scraper)

🎉 Videos and reels of public Facebook Pages, newest first, exactly as Facebook lists them to a signed-out visitor — **title, the post's text and hashtags, exact time, plays, duration, thumbnail, the video's address, reactions in total and by kind** — plus what we add: plays per hour since publication. Many Pages a run, filters by plays and date, only-new mode for recurring runs. No login, no cookies, no account of anyone.

### 🔍 What is the Facebook Page Videos Scraper — and when should you use it?

Give this Actor public Facebook Pages and it returns their videos and reels as clean rows — newest first, with play counts, duration, reactions by kind and a per-hour velocity.

**Use it when you need:** a Page's video performance (plays, reactions, velocity); the fastest-growing videos; or a recurring feed of only-new videos.

**Use something else when:** you need a Page's text posts and to tell reels from videos → [Page Posts](https://apify.com/foxlabs/facebook-page-posts-scraper); comments on a video's post → [Post Comments](https://apify.com/foxlabs/facebook-post-comments-scraper).

### 🤖 Use with AI agents

**Already on the Apify MCP server?** Ask for this Actor by name: `foxlabs/facebook-page-videos-scraper`. An agent can discover it, run it and read the dataset over MCP.

**Real-time Standby API.** This Actor ships a Standby endpoint so an agent can fetch a Page's newest videos on demand — `GET /videos?page=NASA&maxVideos=12`, billed with the same `video` event.

Otherwise paste this into Claude, ChatGPT, Cursor or any MCP-enabled assistant:

```
I want public Facebook Page videos & reels using the Apify Actor
`foxlabs/facebook-page-videos-scraper`.

Input: `pages` is a list of Pages; `maxVideosPerPage` caps rows; `minViews` and `publishedAfter`
filter. Each row has title, views, viewsPerHour, durationSeconds, reactionsByType and playableUrl.

Start with:
{ "pages": ["NASA"], "maxVideosPerPage": 25 }

Ask me which Pages to track, run the Actor, then summarise the videos by plays.
```

The machine-readable API, MCP config and OpenAPI definition live at `apify.com/foxlabs/facebook-page-videos-scraper.md`.

### 📋 Overview

Everything you need to turn a public Facebook Page's videos into clean, structured data — plays, duration, reactions by kind and velocity — in one Actor, with no login, cookies or account.

**Why teams pick this Actor:**

- ✅ **Plays + velocity** — views, views of the post, and plays per hour since publication.
- 🎞️ **The video file** — `playableUrl` (an mp4 on Facebook's CDN, 30 of 30 in our measurements; signed, download soon).
- ❤️ **Reactions by kind** — like/love/care/haha/wow/sad/angry each with its count.
- 🔁 **Only-new mode** — schedule recurring runs that bring only videos not seen before.
- 💰 **Pay only for results** — one `video` event per row; filters, status rows and unreadable Pages free.
- 🤖 **Agent-ready** — MCP + a real-time Standby API.

### ✨ Features

- 🔍 **Videos & reels, newest first** — by Page name, @handle, numeric id or URL.
- ▶️ **Play metrics** — `views`, `postViews`, `viewsPerHour`, `durationSeconds`, `thumbnailUrl`.
- 🎬 **File + live** — `playableUrl` (signed mp4), `isLive` for live broadcasts.
- 🧹 **Filters** — minimum plays, published-after date.
- 🔁 **Only-new lists** — remember delivered videos and skip them next run.

### 🎬 Quick Start

```bash
curl -X POST "https://api.apify.com/v2/acts/foxlabs~facebook-page-videos-scraper/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"pages": ["NASA"], "maxVideosPerPage": 25}'
```

### 🚀 Getting Started (3 steps)

1. **Choose your Pages** — one per line: name, `@handle`, numeric id or URL.
2. **Set the cap & filters** — `maxVideosPerPage`, `minViews`, `publishedAfter`.
3. **Run and export** — get a clean dataset as JSON, CSV or Excel.

### 📥 Input

| Field | Default | What it does |
|---|---|---|
| `pages` | — | One Page per line: name, `@NASA`, numeric id, or URL. A Page written twice is read once. |
| `maxVideosPerPage` | 100 | Videos to deliver per Page, newest first. |
| `maxVideos` | 100000 | Rows in the whole run. |
| `minViews` | — | Keep only videos with at least this many plays. |
| `publishedAfter` | — | Keep only videos on/after this date; the walk stops once three in a row are older. |
| `onlyNewVideos`, `listName` | false, `default` | Remember delivered videos under a name and skip them later. |
| `proxyConfiguration` | residential Apify Proxy | Nothing to change for normal use. |

### 📤 Output

One row per video (`type: "video"`). A value Facebook does not give is `null`.

| Field | What it is |
|---|---|
| `videoId`, `postId`, `url` | the video's id, its post's id, and the video's address |
| `kind` | `video`, or `live` while broadcasting (reels list as videos here) |
| `title`, `text`, `hashtags` | the title, the post's text, its hashtags |
| `publishedAt`, `hoursSincePost` | when it was published (UTC) and how long ago |
| `views`, `postViews`, `viewsPerHour` | plays of the video and post, and plays per hour |
| `durationSeconds`, `thumbnailUrl`, `isLive` | length, cover, live status |
| `playableUrl` | the mp4 file (signed, expires after hours — download soon) |
| `reactions`, `reactionsByType` | all reactions and each kind with its count |
| `pageId`, `pageName`, `pageUrl` | the Page |
| `position`, `input`, `type`, `error` | place in the list; input line; row type / free status row |

(Not in Facebook's list, so `null`: HD file address, comment/share counts, width/height — they live on each video's own page.)

```json
{
  "type": "video",
  "videoId": "4007941182848761",
  "url": "https://www.facebook.com/NASA/videos/be-a-flight-director/4007941182848761/",
  "kind": "video",
  "pageName": "NASA - National Aeronautics and Space Administration",
  "title": "Be a Flight Director",
  "publishedAt": "2026-10-07T15:05:51.000Z",
  "hoursSincePost": 78.9,
  "views": 198554,
  "viewsPerHour": 2516.5,
  "durationSeconds": 40.3,
  "playableUrl": "https://video….fbcdn.net/…mp4?…",
  "reactions": 2594,
  "reactionsByType": { "like": 2228, "love": 310, "care": 38, "wow": 12, "haha": 4, "angry": 2 },
  "position": 1,
  "input": "NASA"
}
```

### 💼 Use cases

**1. Video performance tracking** — see a Page's videos ranked by plays and velocity.
*Input:* the Page, `minViews` set. *Output:* videos with `viewsPerHour`. *Use:* learn what formats earn plays.

**2. Competitor content** — watch a rival's video cadence and reach.
*Input:* competitor Pages, `onlyNewVideos` scheduled. *Output:* new videos + plays. *Use:* benchmark their output.

**3. Media download pipeline** — grab the mp4 file and thumbnail soon after a run.
*Input:* the Page. *Output:* `playableUrl` + `thumbnailUrl`. *Use:* archive or repurpose (signed URLs expire — download promptly).

### 🔗 Integration

**JavaScript / Node.js**

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: 'YOUR_TOKEN' });
const run = await client.actor('foxlabs/facebook-page-videos-scraper').call({
  pages: ['NASA'], maxVideosPerPage: 25,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items[0]);
```

**Python**

```python
from apify_client import ApifyClient
client = ApifyClient('YOUR_TOKEN')
run = client.actor('foxlabs/facebook-page-videos-scraper').call(
    run_input={'pages': ['NASA'], 'maxVideosPerPage': 25}
)
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)
```

Written for `apify-client` 3 for Python, where `call()` returns a run object; with version 1 or 2 it returns a dict — write `run['defaultDatasetId']` there.

**Automation (n8n / Zapier / Make):** schedule or webhook → HTTP request to the Actor API with your `pages` → handle the JSON dataset → push to a sheet, CRM or dashboard.

### 📊 Pricing

Pay per event: **`video`** for every delivered video row. The price is on the Pricing tab. Nothing else is charged: no start fee, nothing for a status row, nothing for a video the filters left out, nothing for a Page that could not be read.

### ❓ FAQ

**How many videos per Page?** The list a signed-out visitor gets ends after ~45 per Page (measured on NASA). Older videos aren't reachable; "only new" runs on a schedule keep the history growing.

**Are reels separated from videos?** No — Facebook lists them with `/videos/` addresses, so `kind` says `video`. The [Page Posts Scraper](https://apify.com/foxlabs/facebook-page-posts-scraper) tells reels from videos.

**Why does `playableUrl` stop working?** It's signed by Facebook's CDN and expires after hours — download soon after the run.

**Can I export to CSV / Excel / JSON?** Yes — directly from the Apify dataset.

**What happens for a bad Page?** A free status row says why (no videos tab, no such Page, signed-in only) — not charged.

### 🐛 Troubleshooting

- **~45 videos max per Page** — Facebook's own list ends there for a visitor; not an error.
- **`playableUrl` empty/expired** — signed and short-lived; download promptly. HD URL, comment/share counts and frame size aren't in the list.
- **Reel shows `kind: video`** — expected (Facebook lists reels under `/videos/`).
- **A Page returns a status row** — no videos tab, no such Page, or signed-in only (free).

**How it reads Facebook:** opens the videos tab as a signed-out visitor (its card carries six videos) and asks Facebook's own list query for the rest (three a call) using the page's tokens. Residential Apify Proxy by default; rate-limited exits dropped and replaced. Every run starts with a one-call check and ends with a clear message if Facebook's queries changed.

### ⚠️ Trademark

Independent, third-party tool. Not affiliated with, endorsed by or connected to Meta Platforms, Inc. "Facebook" and related marks belong to their owners and are used here for identification only.

### ⚖️ Is it legal to scrape this data?

It reads only what Facebook shows a signed-out visitor, about Pages (businesses and organisations). The Actor does not log in, use anyone's account or cookies, or solve CAPTCHAs. See Apify's blog post on the legality of web scraping.

### 🤝 Support & contact

- 🌐 **Website:** [data.foxlabs.com.tr](https://data.foxlabs.com.tr)
- 📧 **Email:** info@foxlabs.com.tr
- 🐛 **Issues:** open a ticket in the Actor's **Issues** tab — include the run id; the run's `SOURCE_REPORT` record holds what was asked and why the run stopped.
- 🧰 **More clean data actors:** [Fox Labs on Apify](https://apify.com/foxlabs)

### Changelog

#### 0.1.1 — 2026-10-11 — the shared core of the family

- The shared core was updated with the Page Events and Reviews Actors; video rows are unchanged.

#### 0.1.0 — 2026-10-11 — first release

- Videos of public Facebook Pages as a signed-out visitor sees them, newest first: the six in the videos tab, then three a call from Facebook's own list query.
- Every row: title, the post's text with hashtags, exact time, plays (and post plays), duration, thumbnail, the signed file address, the video's address and post id, reactions in total and by kind, the Page's record, plays per hour.
- Filters (minimum plays, published-after) that leave videos out without charging; free status rows for empty lines; "only new" lists; restarted runs continue without duplicates. Standby mode prepared; published in batch mode.

# Changelog

This Actor's version history is a separate document: https://apify.com/foxlabs/facebook-page-videos-scraper/changelog.md

# Actor input Schema

## `pages` (type: `array`):

One Page per line: a name (NASA), @NASA, a numeric id, or an address (https://www.facebook.com/NASA). The forms can be mixed; a Page written twice is read once. Only public Pages can be read — a Page Facebook shows to signed-in users only gets a free status row that says so.

## `maxVideosPerPage` (type: `integer`):

How many videos to deliver for each Page, newest first. Facebook hands the list out three videos a call after the first six.

## `maxVideos` (type: `integer`):

The run stops when this many rows have been delivered. You are charged only for delivered rows.

## `minViews` (type: `integer`):

Deliver only videos with at least this many plays. Leave empty for every video.

## `publishedAfter` (type: `string`):

Deliver only videos published on or after this date (2026-10-01, or with a time 2026-10-01T12:00:00Z). The walk down a Page stops once three videos in a row are older.

## `includeEngagement` (type: `boolean`):

Add the number of comments on each video. This reads each delivered video's own page, so a run costs noticeably more and takes longer. Leave off for the fast list (reactions and plays come either way). Facebook does not show a video's share count to visitors who are not signed in, so share count is not available.

## `onlyNewVideos` (type: `boolean`):

Remember delivered videos under the list name below and skip them in later runs. Schedule the same Pages and each run brings only the videos it has not delivered before. With this on, "Maximum videos per Page" is how far down each Page the Actor looks.

## `listName` (type: `string`):

Name of the memory used by "Only videos not delivered before" (looked at only when that is on). Letters, digits and hyphens (a hyphen not first or last), up to 40 characters; capitals are read as lower case.

## `proxyConfiguration` (type: `object`):

Nothing to change for normal use: the Actor reads Facebook through Apify Proxy residential addresses, the only kind Facebook serves its public Pages to (measured: residential 25 of 25 requests, datacenter 0 — sent to the login page). Set a proxy here to send every request through it instead.

## Actor input object example

```json
{
  "pages": [
    "NASA"
  ],
  "maxVideosPerPage": 30,
  "maxVideos": 100000,
  "includeEngagement": false,
  "onlyNewVideos": false,
  "listName": "default"
}
```

# Actor output Schema

## `dataset` (type: `string`):

No description

# 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 = {
    "pages": [
        "NASA"
    ],
    "maxVideosPerPage": 30
};

// Run the Actor and wait for it to finish
const run = await client.actor("foxlabs/facebook-page-videos-scraper").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 = {
    "pages": ["NASA"],
    "maxVideosPerPage": 30,
}

# Run the Actor and wait for it to finish
run = client.actor("foxlabs/facebook-page-videos-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "pages": [
    "NASA"
  ],
  "maxVideosPerPage": 30
}' |
apify call foxlabs/facebook-page-videos-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,foxlabs/facebook-page-videos-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

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