DEV Community: Bloody Valentine

One Video, Five Outputs: Repurpose YouTube Into Articles, Threads, and Shorts Scripts

Bloody Valentine — Sat, 05 Sep 2026 13:10:51 +0000

One Video, Five Outputs: Repurpose YouTube Into Articles, Threads, and Shorts Scripts

One good video holds an article, a thread, three shorts, and a newsletter
section. Creators know this. What stops most developers from automating it
is the boring middle step: getting the transcript into a shape an LLM (and
a video editor) can use. Part 1 covered extraction,
part 2 covered RAG. This one is the repurposing pipeline I
actually run: transcript in, five publishable outputs out.

The input is my Apify Actor
(lexiie/youtube-transcript-api),
because repurposing needs two things plain caption scrapers do poorly:
segments with timestamps (to find cut points) and ready-made SRT
(to burn into clips). Both come back in one dataset item per video.

Step 1: fetch once, reuse everywhere

import os
import requests

ACTOR = "lexiie~youtube-transcript-api"
TOKEN = os.environ["APIFY_TOKEN"]

(resp := requests.post(
    f"https://api.apify.com/v2/acts/{ACTOR}/run-sync-get-dataset-items",
    params={"token": TOKEN},
    json={"urls": ["https://www.youtube.com/watch?v=VIDEO_ID"],
          "language": "en"},
    timeout=300,
)).raise_for_status()
video = resp.json()[0]
assert video["status"] == "success", video.get("error")

text, segments, srt = video["text"], video["segments"], video["srt"]
print(len(text), "chars,", len(segments), "segments")

Everything below reads from these three variables. Fetch once, even if you
generate ten outputs.

Output 1: article draft with real quotes

The trick is structural, not clever prompting. Hand the LLM the full text
plus an outline, and require verbatim quotes so the draft stays grounded
instead of drifting into generic summary:

import openai

draft = openai.chat.completions.create(
    model="gpt-4o-mini",
    messages=[
        {"role": "system", "content":
         "Turn the transcript into an 800-word article. Keep the author's "
         "voice. Include at least 3 verbatim quotes marked with segment "
         "timestamps like [12:04]. No new facts beyond the transcript."},
        {"role": "user", "content": text[:12000]},
    ],
).choices[0].message.content

The [12:04] markers are checkable: each maps back to a segment, so an
editor (or a script) can verify every quote against the source in seconds.
On manual-caption videos the quotes are near perfect. On auto captions,
budget one proofreading pass for homophones.

Output 2: X thread

Threads want one idea per post and a hook that earns the click. Score
segments for "standalone punch" with a dead simple heuristic, then expand
the winners:

def score(s):
    t = s["text"]
    return (len(t)                       # substance
            + 40 * ("?" in t)            # questions hook
            + 40 * ("!" in t)            # strong claims hook
            - 60 * (len(t) < 40))        # skip fragments

best = sorted(segments, key=score, reverse=True)[:7]
for s in best:
    print(f"[{s['start']:.0f}s] {s['text']}")

Feed those seven moments to the LLM with "write a 7-post thread, one
moment per post, first post under 200 characters." The timestamps ride
along, so each post can link the exact moment with a &t= URL. Threads
with timestamp links outperform plain ones in my experience: skeptics
click through, believers don't need to.

Output 3: shorts scripts with cut points

A 30 to 60 second short needs a hook in the first 3 seconds, then two or
three beats, then a payoff. That structure maps cleanly onto segments:
the hook is your highest scoring opening segment, beats are the next
strong moments in chronological order:

hook = max(segments[:8], key=score)          # open strong
beats = sorted(segments, key=score, reverse=True)[1:4]
beats.sort(key=lambda s: s["start"])          # back into story order

total = sum(b["duration"] for b in [hook, *beats])
print(f"~{total:.0f}s of source material")
for b in [hook, *beats]:
    print(f"cut {b['start']:.1f}s -> {b['start'] + b['duration']:.1f}s | {b['text']}")

