DEV Community: meng xipeng

How to Transcribe Douyin (抖音) Videos to Chinese Text Without an API Key

meng xipeng — Mon, 26 Oct 2026 09:26:12 +0000

Douyin (抖音) doesn't publish subtitles in its web data, so if you want the words spoken in a video you have to run speech recognition yourself. Most open-source Douyin "video to text" projects chain together a video downloader, ffmpeg and a paid speech API (DashScope, SiliconFlow and so on), and they tend to break whenever Douyin changes its cookies.

This tutorial shows two ways to get timestamped Chinese transcripts with punctuation without any of that: a no-code run and a few lines of Python. Then a do-it-yourself section on running the speech model on your own machine, with the accuracy comparison I measured between Whisper and SenseVoice on real Douyin narration.

Disclosure: I built the Apify actor used in options 1 and 2 (Douyin Transcript Scraper). The DIY section works without it.

What you get per video

One row per video. Real values from a run on 26 Oct 2026, an 11-minute movie-explainer video (电影解说) by 心影说:

Field	Example
`url`, `videoId`	`https://www.douyin.com/video/7696934197226786058`
`authorNickname`	`心影说`
`description`	`法律迟迟不肯给出公道，八旬老兵该如何讨回尊严？ #伏罗希洛夫射手 #电影解说`
`createdAt`	`2026-10-17T09:00:00Z`
`durationSeconds`	`664.7`
`likeCount`, `commentCount`, `shareCount`, `collectCount`	`163`, `2`, `10`, `21`
`language`	`zh`
`characterCount`	`4031`
`hook`	the opening sentence (segments starting in the first 3 seconds)
`transcript`	timed segments `[{"start": 0.07, "end": 17.94, "text": "老人架起狙击步枪，…"}]`
`musicTitle`, `audioSource`	`@心影说创作的原声`, `original_sound_mp3`

Option 1: No code (Apify Console)

Open the actor page and click Try for free. Apify's free plan includes monthly platform credit; the actor itself is pay-per-event (see the Store page for the current price), and videos without speech aren't charged.
Paste Douyin videos (douyin.com/video/… links, v.douyin.com/… share links or numeric IDs), or add creators by profile link (douyin.com/user/MS4wLjAB…).
Pick the Transcript format: timed segments, plain text or both.
Click Start and export the results as CSV, JSON or Excel.

For creators, the actor transcribes their newest videos up to Max videos per creator. Douyin shows logged-out visitors roughly the 40 newest videos of an account, so for older videos paste their links directly.

Option 2: Python

pip install apify-client, then take your API token from Apify Console → Settings → Integrations.

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

