# Lexonia Video Lens (`lexonia/lexonia-video-scrape`) Actor

Turn any video into text your AI can use — paste a URL for a transcript + AI summary + translation in 30+ languages. Real speech-to-text, not just captions: YouTube, TikTok, Vimeo, China's Bilibili (B站) & Douyin (抖音). Runs on OpenAI, Claude, Qwen or DeepSeek. LLM-ready via MCP, n8n & Make.

- **URL**: https://apify.com/lexonia/lexonia-video-scrape.md
- **Developed by:** [Lexonia Group](https://apify.com/lexonia) (community)
- **Categories:** AI, Videos, Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $30.00 / 1,000 audio transcriptions

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/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

## Lexonia Video Lens — Transcribe & Translate Any Video (Douyin, Bilibili, TikTok, YouTube, Vimeo)

**Get the words out of any video — including the ones your AI can't reach.** Paste a video URL and get back clean, structured, LLM-ready data: the spoken transcript, an AI summary, and (optionally) a full translation, in the languages you choose — language **auto-detected**.

**🌐 Languages:** Chinese · English · <details><summary><strong>more…</strong></summary>

Chinese (Mandarin) · Chinese (Traditional) · English · Spanish · German · Japanese · Korean · French · Portuguese · Russian · Arabic · Hindi · Italian · Dutch · Polish · Ukrainian · Turkish · Vietnamese · Indonesian · Malay · Thai · Filipino · Bengali · Swedish · Norwegian · Danish · Finnish · Greek · Czech · Romanian · Hungarian · Hebrew — **and any language you request.**

**Want a language that's not listed?** Email **info@lexoniagroup.com** with **"add another language"** in the subject.

</details>

Typically, your LLM summarizes and translates text brilliantly — but it **can't reach into China's Douyin (抖音) & Bilibili (B站), and it can't *listen* to a video's audio.** This Actor does: it fetches and transcribes the speech your AI can't get on its own, then hands it back ready to reason over.

- 🌏 **Reaches China video.** Douyin & Bilibili speech → an English (or any-language) summary + translation — the raw material for research your assistant otherwise can't obtain.
- 🎙️ **Transcribes audio, not just captions.** Real AI speech-to-text, so it works even when a video has no captions.
- 🧠 **Runs on YOUR AI, anywhere.** OpenAI, Claude, or China's **Qwen / DeepSeek** — usable **inside mainland China**, where OpenAI & Claude are blocked. No lock-in.
- 🔌 **Agent- & workflow-native.** Call it from **Claude / ChatGPT (Apify MCP)**, **n8n**, or **Make** — or drop the JSON straight into any LLM.
- 🈶 **Auto-detects language** with an honest confidence score.

### Supported platforms

| Platform | How it's transcribed |
|---|---|
| **Douyin (抖音)** — China's "TikTok" | audio speech-to-text |
| **Bilibili (B站)** — China's "YouTube" | audio speech-to-text |
| **TikTok** | audio speech-to-text |
| **YouTube** | native captions |
| **Vimeo** | caption track (captioned videos) |

The Actor auto-detects the platform from the URL.

### Languages — get it in yours

Understand any video in **the language you work in**, not just English. Summaries in **20+ languages** and full transcript translation in **30+** — English, Chinese, German, Japanese, Korean, French, Spanish, Portuguese, Russian, Arabic, Hindi, Indonesian, Vietnamese, Ukrainian, and more. Auto-detect the source; choose one or several output languages.

> **Need a language you don't see?** Email **info@lexoniagroup.com** with **"add another language"** in the subject — tell us the language and how you'd use it, and we'll add it.

### Whole channels — and a cost preview before you commit

- **Paste a whole channel / creator profile** in **Channel URLs** instead of listing every video. The Actor pulls its recent videos automatically — **YouTube** (channel/@handle), **Bilibili** (space), and **Douyin** (user). Choose **oldest-first** (read a creator from the beginning) or newest-first, and cap how many with **Max videos per channel**. Each video starts on its own page in the PDF export.
- **Preview first.** Turn on **Estimate only** to get the video count, the **expected cost you'll pay**, and the **approximate time** — *without* transcribing anything. Check a channel's cost, then flip it off to run for real.

### How to transcribe a Bilibili video into English

Give the Actor a Bilibili URL, set `translateLanguages` to `English` (and/or add `English` to `summaryLanguages`), and run it. You get the original Chinese transcript **plus** a full English translation and an English summary — no Mandarin required.

### How to get a Douyin (抖音) transcript with an AI summary

Paste a Douyin link and pick your summary languages. The Actor transcribes the speech and returns a summary in each language you chose — ideal for tracking Chinese social-media trends without speaking the language.

### How to transcribe a TikTok or YouTube video with AI

Same flow for TikTok, YouTube, and Vimeo: paste the URL, choose your output languages, and get a transcript + AI summary (+ optional full translation and SRT/VTT subtitles).

### Features

- **Transcription** in the video's original language — handles both short clips and long videos.
- **AI summaries** in 30+ languages — pick any combination (Original + English, Japanese, Chinese, Spanish, Arabic, …).
- **Full transcript translation** — a complete, faithful translation of the entire transcript (not just a summary) into any language you choose.
- **Automatic language detection** with a confidence score.
- **Subtitles** — export timed `.srt` / `.vtt` files (YouTube, TikTok, Bilibili).
- **Multi-format output** — JSON (LLM-ready), CSV, Markdown, and PDF (Chinese/Japanese/Korean render correctly).
- **Choice of AI model** — OpenAI, Anthropic (Claude), DeepSeek, or Qwen. DeepSeek/Qwen work inside mainland China, where OpenAI and Claude are blocked.
- **Premium model quality by default** — the strongest model for accurate summaries and translations; switch to Standard for a faster, cheaper run.

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `videoUrls` | array | — | **Required.** One or more video URLs. |
| `language` | select | `auto` | **Auto-detect** (recommended). Pick a language only to force a specific YouTube caption track. |
| `includeSummary` | boolean | `true` | Generate an AI summary. |
| `summaryLanguages` | array | `["original"]` | Languages for the summary. `original` = the video's own language; add targets to translate the summary into. |
| `translateLanguages` | array | `[]` | Languages to translate the **full transcript** into (premium deliverable). |
| `modelTier` | select | `standard` | `standard` (fast/economical) or `premium` (best quality). |
| `summaryProvider` | select | `openai` | `openai`, `anthropic`, `deepseek`, or `qwen`. |
| `apiKey` | string (secret) | — | Optional. Leave blank to use the bundled model; or bring your own key. |
| `summaryStyle` | select | `bullets` | `bullets`, `paragraph`, or `detailed`. |
| `outputFormats` | array | `["json","csv"]` | `json`, `csv`, `markdown`, `pdf` — all free. |
| `subtitleFormats` | array | `[]` | `srt` and/or `vtt` timed subtitle files. |

#### Example input

```json
{
  "videoUrls": ["https://www.douyin.com/video/..."],
  "summaryLanguages": ["original", "English"],
  "translateLanguages": ["English"],
  "modelTier": "premium",
  "outputFormats": ["json", "pdf"]
}
```

### Output

Each video produces one structured dataset item:

```json
{
  "url": "https://www.douyin.com/video/...",
  "platform": "douyin",
  "title": "Video title",
  "author": "Creator name",
  "detectedLanguage": "Chinese",
  "detectedLanguageCode": "zh",
  "languageConfidence": 98,
  "languageUncertain": false,
  "transcript": "原始中文字幕...",
  "transcriptWordCount": 1234,
  "transcriptTranslations": { "English": "Full English translation of everything said..." },
  "summaries": { "original": "中文摘要...", "English": "English summary..." },
  "summary": "中文摘要..."
}
```

### Use with Claude or ChatGPT (MCP)

This Actor is available through the **Apify MCP server**, so AI assistants can call it as a tool — just ask, in plain language, *"transcribe and summarize this Douyin video in English."*

- **Claude / ChatGPT** — add a custom connector pointing to `https://mcp.apify.com` (with your Apify token). The assistant can then run this Actor automatically whenever you need a foreign-language video understood.

### Pricing

Pay-per-event — you pay only for what you process: transcription per minute (or a flat per-video rate for caption platforms), AI summary per language, full translation **per 1,000 words** per language, and optional premium model or subtitles. No subscription. Free JSON/CSV/Markdown/PDF export. Works with the bundled model or your own key (OpenAI, Claude, Qwen, DeepSeek).

### Use cases

- **China-market research & brand monitoring** — read what China is watching on Douyin/Bilibili, in English.
- **Cross-border marketing & localization** — turn foreign creator content into briefs your team can act on.
- **Research & journalism** — search and quote foreign-language video at scale.
- **AI agents & apps** — feed clean, structured transcripts and summaries straight into your LLM pipeline.

***

Built by **Lexonia Group LLC**.

# Actor input Schema

## `videoUrls` (type: `array`):

One or more video URLs — YouTube, TikTok, Vimeo, Bilibili (B站), or Douyin (抖音). Each video is transcribed in its original language (via captions or AI speech-to-text) and summarized in the languages you choose below.

## `channelUrls` (type: `array`):

Optional. Paste a whole channel or creator profile and the Actor pulls its recent videos automatically — no need to list each video. Supported: YouTube (channel/@handle), Bilibili (space.bilibili.com/…), Douyin (douyin.com/user/…). Order and count are controlled by the two fields below. (For TikTok/Vimeo channels, paste video URLs above for now.)

## `maxVideosPerChannel` (type: `integer`):

How many videos to pull from each channel/profile above. Kept modest by default because each video is transcribed. Raise it for a bigger batch (watch your cost cap below).

## `channelVideoOrder` (type: `string`):

For channel/profile inputs: process the OLDEST videos first (default — good for reading a creator from the beginning) or the NEWEST first (latest uploads).

## `estimateOnly` (type: `boolean`):

Turn ON to get a quick preview: how many videos, the expected cost you'll pay, and the approximate time — WITHOUT transcribing anything. Great for checking a whole channel before you commit. Turn OFF to run for real. NOTE FOR AI ASSISTANTS (Claude/ChatGPT via MCP): when the input is a whole channel or several videos, run with estimateOnly=true FIRST, show the user the returned estimatedCostUsd range, and only run again with estimateOnly=false once they approve.

## `language` (type: `string`):

Leave on 'Auto-detect' (recommended) and the Actor figures out the video's language for you — it also reports a confidence score in the output. Only pick a specific language to force a particular YouTube caption track. The transcript is always kept in its original language.

## `includeSummary` (type: `boolean`):

Whether to generate a summary of each transcript with an LLM. Requires an API key below. If off, only the raw transcript is produced.

## `summaryLanguages` (type: `array`):

Pick one or more languages to produce the summary in. 'Original' keeps the video's own language; add any others to translate the summary into. A Chinese video with \[Original, English] returns both a Chinese and an English summary. Covers the languages of the world's major economies.

## `translateLanguages` (type: `array`):

Optional. Produce a COMPLETE, word-for-word translation of the entire transcript into each language you pick here — not just a summary. Ideal for reading a foreign-language video in full (e.g. a Chinese Douyin/Bilibili video translated into English). Billed per language.

## `summaryProvider` (type: `string`):

Which LLM provider to use. 'openai' uses GPT; 'anthropic' uses Claude; 'deepseek' and 'qwen' are China-market models (OpenAI/Claude are blocked in mainland China). The API key you supply must match this provider.

## `apiKey` (type: `string`):

Optional. Leave blank to use the bundled model (summary billed per the Store price). Or provide your own key for the provider above to run on your own account. Never stored.

## `transcriptionApiKey` (type: `string`):

API key for AI speech-to-text on platforms without captions (Bilibili, Douyin, TikTok). Uses OpenAI — leave blank if your summary provider is already OpenAI (that key is reused).

## `bilibiliSessdata` (type: `string`):

Advanced: a Bilibili SESSDATA cookie can unlock higher-quality audio or member-only videos. Optional — most public videos work without it.

## `modelTier` (type: `string`):

Choose the AI model quality for summaries and translations. 'Premium' (default) uses a stronger model for noticeably better, more accurate summaries and translations — best for foreign-language and Chinese video. 'Standard' is a faster, cheaper downgrade if you want to save. (A 'Summary model' override below decides which model actually runs, but selecting Premium still applies the premium surcharge.)

## `summaryModel` (type: `string`):

Override the default model. Defaults: gpt-4o-mini (OpenAI), claude-haiku-4-5 (Anthropic), deepseek-chat (DeepSeek), qwen-plus (Qwen).

## `summaryBaseUrl` (type: `string`):

Advanced: override the endpoint for any OpenAI-compatible provider (e.g. a self-hosted model or a regional endpoint). Leave blank to use the provider default.

## `summaryStyle` (type: `string`):

How each summary should be formatted.

## `outputFormats` (type: `array`):

Which files to save to the key-value store — all free. JSON is LLM-ready (drop it straight into ChatGPT/Claude), CSV for spreadsheets, Markdown/PDF for a shareable document. The dataset itself is always structured and natively exportable too.

## `subtitleFormats` (type: `array`):

Optional. Generate timed subtitle files for each video, saved to the run's storage. Available where timing data exists: YouTube (captions), TikTok and Bilibili (speech-to-text). Billed per video.

## `maxCostUsd` (type: `integer`):

Safety cap on what a single run may spend on transcription/AI processing. Once reached, the run stops before starting more videos (already-finished results are kept). Leave blank for the built-in default.

## Actor input object example

```json
{
  "videoUrls": [
    "https://www.youtube.com/watch?v=dQw4w9WgXcQ"
  ],
  "channelUrls": [],
  "maxVideosPerChannel": 10,
  "channelVideoOrder": "oldest",
  "estimateOnly": false,
  "language": "auto",
  "includeSummary": true,
  "summaryLanguages": [
    "original"
  ],
  "translateLanguages": [],
  "summaryProvider": "openai",
  "modelTier": "premium",
  "summaryStyle": "bullets",
  "outputFormats": [
    "json",
    "csv"
  ],
  "subtitleFormats": []
}
```

# 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 = {
    "videoUrls": [
        "https://www.youtube.com/watch?v=dQw4w9WgXcQ"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("lexonia/lexonia-video-scrape").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 = { "videoUrls": ["https://www.youtube.com/watch?v=dQw4w9WgXcQ"] }

# Run the Actor and wait for it to finish
run = client.actor("lexonia/lexonia-video-scrape").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 '{
  "videoUrls": [
    "https://www.youtube.com/watch?v=dQw4w9WgXcQ"
  ]
}' |
apify call lexonia/lexonia-video-scrape --silent --output-dataset

```

## MCP server setup

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

```

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/lcnncDqvX5VfQArXg/builds/zFDpkR4I5jaMYNKCD/openapi.json