The cut X -> Y lines are an edit decision list your editor can follow
blindly, and the total tells you upfront whether you have 30 seconds of
material or need a wider net. Prompt the LLM with these beats for the
on-screen caption text, keeping each line under 40 characters.

Output 4: subtitles, done already

This one is free: the srt field from step 1 is an upload-ready SubRip
file. Save it next to the clip and burn it in or upload it as a caption
track:

open("clip.srt", "w").write(srt)

Shorts with burned-in captions retain measurably better, and you just
skipped the entire "transcribe the clip" step because the transcript came
with timestamps attached. For Indonesian audiences, refetch with
"targetLanguage": "id" and you get translated SRT the same way.

Output 5: newsletter section

Same article draft from output 1, reframed: ask the LLM for a 150-word
section with one quote and one timestamp link, in the voice of your
newsletter. Newsletters thrive on "watch this 40-second moment" links, and
you now manufacture those on demand.

What breaks (honest notes)

Music and vlogs with thin dialogue transcribe to almost nothing. The Actor's ASR path returns these as failures instead of billing you, so filter status and move on.
Auto captions need a proof pass before publishing verbatim quotes. Fine for threads and drafts, risky for attributed quotes in articles.
Long podcasts (2h+) exceed a single LLM context window. Chunk by segments (see part 2's chunking recipe) and summarize per chunk, then summarize the summaries.

RAG Over YouTube Playlists: From Video URLs to Cited Answers in 60 Lines

Bloody Valentine — Sat, 05 Sep 2026 12:58:21 +0000

RAG Over YouTube Playlists: From Video URLs to Cited Answers in 60 Lines

In the previous post I covered how to extract YouTube
transcripts four ways. This one builds the thing everyone actually wants:
ask a question, get an answer cited to the exact video and timestamp.
No vector-database server, no framework. sentence-transformers handles
embeddings, numpy handles retrieval, and transcripts with timestamps do
the heavy lifting.

The full script is ~60 lines. Every step runs on your laptop except the
transcript fetch, which goes through my Apify Actor
(lexiie/youtube-transcript-api).
Playlist in, timestamped segments out.

Step 0: install

pip install requests sentence-transformers numpy openai

APIFY_TOKEN from Apify Console → Settings → Integrations. You only need
an OpenAI key for the final answer step. Retrieval works without it.

Step 1: fetch transcripts (one item per video)

import os
import requests

ACTOR = "lexiie~youtube-transcript-api"
TOKEN = os.environ["APIFY_TOKEN"]

resp = requests.post(
    f"https://api.apify.com/v2/acts/{ACTOR}/run-sync-get-dataset-items",
    params={"token": TOKEN},
    json={"urls": ["https://www.youtube.com/playlist?list=PL..."],
          "language": "en"},
    timeout=600,
)
resp.raise_for_status()
items = [i for i in resp.json() if i["status"] == "success"]
print(f"{len(items)} videos transcribed")

Note the filter: private videos, removed uploads, and caption-less videos
(without the ASR fallback) come back as status: failed with a structured
error.code. They're free, and they never kill the run. For caption-less videos
worth transcribing, add "enableAsrFallback": True (GPU transcription,
flat ~$0.10/video, takes minutes, so bump the timeout to 900s).

Step 2: chunk by segments, keep timestamps

Caption segments are natural chunk boundaries. Each already carries
start/duration. Group a few per chunk so embeddings have context, and
carry the video ID plus offsets for citations later:

def chunk_item(item, per_chunk=4):
    segs = item["segments"]
    return [{
        "videoId": item["videoId"],
        "title": item.get("title", item["videoId"]),
        "start": segs[i]["start"],
        "text": " ".join(s["text"] for s in segs[i:i + per_chunk]),
    } for i in range(0, len(segs), per_chunk)]

chunks = [c for i in items for c in chunk_item(i)]
print(f"{len(chunks)} chunks from {len(items)} videos")

A 10-video playlist typically yields a few hundred chunks. Small enough
to hold in memory, big enough to need retrieval.

Step 3: embed once, retrieve with numpy

import numpy as np
from sentence_transformers import SentenceTransformer

model = SentenceTransformer("all-MiniLM-L6-v2")  # 80MB, runs on CPU
embs = model.encode([c["text"] for c in chunks], normalize_embeddings=True)

def retrieve(question, k=5):
    q = model.encode([question], normalize_embeddings=True)[0]
    scores = embs @ q
    return [chunks[i] for i in np.argsort(-scores)[:k]]

No server, no index to maintain. This holds up to tens of thousands of
chunks. Past that, reach for FAISS or a hosted vector DB, but most
playlist corpora never get there.

Step 4: answer with citations

Stuff the retrieved chunks into an LLM prompt with their source attached,
and require citations in the output:

import openai

def ask(question):
    hits = retrieve(question)
    context = "\n\n".join(
        f"[{h['videoId']} @ {h['start']:.0f}s | {h['title']}] {h['text']}"
        for h in hits)
    resp = openai.chat.completions.create(
        model="gpt-4o-mini",
        messages=[
            {"role": "system", "content":
             "Answer from the context only. Cite every claim as "
             "[videoId @ seconds]. Say when the context is insufficient."},
            {"role": "user", "content": f"Context:\n{context}\n\nQ: {question}"},
        ],
    )
    return resp.choices[0].message.content, hits

answer, hits = ask("What does the author recommend for rate limiting?")
print(answer)

The citation format doubles as a deep link. Render it for users as
https://www.youtube.com/watch?v={videoId}&t={seconds}s and they land on
the exact moment. That single trick is what separates "AI answered" from
"AI answered and I can verify it in one click."

Keeping it fresh

Playlists grow. Re-run the fetch weekly and skip videos you already have
(match on videoId against your stored chunks). You only pay per
successful transcript (~$0.003 captions), so a weekly sync of a
slow-moving playlist costs cents. Failures are free, so new private or
removed videos in the playlist don't cost you anything either.

What I'd add next

Deduplicate intros/outros: channels repeat the same 30s intro; hash first-chunk texts per channel and drop near-duplicates.
Rerank: a cross-encoder over the top-20 before the top-5 improves answers noticeably on dense topics.
Multi-playlist: tag chunks with playlistId (the Actor returns it) and filter retrieval per collection.

How to Get YouTube Transcripts as a Developer (4 Methods That Work in 2026)

Bloody Valentine — Sat, 05 Sep 2026 12:37:12 +0000

How to Get YouTube Transcripts as a Developer (4 Methods That Work in 2026)

YouTube transcripts unlock a lot: AI video summarizers, searchable course
databases, RAG over video libraries, dataset generation for fine-tuning,
repurposing videos into articles. But getting transcripts programmatically
is full of sharp edges: disabled captions, rate limits, datacenter IP
blocks, and YouTube's ever-changing frontend.

This guide walks through every practical method with working code. Method 4
is the managed service I run. Skip ahead if you just want the API call.
The DIY methods below are real and will serve you well for small jobs.

What you're actually fetching

YouTube stores captions as timed tracks in two flavors:

Manual captions: uploaded by creators, best accuracy
Auto-generated captions: YouTube's speech recognition, most videos

Each track is text plus timing (text/start/duration), servable as SRT,
VTT, or YouTube's timedtext XML. Everything below ultimately resolves to
that shape.

Method 1: youtube-transcript-api (Python)

The standard open-source library. Start here for scripts and prototypes.

pip install youtube-transcript-api

from youtube_transcript_api import YouTubeTranscriptApi

video_id = "dQw4w9WgXcQ"  # the ID from the watch URL

transcript = YouTubeTranscriptApi.get_transcript(video_id)
for entry in transcript:
    print(f"[{entry['start']:.2f}s] {entry['text']}")

It returns a list of dicts, one {'text', 'start', 'duration'} per segment.
For other languages, list what's available first, then fetch or translate:

tl = YouTubeTranscriptApi.list_transcripts(video_id)
for t in tl:
    print(t.language_code, "generated:" , t.is_generated)

transcript = YouTubeTranscriptApi.get_transcript(video_id, languages=["id", "en"])

track = tl.find_transcript(["en"])
translated = track.translate("id").fetch()  # free, server-side

Handle the caption-less case explicitly instead of catching bare
Exception. You'll need these codes downstream:

from youtube_transcript_api._errors import TranscriptsDisabled, NoTranscriptFound

try:
    transcript = YouTubeTranscriptApi.get_transcript(video_id)
except TranscriptsDisabled:
    print("captions disabled: needs audio transcription (Method 3)")
except NoTranscriptFound:
    print("no track in the requested languages, try others first")

And format for output with the built-in formatters rather than
hand-rolling SRT timestamps:

from youtube_transcript_api.formatters import TextFormatter, SRTFormatter, WebVTTFormatter

plain = TextFormatter().format_transcript(transcript)
srt = SRTFormatter().format_transcript(transcript)
vtt = WebVTTFormatter().format_transcript(transcript)

Method 2: yt-dlp subtitles (CLI)

If you live in the terminal, yt-dlp pulls subtitle files without a line
of Python:

# auto-generated subs, no media download
yt-dlp --write-auto-sub --skip-download "https://youtube.com/watch?v=VIDEO_ID"

# manual subs as SRT
yt-dlp --write-sub --sub-format srt --skip-download "https://youtube.com/watch?v=VIDEO_ID"

# see what's on offer first
yt-dlp --list-subs "https://youtube.com/watch?v=VIDEO_ID"

Great for one-off downloads. Weak for pipelines: you parse files off disk,
and there's no fallback when neither track exists.

Method 3: Whisper fallback for caption-less videos

When captions don't exist, someone has to listen to the audio. The DIY
pipeline is download-then-transcribe:

pip install yt-dlp openai-whisper torch

import whisper
import yt_dlp

with yt_dlp.YoutubeDL({"format": "bestaudio/best", "quiet": True}) as ydl:
    info = ydl.extract_info("https://www.youtube.com/watch?v=VIDEO_ID")
    audio = info["requested_downloads"][0]["filepath"]  # or --extract-audio to wav

model = whisper.load_model("small")  # base = fast/rough, small+ = better
result = model.transcribe(audio, word_timestamps=True)
segments = [
    {"text": s["text"].strip(), "start": s["start"],
     "duration": s["end"] - s["start"]}
    for s in result["segments"]
]

Honest costs of this path: a GPU (or very patient CPU), model downloads,
audio storage, and minutes of compute per video. Fine occasionally,
painful at 100 videos/day. This is exactly the step a managed service
should absorb for you.

The problems everyone hits (with fixes)

1. Rate limits and IP blocks. A fresh datacenter IP (AWS/GCP/most VPS)
works for a while, then YouTube starts returning 429s and bot-check pages.
I measured a block after ~100–200 requests in a few hours from a cloud IP.
Fix: add delays between requests for small jobs; for bulk workloads, route
through residential proxies (real ISP IPs), not more cloud boxes. I run my
own bulk jobs on WebShare residential proxies.
They're cheap per-GB and work out of the box (signing up through that link
supports this project at no extra cost to you).

