# Audio & Video Transcriber + Mention Finder (`ocrad/audio-video-transcriber-mention-finder`) Actor

Turn any video, podcast or audio link into text and find every mention of your brands, names or keywords, with a timestamp and a link to the exact second. Get subtitles, TXT files and AI-ready chunks with token counts. English, French and 95+ languages. Pay per second, with no minimum.

- **URL**: https://apify.com/ocrad/audio-video-transcriber-mention-finder.md
- **Developed by:** [Ocrad](https://apify.com/ocrad) (community)
- **Categories:** AI, Videos, Agents
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.70 / 1,000 transcribed seconds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

### Audio & Video Transcriber + Mention Finder

***

Turn any video, podcast or audio link into text, and find every spoken mention of the brands, people or keywords you care about. Each mention comes back with its timestamp, the words around it and a link that opens the media at that exact second.

Paste links from YouTube, TikTok, Instagram, Facebook, X, Vimeo, Dailymotion, SoundCloud or Twitch, a podcast RSS feed, an Apple Podcasts show or episode, or a direct audio or video file. You get:

- The full transcript, timed segments and the detected language.
- Ready-to-use **SRT and VTT subtitles** and a **plain-text file** per item.
- **Mentions** of your terms, with a count per term and the time of the first mention.
- **AI-ready chunks**: the transcript split into timed pieces with token counts, ready for an LLM prompt, a vector database or RAG search.

**Captions first, to save you money.** When a video already has captions (most YouTube videos do), those are delivered in seconds for a small flat fee instead of being transcribed second by second.

***

#### **📋 Example Output**

A real record from the prefilled input: the first 3 minutes of a NASA podcast episode with the terms `NASA`, `Artemis` and `Moon`. Long fields are shortened here (`text`, `segments`, `mentions` and `chunks` hold everything in a real run).

```json
{
  "url": "https://traffic.megaphone.fm/NATIONALAERONAUTICSANDSPACEADMINISTRATION2348421011.mp3",
  "inputUrl": "https://traffic.megaphone.fm/NATIONALAERONAUTICSANDSPACEADMINISTRATION2348421011.mp3",
  "pageUrl": null,
  "platform": "file",
  "sourceType": "file",
  "title": "Artemis III: Paving the Way to Lunar Landings",
  "uploader": "Houston We Have a Podcast",
  "publishedAt": "2024",
  "durationSeconds": 3584.9,
  "thumbnailUrl": null,
  "transcriptSource": "whisper",
  "captionsType": null,
  "model": "base",
  "language": "en",
  "languageProbability": 0.9972,
  "translatedToEnglish": false,
  "transcribedSeconds": 180.0,
  "text": "Hey, one quick thing before we start the show. Just want to remind you to subscribe to this official NASA podcast wherever you're listening right now. NASA is working on some extremely cool stuff, and you will hear about it right here. Subscribe to this podcast to make sure you get the latest from N …",
  "wordCount": 442,
  "segments": [
    {
      "start": 0.94,
      "end": 5.98,
      "text": "Hey, one quick thing before we start the show. Just want to remind you to subscribe to"
    },
    {
      "start": 5.98,
      "end": 12.04,
      "text": "this official NASA podcast wherever you're listening right now. NASA is working on some"
    }
  ],
  "mentions": [
    {
      "term": "NASA",
      "matchedText": "NASA",
      "score": 100,
      "start": 6.8,
      "end": 7.04,
      "timestamp": "00:00:06",
      "context": "the show. Just want to remind you to subscribe to this official NASA podcast wherever you're listening right now. NASA is working on some extremely",
      "link": "https://traffic.megaphone.fm/NATIONALAERONAUTICSANDSPACEADMINISTRATION2348421011.mp3#t=6",
      "approximateTime": false
    },
    {
      "term": "NASA",
      "matchedText": "NASA",
      "score": 100,
      "start": 10.46,
      "end": 10.98,
      "timestamp": "00:00:10",
      "context": "to subscribe to this official NASA podcast wherever you're listening right now. NASA is working on some extremely cool stuff, and you will hear about",
      "link": "https://traffic.megaphone.fm/NATIONALAERONAUTICSANDSPACEADMINISTRATION2348421011.mp3#t=10",
      "approximateTime": false
    }
  ],
  "mentionCount": 23,
  "mentionsByTerm": {
    "NASA": 13,
    "Artemis": 7,
    "Moon": 3
  },
  "termsFound": [
    "NASA",
    "Artemis",
    "Moon"
  ],
  "termsNotFound": [],
  "firstMentionAt": "00:00:06",
  "chunks": [
    {
      "index": 0,
      "start": 0.94,
      "end": 109.56,
      "text": "Hey, one quick thing before we start the show. Just want to remind you to subscribe to this official NASA podcast wherev …",
      "tokenCount": 382
    }
  ],
  "chunkCount": 2,
  "tokenCount": 551,
  "tokenizer": "cl100k_base",
  "srtFileUrl": "https://api.apify.com/v2/key-value-stores/<storeId>/records/001-artemis-iii-paving-the-way-to-lunar-landings.srt",
  "vttFileUrl": "https://api.apify.com/v2/key-value-stores/<storeId>/records/001-artemis-iii-paving-the-way-to-lunar-landings.vtt",
  "txtFileUrl": "https://api.apify.com/v2/key-value-stores/<storeId>/records/001-artemis-iii-paving-the-way-to-lunar-landings.txt",
  "billedSeconds": 180,
  "status": "ok",
  "charged": true,
  "error": null,
  "processedAt": "2026-11-05T17:49:19.034815+00:00"
}
```

`approximateTime` is `true` only when the timing comes from a caption line rather than the exact word, which can happen with manual captions; the link is then accurate to within a few seconds.

#### **🔎 Mention Finder**

Put your terms in `mentionTerms`: brand names, people, products, competitors, keywords.

- **Fuzzy matching** (default) also catches small mishearings and plurals: "Tim Horton" still matches `Tim Hortons`, and "TimHortons" spoken as one word matches too. Names of 5-8 letters may differ by one letter and longer names by two. Names of 4 letters or fewer (`IBM`, `Uber`) always match exactly, so short words never flood the results.
- **Exact matching** takes the words exactly as typed, ignoring only case, accents and punctuation.
- Your terms are also given to the speech model as hints, so names come out spelled right more often.
- Each mention has a `link` that opens the media at that second on YouTube, Vimeo, Dailymotion, Twitch, SoundCloud and direct audio/video files. On other platforms the `timestamp` says where to look.

Use it to monitor what creators, podcasts or competitors say about a brand, check sponsor reads, or jump straight to the part of a long interview that matters.

#### **🤖 AI-ready chunks**

With `aiChunks` on (default), every item has `chunks`: the transcript split at segment boundaries into pieces of about `chunkTokens` tokens, each with `start` and `end` times and a `tokenCount` measured with the `cl100k_base` tokenizer. `chunkOverlapTokens` repeats the end of each chunk at the start of the next so no sentence loses its context. Feed the chunks straight into embeddings, a vector store or a prompt; the times let an answer cite the exact moment in the media.

#### ⚙️ **Configuration**

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `mediaUrls` | Array | *(required)* | Video, audio or podcast links, one per line. Up to 100 per run. |
| `mentionTerms` | Array | `[]` | Brands, names or keywords to find. Leave empty for a plain transcript. |
| `matchMode` | String | `fuzzy` | `fuzzy` catches small mishearings and plurals; `exact` matches the words as typed. |
| `preferCaptions` | Boolean | `true` | Deliver the media's own captions when it has them (faster, flat fee). Off = always transcribe the audio. |
| `language` | String | auto | Spoken language code (`en`, `fr`, `es` ...). Also picks which caption track is used. |
| `translateToEnglish` | Boolean | `false` | English transcript whatever the spoken language (uses the speech model). |
| `model` | String | `base` | `tiny` (fastest), `base` (recommended) or `small` (most accurate). Same price for all three. |
| `maxMinutesPerItem` | Integer | `60` | Longer media is transcribed and billed only up to this length. |
| `maxItemsPerFeed` | Integer | `1` | Newest items taken from a podcast feed, Apple Podcasts show, YouTube channel or playlist. |
| `aiChunks` | Boolean | `true` | Add AI-ready chunks with token counts. Free. |
| `chunkTokens` | Integer | `400` | Target chunk size in tokens. |
| `chunkOverlapTokens` | Integer | `40` | Tokens repeated between neighbouring chunks. |
| `includeSegments` | Boolean | `true` | Add the timed segments to each record. |
| `proxyConfiguration` | Object | Apify Proxy (auto) | Direct audio files and podcast feeds are fetched without a proxy. |

##### Example Input

```json
{
  "mediaUrls": [
    "https://www.youtube.com/watch?v=UF8uR6Z6KLc",
    "https://podcasts.apple.com/ca/podcast/le-radiojournal/id1438775013"
  ],
  "mentionTerms": ["Stanford", "Apple", "Ottawa", "gouvernement"],
  "maxMinutesPerItem": 30
}
```

The YouTube video is delivered from its captions; the newest Radio-Canada news bulletin is transcribed in French.

#### 💰 **Pricing**

Pay per event, with no subscription:

| Event | Price | When |
|-------|-------|------|
| Run start | $0.005 | Once per run at the default 2 GB memory |
| Transcribed second | $0.0007 per second ($0.042 per minute) | Audio transcribed by the speech model. Real seconds, **no minimum**: a 20-second clip bills 20 seconds |
| Captions transcript | $0.003 per item | Media delivered from its own captions, whatever its length |
| Mention report | $0.002 per item | Only items where at least one of your terms was found |

Subtitles, text files, chunks and token counts are included. **Items that are not delivered are never charged**: music or silence (`no_speech`), removed or private media, unsupported links, downloads that fail. Each of those still gets a row with `status` and `error` saying why, and the run's `SUMMARY` record lists them all. A run never charges more than the maximum cost you set: long media is trimmed to fit before it is transcribed.

| Example | Cost |
|---------|------|
| 20-second TikTok, transcribed | $0.019 |
| 10-minute YouTube video with captions | $0.008 |
| 10-minute video without captions, with mentions found | $0.427 |
| 45-minute podcast episode | $1.895 |

#### **How it works**

1. **Resolve**: each link is read as a single video, a channel or playlist, a podcast feed, an Apple Podcasts show or episode, or a direct file.
2. **Captions or audio**: when captions exist in the spoken language they are used; otherwise only the audio track is fetched, up to `maxMinutesPerItem` (a 2-hour episode capped at 10 minutes downloads about 10 minutes).
3. **Transcribe**: Whisper (faster-whisper, int8, voice-activity filtered) turns speech into timed text, with word-level times when you are looking for mentions.
4. **Find, chunk, export**: mentions, chunks, SRT, VTT and TXT are built from the same timed text and saved with the record.

Run memory decides speed: Apify gives about one CPU core per 4 GB. 2 GB (default) suits clips and short videos; give long podcasts 4-8 GB to finish faster. The `small` model needs 2 GB or more and is chosen down automatically if the run has less.

#### **Use it from the API, MCP and AI agents**

Call it as `ocrad/audio-video-transcriber-mention-finder` from the Apify API, any Apify SDK, or the [Apify MCP server](https://mcp.apify.com) as a tool. Minimal input: `{"mediaUrls": ["<link>"]}`. Check `status` before reading `text`: `ok` rows are delivered and charged, every other status is free and carries `error`. Results are in the default dataset; subtitle and text files are linked from each row.

***

#### 💬 **Support and Feedback**

Reach out via Apify support channels or leave feedback on the Actor's page.

#### **Is it legal to transcribe this content?**

The Actor only processes publicly accessible media that you point it at and does not bypass logins, paywalls or DRM. Transcripts can contain personal data (names, voices, opinions); process it only with a legitimate reason and respect each platform's terms and copyright. Personal data is protected by GDPR, PIPEDA, Quebec's Law 25 and other regulations — consult your legal advisor if unsure.

# Actor input Schema

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

One link per line: YouTube (video, Short, channel or playlist), TikTok, Instagram, Facebook, X, Vimeo, Dailymotion, SoundCloud, Twitch, a podcast RSS feed, an Apple Podcasts show or episode, or a direct audio/video file (mp3, m4a, wav, mp4, ...). Up to 100 links per run.

## `mentionTerms` (type: `array`):

Words or names to find in the speech. Each mention comes back with its timestamp, the words around it and a link that opens the media at that second (where the platform supports it). The terms are also given to the speech model as hints so they are spelled right. Leave empty for a plain transcript.

## `matchMode` (type: `string`):

Fuzzy allows one wrong letter in names of 5-8 letters and two in longer names. Names of 4 letters or fewer always match exactly.

## `preferCaptions` (type: `boolean`):

When the video already has captions (most YouTube videos do), deliver those instead of transcribing the audio: much faster and charged a small flat fee instead of per second. Turn off to always transcribe the audio with the speech model.

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

ISO code of the spoken language, for example en, fr, es, de. Leave empty to detect it automatically. Also picks which caption track is used.

## `translateToEnglish` (type: `boolean`):

Output an English transcript whatever the spoken language. Always uses the speech model (captions are skipped).

## `model` (type: `string`):

Whisper model used when the audio is transcribed. Same price for every model.

## `maxMinutesPerItem` (type: `integer`):

Longer media is transcribed up to this length and billed only for what was transcribed. Use it to cap spend per item.

## `maxItemsPerFeed` (type: `integer`):

For a podcast feed, Apple Podcasts show, YouTube channel or playlist: how many of the newest items to transcribe.

## `aiChunks` (type: `boolean`):

Add the transcript split into timed chunks with token counts, ready for an LLM prompt, a vector database or RAG search. Free.

## `chunkTokens` (type: `integer`):

Target size of each chunk, counted with the cl100k_base tokenizer. Chunks break at segment boundaries, never mid-sentence.

## `chunkOverlapTokens` (type: `integer`):

How much of the end of each chunk is repeated at the start of the next one, so context is not lost at the edges.

## `includeSegments` (type: `boolean`):

Add the timed segments (start, end, text) to each record. Turn off for smaller records when you only need the text, mentions and files.

## `proxyConfiguration` (type: `object`):

Defaults to Apify Proxy (auto). Direct audio files and podcast feeds are fetched without a proxy.

## Actor input object example

```json
{
  "mediaUrls": [
    "https://traffic.megaphone.fm/NATIONALAERONAUTICSANDSPACEADMINISTRATION2348421011.mp3"
  ],
  "mentionTerms": [
    "NASA",
    "Artemis",
    "Moon"
  ],
  "matchMode": "fuzzy",
  "preferCaptions": true,
  "translateToEnglish": false,
  "model": "base",
  "maxMinutesPerItem": 3,
  "maxItemsPerFeed": 1,
  "aiChunks": true,
  "chunkTokens": 400,
  "chunkOverlapTokens": 40,
  "includeSegments": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `url` (type: `string`):

Media link that was transcribed

## `inputUrl` (type: `string`):

Link you gave (a feed or channel expands to several items)

## `pageUrl` (type: `string`):

Episode web page, when the feed lists one

## `platform` (type: `string`):

youtube, tiktok, podcast, file, ...

## `sourceType` (type: `string`):

video, audio, podcast-episode or file

## `title` (type: `string`):

Media title

## `uploader` (type: `string`):

Channel, show or artist

## `publishedAt` (type: `string`):

Publication date

## `durationSeconds` (type: `string`):

Full length of the media in seconds

## `thumbnailUrl` (type: `string`):

Thumbnail image

## `transcriptSource` (type: `string`):

captions (the media's own captions) or whisper (speech model)

## `captionsType` (type: `string`):

manual or auto, when captions were used

## `model` (type: `string`):

Speech model used (tiny, base, small)

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

Spoken language code

## `languageProbability` (type: `string`):

Language detection confidence 0-1

## `translatedToEnglish` (type: `string`):

true when the transcript was translated to English

## `transcribedSeconds` (type: `string`):

Seconds of audio transcribed by the speech model

## `billedSeconds` (type: `string`):

Seconds charged for this item

## `text` (type: `string`):

Full transcript

## `wordCount` (type: `string`):

Words in the transcript

## `segments` (type: `string`):

Timed segments \[{start, end, text, words?}]

## `mentions` (type: `string`):

Each mention: term, matchedText, score, start, end, timestamp, context, link

## `mentionCount` (type: `string`):

Total mentions found

## `mentionsByTerm` (type: `string`):

Mentions per term

## `termsFound` (type: `string`):

Terms mentioned at least once

## `termsNotFound` (type: `string`):

Terms never mentioned

## `firstMentionAt` (type: `string`):

Time of the first mention (hh:mm:ss)

## `chunks` (type: `string`):

AI-ready chunks \[{index, start, end, text, tokenCount}]

## `chunkCount` (type: `string`):

Number of chunks

## `tokenCount` (type: `string`):

Tokens in the full transcript

## `tokenizer` (type: `string`):

Tokenizer used for counts

## `srtFileUrl` (type: `string`):

Download link for the .srt subtitles

## `vttFileUrl` (type: `string`):

Download link for the .vtt subtitles

## `txtFileUrl` (type: `string`):

Download link for the plain-text transcript

## `status` (type: `string`):

ok, or why the item was not delivered (no_speech, source_unavailable, blocked, bad_input, unsupported, download_failed, budget_cap, deadline)

## `charged` (type: `string`):

true only when the item was delivered and charged

## `chargedEvents` (type: `string`):

Events charged for this item

## `error` (type: `string`):

Reason in plain language when not delivered

## `processedAt` (type: `string`):

When the item was processed (ISO)

## `route` (type: `string`):

How the media was reached: proxy or direct

# 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://traffic.megaphone.fm/NATIONALAERONAUTICSANDSPACEADMINISTRATION2348421011.mp3"
    ],
    "mentionTerms": [
        "NASA",
        "Artemis",
        "Moon"
    ],
    "maxMinutesPerItem": 3,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("ocrad/audio-video-transcriber-mention-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://traffic.megaphone.fm/NATIONALAERONAUTICSANDSPACEADMINISTRATION2348421011.mp3"],
    "mentionTerms": [
        "NASA",
        "Artemis",
        "Moon",
    ],
    "maxMinutesPerItem": 3,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("ocrad/audio-video-transcriber-mention-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://traffic.megaphone.fm/NATIONALAERONAUTICSANDSPACEADMINISTRATION2348421011.mp3"
  ],
  "mentionTerms": [
    "NASA",
    "Artemis",
    "Moon"
  ],
  "maxMinutesPerItem": 3,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call ocrad/audio-video-transcriber-mention-finder --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,ocrad/audio-video-transcriber-mention-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/oAu85IOjmxcalxflE/builds/vMYHt0YcbQi2uAW0u/openapi.json
