# Audio to Text Transcriber with Subtitles (`ridgeline_apps/audio-transcriber`) Actor

Speech to text for audio files: transcribe MP3, WAV, FLAC and OGG to text with timestamps and SRT/VTT subtitles. 40+ languages, translation to English, private on-server speech models. Silent files are free.

- **URL**: https://apify.com/ridgeline_apps/audio-transcriber.md
- **Developed by:** [Promise Land Provision LLC](https://apify.com/ridgeline_apps) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 1,000 audio minutes

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

## Audio to Text Transcriber with Subtitles

Turn audio files into text: paste file links or upload files and get a clean transcript, timestamped segments and ready-to-use SRT and VTT subtitles. It reads MP3, WAV, FLAC and OGG files in 40+ languages, and can translate any of them into English.

**Built for:** podcast and interview transcripts, meeting and lecture notes, voice notes, subtitles for your own recordings, and feeding spoken content into AI, RAG and search pipelines from Make, Zapier or n8n.

### What you get

- **Clean transcript** with paragraphs at natural pauses, plus word count and detected language.
- **Timestamped segments:** start and end time (in seconds) for every sentence or phrase.
- **Subtitles:** SRT and WebVTT text you can save as a file and load in a video editor or player.
- **Word timestamps (optional):** start, end and confidence of every word, for karaoke-style captions and search.
- **Translate to English** from any supported language in the same run.
- **Two accuracy levels:** Standard (fast, great for clear speech) and High accuracy (better with accents, noise and unusual words).
- **Private by design:** speech recognition runs inside your own Apify run. Your audio is never sent to an outside AI service.
- **Fair billing:** you pay per minute of audio. Files with no speech, unsupported files and failed downloads are free, and the run stops cleanly at your maximum cost per run.

### How to use

1. Add audio file links (one per line) or upload files in **Audio files**.
2. Choose **Accuracy** and, if you know it, the **Spoken language** (Auto-detect works for most files).
3. Click **Start**, then download results as JSON, CSV, XLSX or HTML, or fetch them with the API.

```bash
curl -X POST "https://api.apify.com/v2/acts/ridgeline_apps~audio-transcriber/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"files": ["https://example.com/interview.mp3"], "language": "en"}'
```

### Input

| Field | Description | Default |
|---|---|---|
| `files` | Audio file URLs or uploaded files (MP3, WAV, FLAC, OGG) | required |
| `accuracy` | `standard` or `high` | `standard` |
| `language` | Spoken language code (`en`, `es`, `de`, ...) or `auto` | `auto` |
| `task` | `transcribe` (original language) or `translate` (to English) | `transcribe` |
| `includeSubtitles` | Add `srt` and `vtt` subtitle text | `true` |
| `includeSegments` | Add timestamped `segments` | `true` |
| `includeWordTimestamps` | Add `words` to each segment | `false` |
| `maxFileSizeMb` | Larger files are skipped (free) | 200 |
| `maxMinutesPerFile` | Longer files are skipped (free) | 180 |

### Output

```json
{
  "url": "https://example.com/interview.mp3",
  "fileName": "interview.mp3",
  "status": "ok",
  "format": "mp3",
  "durationSeconds": 754.2,
  "billedMinutes": 13,
  "language": "en",
  "languageProbability": 0.98,
  "text": "Welcome back to the show. Today we're talking about...\n\nThanks for having me...",
  "wordCount": 1893,
  "segments": [
    { "start": 0.0, "end": 3.12, "text": "Welcome back to the show." }
  ],
  "srt": "1\n00:00:00,000 --> 00:00:03,120\nWelcome back to the show.\n...",
  "vtt": "WEBVTT\n\n00:00:00.000 --> 00:00:03.120\nWelcome back to the show.\n..."
}
```

Files that can't be processed come back with `"status": "error"` and a plain-English `error`. They are never charged.

### Pricing

Pay per minute of audio, with no subscription. Each file is billed in whole minutes, rounded up (a 2:10 file counts as 3 minutes). High accuracy costs more per minute than Standard. Files with no speech and failed files are free. The exact prices are on the Pricing tab, and you can set a maximum cost per run in the run options.

### Speed and run settings

On the default 4 GB memory, Standard transcribes about 8 minutes of audio per minute of run time; High accuracy about 3. For long files, raise the run **Timeout** in the run options (for example, a 3-hour recording on High accuracy needs about an hour). More memory gives more CPU and finishes faster.

### FAQ

**Which formats are supported?** MP3, WAV, FLAC and OGG (Vorbis). M4A, AAC, Opus, WMA and video files are not supported: convert them to MP3 first. Unsupported files are reported as errors and not charged.

**How accurate is it?** On clear speech, transcripts are usually very accurate. Strong accents, background noise, crosstalk and names lower accuracy; use High accuracy and set the spoken language for the best results.

**Does it label speakers?** No. Speaker labels (diarization) are not included.

**Can it transcribe a video-site or podcast page link?** No. It needs a direct link to an audio file (or an upload). It does not download from video or streaming platforms.

**Where does my audio go?** Files are downloaded into your own Apify run and transcribed there. Nothing is sent to any third-party AI or transcription service.

### Legal

Only transcribe audio you have the right to use, and follow the recording-consent laws that apply to you. You're responsible for the files you submit and how you use the transcripts. Not intended for medical records (PHI) or other regulated data that requires a signed processing agreement.

Built on open-source software: Whisper speech models by OpenAI (MIT), faster-whisper and CTranslate2 (MIT), miniaudio (MIT; public-domain decoders), ONNX Runtime (MIT), Hugging Face Tokenizers (Apache-2.0) and httpx (BSD-3-Clause).

Questions or a feature request? Open an issue on the **Issues** tab.

# Actor input Schema

## `files` (type: `array`):

Paste audio file URLs (one per line) or upload files. Supports MP3, WAV, FLAC and OGG (Vorbis). M4A, AAC, Opus and video files are not supported: convert them to MP3 first.

## `accuracy` (type: `string`):

Standard is fast and works well for clear speech. High accuracy uses a larger model: better with accents, noise and less common words, about 3x slower and priced higher.

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

Pick the language spoken in the audio, or leave Auto-detect. Setting it improves accuracy for short or noisy files.

## `task` (type: `string`):

Transcribe keeps the original language. Translate produces an English transcript from any supported language.

## `includeSubtitles` (type: `boolean`):

Add ready-to-use subtitle text in SRT and WebVTT formats to each result.

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

Add the transcript as a list of segments with start and end times in seconds.

## `includeWordTimestamps` (type: `boolean`):

Add the start and end time and confidence of every word. Slightly slower.

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

Larger files are skipped and not charged.

## `maxMinutesPerFile` (type: `integer`):

Longer files are skipped and not charged. Long files also need a longer run timeout: plan about 1 minute of run time per 8 minutes of audio on Standard (4 GB memory).

## Actor input object example

```json
{
  "files": [
    "https://raw.githubusercontent.com/openai/whisper/main/tests/jfk.flac"
  ],
  "accuracy": "standard",
  "language": "auto",
  "task": "transcribe",
  "includeSubtitles": true,
  "includeSegments": true,
  "includeWordTimestamps": false,
  "maxFileSizeMb": 200,
  "maxMinutesPerFile": 180
}
```

# Actor output Schema

## `results` (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 = {
    "files": [
        "https://raw.githubusercontent.com/openai/whisper/main/tests/jfk.flac"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("ridgeline_apps/audio-transcriber").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 = { "files": ["https://raw.githubusercontent.com/openai/whisper/main/tests/jfk.flac"] }

# Run the Actor and wait for it to finish
run = client.actor("ridgeline_apps/audio-transcriber").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 '{
  "files": [
    "https://raw.githubusercontent.com/openai/whisper/main/tests/jfk.flac"
  ]
}' |
apify call ridgeline_apps/audio-transcriber --silent --output-dataset

```

## MCP server setup

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

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/hIf1zxOgBqosyrgyD/builds/MMEzj7Aops1Ux8oSe/openapi.json