import time
for vid in video_ids:
    try:
        transcripts[vid] = YouTubeTranscriptApi.get_transcript(vid)
    except Exception as e:
        transcripts[vid] = None  # record it, don't crash the batch
    time.sleep(1)

2. One bad video kills the batch. Private, removed, or caption-less
videos raise, so isolate per-video errors (as above) and keep going.

3. Dirty text. Auto captions come with [Music]/[Applause] artifacts
and shaky casing. Minimal cleanup before embedding:

import re
text = re.sub(r"\[.*?\]", "", " ".join(e["text"] for e in transcript))
text = re.sub(r"\s+", " ", text).strip()

Real-world example: RAG over a playlist

This is where DIY glues everything together: fetch every video, chunk by
segment timestamps so citations link back to the exact moment:

playlist = ["https://www.youtube.com/watch?v=VID1",
            "https://www.youtube.com/watch?v=VID2"]
chunks = []
for url in playlist:
    vid = url.split("v=")[-1]
    try:
        t = YouTubeTranscriptApi.get_transcript(vid)
    except Exception:
        continue  # failed video ≠ failed pipeline
    chunks += [{"videoId": vid, "start": s["start"], "text": s["text"]}
               for s in t]
# chunks → embed → vector DB. Re-run weekly; new videos append.

