# Podcast & Video Clip Finder (AI Shorts Moments + SRT) (`prime619/podcast-clip-finder`) Actor

Find the best 20-60 s moments in a podcast RSS episode or audio/video file for TikTok, Reels and Shorts. Returns ranked clip timestamps, transcript excerpts, per-clip SRT/VTT subtitles and hook title ideas. Transcription via your own Groq API key (Whisper).

- **URL**: https://apify.com/prime619/podcast-clip-finder.md
- **Developed by:** [Philipp Primisser](https://apify.com/prime619) (community)
- **Categories:** Videos, AI
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $14.00 / 1,000 clips

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## 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).

```json
{
  "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](https://console.groq.com/keys) 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](https://apify.com/prime619/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](https://archive.org/details/gettysburg_shurtagal_librivox)). 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](https://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

```json
{
  "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:

```json
{
  "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](https://dev.to/prime619/word-by-word-captions-with-python-and-ffmpeg-no-capcut-watermark-10a): burn word-highlighted captions into the clips you cut ([GitHub](https://github.com/philippprimisser-max/whisper-word-captions)).

### Related Actors by the same developer

- [Podcast Transcriber](https://apify.com/prime619/podcast-transcriber): turns any podcast episode or audio file into text with timestamps, SRT and VTT (Whisper), no API key needed.
- [Podcast Transcript Scraper](https://apify.com/prime619/podcast-transcript-fetcher): pulls the transcripts podcasters already publish in their RSS feed. Cheaper and faster than transcribing when a show has them.

# Changelog

This Actor's version history is a separate document: https://apify.com/prime619/podcast-clip-finder/changelog.md

# Actor input Schema

## `rssFeedUrls` (type: `array`):

Public podcast RSS feed(s). Episodes are taken from the audio/video enclosures. Use the settings below to pick which episodes.

## `episodeSelection` (type: `string`):

Pick the newest episodes, the oldest ones, or episodes whose title contains a text.

## `episodeTitleFilter` (type: `string`):

Only used with "Title contains…". Case-insensitive.

## `maxEpisodesPerFeed` (type: `integer`):

How many episodes to process from each feed.

## `mediaUrls` (type: `array`):

Direct, publicly accessible links to media files (mp3, m4a, wav, mp4, mov, webm …). Page links from YouTube, Spotify, TikTok, Instagram etc. are not supported. The prefilled link is a free 1:40 min public-domain demo (LibriVox, Gettysburg Address): it runs without a Groq key, is never charged, and is also used when you leave all sources empty.

## `confirmRights` (type: `boolean`):

Required for your own sources. Only process media you own, have licensed, or are otherwise allowed to transcribe and clip. You are responsible for how you use the output. Not needed for the built-in public-domain demo sample.

## `transcriptionProvider` (type: `string`):

Groq (recommended): fast Whisper large-v3-turbo with your own Groq API key - Groq bills you directly (about $0.04 per audio hour at the time of writing). Local: open-source Whisper running inside the Actor, no key needed, but slower, less accurate with small models, limited to 60 minutes per episode and billed at a higher per-minute event price (see Pricing).

## `groqApiKey` (type: `string`):

Your own key from https://console.groq.com/keys. Stored encrypted by Apify, only used for calls to api.groq.com. Also used for optional LLM clip scoring.

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

Two-letter ISO code like "en" or "de". Leave empty for automatic detection. Setting it improves accuracy.

## `localModel` (type: `string`):

Only for the local engine. Bigger = better but slower and needs more memory: base needs at least 2 GB, small at least 4 GB run memory (tiny works with 1 GB).

## `groqWhisperModel` (type: `string`):

whisper-large-v3-turbo is cheaper and faster; whisper-large-v3 is a bit more accurate.

## `maxClipsPerEpisode` (type: `integer`):

Upper limit of clips returned per episode (each delivered clip is a billable event).

## `minClipSeconds` (type: `integer`):

Clips start and end on sentence boundaries; no clip will be shorter than this.

## `maxClipSeconds` (type: `integer`):

No clip will be longer than this. 60 s fits TikTok, Reels and Shorts.

## `maxAudioMinutesPerEpisode` (type: `integer`):

Only the first N minutes of each episode are processed (cost cap). Billable audio minutes never exceed this.

## `useLlmScoring` (type: `boolean`):

Uses your Groq key to let an LLM rate the top candidates and write hook titles (a few tenths of a cent per episode on Groq). Without a key, heuristic ranking and simple title suggestions are used.

## `llmModel` (type: `string`):

Any Groq chat model ID that supports JSON mode. Default openai/gpt-oss-120b gave clearly better clip ratings and hook titles than openai/gpt-oss-20b in our tests and still costs well under one cent per episode on your Groq key.

## `hookTitlesPerClip` (type: `integer`):

How many title/hook ideas to return per clip.

## `minLlmScore` (type: `integer`):

Clips the AI rates below this score are not delivered and therefore not charged, so you may get fewer than 'Max clips per episode'. Set 0 to always receive the maximum number of clips. Ignored when AI scoring is off or fails.

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

Subtitle files created for every clip (timestamps start at 00:00 of the clip).

## `maxWordsPerCue` (type: `integer`):

Short lines (5-8 words) work best for vertical video.

## `saveFullTranscript` (type: `boolean`):

Store the full episode transcript (JSON with word timestamps, TXT and SRT) in the key-value store.

## `maxFileSizeMb` (type: `integer`):

Larger files are rejected before processing (protects you from accidental huge downloads).

## Actor input object example

```json
{
  "episodeSelection": "latest",
  "maxEpisodesPerFeed": 1,
  "mediaUrls": [
    "https://archive.org/download/gettysburg_shurtagal_librivox/Gettysburg_Address_Lincoln_64kb.mp3"
  ],
  "confirmRights": false,
  "transcriptionProvider": "groq",
  "localModel": "base",
  "groqWhisperModel": "whisper-large-v3-turbo",
  "maxClipsPerEpisode": 5,
  "minClipSeconds": 20,
  "maxClipSeconds": 60,
  "maxAudioMinutesPerEpisode": 180,
  "useLlmScoring": true,
  "llmModel": "openai/gpt-oss-120b",
  "hookTitlesPerClip": 3,
  "minLlmScore": 5,
  "subtitleFormats": [
    "srt",
    "vtt"
  ],
  "maxWordsPerCue": 7,
  "saveFullTranscript": true,
  "maxFileSizeMb": 500
}
```

# Actor output Schema

## `clips` (type: `string`):

Ranked clip moments (dataset): timestamps, transcript, hook titles, subtitle links.

## `subtitles` (type: `string`):

SRT/VTT file per clip.

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

Full episode transcripts (JSON with word timestamps, TXT, SRT).

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

Status per episode, errors, billed audio minutes.

# 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 = {
    "mediaUrls": [
        "https://archive.org/download/gettysburg_shurtagal_librivox/Gettysburg_Address_Lincoln_64kb.mp3"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("prime619/podcast-clip-finder").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 = { "mediaUrls": ["https://archive.org/download/gettysburg_shurtagal_librivox/Gettysburg_Address_Lincoln_64kb.mp3"] }

# Run the Actor and wait for it to finish
run = client.actor("prime619/podcast-clip-finder").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 '{
  "mediaUrls": [
    "https://archive.org/download/gettysburg_shurtagal_librivox/Gettysburg_Address_Lincoln_64kb.mp3"
  ]
}' |
apify call prime619/podcast-clip-finder --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,prime619/podcast-clip-finder"
        }
    }
}
```

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/z8UgscUISmK0FveZC/builds/IuUAGLERK5yJpEboq/openapi.json