# Facebook Video Transcript Extractor (`scraper-engine/facebook-video-transcript`) Actor

Facebook Video Transcript Extractor automatically downloads and extracts text transcripts from Facebook videos. It supports public video URLs, converts spoken content into editable text, and outputs transcripts in structured formats like JSON or TXT for analysis or reuse.

- **URL**: https://apify.com/scraper-engine/facebook-video-transcript.md
- **Developed by:** [Scraper Engine](https://apify.com/scraper-engine) (community)
- **Categories:** Social media, Videos, Other
- **Stats:** 51 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$19.99/month + usage

To use this Actor, you pay a monthly rental fee to the developer. The rent is subtracted from your prepaid usage every month after the free trial period. You also pay for the Apify platform usage, which gets cheaper the higher Apify subscription plan you have.

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

## 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 Transcript Extractor — Full Transcript and Video ID

Facebook Video Transcript Extractor turns any public Facebook video or Reel URL into clean, readable text. Paste one or more links and get back the full spoken transcript, the numeric video ID, and a collection timestamp for each video — structured JSON, ready to filter, export, or feed straight into an LLM pipeline. No login, no manual transcription, no video downloads. Run it from the Actor's Apify page and the first transcript lands in your dataset before the run finishes.

### 💡 What is Facebook Video Transcript Extractor?

Facebook Video Transcript Extractor is an Apify Actor that fetches one or more public Facebook video or Reel pages and returns the video's spoken-content transcript as plain text, along with its video ID and a scrape timestamp. It works directly against public URLs — no Facebook account, login, or cookies are used or required. It's built for content teams repurposing video into text, researchers and journalists working from video statements, and developers building searchable or LLM-ready video datasets.

### 📖 What Facebook video data is publicly available to scrape?

Anyone who can open a Facebook video's page in a browser without logging in can see its transcript (when the video has one), its URL, and its numeric ID — that's the same data this Actor reads.

| Data category | Publicly available | Restricted |
| --- | --- | --- |
| Video URL and numeric video ID | ✅ Yes, for any public video/Reel link | — |
| Spoken transcript / captions | ✅ Yes, when the video carries one | Not returned for private, friends-only, or region-restricted videos |
| Page/poster name, view counts, reactions, comments | ✅ Visible on the page | Not extracted by this Actor — it returns transcript data only |
| Full video file / thumbnail | ✅ Visible on the page | Not extracted by this Actor |
| Private or friends-only videos | ❌ No | Requires a logged-in, authorized account |

Facebook Video Transcript Extractor only returns publicly visible data — what any visitor sees. Nothing behind a login wall.

### 🧩 What data can I extract with Facebook Video Transcript Extractor?

Every run returns one row per video with five fields: the source URL, the video's ID, its transcript, an error message when extraction fails, and a scrape timestamp.

#### Identifying fields

| Field Name | Description |
| --- | --- |
| `url` | The Facebook video URL you submitted. |
| `videoId` | The numeric Facebook video ID, extracted from `/videos/<id>`, `/reel/<id>`, or `/watch/?v=<id>` style links. |
| `scrapedAt` | ISO 8601 UTC timestamp of when the row was collected. |

#### Content and status fields

| Field Name | Description |
| --- | --- |
| `transcript` | The full spoken transcript text, cleaned of line breaks and extra whitespace. `null` if none could be found. |
| `error` | A short message explaining why no transcript was returned (e.g. no transcript exists, or the request failed). `null` on success. |

#### 🤖 Add-on: Need additional Facebook data?

If you also need the events a Page or Group is running, pair this Actor with Facebook Event Search Scraper. For review and recommendation posts left on Facebook Pages, use Facebook Reviews Scraper. Both live in the same Scraper Engine catalogue and pair naturally with video transcript data for a fuller picture of a Page's public content.

### 🔌 How does Facebook Video Transcript Extractor differ from the official Facebook API?

Meta's Graph API can return video captions, but only for videos your access token can see — arbitrary public videos posted by other people or Pages are out of reach without their authorization. As of 2026-08-15, Meta's own Graph API reference states you need "a valid Page Access Token or User Access Token" for any video, even one with public privacy settings, and the `video-caption` node returns metadata (`locale`, `is_auto_generated`, `uri`) pointing to a caption file rather than parsed transcript text ([developers.facebook.com/docs/graph-api/reference/video/](https://developers.facebook.com/docs/graph-api/reference/video/), [developers.facebook.com/docs/graph-api/reference/video-caption/](https://developers.facebook.com/docs/graph-api/reference/video-caption/)).

| Feature | Facebook Graph API | Facebook Video Transcript Extractor |
| --- | --- | --- |
| Access requirement | Page or User access token tied to the video, per Meta's own docs | Just the video's public URL |
| Video scope | Videos your token can access (owned, or ones you're tagged in) | Any public Facebook video or Reel URL, regardless of who posted it |
| Returned content | Caption file metadata and a `uri` link, not extracted text | Cleaned, plain-text transcript ready to read or index |
| Setup | Register a Meta developer app and generate an access token | Paste URLs into the input field and run |
| Output consistency | Follows the raw Graph API node/field structure | Consistent `url` / `videoId` / `transcript` / `error` / `scrapedAt` row every time |

Use the Graph API when you own the Page or video and only need its own caption file. Use Facebook Video Transcript Extractor when you need readable transcript text for public videos you don't own, without registering an app or requesting a token.

### 🪄 How to use Facebook Video Transcript Extractor

Facebook Video Transcript Extractor runs entirely through the Apify platform — there's no separate signup or API key beyond your Apify account.

1. Open the Actor's page on Apify and start a new run.
2. Paste one or more public Facebook video or Reel URLs into the **Video URLs** (`urls`) field. The input schema doesn't mark this field as required, but the run stops with an error if it's left empty.
3. Optionally fill in **Proxy Settings** (`proxyConfiguration`) if you want automatic proxy fallback for unreliable requests.
4. Click **Start** and watch rows land in the dataset as each video finishes.
5. Download results as JSON, CSV, or another format Apify datasets support, from the Output tab.

#### How to scale to bulk transcript extraction

`urls` accepts an array, so a single run processes every video you list — there's no separate "bulk mode" to enable. The Actor loops through the list one video at a time, pushing a row per video as it finishes. If a paid run has a per-event charge limit configured, the Actor stops itself and logs "Charge limit reached, stopping the Actor" once that limit is hit, leaving any remaining URLs unprocessed for that run.

### 🎯 What can you do with Facebook video transcript data?

- 📝 **Content teams** repurposing video use the `transcript` field to turn a spoken statement into a blog post or caption draft without watching the clip.
- 🔬 **Researchers and journalists** use `transcript` alongside `videoId` and `scrapedAt` to build a timestamped, searchable archive of statements made across multiple videos.
- 🌐 **SEO and accessibility teams** use `transcript` to publish a text version of video content for indexing and screen readers.
- 🤖 **AI engineers** feed the `transcript` field of each row into a RAG pipeline or vector store, using `url` and `videoId` as stable document identifiers for citation and dedup.
- ⚙️ **Developers** monitor the `error` field to route failed rows into a retry queue instead of silently losing them.

### 🛡️ How does Facebook Video Transcript Extractor handle rate limits and blocking?

Requests go straight to Facebook's own pages and its `api/graphql/` endpoint using standard HTTP requests with browser-like headers — there's no headless browser involved. Proxy handling follows a fixed fallback order, as implemented: a run starts with no proxy; if a request is refused and **Proxy Settings** is configured, it retries once through your configured proxy groups, then through a wider residential route if that also fails, retrying the residential route up to 3 times. Once a fallback tier succeeds, the Actor sticks with that tier for the rest of the run. If **Proxy Settings** is left empty, a failed request is not retried through a fallback tier. Each video is processed independently — a failure on one URL (page unreachable, no transcript found, request error) produces an error row for that video instead of stopping the run.

### ⬇️ Input

| Parameter | Required | Type | Description | Example Value |
| --- | --- | --- | --- | --- |
| `urls` | No | array (string list) | Paste one or more Facebook video URLs here. Each URL should point to a public Facebook video (e.g. facebook.com/.../videos/... or facebook.com/reel/...). Each link is processed and its complete spoken transcript extracted. | `["https://www.facebook.com/100044280796927/videos/2301741263587145"]` |
| `proxyConfiguration` | No | object (proxy editor) | Optional — configure proxy settings for this run to improve reliability. Leave empty to run without a proxy. | `{"useApifyProxy": false}` |

Note: the schema doesn't flag `urls` as required, but a run started with an empty list fails immediately with `'urls' must be provided`.

#### Example input

```json
{
  "urls": [
    "https://www.facebook.com/100044280796927/videos/2301741263587145",
    "https://www.facebook.com/100044280796927/videos/4141502542759187"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

### ⬆️ Output

Each processed video is written as one typed, normalized JSON row with the same five keys every time — a successful row carries a filled `transcript` and a `null` error; a failed row carries a `null` transcript and a short `error` message. Download results as JSON, CSV, Excel, or any other format Apify dataset exports support.

Successful rows are charged under the `row_result` pay-per-event; rows where no transcript could be extracted are pushed to the dataset directly and are **not** charged. To see only the charged, successful rows, filter your export where `transcript` is not `null` (equivalently, `error` is `null`).

#### Example output

```json
[
  {
    "url": "https://www.facebook.com/100044280796927/videos/2301741263587145",
    "videoId": "2301741263587145",
    "transcript": "We're also working with the military on it because they want to make sure the technology holds up in the field before it ever reaches consumers.",
    "error": null,
    "scrapedAt": "2026-08-15T09:32:07.481203+00:00"
  },
  {
    "url": "https://www.facebook.com/100044280796927/videos/9999999999999",
    "videoId": "9999999999999",
    "transcript": null,
    "error": "No transcript found for this video",
    "scrapedAt": "2026-08-15T09:32:11.203981+00:00"
  }
]
```

### ⚙️ How does it work?

For each URL, the Actor requests the video's public Facebook page directly over HTTP. It reads the page's own embedded data — or, if needed, fetches a linked script file — to find the internal query identifier Facebook's front end uses for that video. It then calls Facebook's own GraphQL endpoint (`api/graphql/`) with that identifier and searches the response for the transcript text, stripping line breaks and extra whitespace. If the identifier can't be resolved dynamically for a given request, a last-resort fallback identifier is used so a transient lookup failure doesn't necessarily fail the video. No browser rendering is used. Only data visible on the public page is returned, and the output always keeps the same five-key shape regardless of how Facebook's internal page structure changes.

### 🔗 Integrations

Facebook Video Transcript Extractor runs on the Apify platform, so it works with anything that can call an Apify Actor or read an Apify dataset.

#### Calling it programmatically

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_API_TOKEN>")

run = client.actor("<your-username>/facebook-video-transcript-extractor").call(
    run_input={
        "urls": ["https://www.facebook.com/100044280796927/videos/2301741263587145"],
        "proxyConfiguration": {"useApifyProxy": False},
    }
)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["videoId"], item["transcript"])
```

Works in Go, Ruby, Node.js, cURL — any language that can make an HTTP request.

#### No-code tools (n8n, Make, LangChain)

In n8n, use the HTTP Request node to call the Actor's run endpoint with your API token, then a second call against the dataset's `run-sync-get-dataset-items` endpoint to pull results. In Make, the HTTP module can drive the same two calls. In LangChain or LlamaIndex, use Apify's dataset loader integration to run the Actor and load transcripts directly into a document pipeline for retrieval or summarization.

### ⚖️ Is it legal to scrape Facebook video transcripts?

Scraping publicly available data — content any visitor can see without logging in — is generally lawful; the output of this Actor is limited to a video's URL, ID, transcript, and a scrape timestamp, not personal profile or account data. This falls under business/content-data scraping rather than a personal-data regime: Facebook's own Terms of Service govern what you may do with content collected from the platform, and database-rights considerations apply to any bulk collection you republish or redistribute. If a transcript captures a named individual's spoken statements and you intend to store or process it as personal data, consult legal counsel before doing so, since that use may bring GDPR or CCPA into scope regardless of the source being public.

### ❓ Frequently asked questions

#### What Facebook video fields does Facebook Video Transcript Extractor return?

Every row returns `url`, `videoId`, `transcript`, `error`, and `scrapedAt` — see [What data can I extract](#-what-data-can-i-extract-with-facebook-video-transcript-extractor) above for the full description of each.

#### Does Facebook Video Transcript Extractor require a Facebook account or login?

No. The Actor sends unauthenticated HTTP requests with an empty cookie jar — it never logs in and never asks for Facebook credentials.

#### How many Facebook videos can I extract in one run?

As many as you list in `urls` — the Actor processes every URL in the array in one run, pushing one row per video, until the list is exhausted or a configured pay-per-event charge limit is reached.

#### What happens if a video is private or has no transcript?

The row is still returned rather than dropped: `transcript` is `null` and `error` explains why — for example "No transcript found for this video" if the video has no spoken-content transcript, or a request-failure message if the page couldn't be reached. Private and friends-only videos can't be read at all, since the Actor never authenticates.

#### Can I scrape multiple Facebook videos at once?

Yes. `urls` is an array — add as many video or Reel links as you need and each is processed and pushed to the dataset as it completes.

#### Does Facebook Video Transcript Extractor work with Reel URLs?

Yes. It recognizes `facebook.com/.../videos/<id>`, `facebook.com/reel/<id>`, and `facebook.com/watch/?v=<id>` link formats and extracts the video ID from any of them.

#### Does Facebook Video Transcript Extractor work with Claude, ChatGPT, and other AI agent tools?

It isn't exposed through an MCP server, but it's callable as a standard Apify Actor from any agent framework that can make an HTTP request or use the `apify_client` SDK — including custom tools built for Claude or ChatGPT agent frameworks.

#### Does Facebook Video Transcript Extractor return data in a format LLMs can use directly?

Yes. Every row is typed, normalized JSON with the same field names across runs — no HTML, no selectors to write. Pass `transcript` straight to an LLM, index it into a vector store, or feed it to an agent tool.

#### What happens when Facebook changes its layout or anti-bot system?

The Actor resolves its internal query identifier dynamically from each page rather than relying on a single hardcoded value, with a fallback identifier if that lookup fails for a given request — this is designed to absorb minor structural changes without failing every video. No specific update turnaround is promised.

#### Can I use Facebook Video Transcript Extractor without managing proxies or browser infrastructure?

Yes. It runs without a proxy by default and needs no browser setup on your side; enabling **Proxy Settings** adds automatic fallback through Apify Proxy if you want extra reliability on longer runs.

#### Which fields work best for AI training data and RAG indexing?

`transcript` is the high-information text field to index or summarize. `url` and `videoId` are stable, consistently structured identifiers to use as document keys or for deduplication across runs.

### 🔗 Related scrapers

| Scraper Name | What it extracts |
| --- | --- |
| Facebook Event Search Scraper | Public Facebook events matching a keyword — title, schedule, venue, and attendance line. |
| Facebook Reviews Scraper | Review and recommendation posts from public Facebook Pages. |
| YouTube Video Subtitles Scraper | Subtitles/transcripts from YouTube videos in bulk. |
| YouTube Video Summarizer | YouTube video metadata, chapters, and timestamped transcripts, with optional AI summaries. |

### 💬 Your feedback

Found a bug, or a video where transcript extraction fails unexpectedly? Let us know through the Issues tab on the Actor's Apify Console page so it can be looked into.

# Actor input Schema

## `urls` (type: `array`):

📋 Paste one or more Facebook video URLs here. Each URL should point to a public Facebook video (e.g. facebook.com/.../videos/... or facebook.com/reel/...). We'll process each link and extract the complete spoken transcript. 💡 Tip: You can add as many URLs as you need — we'll handle them all!

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

⚙️ Optional — Configure proxy settings for this run to improve reliability. Leave empty to run without a proxy.

## Actor input object example

```json
{
  "urls": [
    "https://www.facebook.com/100044280796927/videos/2301741263587145",
    "https://www.facebook.com/100044280796927/videos/4141502542759187"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

All scraped items in the Actor's default dataset.

# 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 = {
    "urls": [
        "https://www.facebook.com/100044280796927/videos/2301741263587145",
        "https://www.facebook.com/100044280796927/videos/4141502542759187"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scraper-engine/facebook-video-transcript").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 = {
    "urls": [
        "https://www.facebook.com/100044280796927/videos/2301741263587145",
        "https://www.facebook.com/100044280796927/videos/4141502542759187",
    ],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("scraper-engine/facebook-video-transcript").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 '{
  "urls": [
    "https://www.facebook.com/100044280796927/videos/2301741263587145",
    "https://www.facebook.com/100044280796927/videos/4141502542759187"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call scraper-engine/facebook-video-transcript --silent --output-dataset

```

## MCP server setup

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

```

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/AsDUICkLIKpY6UTZo/builds/iUYGHAs2UmYLw7exF/openapi.json