It works, until a playlist is half caption-less videos, or your cloud IP
gets blocked mid-run, or you need it to run unattended every night.

Method 4: the managed shortcut (my Actor)

I packaged the whole guide above into one API call: caption fetching
with language fallback, free server-side translation, playlist expansion,
per-video error isolation, plus a GPU Whisper fallback for caption-less
videos:
lexiie/youtube-transcript-api.

curl -s -X POST "https://api.apify.com/v2/acts/lexiie~youtube-transcript-api/run-sync-get-dataset-items?token=${APIFY_TOKEN}" \
  -H 'Content-Type: application/json' \
  -d '{"urls": ["https://www.youtube.com/watch?v=dQw4w9WgXcQ"], "language": "en"}'

One dataset item per video, same 4-format shape from both engines
(transcriptType: MANUAL | AUTO_GENERATED | ASR_GENERATED), with
playlistId/videoIndex on playlist runs and a structured error.code
on failures. Thin clients so you never touch HTTP:
Python
(pip install requests only) and
Node
(native fetch only), plus an agent skill
and copy-paste examples
for playlists, translation, ASR fallback, and partial failure.

Pricing is pay-per-event, failures free: caption transcripts ~$0.003 each
(tiered down to ~$0.0015), AI fallback a flat ~$0.10 per video regardless
of duration. Per-minute STT APIs bill $0.12–$4.00 per audio hour by comparison.
(Exact rates on the Store Pricing tab.)

