Podcast & Video Clip Finder: AI Shorts Moments + SRT Subtitles

Try it free: Apify's free plan includes monthly platform credit, no credit card needed. The example input below runs the free demo (a 63-second public-domain recording, no charges). With your own episode, a 10-minute file with 3 clips costs about $0.26 with the built-in local Whisper (10 × $0.02 + 3 × $0.02) or about $0.16 with your own Groq key (10 × $0.01 + 3 × $0.02).

{
  "mediaUrls": [
    "https://archive.org/download/gettysburg_shurtagal_librivox/Gettysburg_Address_Lincoln_64kb.mp3"
  ],
  "transcriptionProvider": "local",
  "maxClipsPerEpisode": 3,
  "confirmRights": true
}

Paste this into the JSON tab of the input form and click Start.

Turn a podcast episode or a long video into a ranked shortlist of 20–60 second clip moments for TikTok, Instagram Reels and YouTube Shorts. For each moment you get the exact timestamps, the transcript excerpt, ready-to-use SRT/VTT subtitles (starting at 00:00 of the clip) and hook title ideas.

You bring the content and your own Groq API key for fast Whisper transcription. The Actor handles the listening, picking and timestamping.

What does Podcast & Video Clip Finder do?

1. Reads your source. Takes a podcast RSS feed (picks the latest, oldest, or title-matching episodes) and/or direct links to audio/video files (mp3, m4a, wav, mp4, mov, webm…).
2. Transcribes it. Uses Whisper large-v3-turbo on Groq with word-level timestamps, or a local open-source Whisper model if you have no key.
3. Finds the best moments. Scores every sentence-aligned window between your min/max length. The heuristics look at hook openers, questions, insight and story markers, emotional words, speaking energy, filler words, small talk, ad reads and intros. Clips start and end on sentence boundaries and never overlap.
4. Optionally re-ranks with an LLM (on by default, uses the same Groq key, default model openai/gpt-oss-120b). The model rates the top 20 candidates for standalone quality and writes hook titles. Clips the AI rates below minLlmScore (default 5 of 10) are dropped, and you are not charged for them, so a weak episode may return fewer clips than your maximum.
5. Delivers a dataset of clips plus subtitle files and the full transcript.

Who is it for?

• Clippers and short-form editors who need to find the strong moments in a 2-hour episode fast.
• Podcasters and agencies who want an automated “episode → clip list” step in n8n, Make or Zapier, or through the Apify API.
• Video editors who want SRT/VTT subtitles per clip to drop into Premiere, DaVinci Resolve, CapCut or Descript.

Clips or the full transcript?

This Actor is made for clips. It goes through an episode and hands you a short list of moments worth posting, each with start and end timestamps, its own subtitle file and a few hook title ideas. You also get the episode transcript as a side file, but the whole Actor (and its price) is built around finding and ranking those moments.

If what you really need is the complete text of every episode, for example to search through old episodes, write notes or keep an archive of a show, use Podcast Transcriber instead. It turns each episode into one plain transcript with TXT, SRT, VTT and JSON files, can pick up only new episodes on a schedule, and costs less per audio minute because it skips the clip ranking.

Try it free (no key needed)

