# Wisprs — AI Transcription & Subtitle Generator (`toshiusklay/wisprs-transcription`) Actor

Transcribe any YouTube video, podcast, TikTok, or audio/video URL to text. Export as SRT, VTT, TXT, JSON, Markdown, or DOCX. Generate AI summaries, chapters, show notes, and Twitter threads. 100+ languages. No Wisprs account needed.

- **URL**: https://apify.com/toshiusklay/wisprs-transcription.md
- **Developed by:** [Gitonga Mwaura](https://apify.com/toshiusklay) (community)
- **Categories:** AI, Automation
- **Stats:** 2 total users, 1 monthly users, 0.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/platform/actors/running/actors-in-store#pay-per-usage

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Wisprs — AI Transcription & Subtitle Generator (YouTube, Podcast, Audio)

Submit any YouTube video, podcast episode, or audio URL and get back a full text transcript, SRT/VTT subtitles, speaker-labeled segments, and structured content like show notes, chapters, or Twitter/X threads — saved to your Apify Dataset automatically.

The Wisprs Transcription Actor is powered by the [Wisprs API](https://wisprs.co), a production-grade async voice processing engine that transcribes audio from any publicly accessible URL. Unlike caption-scraping actors that fail on 30–40% of videos (music, Shorts, unlisted), Wisprs uses Whisper-based transcription and yt-dlp to cover 100% of video and audio URLs. Accuracy is excellent on clear audio; results vary by language, accent, and recording quality.

---

### What does this Actor do?

1. Takes a list of YouTube, podcast, or audio/video URLs from your `startUrls` input
2. Submits each URL to the Wisprs transcription API (async job queue — no timeouts)
3. Polls until each job completes (typically 1–3 minutes per 15-minute video)
4. Exports the transcript in your chosen formats: TXT, SRT, VTT, JSON, or Markdown
5. Optionally generates structured content from the transcript via the Wisprs repurpose engine — podcast show notes, timestamped chapters, guest quotes, Twitter/X threads, or blog posts
6. Saves one dataset row per URL — ready for downstream automation

---

### How do I use this Actor to transcribe a YouTube video?

**Step 1 — Run the Actor**

Set the following input:

```json
{
  "startUrls": [{ "url": "https://www.youtube.com/watch?v=EXAMPLE" }],
  "language": "auto",
  "exportFormats": ["txt", "srt"],
  "repurposeMode": "none"
}
````

**Step 2 — Check your Dataset**

When the run completes, your Dataset contains one row per URL with the full transcript, SRT subtitles, and any repurposed content you requested.

***

### What data does the Actor extract?

Each dataset row includes:

| Field | Description |
|---|---|
| `url` | The submitted URL |
| `jobId` | Wisprs job identifier for tracking |
| `transcriptionId` | Transcription identifier for the Wisprs API |
| `status` | `completed` or `failed` |
| `durationSeconds` | Audio/video duration in seconds |
| `detectedLanguage` | ISO 639-1 code of the detected language |
| `transcript_txt` | Full plain-text transcript |
| `transcript_srt` | SRT subtitle file content |
| `transcript_vtt` | WebVTT subtitle file content |
| `transcript_json` | Word-level timestamps in JSON |
| `transcript_md` | Transcript in Markdown format |
| `repurposed_show_notes` | Structured show notes (summary, chapters, quotes) |
| `repurposed_thread` | Twitter/X thread array |
| `repurposed_summary` | 2–4 sentence summary |
| `repurposed_chapters` | Timestamped chapter markers |

***

### How much will it cost to transcribe a 30-minute podcast?

Pricing is per-event:

- **$0.005** per transcription submitted (one-time per URL)
- **$0.015 per audio minute** processed (e.g. a 30-minute episode = $0.45)
- **$0.075** per repurpose result generated (show notes, thread, etc.)

**Example: 10 podcast episodes averaging 45 minutes each**

- Submission: 10 × $0.005 = $0.05
- Audio minutes: 10 × 45 × $0.015 = $6.75
- Show notes (optional): 10 × $0.075 = $0.75
- **Total: ~$7.55** for 10 complete episodes with show notes

The Apify free plan includes $5 of monthly credits — enough to transcribe 5–6 short videos at no cost.

***

### Input

| Field | Type | Required | Default | Description |
|---|---|---|---|---|
| `startUrls` | Array | Yes | — | YouTube, podcast, or audio/video URLs |
| `language` | String | No | `auto` | ISO 639-1 code or `auto` |
| `diarize` | Boolean | No | `false` | Label speakers (host vs guest) |
| `exportFormats` | Array | No | `["txt","srt"]` | txt, srt, vtt, json, md |
| `repurposeMode` | String | No | `none` | none, summary, show\_notes, thread, chapters, quotes |
| `webhookUrl` | String | No | — | Callback URL per completed job |
| `maxPollSeconds` | Integer | No | `900` | Max wait per job (60–3600s) |
| `pollIntervalSeconds` | Integer | No | `10` | Status check interval (5–60s) |

***

### Supported URLs

- YouTube videos, Shorts, and playlist-linked videos
- Direct audio: mp3, wav, m4a, ogg, flac
- Direct video: mp4, webm, mov
- Podcast RSS episode links
- TikTok, Loom, Vimeo, and most public video/audio hosts

***

### Language support

100+ languages with automatic detection. The detected language appears in each dataset row as `detectedLanguage`. Pass a specific ISO 639-1 code (`"en"`, `"es"`, `"fr"`) to skip auto-detection and speed up processing slightly for known-language content.

***

### Related Actors

- [Wisprs — Podcast Show Notes Generator](https://apify.com/wisprs/podcast-show-notes) — tuned specifically for long-form podcast episode pipelines
- [Wisprs — YouTube Content Repurposer](https://apify.com/wisprs/youtube-repurposer) — YouTube URL → thread, blog post, LinkedIn article in one call

***

### Related Actors

- [Wisprs — Podcast Show Notes Generator](https://apify.com/wisprs/wisprs-podcast-show-notes) — podcast episodes → show notes, chapters, guest quotes with speaker diarization
- [Wisprs — YouTube Content Repurposer](https://apify.com/wisprs/wisprs-youtube-repurposer) — YouTube → Twitter thread, LinkedIn article, blog post, chapters
- [Wisprs — Social Media Transcriber](https://apify.com/wisprs/wisprs-social-media-transcriber) — TikTok, Instagram Reels, YouTube Shorts at $1.00/1k

***

### FAQ

**Do I need an OpenAI API key or a Wisprs account?**
No. No external API key or account required. The Actor handles authentication internally — you pay only via Apify credits.

**Does it work for videos without captions?**
Yes. Unlike caption-scraping actors, Wisprs transcribes the audio directly using Whisper. It covers captionless videos, music videos, private-link Loom recordings, and anything with audio.

**Is there a video length limit?**
No hard limit. The async job queue handles videos of any length. A 90-minute webinar typically completes in 5–10 minutes.

**What if a job fails?**
The dataset row will have `status: "failed"` and an `errorMessage` explaining why (unsupported format, private video, no audio, etc.).

***

### Support

- Documentation: [wisprs.co/docs](https://wisprs.co/docs)
- Email: tosh@belvadigital.com
- Issues: report via the Apify Actor page

***

*Submit a URL. Get subtitles, transcripts, and show notes. Done.*

# Actor input Schema

## `startUrls` (type: `array`):

List of YouTube, podcast episode, or direct audio/video URLs to transcribe. Supports mp3, mp4, wav, m4a, YouTube, TikTok, Loom, and most video/audio hosts.

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

ISO 639-1 language code (e.g. 'en', 'es', 'fr'). Leave blank or set 'auto' to detect automatically.

## `diarize` (type: `boolean`):

Label who is speaking in the transcript (host vs guest). Useful for podcasts and interviews.

## `exportFormats` (type: `array`):

Transcript formats to include in the dataset output.

## `repurposeMode` (type: `string`):

Optionally generate structured content from the transcript. 'none' to skip. 'show\_notes' for podcast show notes with chapters and quotes. 'thread' for a Twitter/X thread. 'summary' for a 2–4 sentence summary. 'chapters' for timestamped chapters.

## `webhookUrl` (type: `string`):

URL to POST a completion notification to for each transcription job. Leave blank to poll instead.

## `maxPollSeconds` (type: `integer`):

Maximum time to wait for each transcription job to complete. Default 900 seconds (15 minutes).

## `pollIntervalSeconds` (type: `integer`):

How often to check job status. Default 10 seconds.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.youtube.com/watch?v=EXAMPLE"
    }
  ],
  "language": "auto",
  "diarize": false,
  "exportFormats": [
    "txt",
    "srt"
  ],
  "repurposeMode": "none",
  "maxPollSeconds": 900,
  "pollIntervalSeconds": 10
}
```

# 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 = {
    "startUrls": [
        {
            "url": "https://www.youtube.com/watch?v=EXAMPLE"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("toshiusklay/wisprs-transcription").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 = { "startUrls": [{ "url": "https://www.youtube.com/watch?v=EXAMPLE" }] }

# Run the Actor and wait for it to finish
run = client.actor("toshiusklay/wisprs-transcription").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "startUrls": [
    {
      "url": "https://www.youtube.com/watch?v=EXAMPLE"
    }
  ]
}' |
apify call toshiusklay/wisprs-transcription --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=toshiusklay/wisprs-transcription",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Wisprs — AI Transcription & Subtitle Generator",
        "description": "Transcribe any YouTube video, podcast, TikTok, or audio/video URL to text. Export as SRT, VTT, TXT, JSON, Markdown, or DOCX. Generate AI summaries, chapters, show notes, and Twitter threads. 100+ languages. No Wisprs account needed.",
        "version": "1.0",
        "x-build-id": "cKjKYbsqpeafrtIru"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/toshiusklay~wisprs-transcription/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-toshiusklay-wisprs-transcription",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/toshiusklay~wisprs-transcription/runs": {
            "post": {
                "operationId": "runs-sync-toshiusklay-wisprs-transcription",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/toshiusklay~wisprs-transcription/run-sync": {
            "post": {
                "operationId": "run-sync-toshiusklay-wisprs-transcription",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "URLs to Transcribe",
                        "type": "array",
                        "description": "List of YouTube, podcast episode, or direct audio/video URLs to transcribe. Supports mp3, mp4, wav, m4a, YouTube, TikTok, Loom, and most video/audio hosts.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "language": {
                        "title": "Language",
                        "type": "string",
                        "description": "ISO 639-1 language code (e.g. 'en', 'es', 'fr'). Leave blank or set 'auto' to detect automatically.",
                        "default": "auto"
                    },
                    "diarize": {
                        "title": "Speaker Diarization",
                        "type": "boolean",
                        "description": "Label who is speaking in the transcript (host vs guest). Useful for podcasts and interviews.",
                        "default": false
                    },
                    "exportFormats": {
                        "title": "Export Formats",
                        "type": "array",
                        "description": "Transcript formats to include in the dataset output.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "txt",
                                "srt",
                                "vtt",
                                "json",
                                "md"
                            ]
                        },
                        "default": [
                            "txt",
                            "srt"
                        ]
                    },
                    "repurposeMode": {
                        "title": "Repurpose Mode",
                        "enum": [
                            "none",
                            "summary",
                            "show_notes",
                            "thread",
                            "chapters",
                            "quotes"
                        ],
                        "type": "string",
                        "description": "Optionally generate structured content from the transcript. 'none' to skip. 'show_notes' for podcast show notes with chapters and quotes. 'thread' for a Twitter/X thread. 'summary' for a 2–4 sentence summary. 'chapters' for timestamped chapters.",
                        "default": "none"
                    },
                    "webhookUrl": {
                        "title": "Webhook URL (optional)",
                        "type": "string",
                        "description": "URL to POST a completion notification to for each transcription job. Leave blank to poll instead."
                    },
                    "maxPollSeconds": {
                        "title": "Max Poll Time (seconds)",
                        "minimum": 60,
                        "maximum": 3600,
                        "type": "integer",
                        "description": "Maximum time to wait for each transcription job to complete. Default 900 seconds (15 minutes).",
                        "default": 900
                    },
                    "pollIntervalSeconds": {
                        "title": "Poll Interval (seconds)",
                        "minimum": 5,
                        "maximum": 60,
                        "type": "integer",
                        "description": "How often to check job status. Default 10 seconds.",
                        "default": 10
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