Build vs. buy, honestly

DIY (Methods 1–3) if you're learning, processing a handful of videos a
month, or have requirements no API meets. The Actor if you need
unattended reliability, caption-less videos transcribed instead of
erroring, or playlist-scale runs without babysitting proxies and GPUs.

Either way, transcripts turn YouTube from a watch-only archive into
queryable data. Happy building, and if you ship something on it (RAG,
summarizer, research corpus), tell me what broke. That's how the roadmap
gets written.

Actor: https://apify.com/lexiie/youtube-transcript-api
Code, SDKs, skill, examples: https://github.com/Lexiie/youtube-transcript-api

How I Turned My Own Project Into an Apify Actor

Bloody Valentine — Sun, 30 Aug 2026 12:49:07 +0000

I started building https://instadl.ink — a fast, no-storage media extractor for Instagram & TikTok. Paste a public URL → get direct CDN links. No permanent video storage, just JSON. When I wanted to monetize the API on Apify, every All-in-One downloader there was a yt-dlp wrapper. So I expanded instadl.ink into an 8-platform Enriched Extractor: direct CDN + views/likes for YouTube, TikTok, Instagram, X, Facebook, Reddit, Pinterest, Vimeo — batch 100, 512 MB, $3/1K. No yt-dlp. No ffmpeg. No 4GB RAM.

qbitlabs charges $0.05 per HD video ($50/1K) for 1000+ sites. easyapi does 1 URL/run at $2.99/1K + usage. rover bundles Cobalt + ffmpeg for 21 platforms but needs 4GB and 50 concurrent. We needed the opposite: one run, 100 URLs, enriched stats, no bytes stored.

Live on Apify: lexiie/all-in-one-media-extractor (expanded from instadl.ink) — Build 0.0.11 PPE+Usage $3.00/1,000 failed = free — YT dQw4w9WgXcQ view 1.8B in 366ms, IG reel Dcm8usVMMcG like 0 comment 397 without proxy.

The bill that pushed us off yt-dlp

We started like everyone else: wrapping instadl (IG + TikTok) with yt-dlp for YouTube. Local test was fine. On Apify it wasn’t:

Build 616MB vs 83MB: yt-dlp + ffmpeg base is 83MB, but 4K merge needs ffmpeg + 4GB RAM for 60s video. Our Node + undici Build 0.0.11 is 616MB including sharp for logo — yt-dlp version was ~900MB before we stripped it.
The math that kills PPE Only $3: 1K videos × 50MB avg = 50GB external transfer $0.2/GB = $10 + KVS 50GB store $0.05/1K writes + 20 CU ffmpeg $4 → cost $14 → profit = 0.8×$3 - $14 = -$12. That’s why qbitlabs must charge +$0.03/GB after 1GB and khadinakbar caps at 250MB. We didn’t want to charge for bytes we don’t need.
The workaround: Don’t download. Return temporary CDN (googlevideo expire ~4h, scontent 86.400s, fbcdn, tiktokcdn) and let browser → CDN or agent → CDN fetch when needed. For RAG/UGC you need the url + stats, not the mp4 in KVS.

That decision forced us HTTP-only. No yt-dlp binary, no Cobalt server, no ffmpeg.

What “enriched extractor” actually means (vs URL-only)

URL-only (burbn/easyapi) gives you https://...mp4 and stops. For RAG you then need 3 more scrapers for views/likes to rank, and for UGC you need follower counts to filter influencers.

We return one item with 3 blocks — metadata / stats / media (nested, pruned if undefined):

{
  "platform": "tiktok",
  "metadata": { "title": "Calm dog...", "uploader": "kings.deals", "duration": 12, "thumbnail": "https://..." },
  "stats": { "viewCount": 860465, "likeCount": 5047, "commentCount": 23, "shareCount": 167, "followers": 0 },
  "media": [{ "url": "https://v16m.tiktokcdn-us.com/...", "quality": "hd", "mimeType": "video/mp4", "width": 1080, "height": 1920 }]
}

Same shape for all 8:

YouTube dQw4w9WgXcQ → 8 qualities 2160p-720p 366ms → view 1.8B like 16M tags channelId
TikTok @moh.shofwan 7645528079783267605 → view 860K like 5K comment 23 share 167 followers 0 + mp4 HD/SD + mp3
Instagram Dcm8usVMMcG → like 0 comment 397 view 4 + caption payal_rajput_tv...
X SpaceX/status/184... → view/like/retweet
Facebook watch?v=101532... → HD/SD mp4 How to share...
Vimeo 22439234 The Mountain → progressive mp4 or dash + plays/likes
Reddit r/pics → fallback_url + ups 450 num_comments 23
Pinterest pin/112426... → orig image + repin

No second call. Dataset views/overview shows inputUrl, platform, type, webpageUrl — fields metadata/stats/media nested.

From instadl.ink to 8 platforms — what broke

I started with instadl.ink — my own fast, no-storage extractor for Instagram & TikTok. To make it monetizable on Apify, I expanded it to 8 platforms. Each new one broke at least once:

YouTube — lightweight innertube POST /youtubei/v1/player returns streamingData without signatureCipher (no decipher). WEB would need poToken.
TikTok — returns gzip without content-encoding header, so manual decompression + retry with new device.
Instagram — embed likeCount regex failed because HTML escaped → fix to permissive edge_liked_by pattern. view 4 is real from embed (null for many reels is normal).
X — syndication token. 404 for Nasa 174... because ID doesn’t exist, not code.
Facebook — login wall not logged in → PRIVATE_CONTENT free.
Vimeo — player.vimeo.com cert hijack in local ISP → ProxyAgent → origin ✅, but progressive empty for some (dash only) → fallback oembed.
Batch — 100 vs 1 (easyapi/qbitlabs 1 URL/run) — 5 concurrent 300ms cache 5m → 100 URLs ≈ 30s vs 100 runs 100× overhead.

Pricing that doesn’t punish batch

PPE+Usage ON → video-extracted $0.003 ($3/1K) event covers extractor, CU/proxy/transfer billed separate to user. failed/private = free (so IG PRIVATE_CONTENT doesn’t cost). PPE Only would be 0.8*3 - costs and we’d be -$12 for bytes.

10 URLs → Max $0.03 (set Minimum $0.01 in Store Monetization → Additional options so user can’t Max $0.001 free ride)
100 URLs 720p best → Max $0.30 + ~$1 compute (5 CU) + 0.1GB proxy $0.80 (only if RESIDENTIAL) → $1.30 vs qbitlabs $5 for HD ($0.05 per HD = $50/1K)
Discounts: BRONZE $0.003 → SILVER $0.0025 → GOLD $0.0015 — same easyapi tier, but we batch 100 so GOLD 100 URLs $0.15 cheaper.