Just click Start with the prefilled input, or run it with an empty input. The Actor then processes a built-in 63 s public-domain demo: an excerpt of LibriVox's recording of Lincoln's Gettysburg Address (archive.org). The demo uses a small local Whisper model and heuristic ranking, needs no Groq key and no rights confirmation, and is never charged (only Apify's tiny automatic Actor-start fee of $0.00005 applies). If the shared server is very busy, the demo falls back to a precomputed transcript of the sample instead of making you wait. Results with your own content and Groq key are faster and better (Whisper large-v3-turbo + AI judge).

How to use it

1. Paste a podcast RSS feed URL and/or direct media URLs.
2. Tick “I own this content or have the right to use it”.
3. Paste your Groq API key. It is free to create at console.groq.com/keys; Groq bills you directly for usage.
4. Optional: set the language, clip length, number of clips and a minutes cap per episode.
5. Click Start. Results appear in the Output tab: clips table, subtitle files, transcripts and run summary.

Input example

{
  "rssFeedUrls": ["https://librivox.org/rss/6481"],
  "episodeSelection": "latest",
  "maxEpisodesPerFeed": 1,
  "confirmRights": true,
  "transcriptionProvider": "groq",
  "groqApiKey": "gsk_…",
  "language": "en",
  "maxClipsPerEpisode": 5,
  "minClipSeconds": 20,
  "maxClipSeconds": 60,
  "maxAudioMinutesPerEpisode": 90
}

Output

One dataset item per clip, best first per episode. Here is a real (shortened) item from a test run on a public-domain LibriVox recording, with heuristic ranking only:

{
  "episodeTitle": "1 Running Away from Life",
  "podcastTitle": "Self and Self-management: Essays about Existing by Arnold Bennett (1867 - 1931)",
  "rank": 1,
  "score": 64.3,
  "scoringMethod": "heuristic",
  "startSeconds": 191.95,
  "endSeconds": 221.59,
  "startTimestamp": "00:03:11.950",
  "endTimestamp": "00:03:41.590",
  "durationSeconds": 29.64,
  "hookTitles": ["What is her aim?", "“You observe how sarcastic I am about the social butterfly”"],
  "text": "You observe how sarcastic I am about the social butterfly. It is necessary to be so. …",
  "transcriptSegments": [{"startSeconds": 191.95, "endSeconds": 197.97, "text": "You observe how sarcastic I am about the social butterfly. It is necessary to be so."}],
  "srt": "1\n00:00:00,000 --> 00:00:02,860\nYou observe how sarcastic I am about\n…",
  "srtUrl": "https://api.apify.com/v2/key-value-stores/<storeId>/records/clip-f95dbcd70a32-01.srt",
  "vttUrl": "https://api.apify.com/v2/key-value-stores/<storeId>/records/clip-f95dbcd70a32-01.vtt",
  "language": "en",
  "transcriptionProvider": "local:base.en"
}

The full field list is in the dataset schema. With LLM scoring enabled you also get llmScore, reason and LLM-written hookTitles.

Key-value store:

• clip-<episodeId>-<rank>.srt / .vtt: subtitles per clip.
• transcript-<episodeId>.json (segments plus word timestamps), .txt and .srt: full transcript.
• RUN_SUMMARY: status per episode, errors, processed and billed minutes.

You can download the dataset as JSON, CSV, Excel or HTML, or fetch it through the API.

Pricing (pay per event)

You pay only for what is actually delivered:

Event	Price	When it is charged
Audio minute (Groq)	$0.01 per started minute	After a successful transcription, for the audio that was actually processed (capped by Max audio minutes per episode)
Audio minute (local Whisper)	$0.02 per started minute	Same, when you choose the local engine (no Groq key needed; uses much more compute)
Clip	$0.02 per clip	For every clip delivered to the dataset

Example: a 60-minute episode with 5 clips costs 60 × $0.01 + 5 × $0.02 = $0.70 on Apify. Groq bills you separately for transcription, about $0.04 per audio hour for whisper-large-v3-turbo at the time of writing; check Groq's pricing page. LLM scoring adds a fraction of a cent per episode on Groq.

• Failed downloads, invalid URLs and failed transcriptions are not charged.
• You set the budget. If you set a maximum total charge for the run, the Actor processes only as many minutes as fit and keeps budget for clips. When the limit is reached it stops cleanly.
• Use Max audio minutes per episode to analyse only the first part of long episodes. For MP3/AAC feeds, only that part is downloaded.

Transcription engines

• Groq Whisper (recommended). Fast and accurate, and supports many languages. Long episodes are split at silences into ~20-minute chunks automatically.
  • Your key is stored encrypted by Apify and sent only to api.groq.com.
  • Groq's free tier has hourly audio limits. On rate limits the Actor retries, but very long batches may need a paid Groq tier.
• Local Whisper. No key needed. It runs open-source faster-whisper on CPU inside the Actor: slower, less accurate with small models, and limited to 60 minutes per episode. It needs more memory: at least 2 GB for base and 4 GB for small (the run stops right away with a clear message if memory is too low).
  • Local Whisper works best for clear English speech. With the default base model, German and other languages come out noticeably less accurate, and results can vary from run to run. For German and other languages, use Groq with your own key (Whisper large-v3-turbo or large-v3) and always set language.
  • The local engine checks its transcript for longer stretches of speech that came back without text and re-transcribes those parts with full precision (float32), at no extra charge.
• Memory. Groq mode needs little memory (about 150 MB peak in tests); the default 1 GB is plenty and keeps runs fast.

Supported sources and limitations

• ✅ Public podcast RSS feeds (audio or video enclosures) and direct, publicly accessible media file URLs.
• ❌ Links to YouTube, Spotify, TikTok, Instagram, Facebook, X, Twitch, Vimeo, Apple Podcasts pages or SoundCloud. These platforms do not allow downloading their media, so the Actor refuses them. Use the show's RSS feed or your own file link instead.
• ❌ Private, password-protected or local-network URLs.
• Scores are suggestions, not guarantees of virality. A human should always review the picks, which is fast because you get the timestamps and text.
• The Actor delivers timestamps, text and subtitles. It does not cut or render video files; do that in your editor using the timestamps.
• Word timing comes from Whisper and can be off by a few hundred milliseconds. Nudge the subtitles in your editor if needed.

Your responsibility for rights

(The built-in demo sample is public domain, so it needs no confirmation. Everything else does.)

Only process media you own or are allowed to use (your own show, a client's show with permission, licensed or public-domain material). You confirm this with the confirmRights checkbox. You are responsible for how you use transcripts, clips and subtitles, including copyright, personality rights and platform rules. The Actor does not grant any rights to the content it analyses.

Privacy

Audio is downloaded to the run's temporary storage, converted, and deleted after processing. Outputs are stored only in your run's dataset and key-value store, under your Apify retention settings. With the Groq engine, audio and transcript excerpts are sent to Groq for processing under Groq's terms and privacy policy. If your content contains personal data, make sure you have a legal basis to process it.

FAQ

Can I use it for German or other languages? Yes, best with the Groq engine. Set language (e.g. de); Whisper can also detect it automatically. The local models are weaker outside English (see Transcription engines). The heuristics include German and English cue words; LLM scoring and hook titles follow the language of the excerpt.

Does it work with video? Yes. Any direct video file with an audio track works; the Actor uses only the audio.

How do I get the clips into my editor? Use startTimestamp/endTimestamp to cut, then import the clip's .srt file. Its timing starts at 00:00, so it lines up with the cut clip.

Can I run it on a schedule? Yes. Schedule it with episodeSelection: "latest" and maxEpisodesPerFeed: 1 to process each new episode.

Why did I get fewer clips than I asked for? The AI judge drops moments it rates below minLlmScore (default 5/10), for example intros, sponsor reads or context-dependent answers. You only pay for delivered clips. Set minLlmScore to 0 to always get the maximum number.

Something went wrong? Check the RUN_SUMMARY record. Every failed episode has a clear error message, and other episodes still continue.

Further reading

• Word-by-word captions with Python and ffmpeg: burn word-highlighted captions into the clips you cut (GitHub).

Related Actors by the same developer

• Podcast Transcriber: turns any podcast episode or audio file into text with timestamps, SRT and VTT (Whisper), no API key needed.
• Podcast Transcript Scraper: pulls the transcripts podcasters already publish in their RSS feed. Cheaper and faster than transcribing when a show has them.