run = client.actor("axlymxp/douyin-transcript-scraper").call(run_input={
    "videoUrls": ["https://www.douyin.com/video/7696934197226786058"],
    "profileUrls": [
        "https://www.douyin.com/user/MS4wLjABAAAAOzRPcYBhm0xO0mXI5UGjHc2udHifSV-6xuI5mpo_UNKFN6qLVzfWb4QMT8BTOk2n",
    ],
    "maxVideosPerProfile": 5,
    "outputFormat": "both",        # segments in `transcript`, joined text in `transcriptText`
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    if item["error"]:              # no_speech, not_available, too_long, ...
        print("skip", item["videoId"], item["error"])
        continue
    print(item["authorNickname"], item["likeCount"], item["characterCount"], "chars")
    print("  ", item["transcriptText"][:80])

A natural next step is to feed transcriptText to an LLM for an English summary or translation.

Example output

One real row (trimmed to two segments; coverUrl removed):

{
  "videoId": "7696934197226786058",
  "url": "https://www.douyin.com/video/7696934197226786058",
  "authorNickname": "心影说",
  "description": "法律迟迟不肯给出公道，八旬老兵该如何讨回尊严？ #伏罗希洛夫射手 #电影解说",
  "createdAt": "2026-10-17T09:00:00Z",
  "durationSeconds": 664.7,
  "likeCount": 163,
  "language": "zh",
  "audioSource": "original_sound_mp3",
  "characterCount": 4031,
  "transcript": [
    {"start": 0.07, "end": 17.94, "text": "老人架起狙击步枪，枪口牢牢锁定了对面的三个败类，但一枪爆头的死法显然只会便宜了这几个人渣。他随即调整枪口的角度，对准了坐在正中间的那人。那小子正用双腿夹着香槟酒瓶。就在他拔出瓶塞的瞬间，老人猛的扣下了扳机。"},
    {"start": 19.3, "end": 41.44, "text": "玻璃碎片混着鲜血，四下飞溅，不但将现场伪装成了意外爆炸，还顺带废掉了这家伙的作案工具。随后，老人迅速把狙击枪锁进柜子，套上外套，捡起地上的弹壳，神色自若的走下楼，悄无声息的混进了人群之中。…"}
  ],
  "error": null
}

DIY: transcribe Mandarin audio yourself (no API key)

If you already have the audio (your own videos, or files you downloaded), you can run a strong Mandarin speech model on a normal CPU.

Whisper or SenseVoice?

I ran the same 60-second clip of that video's narration through three models on a single cloud vCPU:

Model	Time for 60 s	What came out
Whisper `base`	11.5 s	Garbled homophones: 扳机 (trigger) became 半斤, 狙击步枪 (sniper rifle) became 嫁起居及不强; traditional and simplified characters mixed
Whisper `small`	37 s	Much better, but in traditional characters, and on another clip it inserted a Korean phrase that nobody said
SenseVoice-Small	9.3 s	Simplified Chinese with punctuation; 扳机, 狙击步枪, 神色自若, 悄无声息 all correct

SenseVoice (from Alibaba's FunAudioLLM team) also covers Cantonese, English, Japanese and Korean. The easiest way to run it on CPU is sherpa-onnx: pip install sherpa-onnx av numpy, then download sherpa-onnx-sense-voice-zh-en-ja-ko-yue-2024-07-17.tar.bz2 and silero_vad.onnx from the sherpa-onnx asr-models release.

import av, numpy as np, sherpa_onnx

SV = "sherpa-onnx-sense-voice-zh-en-ja-ko-yue-2024-07-17"

def load_audio(path, rate=16000):
    """Any audio/video file -> 16 kHz mono float32 (PyAV, no ffmpeg binary needed)."""
    chunks = []
    with av.open(path) as c:
        rs = av.AudioResampler(format="s16", layout="mono", rate=rate)
        for frame in c.decode(audio=0):
            chunks += [f.to_ndarray().reshape(-1) for f in rs.resample(frame)]
        chunks += [f.to_ndarray().reshape(-1) for f in rs.resample(None)]
    return np.concatenate(chunks).astype(np.float32) / 32768.0

recognizer = sherpa_onnx.OfflineRecognizer.from_sense_voice(
    model=f"{SV}/model.int8.onnx", tokens=f"{SV}/tokens.txt",
    num_threads=1, use_itn=True, language="auto")   # use_itn adds punctuation

vad_cfg = sherpa_onnx.VadModelConfig()
vad_cfg.silero_vad.model = "silero_vad.onnx"
vad_cfg.silero_vad.max_speech_duration = 20        # target length; it cuts at the next pause, so some run longer
vad_cfg.sample_rate = 16000
vad = sherpa_onnx.VoiceActivityDetector(vad_cfg, buffer_size_in_seconds=60)

samples = load_audio("my_video.mp3")
window = vad_cfg.silero_vad.window_size
segments = []
for i in range(0, len(samples) + window, window):
    if i < len(samples):
        vad.accept_waveform(samples[i:i + window])
    else:
        vad.flush()
    while not vad.empty():
        segments.append((vad.front.start / 16000, np.array(vad.front.samples, dtype=np.float32)))
        vad.pop()

for start, seg in segments:                         # one segment per decode call (see below)
    stream = recognizer.create_stream()
    stream.accept_waveform(16000, seg)
    recognizer.decode_stream(stream)
    print(f"[{start:7.2f}] {stream.result.text}")

Two things that cost me time:

Cut the audio into short segments. On a single 60-second chunk, SenseVoice dropped words in one of three clips. Splitting with voice-activity detection into shorter pieces (most of mine ended up 15-25 seconds) fixed that, and gives you timestamps for free.
Don't batch segments of different lengths. sherpa-onnx can decode a list of streams at once (decode_streams), but the batch is padded to its longest segment. On one vCPU that made transcription about 2.5x slower than decoding one segment at a time: roughly 19 s of CPU per audio minute instead of 7.7 s.

Getting the audio out of Douyin is the other half of the job: the video and its download links come from Douyin's signed web API, and the files are big (an 11-minute explainer is 150-210 MB as video). When a video uses the creator's original sound, its audio-only MP3 is much smaller (17-29 MB for 11-17 minutes), which is what the actor downloads.

FAQ

Do I need a Douyin account? No. Only public videos are read, logged out.

Does Douyin provide subtitles? Not in its public web data; every transcript is generated from the audio.

How accurate is it? Clear Mandarin narration comes out very well. Background music, dialects, heavy slang or several people talking at once lower accuracy, and song lyrics are transcribed like speech.

Traditional characters? SenseVoice outputs simplified Chinese; convert with a library such as OpenCC if you need traditional.

Is it legal? These are public videos read without logging in. How you use the transcripts is on you: respect Douyin's terms, copyright and privacy law.

Questions or a video that won't work? Open an issue on the actor page and I'll take a look.

How to Get TikTok Video Transcripts (Even When There Are No Captions)

meng xipeng — Mon, 26 Oct 2026 06:27:25 +0000

TikTok shows auto-captions on many videos, but there's no button to export them and no official transcript API. Most "TikTok transcript API" guides end with signing up for a third-party key, and many of those tools only return text for videos that already have captions.

This tutorial covers three routes: a no-code run, a few lines of Python for bulk jobs, and a do-it-yourself script that pulls TikTok's own caption file with no key at all. I'll also show what happens with videos that have no captions, which in my test was more than half of them.

Disclosure: I built the Apify actor used in options 1 and 2 (TikTok Transcript Scraper). Option 3 doesn't use it.

Captions vs. no captions: what I found

I ran 24 random public TikToks (from #dance, #photomode and #asmr) through the actor on 26 Oct 2026:

10 had TikTok's own auto-generated caption track, which came back as is.
14 had no caption track. Of those, 3 contained speech and were transcribed with Whisper AI; the other 11 were music-only dances or silent ASMR, so there was nothing to transcribe.

A captions-only tool would have returned nothing for those 3 spoken videos. That's why the actor falls back to speech-to-text.

What you get per video

One row per video. Real values from a run on 26 Oct 2026:

Field	Example
`url`, `videoId`	`https://www.tiktok.com/@renreports/video/7307726351291960622`
`authorUsername`	`renreports`
`createdAt`	`2023-12-01T20:30:54Z`
`playCount`, `likeCount`, `commentCount`, `shareCount`, `collectCount`	`66900`, `2703`, `54`, `228`, `2927`
`durationSeconds`	`139`
`transcriptSource`	`tiktok_captions` (or `ai_whisper` when the video had none)
`language`, `isAutoGenerated`, `isTranslated`	`en`, `true`, `false`
`hook`	`I work in influencer marketing and I look at media kids all day long.`
`transcript`	`[{"start": 0.08, "end": 1.28, "text": "I work in influencer marketing"}, …]`
`wordCount`	`512`
`hashtags`, `musicTitle`, `isOriginalSound`	the post's hashtags and sound

Note "media kids" in the hook: that's TikTok's own auto-caption (it means "media kits"). Captions are returned exactly as TikTok generated them.

Option 1: No code (Apify Console)

Open the actor page and click Try for free. Apify's free plan includes monthly platform credit; the actor itself is pay-per-event (current price on the Store page), and videos without speech aren't charged.
Paste links into TikTok videos: full URLs (tiktok.com/@user/video/…), mobile links or bare numeric video IDs.
Pick the Transcript source:
- auto: TikTok's captions when present, Whisper AI otherwise,
- captions: TikTok's captions only (cheapest; no AI),
- ai: always transcribe the audio, e.g. to translate everything to English.
Click Start and export the results as CSV, JSON or Excel.

Option 2: Python

pip install apify-client, then take your API token from Apify Console → Settings → Integrations.

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

run = client.actor("axlymxp/tiktok-transcript-scraper").call(run_input={
    "videoUrls": [
        "https://www.tiktok.com/@renreports/video/7307726351291960622",
        "7477698081920748830",                     # a bare video ID works too
    ],
    "transcriptSource": "auto",
    "outputFormat": "both",                        # segments + one joined string
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    if item["error"]:                              # no_speech, not_available, ...
        print("skip", item["videoId"], item["error"])
        continue
    print(item["authorUsername"], item["playCount"], item["transcriptSource"])
    print("  hook:", item["hook"])
    print("  text:", item["transcriptText"][:200])

outputFormat accepts segments ([{start, end, text}]), text (one string) or both (segments in transcript, the string in transcriptText).

Rank hooks by plays

rows = [i for i in client.dataset(run["defaultDatasetId"]).iterate_items() if i["hasSpeech"]]
for i in sorted(rows, key=lambda i: i["playCount"] or 0, reverse=True):
    print(f'{i["playCount"]:>10,}  {i["hook"]}')

Example output

One real row (trimmed to three segments; description and coverUrl removed):

{
  "videoId": "7307726351291960622",
  "url": "https://www.tiktok.com/@renreports/video/7307726351291960622",
  "authorUsername": "renreports",
  "createdAt": "2023-12-01T20:30:54Z",
  "durationSeconds": 139,
  "playCount": 66900,
  "likeCount": 2703,
  "shareCount": 228,
  "hashtags": ["influencermediakit", "influencermarketingtips", "contentcreatortips", "ugccreatortips2024", "socialmediamarketingtips"],
  "transcriptSource": "tiktok_captions",
  "language": "en",
  "isAutoGenerated": true,
  "isTranslated": false,
  "hook": "I work in influencer marketing and I look at media kids all day long.",
  "transcript": [
    {"start": 0.08, "end": 1.28, "text": "I work in influencer marketing"},
    {"start": 1.28, "end": 3.36, "text": "and I look at media kids all day long."},
    {"start": 3.36, "end": 5.08, "text": "And here is one mistake that I see"}
  ],
  "wordCount": 512,
  "error": null
}

Option 3: DIY, TikTok's own captions with no API key

A public TikTok video page embeds its data as JSON in a <script id="__UNIVERSAL_DATA_FOR_REHYDRATION__"> tag, including links to the caption files. No signing, cookies or login are needed to read it. You need curl_cffi (pip install curl_cffi) so the request looks like a normal browser:

import json, re
from curl_cffi import requests

url = "https://www.tiktok.com/@renreports/video/7307726351291960622"
s = requests.Session(impersonate="chrome124")
html = s.get(url, headers={"Accept-Language": "en-US,en;q=0.9"}).text

m = re.search(r'<script id="__UNIVERSAL_DATA_FOR_REHYDRATION__"[^>]*>(.*?)</script>', html, re.S)
if not m:
    raise SystemExit("No page data: TikTok served a challenge page to this IP")
item = json.loads(m.group(1))["__DEFAULT_SCOPE__"]["webapp.video-detail"]["itemInfo"]["itemStruct"]

tracks = (item["video"].get("claInfo") or {}).get("captionInfos") or []
for t in tracks:
    print(t["languageCode"], "auto" if t["isAutoGen"] else "manual", "original" if t["isOriginalCaption"] else "translation")

if tracks:
    vtt = s.get(tracks[0]["url"], headers={"Referer": "https://www.tiktok.com/"}).text
    print(vtt[:300])   # WebVTT: "00:00:00.080 --> 00:00:01.280 / I work in influencer marketing" ...

Things I ran into while building this:

Some IPs get a challenge page instead of the data. From Apify's cloud servers (datacenter and residential) the page came back fine. From one AWS server in Singapore, TikTok returned a "SlardarWAF" challenge every time. If m is None, try a different network.
Use the same session for the page and the files. The video file URL (video.playAddr) returned HTTP 403 when downloaded without the cookies from the page request. Keep one session for the page, the caption file and the media.
"Original sound" isn't always this video's audio. music.playUrl is a handy audio-only MP3 when music.original is true, but in one case an 8-second video pointed to a 46-second sound from another upload. Compare music.duration with video.duration before using it.
No captions? Run Whisper on the audio. Download the audio (music.playUrl when it matches, otherwise video.playAddr) and transcribe it with faster-whisper. Expect small differences on mumbled clips: for one video TikTok's captions said "Bagels to make him dance" and Whisper heard "Beggles to make you dance".

Scheduling and integrations

Run the actor from a schedule, Make, Zapier or the API whenever you collect new TikTok links, and send the dataset to Google Sheets, Slack or a webhook. An interrupted run resumes where it stopped when started again with the same input.

FAQ

Do I need a TikTok account? No. Only public videos are read, logged out.

What about videos with music only? They come back with error: no_speech and aren't charged. Sung lyrics, on the other hand, are transcribed like speech.

Other languages? TikTok often has caption tracks in several languages; set your preferred order with Preferred caption languages. isTranslated: true marks a track that is TikTok's translation rather than the original language. Whisper detects ~100 spoken languages and can translate to English.

Can it take a username or hashtag? Not yet: it takes video links or IDs. Listing a creator's videos needs TikTok's signed web API, which a plain HTTP client can't produce.

Is it legal? These are public videos read without logging in. How you use the data is on you: respect TikTok's terms and privacy law (GDPR/CCPA).

Questions or a video that won't work? Open an issue on the actor page and I'll take a look.

How to Get Transcripts for a Whole YouTube Channel or Playlist (No API Key)

meng xipeng — Mon, 26 Oct 2026 05:25:48 +0000

Getting the transcript of one YouTube video is easy: open the video, click Show transcript, copy. Getting transcripts for every video on a channel, or a 200-video playlist, as clean timed data you can feed into a script or an LLM, is where it gets annoying.

The usual routes need a YouTube Data API key and some glue code, or they work on your laptop and then fail as soon as you run them on a server. This tutorial covers three ways to do it: no code, a few lines of Python, and a do-it-yourself route with the open-source youtube-transcript-api library. For the DIY route I'll show what happened when I ran it from a cloud server.

Disclosure: I built the Apify actor used in options 1 and 2 (YouTube Transcript & Subtitles Scraper). Option 3 doesn't use it.

What you get per video

One row per video. These are real field names and values from a run on 26 Oct 2026 (Steve Jobs' Stanford commencement speech):

Field	Example
`videoId`, `url`	`UF8uR6Z6KLc`
`title`	`Steve Jobs' 2005 Stanford Commencement Address`
`channelName`, `channelId`	`Stanford`, `UC-EnprmCZ3OXyAoG7vjVNCA`
`durationSeconds`, `viewCount`	`904`, `49320612`
`language`, `languageName`	`en`, `English - English`
`isAutoGenerated`	`false` (a human-made caption track)
`segmentCount`, `wordCount`	`244`, `2298`
`transcript`	`[{"start": 22.492, "duration": 7.527, "text": "Thank You. I am honored to be with you today at your commencement"}, …]`
`availableLanguages`	every caption track on the video: Arabic, English (manual and auto-generated), Italian, …
`error`, `errorReason`	`null` when it worked (see the FAQ for the codes)

When a video has both a human-made and an auto-generated track in your language, the human-made one wins.

Option 1: No code (Apify Console)

Open the actor page and click Try for free. Apify's free plan includes monthly platform credit; the actor itself is pay-per-event (see the Store page for the current price, and videos without captions aren't charged).
Paste into Videos, playlists or channels any mix of:
- video URLs (watch?v=, youtu.be/, /shorts/, /live/) or bare 11-character IDs,
- playlist URLs or IDs (PL…),
- channel URLs (/@TED, /channel/UC…). Playlists and channels are expanded to their videos (channels newest first) up to Max videos.
Set Preferred languages (e.g. en, es, pt-BR) and the Transcript format: timed segments, plain text, or both.
Click Start and export the results as CSV, JSON or Excel, or send them to Google Sheets.

For a sense of speed: the 30 newest videos of @TED took 16 seconds and returned 29 transcripts. The 30th came back with error: bot_detected (YouTube refused that one request) and wasn't charged.

Option 2: Python

pip install apify-client, then take your API token from Apify Console → Settings → Integrations.

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

run = client.actor("axlymxp/youtube-transcript-scraper").call(run_input={
    "videoUrls": [
        "https://www.youtube.com/@TED",                      # a whole channel
        "https://www.youtube.com/watch?v=UF8uR6Z6KLc",       # a single video
    ],
    "languages": ["en"],
    "maxVideos": 50,
    "outputFormat": "both",       # segments in `transcript`, joined text in `transcriptText`
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    if item["error"]:
        print("skip", item["videoId"], item["error"])
        continue
    print(item["title"], "|", item["wordCount"], "words |", "auto" if item["isAutoGenerated"] else "manual")

Save one text file per video

Handy for search indexes, RAG pipelines or just reading:

import pathlib, re

out = pathlib.Path("transcripts")
out.mkdir(exist_ok=True)
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    if item["error"]:
        continue
    name = re.sub(r"[^\w\- ]", "", item["title"])[:80].strip() or item["videoId"]
    (out / f"{name} [{item['videoId']}].txt").write_text(item["transcriptText"], encoding="utf-8")

If you only need text, set "outputFormat": "text": transcript then holds one string instead of segments, which is the most compact input for an LLM.

Example output

One real row (trimmed to three segments; transcriptText, description, keywords and thumbnailUrl removed):

{
  "videoId": "UF8uR6Z6KLc",
  "url": "https://www.youtube.com/watch?v=UF8uR6Z6KLc",
  "title": "Steve Jobs' 2005 Stanford Commencement Address",
  "channelName": "Stanford",
  "durationSeconds": 904,
  "viewCount": 49320612,
  "language": "en",
  "languageName": "English - English",
  "isAutoGenerated": false,
  "isTranslated": false,
  "segmentCount": 244,
  "wordCount": 2298,
  "transcript": [
    {"start": 7.47, "duration": 2.899, "text": "This program is brought to you by Stanford University."},
    {"start": 10.47, "duration": 3.973, "text": "Please visit us at stanford.edu"},
    {"start": 22.492, "duration": 7.527, "text": "Thank You. I am honored to be with you today at your commencement"}
  ],
  "error": null
}

Option 3: DIY with youtube-transcript-api

If you'd rather run everything yourself, youtube-transcript-api is the standard open-source library. With version 1.2.4:

from youtube_transcript_api import YouTubeTranscriptApi

api = YouTubeTranscriptApi()
transcript = api.fetch("UF8uR6Z6KLc", languages=["en"])
for s in transcript.snippets[:3]:
    print(s.start, s.text)

That works on most home connections. Cloud servers are a different story. I ran exactly this on an Apify cloud server on 26 Oct 2026:

5 of 5 videos failed with RequestBlocked ("YouTube is blocking requests from your IP") when sent directly from the server.
5 of 5 worked once the same requests went through a residential proxy, which the library supports out of the box:

from youtube_transcript_api.proxies import GenericProxyConfig

api = YouTubeTranscriptApi(proxy_config=GenericProxyConfig(
    http_url="http://user:pass@your-residential-proxy:8000",
    https_url="http://user:pass@your-residential-proxy:8000",
))

For whole channels you also need the list of video IDs. scrapetube does that without an API key, but watch out: on that same cloud server, scrapetube.get_channel(channel_url="https://www.youtube.com/@TED") returned an empty list with no error. If your channel job reports zero videos, check where it runs before you debug your code.

So the DIY route is free in software but you'll manage proxies, retries, language selection and resuming yourself. That plumbing is what the actor handles: residential proxy by default, manual-over-auto track selection, free rows for videos without captions, and resuming an interrupted run.

Scheduling and integrations

To keep a channel's transcripts up to date, save your input as an Apify task with the channel URL and a modest Max videos (say 20), and schedule it daily or weekly. Send the dataset to Google Sheets, Slack, Make, Zapier or a webhook after each run. An interrupted run resumes where it stopped when you start it again with the same input.

FAQ

Do I need a YouTube API key? No. Neither the actor nor the DIY route uses the YouTube Data API.

What if a video has no captions? It comes back with error: no_captions and isn't charged. Transcripts come from YouTube's own caption tracks (human-made or auto-generated); the actor doesn't do speech-to-text.

Can I get a specific language or a translation? Set Preferred languages in order of preference; en also matches en-US and en-GB. If none exists, Fall back to any available language returns the video's default track (or error: language_not_available if you turn it off). Translate to uses YouTube's own caption translation; YouTube throttles that per IP, so when it refuses, the row keeps the original language and says translationError: rate_limited.

Shorts and live streams? Shorts work like normal videos. On clips without speech, the auto-generated track may hold only tags like [Music] or [Laughter].

Is it legal? These are publicly available captions, fetched without logging in. How you use them is on you: respect YouTube's terms and copyright, especially if you republish transcripts.

Questions or a video that won't work? Open an issue on the actor page and I'll take a look.

How to Transcribe Instagram Reels to Text in Bulk (No Code + Python)

meng xipeng — Mon, 26 Oct 2026 03:28:27 +0000

Instagram doesn't give you the words spoken in a reel. Public reel data has the caption, likes and comments, but no transcript and no auto-captions you can download. Most guides about this get you one reel at a time: download the video, upload it to a transcription site, copy the text.

That's fine for one reel. It breaks down when you want the last 50 reels of five creators, with timestamps, in a spreadsheet or a Python script. This tutorial shows two ways to do that: a no-code run in the browser and a few lines of Python. At the end there's a do-it-yourself section on running Whisper on audio you already have.

Disclosure: I built the Apify actor used below (Instagram Reels Transcript Scraper). The DIY section at the end works without it.

What you get per reel

Every reel comes back as one row. These are real field names and values from a run on 26 Oct 2026:

Field	Example
`url`	`https://www.instagram.com/reel/DS46KJNjva9/`
`ownerUsername`	`jayshetty`
`takenAt`	`2025-12-30T13:25:00Z`
`likeCount` / `commentCount`	`50887` / `342`
`playCount`	`999070` (filled for reels collected from a creator's profile)
`durationSeconds`	`8.81`
`language` / `languageProbability`	`en` / `0.984`
`hook`	`One of my favorite quotes from Zig Ziglar is,`
`transcript`	timed segments: `[{"start": 0, "end": 2.8, "text": "…"}]`
`hasSpeech`	`true` (music-only reels come back `false`)
`caption`, `hashtags`, `mentions`, `musicTitle`	the post text and audio info

The hook field holds the opening line (segments that start in the first 3 seconds). If you study why some reels outperform others, that's often the part you care about most.

Option 1: No code (Apify Console)

Open the actor page and click Try for free. Apify's free plan includes monthly platform credit; the actor itself is pay-per-event, and the current price is on the Store page.
Fill in one or both inputs:
- Reel or post URLs: paste links like https://www.instagram.com/reel/DS46KJNjva9/ (bare shortcodes work too).
- Creators: natgeo, @natgeo or https://www.instagram.com/natgeo/. The actor lists the creator's reels newest first and works back through their history.
Optional: set Max reels per creator, Only reels posted after (a date), Spoken language (leave empty to auto-detect), or Translate to English.
Click Start. When the run finishes, export the dataset as CSV, JSON or Excel, or send it to Google Sheets.

No Instagram account or cookies are needed; the actor only reads public reels.

Option 2: Python

Install the client: pip install apify-client, then get your API token from Apify Console → Settings → Integrations.

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

run = client.actor("axlymxp/instagram-reel-transcript-scraper").call(run_input={
    "reelUrls": ["https://www.instagram.com/reel/DS46KJNjva9/"],
    "usernames": ["hubermanlab"],
    "maxReelsPerProfile": 15,
    "newerThan": "2026-09-01",
    "outputFormat": "both",          # timed segments + one joined string
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    if item["error"]:                 # no_speech, not_available, ...
        print("skip", item["url"], item["error"])
        continue
    print(item["ownerUsername"], item["playCount"], item["url"])
    print("  hook:", item["hook"])
    print("  text:", item["transcriptText"][:200])

outputFormat accepts segments (a list of {start, end, text}), text (one string) or both (segments in transcript, the string in transcriptText). For LLM input, text is the most compact.

Turn it into a CSV of hooks

A common next step is ranking a creator's reels by plays and reading their opening lines side by side:

import csv

rows = [i for i in client.dataset(run["defaultDatasetId"]).iterate_items() if i["hasSpeech"]]
rows.sort(key=lambda i: i["playCount"] or 0, reverse=True)

with open("hooks.csv", "w", newline="") as f:
    w = csv.writer(f)
    w.writerow(["plays", "likes", "posted", "hook", "url"])
    for i in rows:
        w.writerow([i["playCount"], i["likeCount"], i["takenAt"], i["hook"], i["url"]])

Example output

One real row (trimmed: caption, thumbnailUrl and videoUrl removed):

{
  "shortcode": "DS46KJNjva9",
  "url": "https://www.instagram.com/reel/DS46KJNjva9/",
  "sourceType": "url",
  "ownerUsername": "jayshetty",
  "ownerFullName": "Jay Shetty",
  "ownerIsVerified": true,
  "takenAt": "2025-12-30T13:25:00Z",
  "likeCount": 50887,
  "commentCount": 342,
  "durationSeconds": 8.81,
  "language": "en",
  "languageProbability": 0.984,
  "hasSpeech": true,
  "hook": "One of my favorite quotes from Zig Ziglar is,",
  "transcript": [
    {"start": 0, "end": 2.8, "text": "One of my favorite quotes from Zig Ziglar is,"},
    {"start": 3.9, "end": 6.1, "text": "you don't have to be great to start,"},
    {"start": 6.7, "end": 8.7, "text": "but you have to start to be great."}
  ],
  "error": null
}

Reels that can't be transcribed still produce a row, with an error code so you can see what happened: no_speech (music-only or silent), not_available (photo post, removed, private or age-restricted), too_long (over your Skip videos longer than limit). These rows aren't charged.

DIY: transcribe audio you already have with faster-whisper

If you already have the video files (your own reels, for example), you can transcribe them locally with faster-whisper, the same open-source Whisper implementation the actor runs:

import av, numpy as np
from faster_whisper import WhisperModel

def load_audio(path, rate=16000):
    """16 kHz mono float32. Decoding with PyAV yourself avoids faster-whisper's
    built-in decoder, which passes an argument that newer PyAV releases removed."""
    chunks = []
    with av.open(path) as c:
        rs = av.AudioResampler(format="s16", layout="mono", rate=rate)
        for frame in c.decode(audio=0):
            chunks += [f.to_ndarray().reshape(-1) for f in rs.resample(frame)]
        chunks += [f.to_ndarray().reshape(-1) for f in rs.resample(None)]
    return np.concatenate(chunks).astype(np.float32) / 32768.0

model = WhisperModel("base", device="cpu", compute_type="int8", cpu_threads=1)
segments, info = model.transcribe(load_audio("my_reel.mp4"), beam_size=1, vad_filter=True)
print(info.language)
for s in segments:
    print(f"[{s.start:6.2f} → {s.end:6.2f}] {s.text.strip()}")

Three things I learned while building the actor:

cpu_threads=1 can be faster. On a small cloud container (about one vCPU), more threads made transcription slower. If you have more cores, run several files in parallel instead (num_workers in WhisperModel).
Turn on vad_filter. Without voice-activity detection, Whisper tends to invent words over background music. Many reels are music with no speech, so this matters.
Instagram serves more than one audio codec. Some of Instagram's own video streams use xHE-AAC audio, which FFmpeg (and so PyAV) can't decode yet. If decoding fails with "Not yet implemented in FFmpeg", the audio is the problem, not your code.

Scheduling and integrations

To follow a set of creators, save the input as an Apify task, set Only reels posted after to a recent date, and schedule it daily or weekly. Each run picks up the new reels; send the dataset to Google Sheets, Slack, Make, Zapier or a webhook. If a run is interrupted, starting it again with the same input continues where it stopped, without duplicate rows.

FAQ

Do I need an Instagram login? No. Only public reels are read, logged out. Private accounts and stories aren't accessible.

How accurate is it? It's Whisper's base model. Clear speech in English and other major languages comes out well; heavy music, several people talking at once, or slang lower accuracy. Setting the spoken language helps on short clips, where auto-detection has little to go on.

Which languages? Whisper covers about 100. With Translate to English on, you get English text for any of them; in my test, Spanish reels from a Spanish-language creator came back translated.

How far back can it go for a creator? In testing it paged through 300 reels per creator, with more still available. Use Max reels per creator and Only reels posted after to set the window.

Is it legal? This reads publicly available posts without logging in. What you do with the data is on you: respect Instagram's terms and privacy law (GDPR/CCPA) when the content includes personal data.

If you try it and something breaks, open an issue on the actor page and I'll take a look.