Store now single event video-extracted PPE+Usage $3/1K. If you want 2 events basic $1.50 / enriched $3 later, just add enriched flag back.

What we intentionally don’t do (and why that’s a feature)

No private bypass — PRIVATE_CONTENT free, pass cookies only if you own the content. InstagramPrivSniffer (collab intended) and jatin-dot-py (polaris_timeline_connection 28% bypass, patched 16 Oct 2025) are ToS violations on Apify — Store would takedown.
No bytes — maxFileSizeMB just skips >250MB for agents; we don’t merge HLS. If you need bytes, use downloader with R2.
No 1000+ sites — qbitlabs 1000+ is yt-dlp list, we do 8 core social + enriched batch 100 without yt-dlp. For SoundCloud/Twitch we’ll add HTTP-only next, not yt-dlp.

Try the exact URLs we tested (no proxy needed for 3)

curl -X POST "https://api.apify.com/v2/acts/lexiie~all-in-one-media-extractor/runs?token=TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"urls":["https://www.youtube.com/watch?v=dQw4w9WgXcQ","https://www.tiktok.com/@moh.shofwan/video/7645528079783267605","https://www.instagram.com/reel/Dcm8usVMMcG/"],"quality":"720p","audioOnly":false}'

Dataset 0.0.11 0R4ECgZIOkkdbjVUb SUCCEEDED 512 MB apify/actor-node:20 returns metadata/stats/media nested — overview view shows inputUrl, platform, type, webpageUrl — latencyMs 366ms YT, 852ms IG, 2838ms TT (3 retries).

Storage inputUrl success platform webpageUrl metadata.title stats.viewCount media[0].url latencyMs — flat for dataset but clean for LLM RAG (no KVS file to fetch).

If you need 1000+ sites, use qbitlabs ($0.05 HD = $50/1K). If you need 8 core social + enriched + batch 100 + direct CDN without yt-dlp/ffmpeg/4GB, use this. Build 0.0.11 live at https://console.apify.com/actors/GdXcUau5zytXfvdvS — star it and request SoundCloud/Twitch next — we’ll add without yt-dlp.

DEV Community: Bloody Valentine

One Video, Five Outputs: Repurpose YouTube Into Articles, Threads, and Shorts Scripts

One Video, Five Outputs: Repurpose YouTube Into Articles, Threads, and Shorts Scripts

Step 1: fetch once, reuse everywhere

Output 1: article draft with real quotes

Output 2: X thread

Output 3: shorts scripts with cut points

Output 4: subtitles, done already

Output 5: newsletter section

What breaks (honest notes)

Links

RAG Over YouTube Playlists: From Video URLs to Cited Answers in 60 Lines

RAG Over YouTube Playlists: From Video URLs to Cited Answers in 60 Lines

Step 0: install

Step 1: fetch transcripts (one item per video)

Step 2: chunk by segments, keep timestamps

Step 3: embed once, retrieve with numpy

Step 4: answer with citations

Keeping it fresh

What I'd add next

Links

How to Get YouTube Transcripts as a Developer (4 Methods That Work in 2026)

How to Get YouTube Transcripts as a Developer (4 Methods That Work in 2026)

What you're actually fetching

Method 1: youtube-transcript-api (Python)

Method 2: yt-dlp subtitles (CLI)

Method 3: Whisper fallback for caption-less videos

The problems everyone hits (with fixes)

Real-world example: RAG over a playlist

Method 4: the managed shortcut (my Actor)

Build vs. buy, honestly

How I Turned My Own Project Into an Apify Actor

The bill that pushed us off yt-dlp

What “enriched extractor” actually means (vs URL-only)

From instadl.ink to 8 platforms — what broke

Pricing that doesn’t punish batch

What we intentionally don’t do (and why that’s a feature)

Try the exact URLs we tested (no proxy needed for 3)