# TikTok Transcript Scraper (`khadinakbar/tiktok-transcript-scraper`) Actor

AI transcript extractor for TikTok videos. Native captions + AI fallback, WEBVTT timestamps, no cookies, no login. MCP/API-ready.

- **URL**: https://apify.com/khadinakbar/tiktok-transcript-scraper.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** Videos, MCP servers, Social media
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 native transcript extracteds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## TikTok Transcript Scraper

TikTok Transcript Scraper is an Apify Actor for turning specific TikTok video URLs into transcript records. It accepts full TikTok links, shortened links, and request-object start URLs, then returns one dataset record per video with the transcript text, WEBVTT cue data, timestamped segments, language, source, status, and extraction time. It is built for public TikTok video speech extraction through Apify, and it is also usable through Apify MCP.

### Best fit and connected workflows

This Actor fits workflows that start with a known TikTok video URL and need structured speech text for downstream use.

Common routing patterns:

- video-to-text pipelines for content analysis and research
- transcript enrichment before summarization, tagging, or indexing
- RAG inputs built from spoken TikTok content
- workflow chains where another Actor emits TikTok URL objects into `startUrls`
- Use paired social workflows with [TikTok Comments Scraper - Replies & Authors](https://apify.com/khadinakbar/tiktok-comments-scraper) when the next step is comment and reply analysis on the same content set

The Actor focuses on individual videos rather than profiles, feeds, hashtags, or sounds, which keeps the input contract precise and the output aligned to transcript extraction.

### Practical scenario

A content strategist, Maya, has a list of three TikTok video URLs from a campaign review. She sends those URLs in `videoUrls` with `language` set to `en` and `useAiFallback` left off. The dataset returns `transcript`, `segments`, `isAiTranscript`, `source`, and `status` for each video. Maya sees one video with native captions and another with a `no_transcribable_audio` status. She uses the transcript text to draft a summary and then sends the same URLs into a downstream notes workflow.

### Input fields

| Field | Type | Description |
|---|---|---|
| `videoUrls` | array | TikTok video URLs to transcribe. Accepts full URLs and shortened forms. This is the main input for specific videos. |
| `startUrls` | array | Alternative request-object input, such as `[{ "url": "https://www.tiktok.com/@user/video/123..." }]`. Useful for chaining from another Actor. |
| `useAiFallback` | boolean | Enables AI speech recognition when native captions are unavailable. AI fallback is available for videos under 2 minutes. |
| `maxTranscripts` | integer | Hard cap on how many videos are transcribed in one run. Default is 100. |
| `language` | string | Two-letter language code passed to the provider, such as `en`, `es`, or `fr`. |

#### Focused input example

```json
{
  "videoUrls": [
    "https://www.tiktok.com/@stoolpresidente/video/7499229683859426602",
    "https://www.tiktok.com/@khaby.lame/video/7137423965982653702"
  ],
  "useAiFallback": false,
  "maxTranscripts": 25,
  "language": "en"
}
```

### Output fields

| Field | Type | Description |
|---|---|---|
| `videoId` | string or null | TikTok numeric video ID when resolved. |
| `url` | string | TikTok video URL as passed to the provider. |
| `transcript` | string or null | Full transcript text with line breaks between segments. |
| `segments` | array | Timestamped segments parsed from WEBVTT. |
| `webvtt` | string or null | Raw WEBVTT response from the provider. |
| `isAiTranscript` | boolean | True when AI fallback produced the transcript. |
| `language` | string or null | Two-letter language code requested for the transcript. |
| `source` | string or null | Provider that produced the transcript: `scrapecreators` or `sociavault`. |
| `status` | string | One of `ok`, `no_transcribable_audio`, or `provider_error`. |
| `note` | string or null | Human-readable explanation for non-`ok` records. |
| `scrapedAt` | string | ISO 8601 timestamp of extraction. |

#### Illustrative output record

```json
{
  "videoId": "7499229683859426602",
  "url": "https://www.tiktok.com/@stoolpresidente/video/7499229683859426602",
  "transcript": "Alright, pizza review time.\nSal's Pizza Factory.",
  "segments": [
    {
      "start": "00:00:00.120",
      "end": "00:00:01.840",
      "text": "Alright, pizza review time."
    },
    {
      "start": "00:00:01.841",
      "end": "00:00:03.761",
      "text": "Sal's Pizza Factory."
    }
  ],
  "webvtt": "WEBVTT\n\n00:00:00.120 --> 00:00:01.840\nAlright, pizza review time.\n\n00:00:01.841 --> 00:00:03.761\nSal's Pizza Factory.\n",
  "isAiTranscript": false,
  "language": "en",
  "source": "scrapecreators",
  "status": "ok",
  "note": null,
  "scrapedAt": "2026-06-27T03:10:00.000Z"
}
```

### How it works

This Actor uses managed transcript providers behind the scenes and keeps the workflow public-data based.

Implementation facts:

1. The Actor accepts TikTok video URLs through `videoUrls` or `startUrls`.
2. It requests a transcript from the provider, with ScrapeCreators as the primary provider and SociaVault as fallback.
3. Native captions are used first.
4. When `useAiFallback` is enabled, AI speech recognition can be used for videos without native transcripts, subject to the provider's two-minute scope.
5. The returned WEBVTT content is parsed into plain-text transcript text and timestamped segments.
6. Results are written to the dataset, and a run summary is written to the output key-value record.

The Actor uses the environment variables `SCRAPECREATORS_API_KEY` and `SOCIAVAULT_API_KEY` in its containerized setup.

### Pricing

This Actor uses Pay per event pricing plus Apify platform usage.

Chargeable events include:

- Actor start
- Native transcript extracted
- AI fallback transcript extracted

The native transcript event is the primary event, and AI fallback uses a separate event. Apify platform usage is billed separately according to the workspace and execution resources used on the platform. For the current pricing details, event pricing, and any platform usage information, check the live Pricing tab on the Actor page.

Example in words: if you run the Actor on ten videos and six return native transcripts while four use AI fallback, the billed transcript events follow those event types, plus the run start event and any Apify platform usage tied to the run.

### Use with AI agents (MCP)

This Actor is usable through Apify MCP as a tool for converting a TikTok video URL into transcript records.

Exact Actor identity: `khadinakbar/tiktok-transcript-scraper`

Tool description:

- Input: one or more TikTok video URLs, or request objects with `url`
- Output: dataset records containing transcript text, WEBVTT, segments, source, status, and timestamps
- Scope: specific TikTok videos, with native captions first and optional AI fallback for eligible videos
- Provenance: each record includes `source`, `status`, and `scrapedAt` so downstream agents can track where the transcript came from and when it was extracted
- Pagination and cost guidance: if your agent processes many URLs, use `maxTranscripts` to cap the run size and keep batches small enough for predictable billing. Each transcript event is charged per extracted video, with AI fallback billed as its own event type when enabled.

> Extract transcripts from these TikTok video URLs and return structured records with transcript text, segments, source, status, and scrape time. Use native captions first, and include AI fallback only when the video has no native transcript and the execution configuration allows it.

### Apify API example

JavaScript example with `APIFY_TOKEN` and dataset readback:

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

const client = new ApifyClient({
  token: process.env.APIFY_TOKEN,
});

const input = {
  videoUrls: [
    'https://www.tiktok.com/@stoolpresidente/video/7499229683859426602'
  ],
  useAiFallback: false,
  maxTranscripts: 10,
  language: 'en',
};

const run = await client.actor('khadinakbar/tiktok-transcript-scraper').call(input);

const { items } = await client.dataset(run.defaultDatasetId).listItems({
  clean: true,
});

console.log(items);
```

### Best results and outcome guidance

A few simple routing choices help keep runs aligned with the contract:

- Use `videoUrls` for direct, manual transcription jobs.
- Use `startUrls` when another Actor already outputs TikTok URL objects.
- Set `language` to the language of the native caption track you expect.
- Keep `useAiFallback` off when you want native-caption-only output.
- Use `maxTranscripts` to set the batch size for a run.

The output is most useful when a downstream step can consume plain text, timestamped segments, or the raw WEBVTT cue format.

### Design note

I found that the dataset contract includes both `transcript` and `segments`, which makes the output useful for plain-text reading and time-aligned processing at the same time.

### FAQ

#### Can this Actor accept a TikTok profile or hashtag?

It is built for specific TikTok video URLs. For profile, hashtag, search, or comment workflows, use a matching Actor from the same portfolio.

#### When should I use `startUrls` instead of `videoUrls`?

Use `videoUrls` for direct runs. Use `startUrls` when another Actor or agent already emits request objects like `{ "url": "..." }`.

#### What is the role of `useAiFallback`?

It enables AI speech recognition for videos that have no native transcript, with the provider scope limited to videos under 2 minutes.

#### What does `source` tell me?

It shows which provider produced the transcript, with values such as `scrapecreators` or `sociavault`.

#### How should I connect this with another TikTok workflow?

A common path is to extract transcripts here first, then route the same video set into TikTok comment analysis, or into summarization and classification tools.

### Responsible use

Use this Actor for TikTok content that you are permitted to access and process. It works on public video URLs and returns structured transcript data for downstream analysis, accessibility, and content workflows. Respect applicable platform terms, copyright, and data protection obligations in your environment.

# Actor input Schema

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

List of TikTok video URLs to transcribe. Accepts full URLs like 'https://www.tiktok.com/@stoolpresidente/video/7499229683859426602' and shortened forms like 'https://vt.tiktok.com/ABC123/' or 'https://www.tiktok.com/t/CODE/'. Returns transcript text with WEBVTT-style timestamped segments. This is the main input — NOT a username, hashtag, or sound; this actor transcribes specific videos, not whole profiles or feeds.

## `startUrls` (type: `array`):

Alternative way to pass targets as request objects, e.g. when chaining from another actor's output: \[{ "url": "https://www.tiktok.com/@user/video/123..." }]. Merged with 'videoUrls'. Use 'videoUrls' for simple manual runs; use this for programmatic/agent pipelines that emit URL objects.

## `useAiFallback` (type: `boolean`):

When enabled, the provider runs AI speech recognition on videos that have no native auto-caption track. AI fallback costs 5x the native rate ($0.025 vs $0.005 per transcript) and only works on videos under 2 minutes. Disabled by default to keep cost predictable — videos without native captions return an empty transcript with a clear note instead.

## `maxTranscripts` (type: `integer`):

Hard cap on how many videos are transcribed (and billed) in one run. Defaults to 100. Set lower to control spend. NOT a per-video length limit — provider transcription is capped at 2-minute videos regardless of this value.

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

Two-letter language code passed to the provider (e.g. 'en', 'es', 'fr', 'de', 'it', 'ja', 'ko', 'zh'). Defaults to 'en'. Tells the provider which native caption track to return; AI fallback auto-detects language regardless. Use 'en' for English videos; switch to the matching code when scraping non-English creators.

## Actor input object example

```json
{
  "videoUrls": [
    "https://www.tiktok.com/@stoolpresidente/video/7499229683859426602",
    "https://www.tiktok.com/@khaby.lame/video/7137423965982653702"
  ],
  "useAiFallback": false,
  "maxTranscripts": 100,
  "language": "en"
}
```

# Actor output Schema

## `transcripts` (type: `string`):

All extracted TikTok video transcripts.

## `summary` (type: `string`):

Counts and billed amount for this run.

# 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.tiktok.com/@stoolpresidente/video/7499229683859426602"
    ],
    "useAiFallback": false,
    "maxTranscripts": 100,
    "language": "en"
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/tiktok-transcript-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 = {
    "videoUrls": ["https://www.tiktok.com/@stoolpresidente/video/7499229683859426602"],
    "useAiFallback": False,
    "maxTranscripts": 100,
    "language": "en",
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/tiktok-transcript-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "videoUrls": [
    "https://www.tiktok.com/@stoolpresidente/video/7499229683859426602"
  ],
  "useAiFallback": false,
  "maxTranscripts": 100,
  "language": "en"
}' |
apify call khadinakbar/tiktok-transcript-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=khadinakbar/tiktok-transcript-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/bcdJNB0YdzIN3cSuK/builds/0EbChSuq2XTDK50oQ/openapi.json