# Facebook Video AI Transcript Scraper API (`lance_api/facebook-video-ai-transcript-scraper-api`) Actor

Transcribe public Facebook videos, Reels, Watch videos, and fb.watch links into text, timestamped segments, SRT, and WebVTT with optional translation and metadata.

- **URL**: https://apify.com/lance\_api/facebook-video-ai-transcript-scraper-api.md
- **Developed by:** [LanceAPI](https://apify.com/lance_api) (community)
- **Categories:** AI, Social media, Developer tools
- **Stats:** 5 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 results

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 AI Transcript Scraper API

**Turn public Facebook videos and Reels into AI-generated transcripts, timestamped segments, SRT, and WebVTT subtitles—with optional translation and structured video metadata.**

Submit one or more public Facebook video URLs and receive a new transcript generated directly from the spoken audio—even when the video has no existing Facebook captions. The defaults work immediately, while optional controls let you keep Results lightweight or add subtitles, translation, and richer context when your workflow needs them.

- **Real AI transcript:** spoken audio becomes new, machine-readable text
- **Choose your output:** request text, timed segments, SRT, WebVTT, metadata, or translation
- **One transcription, multiple formats:** selecting more formats does not create multiple transcription jobs
- **Batch-safe processing:** one failed URL does not cancel the rest of the batch
- **Transparent pricing:** unnecessary and unsuccessful AI work is not silently billed
- **No usable transcript, no transcription charge**

**Built for clean API workflows:** request only the data you need, keep Results lightweight when you want simplicity, or enable richer metadata and translation when you need more context.

### 🎛️ Control exactly what you receive

You do not have to accept one large, fixed payload. The Actor starts with sensible defaults and lets each workflow choose the useful parts.

#### Choose the transcript format for your workflow

- Request `text` for the smallest, simplest transcript payload—ideal for LLM prompts, search, summarization, storage, and content indexing.
- Add `segments` when you need timestamps, quote extraction, timestamp-aware analysis, or alignment back to the video.
- Request `srt` for subtitle import, editing, and localization workflows.
- Request `vtt` for web video, accessibility, and subtitle workflows.

Need everything? Select all four. They come from the same AI transcription pass, so requesting more formats does not create multiple transcription jobs or multiply AI transcription charges.

#### Keep the Result lean—or add research context

Set `includeMediaMetadata` to `false` when you want a transcript-focused Result without `content`, `media`, `author`, or `engagement`. This produces a leaner payload with simpler parsing and less unnecessary data.

Keep it `true` when research or analytics needs available Facebook content details, author/Page information, engagement metrics, thumbnails, and temporary media URLs. One Actor can therefore serve both lightweight transcript pipelines and richer research workflows.

#### Translation is opt-in, not forced

Keep translation off for the leanest, lowest-cost transcription workflow. Turn it on only when another language is useful—the original transcript is always preserved. `targetLanguage` matters only when translation is enabled, so original-language workflows need no extra language configuration.

If the detected language already matches the target language, the Actor reuses the original transcript instead of performing or charging an unnecessary translation.

### Transparent by design

You always know what creates a charge. A run has a small fixed start fee, successful Results have a plan-based processing fee, and AI transcription is charged only after audio successfully produces a usable transcript. Translation is completely optional.

**No surprise AI charges:** failed transcription is not charged, failed translation is not charged, canonical duplicates are processed once, and Text + Segments + SRT + WebVTT still use one transcription pass.

**No usable transcript → no successful-Result processing fee and no AI transcription fee.** See the Actor’s Pricing tab for current plan-specific rates.

### 🚀 Quick start

1. Paste one or more public Facebook video URLs into `urls`.
2. Keep the default transcript formats or select the formats you need.
3. Enable translation only when needed.
4. Run the Actor.
5. Open the Dataset to retrieve the transcript and available metadata.

```json
{
  "urls": [
    "https://www.facebook.com/reel/123456789012345/"
  ]
}
```

Replace the illustrative URL with a public Facebook video URL you are permitted to process.

The defaults already return plain transcript text plus timestamped segments. Add SRT, WebVTT, translation, or metadata controls only when your workflow needs them.

### Supported Facebook URLs

The Actor recognizes these public Facebook URL families:

- Facebook Reels: `facebook.com/reel/{videoId}`
- Canonical Facebook video pages: `facebook.com/{name}/videos/{videoId}`
- Facebook Watch URLs: `facebook.com/watch/?v={videoId}`
- Mobile Facebook video URLs on `m.facebook.com`

The resolver also recognizes `fb.watch`, `/share/r/`, and `/share/v/` redirect links. These short and share links are less reliable than canonical Reel, Watch, and video URLs and may work only when Facebook exposes a publicly resolvable destination.

**Public Facebook videos only.** Private, friends-only, deleted, login-required, age-restricted, region-restricted, live-in-progress, or otherwise inaccessible content cannot be processed.

### Common use cases

#### AI, RAG, and automation

Use structured transcript text and timestamps for summarization, semantic search, classification, retrieval-augmented generation, and AI-agent workflows.

#### Subtitles and localization

Generate SRT or WebVTT output for authorized editing, accessibility, localization, and web-video workflows, with optional transcript translation.

#### Research and monitoring

Review what submitted public creators, brands, and competitors say in video content, including public messaging and spoken mentions.

#### Searchable content databases

Create transcript archives, index spoken Facebook content, connect it to knowledge systems, or use it in content-repurposing workflows.

### Input

The defaults are intentionally useful out of the box. Most users only need to provide `urls`; the remaining options control how much data is returned and whether translation is added.

| Field | Type | Required | Default | Limits | Description |
| --- | --- | --- | --- | --- | --- |
| `urls` | `string[]` | Yes | — | 1–100 Schema items; up to 5 unique URLs on non-paying runs and 100 on paying runs | Public Facebook Reel, video-page, Watch, mobile, or resolvable redirect URLs. Values are trimmed, normalized, and deduplicated. |
| `formats` | `string[]` | No | `["text", "segments"]` | Values: `text`, `segments`, `vtt`, `srt` | Selects which transcript fields appear. All formats come from one transcription result. |
| `translate` | `boolean` | No | `false` | — | Adds a translated transcript while preserving the original transcript. |
| `targetLanguage` | `string` | No | `"en"` | A supported target-language code | Used only when `translate` is `true`. Suggested values include `en`, `es`, `pt`, `fr`, `de`, `it`, `ja`, `ko`, `zh-CN`, `zh-TW`, `ar`, `hi`, `ru`, `id`, `tr`, `vi`, `th`, `nl`, `pl`, and `uk`. |
| `includeMediaMetadata` | `boolean` | No | `true` | — | When `false`, successful items omit `content`, `media`, `author`, and `engagement`. |

Canonical duplicates are processed once. When a video ID is available, deduplication uses that ID; otherwise it uses the normalized URL. Tracking variants of the same video do not produce repeated Results or repeated usage charges.

### Input examples

#### Basic Facebook video transcription

```json
{
  "urls": ["https://www.facebook.com/watch/?v=123456789012345"]
}
```

#### Batch transcription

```json
{
  "urls": [
    "https://www.facebook.com/reel/123456789012345/",
    "https://www.facebook.com/example/videos/234567890123456/"
  ],
  "formats": ["text", "segments"]
}
```

#### SRT only

```json
{
  "urls": ["https://www.facebook.com/reel/123456789012345/"],
  "formats": ["srt"]
}
```

#### All transcript formats

```json
{
  "urls": ["https://www.facebook.com/reel/123456789012345/"],
  "formats": ["text", "segments", "vtt", "srt"]
}
```

#### Translate to English

```json
{
  "urls": ["https://www.facebook.com/reel/123456789012345/"],
  "formats": ["text", "segments", "srt"],
  "translate": true,
  "targetLanguage": "en"
}
```

#### Transcript without media metadata

```json
{
  "urls": ["https://www.facebook.com/reel/123456789012345/"],
  "formats": ["text"],
  "includeMediaMetadata": false
}
```

### Short output example

```json
{
  "inputUrl": "https://www.facebook.com/reel/123456789012345/",
  "normalizedUrl": "https://www.facebook.com/reel/123456789012345/",
  "success": true,
  "status": "success",
  "transcript": {
    "source": "ai",
    "language": "en",
    "characterCount": 48,
    "text": "Example Facebook video transcript from spoken audio.",
    "segments": [
      {
        "id": 0,
        "start": 0,
        "end": 4.8,
        "text": "Example Facebook video transcript from spoken audio."
      }
    ]
  },
  "translation": null,
  "error": null
}
```

### Transcript formats

#### `text`

Plain transcript text for search, summarization, LLM prompts, content analysis, and database indexing.

#### `segments`

Timestamped transcript segments containing `id`, `start`, `end`, and `text`. Times are measured in seconds and are useful for timestamp-aware analysis, quote extraction, and media alignment.

#### `vtt`

A complete WebVTT subtitle document returned as a string for authorized web-video, accessibility, localization, or editing workflows.

#### `srt`

A complete SubRip subtitle document returned as a string for authorized video editing, subtitle import, and accessibility workflows.

**All selected formats are derived from the same transcription pass. Requesting text, segments, WebVTT, and SRT together does not multiply the transcription charge.**

The Actor returns segment-level timestamps. It does not return speaker diarization, speaker names, or word-level timestamps.

### Translation

Set `translate` to `true` and provide `targetLanguage` to add a translated transcript. **The original transcript is preserved** in `transcript`; translated content appears separately in `translation`.

```json
{
  "translation": {
    "source": "translation",
    "language": "en",
    "characterCount": 43,
    "text": "This is an example translated transcript.",
    "segments": [
      {
        "id": 0,
        "start": 0,
        "end": 4.8,
        "text": "This is an example translated transcript."
      }
    ],
    "srt": "1\n00:00:00,000 --> 00:00:04,800\nThis is an example translated transcript."
  }
}
```

- Translation is optional. If disabled, `translation` is `null` and there is no translation charge.
- If the detected language already matches the target language, the original transcript is reused without a translation charge.
- `zh-CN` and `zh-TW` are distinct targets when simplified/traditional conversion is requested.
- Translation preserves segment timing from the original transcript.
- If translation fails after transcription succeeds, the item becomes `partial_success`, preserves the original transcript, and does not charge the failed translation.
- Translation character units use the original transcript, not translated output or number of formats.

### Output

Each unique accepted URL creates one Dataset item. Successful items contain the transcript and may include metadata. Failed items contain an actionable item-level status and error without canceling the rest of the batch.

Metadata is best effort. A missing title, author field, or engagement count does not make a successful transcript fail. Unavailable counts are returned as `null`, not estimated or replaced with zero.

**Temporary media URLs:** Facebook media and thumbnail URLs may expire. They are not permanent storage links, and the Actor does not save video or audio files in the Dataset.

### Complete output field reference

#### Processing and input

| Field | Type | Nullable | Meaning |
| --- | --- | --- | --- |
| `success` | `boolean` | No | `true` when a usable original transcript was produced, including `partial_success`. |
| `status` | `string` | No | Item processing status. |
| `error` | `object` | Yes | Error with `code`, `message`, and `retryable`, or `null`. |
| `inputUrl` | `string` | No | Trimmed URL supplied for this unique item. |
| `normalizedUrl` | `string` | Yes | Canonical or normalized Facebook URL when available. |

#### Content

| Field | Type | Nullable | Unit / format | Meaning |
| --- | --- | --- | --- | --- |
| `content.videoId` | `string` | Yes | — | Facebook video ID when resolved. |
| `content.type` | `string` | No | `reel`, `video`, `unknown` | Normalized media type. |
| `content.title` | `string` | Yes | — | Available video title. |
| `content.description` | `string` | Yes | — | Available description. |
| `content.publishedAt` | `string` | Yes | ISO 8601 | Publication time when available. |
| `content.durationSeconds` | `number` | Yes | Seconds | Best available media duration. |

#### Media

| Field | Type | Nullable | Meaning |
| --- | --- | --- | --- |
| `media.videoUrl` | `string` | Yes | Temporary resolved video URL. |
| `media.audioUrl` | `string` | Yes | Temporary separate audio URL when available. |
| `media.thumbnailUrl` | `string` | Yes | Temporary thumbnail URL when available. |
| `media.mediaUrlsTemporary` | `boolean` | No | Indicates returned URLs may expire. |

#### Author

| Field | Type | Nullable | Meaning |
| --- | --- | --- | --- |
| `author.id` | `string` | Yes | Available author or Page ID. |
| `author.username` | `string` | Yes | Available username. |
| `author.displayName` | `string` | Yes | Available display name. |
| `author.url` | `string` | Yes | Available author or Page URL. |
| `author.verified` | `boolean` | Yes | Verification state when exposed. |

#### Engagement

| Field | Type | Nullable | Meaning |
| --- | --- | --- | --- |
| `engagement.viewCount` | `number` | Yes | View count when independently available. |
| `engagement.playCount` | `number` | Yes | Play count when independently available. |
| `engagement.reactionCount` | `number` | Yes | Total reactions when available. |
| `engagement.likeCount` | `number` | Yes | Like count when independently available. |
| `engagement.commentCount` | `number` | Yes | Comment count when available. |
| `engagement.shareCount` | `number` | Yes | Share count when available. |

#### Transcript and translation

| Field | Type | Nullable | Unit / availability | Meaning |
| --- | --- | --- | --- | --- |
| `source` | `string` | No | `ai` or `translation` | Original or translated transcript. |
| `language` | `string` | Yes | Language code | Detected original or requested target language. |
| `characterCount` | `number` | No | Unicode characters | Length of returned text. |
| `text` | `string` | Conditional | When `text` requested | Plain transcript. |
| `segments` | `object[]` | Conditional | When `segments` requested | Timed segments. |
| `segments[].id` | `number` | No | Zero-based | Segment identifier. |
| `segments[].start` | `number` | No | Seconds | Start time. |
| `segments[].end` | `number` | No | Seconds | End time. |
| `segments[].text` | `string` | No | — | Original or translated text. |
| `vtt` | `string` | Conditional | When `vtt` requested | Complete WebVTT document. |
| `srt` | `string` | Conditional | When `srt` requested | Complete SRT document. |

### Status values

| Status | Meaning | Transcript | Translation | Typical retry behavior |
| --- | --- | --- | --- | --- |
| `success` | Original transcript and any requested translation succeeded. | Present | Present or `null` | No retry needed |
| `partial_success` | Original transcript succeeded; optional translation failed. | Present | `null` | Retry only if translation is still needed |
| `invalid_url` | Input is not a valid URL. | `null` | `null` | Correct the URL |
| `unsupported_url` | Not a supported Facebook video URL. | `null` | `null` | Use a supported video URL |
| `login_required` | Facebook requires login. | `null` | `null` | Not retryable without public access |
| `private_content` | Content is private or restricted. | `null` | `null` | Not retryable without public access |
| `media_not_found` | No accessible media source was resolved. | `null` | `null` | Usually not retryable; verify availability |
| `unsupported_media` | Media exceeds supported limits or cannot be processed. | `null` | `null` | Usually not retryable |
| `no_audio` | No usable audio source is present. | `null` | `null` | Not retryable for the same media |
| `no_speech` | Audio contains no detectable spoken language. | `null` | `null` | Not retryable for the same media |
| `transcription_failed` | AI transcription did not complete. | `null` | `null` | Check `error.retryable` |
| `rate_limited` | A public media request was rate limited. | `null` | `null` | Retry later |
| `temporarily_unavailable` | Resolution failed for a potentially temporary reason. | `null` | `null` | Retry later |
| `processing_failed` | Another item-level error occurred. | `null` | `null` | Check `error.retryable` |

#### No-speech example

```json
{
  "inputUrl": "https://www.facebook.com/reel/123456789012345/",
  "normalizedUrl": "https://www.facebook.com/reel/123456789012345/",
  "success": false,
  "status": "no_speech",
  "transcript": null,
  "translation": null,
  "error": {
    "code": "NO_SPEECH",
    "message": "No speech was detected in the media.",
    "retryable": false
  }
}
```

#### Failed-input example

```json
{
  "inputUrl": "https://www.facebook.com/example",
  "normalizedUrl": null,
  "success": false,
  "status": "unsupported_url",
  "content": null,
  "media": null,
  "author": null,
  "engagement": null,
  "transcript": null,
  "translation": null,
  "error": {
    "code": "UNSUPPORTED_URL",
    "message": "The URL is not a supported Facebook video URL.",
    "retryable": false
  }
}
```

#### Translation partial-success example

```json
{
  "inputUrl": "https://www.facebook.com/reel/123456789012345/",
  "normalizedUrl": "https://www.facebook.com/reel/123456789012345/",
  "success": true,
  "status": "partial_success",
  "transcript": {
    "source": "ai",
    "language": "es",
    "characterCount": 22,
    "text": "Transcripción original."
  },
  "translation": null,
  "error": {
    "code": "TRANSLATION_FAILED",
    "message": "Translation could not be completed.",
    "retryable": true
  }
}
```

### Complete output example

```json
{
  "inputUrl": "https://www.facebook.com/reel/123456789012345/",
  "normalizedUrl": "https://www.facebook.com/reel/123456789012345/",
  "success": true,
  "status": "success",
  "content": {
    "videoId": "123456789012345",
    "type": "reel",
    "title": null,
    "description": "Illustrative public Facebook Reel description.",
    "publishedAt": "2026-08-01T10:30:00.000Z",
    "durationSeconds": 42.6
  },
  "media": {
    "videoUrl": "https://video.example/video.mp4",
    "audioUrl": "https://video.example/audio.m4a",
    "thumbnailUrl": "https://media.example/thumbnail.jpg",
    "mediaUrlsTemporary": true
  },
  "author": {
    "id": "1000123456789",
    "username": null,
    "displayName": "Example Creator",
    "url": "https://www.facebook.com/example.creator",
    "verified": null
  },
  "engagement": {
    "viewCount": null,
    "playCount": 12000,
    "reactionCount": 450,
    "likeCount": null,
    "commentCount": 38,
    "shareCount": 21
  },
  "transcript": {
    "source": "ai",
    "language": "es",
    "characterCount": 51,
    "text": "Este es un ejemplo de una transcripción de Facebook.",
    "segments": [{"id": 0, "start": 0, "end": 4.8, "text": "Este es un ejemplo de una transcripción de Facebook."}],
    "vtt": "WEBVTT\n\n00:00:00.000 --> 00:00:04.800\nEste es un ejemplo de una transcripción de Facebook.",
    "srt": "1\n00:00:00,000 --> 00:00:04,800\nEste es un ejemplo de una transcripción de Facebook."
  },
  "translation": {
    "source": "translation",
    "language": "en",
    "characterCount": 46,
    "text": "This is an example Facebook video transcript.",
    "segments": [{"id": 0, "start": 0, "end": 4.8, "text": "This is an example Facebook video transcript."}],
    "vtt": "WEBVTT\n\n00:00:00.000 --> 00:00:04.800\nThis is an example Facebook video transcript.",
    "srt": "1\n00:00:00,000 --> 00:00:04,800\nThis is an example Facebook video transcript."
  },
  "error": null
}
```

All URLs and values in this output example are illustrative.

### API usage

#### JavaScript

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('lance_api/facebook-video-ai-transcript-scraper-api').call({
  urls: ['https://www.facebook.com/reel/123456789012345/'],
  formats: ['text', 'segments'],
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("lance_api/facebook-video-ai-transcript-scraper-api").call(
    run_input={
        "urls": ["https://www.facebook.com/reel/123456789012345/"],
        "formats": ["text", "segments", "srt"],
    }
)
items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items)
```

#### cURL

```bash
curl -X POST \
  'https://api.apify.com/v2/actors/lance_api~facebook-video-ai-transcript-scraper-api/runs' \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"urls":["https://www.facebook.com/reel/123456789012345/"],"formats":["text","segments"]}'
```

Keep your Apify Token in an environment variable or secret manager. Do not place it in source code, prompts, screenshots, or URL query parameters.

### 💰 Pricing

Your usage can contain four clearly separated charges:

- **Actor start:** a fixed **$0.005 fee** applies once per run.
- **Successful Result processing:** charged only when a URL produces a usable Result.
- **AI transcription:** charged by started audio minute only after a usable transcript is produced.
- **Translation:** optional and charged by started source-text units only when translation is actually performed.

**No surprise AI charges:** failed transcription is not charged, failed translation is not charged, canonical duplicates are processed once, and requesting Text + Segments + SRT + WebVTT still uses one transcription pass.

If transcription succeeds but translation fails, the successful transcript and Result processing remain billable; the failed translation does not. If source and target languages match, no translation operation or translation charge occurs.

Check the Actor’s Pricing tab for the latest Free, Starter, Scale, and Business rates.

### How it works

1. Validate, normalize, and deduplicate submitted Facebook URLs.
2. Resolve publicly accessible Facebook media.
3. Select usable audio or media for transcription.
4. Generate one AI transcript with language detection and timed segments.
5. Derive requested text, segments, WebVTT, and SRT formats.
6. Optionally translate the completed transcript and save the structured Result to the Dataset.

### 🤖 Use with AI agents

This Actor can be called through the Apify MCP Server by compatible AI clients. Connect the Apify MCP Server, then call:

`lance_api/facebook-video-ai-transcript-scraper-api`

Example prompt:

> Use the Apify Actor `lance_api/facebook-video-ai-transcript-scraper-api` to transcribe these public Facebook video URLs. Return the original transcript, timestamped segments, and SRT subtitles. Translate the transcript to English when requested and summarize the Results in a table.

MCP executions use the same Actor pricing as standard executions.

### FAQ

#### Does this Actor use existing Facebook captions?

No. It generates a new transcript from spoken audio using AI.

#### Which Facebook URL types are supported?

Canonical Reel, video-page, Watch, and mobile video URLs are recognized. `fb.watch` and share redirects are less reliable and work only when a public destination can be resolved.

#### Can I process multiple videos at once?

Yes. The Schema accepts up to 100 URLs. Non-paying runs are limited to 5 unique URLs; paying runs support up to 100.

#### What happens if one URL fails?

The failure is returned as an item-level Dataset record. Other unique URLs continue processing.

#### What happens if a video has no audio or speech?

It returns `no_audio` or `no_speech`. No successful-Result or AI transcription fee applies, but the run start fee still applies.

#### Do four formats cost four times?

No. One transcription generates all requested formats.

#### Can transcripts be translated, and is the original kept?

Yes. The original remains in `transcript`; the translated version appears separately in `translation`.

#### Is unnecessary or failed translation charged?

No. Matching source and target languages reuse the original transcript. If translation fails, the original transcript is preserved and the failed translation is not charged. Simplified and Traditional Chinese remain distinct when conversion is requested.

#### How am I charged?

Every run has a $0.005 start fee. Each successful Result has a plan-specific processing fee. AI transcription uses `ceil(durationSeconds / 60)`. Optional translation is charged per started 1,000 source characters.

#### Are duplicate URLs charged twice?

No. Canonical duplicates are processed once.

#### Are media URLs permanent, and are media files stored?

No. **Temporary media URLs** may expire. The Actor stores structured Dataset Results and does not permanently host Facebook video or audio files.

#### Can it access private Facebook content?

No. It processes publicly accessible content and does not bypass access controls.

#### Can AI agents use this Actor?

Yes. It provides structured output for Apify API and MCP workflows.

### Limitations

- Publicly accessible content only; private, login-required, age-restricted, region-restricted, or deleted media is unsupported.
- Live streams that have not completed are unsupported.
- Facebook page structures, accessibility rules, and media URLs can change without notice.
- Canonical Reel, Watch, and video URLs are more reliable than short/share redirect URLs.
- Returned media URLs are temporary and may expire.
- Metadata is best effort; unavailable fields and counts may be `null`.
- Transcription quality may be affected by background music, noise, accents, low volume, or overlapping speech.
- Speaker diarization, speaker names, and word-level timestamps are not returned.
- Translation is limited to supported target-language codes.
- The Actor does not download or permanently host Facebook media.
- The Actor does not bypass login, privacy, regional, or other access controls.

### Public data and responsible use

Only process content you are legally permitted to access and process. Respect privacy, copyright, contractual restrictions, and Facebook/Meta terms. Do not attempt to bypass access controls.

Do not use this Actor for harassment, spam, unlawful profiling, copyright infringement, or attempts to obtain non-public information.

This is an unofficial Actor and is not affiliated with, endorsed by, or sponsored by Facebook or Meta.

### Support

For help, open an issue on the Actor page or email **lanceapi2026@hotmail.com**.

Include the Run ID, a non-sensitive example Facebook URL, the returned status and error, and the expected versus actual result.

Never send your Apify Token, Facebook cookies, login credentials, API keys, or other secrets.

# Actor input Schema

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

Public Facebook video, Reel, Watch, or fb.watch URLs.

## `formats` (type: `array`):

All selected formats are derived from one AI transcription pass.

## `translate` (type: `boolean`):

Keep the original transcript and add a translated version.

## `targetLanguage` (type: `string`):

Used only when translation is enabled.

## `includeMediaMetadata` (type: `boolean`):

Include Facebook content, media, author, and engagement data.

## Actor input object example

```json
{
  "urls": [
    "https://www.facebook.com/reel/123456789012345/"
  ],
  "formats": [
    "text",
    "segments"
  ],
  "translate": false,
  "targetLanguage": "en",
  "includeMediaMetadata": true
}
```

# Actor output Schema

## `results` (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 = {
    "urls": [
        "https://www.facebook.com/reel/123456789012345/"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("lance_api/facebook-video-ai-transcript-scraper-api").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/reel/123456789012345/"] }

# Run the Actor and wait for it to finish
run = client.actor("lance_api/facebook-video-ai-transcript-scraper-api").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/reel/123456789012345/"
  ]
}' |
apify call lance_api/facebook-video-ai-transcript-scraper-api --silent --output-dataset

```

## MCP server setup

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

```

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/9eJzJ9uJmQ9NUxm08/builds/PuwFNSc4m3fJLYWX5/openapi.json