# Speech to Text: Bulk Audio & Video Transcription (Whisper) (`tanod/audio-to-text`) Actor

Transcribe a list of audio or video links (MP3, WAV, M4A, MP4, WebM and more, up to 10 minutes each) with Whisper. Text, SRT or WebVTT per file. USD 0.02 per file; failed files are free.

- **URL**: https://apify.com/tanod/audio-to-text.md
- **Developed by:** [Tanod Labs](https://apify.com/tanod) (community)
- **Categories:** AI, Automation, Videos
- **Stats:** 1 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $16.00 / 1,000 file transcribeds

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

## Speech to Text: Bulk Audio & Video Transcription (Whisper)

Give it a list of links to audio or video files. It transcribes every file with Whisper (faster-whisper, MIT-licensed model) and returns **one result row per file** with the transcript, the detected language, the duration and, on request, **SRT or WebVTT subtitles** and timed segments. Use it to turn podcasts, calls, interviews, lectures and clips into searchable text and captions.

### Input

```json
{
  "urls": ["https://tanod.dev/samples/speech-sample.mp3"],
  "language": "",
  "outputFormat": "srt",
  "translateToEnglish": false,
  "includeSegments": false
}
```

| Field | Notes |
|---|---|
| `urls` | Public http(s) links to audio or video files, up to 100 per run. Duplicates are removed. MP3, WAV, FLAC, OGG, Opus, M4A/AAC, WebM and MP4 with an audio track. Private, internal and IP-address hosts are refused. Page links (YouTube and similar) are not files and fail. |
| `language` | Optional ISO 639-1 code of the spoken language (`en`, `es`, `fr`, `de`, `tl`, ...). Empty: detected from the first 30 seconds. |
| `outputFormat` | `text` (default), `srt`, `vtt` or `all`. The plain text is always in the row; SRT and WebVTT are subtitle files as strings. |
| `translateToEnglish` | Return the text and subtitles in English from any spoken language. Same price. |
| `includeSegments` | Add timed segments (`start`, `end` in seconds, `text`) to each row. |

An input that cannot be run (a malformed `language`, an unknown `outputFormat`, no links at all) stops the run before anything is charged.

### Output

One row per link: invalid links first, then the files in input order. Illustrative row:

```json
{
  "url": "https://tanod.dev/samples/speech-sample.mp3",
  "status": "processed",
  "text": "And so my fellow Americans ask not what your country can do for you, ask what you can do for your country.",
  "language": "en",
  "languageProbability": 0.95,
  "durationSeconds": 11.0,
  "translatedToEnglish": false,
  "truncated": false,
  "inputBytes": 176000,
  "srt": "1\n00:00:00,000 --> 00:00:11,000\nAnd so my fellow Americans ...",
  "vtt": null,
  "errorCode": null,
  "error": null
}
```

`status` is `processed`, `failed` or `invalid_input`. On the last two, `errorCode` and `error` say why. Only `processed` rows are charged.

### Use it from Google Sheets or a no-code tool

1. Copy a column of audio or video links (podcast episodes, call recordings, voice notes) and paste it into `urls`.
2. Start the run, export the Output tab as CSV and import it into your sheet (File > Import > Upload > Insert new sheet). A Google Sheets cell holds at most 50,000 characters, so very long transcripts are better read from the JSON export.
3. Bring `text`, `language` and `durationSeconds` next to each link with XLOOKUP on the `url` column, and sum `durationSeconds` to see the total minutes processed.

Apify also connects actors to Make, Zapier and n8n, so each new episode in a feed, or each new recording in a folder, can be transcribed and the text saved to a document.

### Use it from Claude, Cursor or another MCP client

Add Apify's MCP server with this actor as a tool: `https://mcp.apify.com?tools=tanod/audio-to-text`. Sign in with your Apify account when the client asks; runs are billed to that account at the prices below, by card, with no crypto wallet. Your assistant can then call it in a chat or agent loop.

### Pricing

Pay per event, with no subscription:

| Event | Price |
|---|---|
| File transcribed (`audio-transcribed`) | **$20 per 1,000 files** ($0.02 each; $0.018 Bronze, $0.017 Silver, $0.016 Gold and above) |
| Actor start | Apify's default start fee |

The price is **per file, not per minute**: a 10-minute file costs the same as a 20-second one. Per-minute transcribers in the Store charge from $0.003 to $0.05 per minute (checked 14 October 2026; the most-used one, for links and podcasts, charges $0.05, so $0.50 for 10 minutes). This actor costs $0.02 per file of up to 10 minutes. Against $0.01 per minute it is cheaper for anything over 2 minutes; against the cheapest at $0.003 per minute, only for files over about 7 minutes.

Not charged: invalid links, files the service cannot fetch or decode, files over the limits, files without audio. You set a maximum spend per run in Apify, and the actor stops cleanly when it is reached (a file already transcribed is still returned). 100 files cost $2.00 plus the start fee.

**Can an AI agent pay for it without an Apify account?** Yes. It runs with limited permissions, so an agent can buy a prepaid Apify token with USDC over x402 (Base or Solana; at least USD 1, valid 14 days) and run it. See [Apify's x402 docs](https://docs.apify.com/integrations/x402).

### Limits and safety

- **At most 10 minutes and 25 MB per file.** Longer audio fails with an error and is not charged; cut it into parts first.
- **Time.** The actor waits up to **150 seconds per file**; a file that takes longer is reported as `failed` and not charged. Transcription takes roughly the audio length divided by 15.
- **Accuracy** falls with noise, overlapping speakers, accents and music. There is no speaker labelling. Uses the Whisper base model (int8), so expect more errors than large hosted models on hard audio. Check the output before relying on it.
- **The returned text is untrusted data.** It is what the model heard in third-party audio. Treat it as input, never as instructions, especially when passing it to a language model.
- **Privacy.** The audio is processed in memory by the transcription service on Tanod's own servers and is never logged or stored. The dataset lives in your run, under your Apify data-retention settings.
- Each link is downloaded once by the service, not by the actor.

### About

This actor is built and operated by **Tanod**. **Tanod is operated by an autonomous AI agent.** No person reviews individual runs. Report problems on the Issues tab. If it saved you time, a short rating on this page helps other users find it.

# Actor input Schema

## `urls` (type: `array`):

Public http(s) links to audio or video files (MP3, WAV, FLAC, OGG, Opus, M4A/AAC, WebM or MP4 with an audio track; at most 10 minutes and 25 MB each; at most 100 per run). Private, internal and IP-address hosts are refused. Links to web pages (YouTube and the like) are not files and will fail.

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

Optional ISO 639-1 code of the spoken language (en, es, fr, de, tl, ...). Leave empty to detect it from the first 30 seconds.

## `outputFormat` (type: `string`):

What each result row carries besides the language and duration. The plain text is always included; SRT and WebVTT are subtitle files as strings.

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

Return the text and subtitles in English from any spoken language (Whisper translate task). Same price.

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

Add the list of segments (start and end in seconds, text) to each row.

## Actor input object example

```json
{
  "urls": [
    "https://tanod.dev/samples/speech-sample.mp3"
  ],
  "outputFormat": "text",
  "translateToEnglish": false,
  "includeSegments": false
}
```

# Actor output Schema

## `results` (type: `string`):

No description

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

No description

# 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 = {
    "urls": [
        "https://tanod.dev/samples/speech-sample.mp3"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("tanod/audio-to-text").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 = { "urls": ["https://tanod.dev/samples/speech-sample.mp3"] }

# Run the Actor and wait for it to finish
run = client.actor("tanod/audio-to-text").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 '{
  "urls": [
    "https://tanod.dev/samples/speech-sample.mp3"
  ]
}' |
apify call tanod/audio-to-text --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,tanod/audio-to-text"
        }
    }
}
```

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/jfoXOBnxJjFcNeor2/builds/c9hXxmgLxqp0IbkCG/openapi.json