# WhipScribe Transcriber — Audio & Video to Text (`whipscribe/whipscribe-transcriber`) Actor

Turn podcast episodes, YouTube videos and audio or video file links into accurate transcripts with timestamps, SRT and VTT subtitles, in 99+ languages. Uses your WhipScribe API key.

- **URL**: https://apify.com/whipscribe/whipscribe-transcriber.md
- **Developed by:** [Neugence Technology Pvt Ltd](https://apify.com/whipscribe) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

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

## WhipScribe Transcriber — Audio & Video to Text

Turn podcast episodes, YouTube videos and audio or video file links into clean, timestamped transcripts — plus ready-to-use **SRT** and **WebVTT** subtitles — in 99+ languages. Paste a list of links, run, and download every transcript as JSON, CSV or Excel from the dataset.

This Actor is the official Apify integration for [WhipScribe](https://whipscribe.com). It uses your own WhipScribe API key, so the transcripts also land in your WhipScribe library where you can read, search and export them.

### Try it without a key

Press **Start** with the default input — no account, no key. The Actor transcribes the prefilled sample (a public-domain reading of the Gettysburg Address, under two minutes) and saves one dataset row with a free preview: the text, timestamped segments, detected language and duration. It takes well under a minute.

Preview mode is deliberately small:

- one link per run, and only the sample recording — links of your own are not transcribed without a key;
- the row is marked `"preview": true` and carries a `message` telling you how to get the full thing;
- no SRT or VTT subtitles.

For full transcripts, subtitles and your own links, add your WhipScribe API key — see "Before you start" below.

### What it does

For every link you give it, the Actor:

1. Sends the link to WhipScribe for transcription.
2. Waits until the transcript is ready (you can turn waiting off).
3. Saves one dataset row with the full text, timestamped segments, subtitles and a link to open the transcript on whipscribe.com.

One bad link never stops the run: it gets its own row with a clear `error` message and the rest carry on.

### What you can transcribe

- **Podcasts** — direct links to episode files (mp3, m4a, …) from an RSS feed or host.
- **YouTube and other public video links**, where WhipScribe can fetch them.
- **Direct audio and video files** — mp3, m4a, wav, mp4, mov, ogg, webm, flac — up to 10 hours each.
- **Meeting and lecture recordings** you can share as a public link.

### Use cases

- **Podcast show notes and SEO** — full transcripts for every episode, ready to publish.
- **Subtitles** — SRT/VTT files for YouTube, Vimeo, social clips and course platforms.
- **Research and monitoring** — turn interviews, talks or earnings calls into searchable text.
- **Content repurposing** — feed transcripts into your own summarising, quoting or clipping workflow.
- **Meetings and lectures** — searchable notes from recordings without typing a word.

### Before you start: your WhipScribe API key

1. Sign in at [whipscribe.com](https://whipscribe.com).
2. Get API access on the [pricing page](https://whipscribe.com/pricing): it comes with the 5,000-minute pack ($24) or the Workspace plan ($19/month).
3. Create a key at [whipscribe.com/apis/keys](https://whipscribe.com/apis/keys) and paste it into the **WhipScribe API key** field. It is stored encrypted and never shown in run logs.

### Input

| Field | What it means |
|---|---|
| `urls` (required) | List of audio or video links. Prefilled with a short public-domain sample. |
| `apiKey` | Your WhipScribe API key. Leave it empty for a free preview of the sample recording (one link per run). |
| `language` | Spoken language, e.g. `en`, `es`, `hi`. Default `auto` detects it for you. |
| `outputFormats` | Any of `txt`, `json`, `srt`, `vtt`. Default `["txt", "json"]`. Plain text is always included. |
| `waitForCompletion` | Default `true`: wait and save the transcripts. `false`: only submit and save job IDs. |
| `timeoutMinutes` | How long to wait for all transcripts (default 60). Unfinished jobs keep running at WhipScribe. |
| `maxConcurrency` | How many links to work on at once (default 3, max 10). |

#### Input example

```json
{
  "urls": [
    "https://example.com/podcast/episode-412.mp3",
    "https://www.youtube.com/watch?v=VIDEO_ID"
  ],
  "apiKey": "YOUR_WHIPSCRIBE_API_KEY",
  "language": "auto",
  "outputFormats": ["txt", "json", "srt"],
  "waitForCompletion": true
}
```

### Output

One dataset item per link:

```json
{
  "url": "https://example.com/podcast/episode-412.mp3",
  "jobId": "35f4be54-aa3e-4adc-85b7-b44f284d1fc3",
  "status": "done",
  "language": "en",
  "durationSeconds": 967,
  "text": "Welcome back to the show. Today we're talking about...",
  "segments": [
    {
      "start": 0.0,
      "end": 16.3,
      "speaker": "SPEAKER_00",
      "text": "Welcome back to the show...",
      "words": [{ "start": 0.0, "end": 0.4, "text": "Welcome" }]
    }
  ],
  "srt": "1\n00:00:00,000 --> 00:00:16,300\nWelcome back to the show...\n",
  "vtt": null,
  "transcriptUrl": "https://whipscribe.com/view?id=35f4be54-aa3e-4adc-85b7-b44f284d1fc3",
  "error": null,
  "preview": false,
  "message": null
}
```

A run without an API key saves one row for the sample recording with `"preview": true`, `srt` and `vtt` set to `null`, and `message` set to: "Preview only. Add your WhipScribe API key for full transcripts, SRT/VTT and your own links — get one at https://whipscribe.com/apis/keys".

`status` is one of:

- `done` — the transcript is ready.
- `queued` / `processing` — you turned waiting off; open `transcriptUrl` later.
- `timeout` — still processing when the wait limit was reached; open `transcriptUrl` later.
- `locked` — the transcript is ready, but your account needs credit to open it.
- `failed` / `error` — see the `error` message.

Fields you did not ask for (for example `srt` when you only chose `txt`) are `null`. If a recording contains no speech (music only, silence), `text` is empty and `error` says so — and you are not charged for it.

### Pricing

The Actor itself is free; you only pay Apify's usual small platform usage for the run. Transcription uses **your WhipScribe credit**:

- **Free preview** — run this Actor without a key (sample recording), or try your own file on [whipscribe.com](https://whipscribe.com).
- **5,000-minute pack: $24.** This is the pack that includes API access, which the key needs. Credits never expire — no subscription.
- **Workspace**: $19/month for unlimited transcription with your own API keys.
- Smaller packs (from $4 for 500 minutes) work on whipscribe.com and top up an account that already has API access; on their own they do not include API keys.

Credit is counted by audio length, and failed jobs never use credit. See current prices at [whipscribe.com/pricing](https://whipscribe.com/pricing).

If your account runs out of credit, the affected rows say so with a link to [whipscribe.com/pricing](https://whipscribe.com/pricing) — add credit and run again.

### FAQ

**Do I need a WhipScribe account?**
Not for a first look: without a key the Actor returns a free preview of the sample recording. For your own links you do — the Actor runs on your WhipScribe API key, so you control spending and every transcript is kept in your WhipScribe library.

**Which languages are supported?**
99+ languages, detected automatically. Set `language` only if you want to force one.

**How long does it take?**
Usually a fraction of the recording's length. Long recordings take longer; raise `timeoutMinutes` for long batches, or turn off `waitForCompletion` and collect transcripts later from `transcriptUrl`.

**Does it identify speakers?**
Segments may carry a speaker label. Named speakers appear in the summary and key quotes when you open the transcript on whipscribe.com.

**What happens if I run the same links again?**
Each run submits the links again and uses credit again. Within one run, a retried request never creates a duplicate job.

**A link failed with a download error. Why?**
Private, login-only, or region-restricted media can't be fetched. Use a public link, or upload the file at [whipscribe.com](https://whipscribe.com).

**Is my data private?**
Your recordings and transcripts belong to your WhipScribe account and are never used for training. Your API key is stored encrypted by Apify.

**Can I use it from my own code or automations?**
Yes — call it through the Apify API, schedule it, or connect it to Make, Zapier, n8n and other Apify integrations. WhipScribe also has its own developer docs at [whipscribe.com/docs](https://whipscribe.com/docs).

### Support

Questions or feature requests: <contact@whipscribe.com>, or open an issue on this Actor's page.

# Actor input Schema

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

Public links to transcribe: YouTube videos, podcast episode files, or direct links to audio/video files (mp3, m4a, wav, mp4, mov, ogg, webm, flac). The prefilled link is a short public-domain sample (the Gettysburg Address). Without an API key the run is a free preview of that sample only, one link per run.

## `apiKey` (type: `string`):

Optional for a first try: leave it empty and the run returns a free preview of the sample recording. For full transcripts, SRT/VTT subtitles and your own links, add your key: sign in at whipscribe.com, get API access (the 5,000-minute pack at $24, or Workspace at $19/month), then create a key at https://whipscribe.com/apis/keys. Stored encrypted.

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

Spoken language of the recordings. Leave on Auto-detect unless you know it — WhipScribe detects 99+ languages. You can also type any ISO 639-1 code.

## `outputFormats` (type: `array`):

What to include in each dataset row. Plain text is always included. JSON adds timestamped segments with word timings; SRT and VTT add ready-to-use subtitle files.

## `waitForCompletion` (type: `boolean`):

On: the run waits until every transcript is ready and saves the text. Off: the run only submits the links and saves the job IDs — open the transcript link later.

## `timeoutMinutes` (type: `integer`):

How long to wait for all transcripts before giving up on the unfinished ones. Unfinished jobs keep running at WhipScribe — their row still carries the job ID and transcript link.

## `maxConcurrency` (type: `integer`):

How many links to submit and track at the same time.

## Actor input object example

```json
{
  "urls": [
    "https://upload.wikimedia.org/wikipedia/commons/a/a1/Gettysburg_by_Britton.ogg"
  ],
  "language": "auto",
  "outputFormats": [
    "txt",
    "json"
  ],
  "waitForCompletion": true,
  "timeoutMinutes": 60,
  "maxConcurrency": 3
}
```

# Actor output Schema

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

One row per link: status, language, duration, text, subtitles and a link to the transcript on whipscribe.com. Without an API key: one free preview row for the sample recording.

# 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://upload.wikimedia.org/wikipedia/commons/a/a1/Gettysburg_by_Britton.ogg"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("whipscribe/whipscribe-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 = { "urls": ["https://upload.wikimedia.org/wikipedia/commons/a/a1/Gettysburg_by_Britton.ogg"] }

# Run the Actor and wait for it to finish
run = client.actor("whipscribe/whipscribe-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 '{
  "urls": [
    "https://upload.wikimedia.org/wikipedia/commons/a/a1/Gettysburg_by_Britton.ogg"
  ]
}' |
apify call whipscribe/whipscribe-transcriber --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,whipscribe/whipscribe-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/uz7usPdq8dcWBeLyp/builds/oadXdtI4VwyRFBrAr/openapi.json