# Vimeo Transcript Extractor 🎞️ (`scriptbase/vimeo-transcript-extractor`) Actor

🎞️ Convert any Vimeo video to text. Extract transcripts, subtitles, and captions with timestamps. Outputs JSON, SRT, or plain text. Auto-captions + speech-to-text fallback. 14+ languages. No login needed.

- **URL**: https://apify.com/scriptbase/vimeo-transcript-extractor.md
- **Developed by:** [Scriptbase](https://apify.com/scriptbase) (community)
- **Categories:** AI, Social media, Automation
- **Stats:** 1 total users, 1 monthly users, 71.4% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $10.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## Vimeo Transcript Extractor

Extract transcripts from Vimeo videos — films, creative portfolios, webinars, online courses, and branded content. Provide a Vimeo URL and get back clean, timestamped text in the format your workflow needs.

Works with any public Vimeo video. No login required.

### What it does

1. You provide a Vimeo video URL or an embedded player URL.
2. The actor extracts the spoken transcript with precise timestamps.
3. You get back structured data in JSON, plain text, SRT, or WebVTT format — ready for subtitles, course notes, or content pipelines.

Vimeo is the platform of choice for filmmakers, educators, and agencies hosting high-quality video. This actor makes that content machine-readable without manual transcription.

### Key features

- **Creative & educational content** — built for the kinds of long-form, polished videos Vimeo hosts: documentary cuts, corporate training, course lectures, and portfolio reels.
- **Embedded player support** — accepts both standard `vimeo.com/<id>` and `player.vimeo.com/video/<id>` URLs, covering embed-only setups.
- **Timestamped segments** — precise `start` and `end` times on every segment, so subtitle editors and e-learning authors can sync text to video precisely.
- **4 output formats** — JSON, plain text, SRT, or WebVTT. Drop SRT directly into a video editor or course platform.
- **Multi-language** — uses Vimeo's own caption tracks when present; speech-to-text fallback covers 14 languages.
- **No login required.**

### Supported languages

When caption tracks are attached to the Vimeo video, the actor uses them directly in any language they were authored. When no captions exist, speech-to-text fallback supports:

| Code | Language |
|------|----------|
| `en` | English |
| `es` | Spanish |
| `fr` | French |
| `de` | German |
| `pt` | Portuguese |
| `it` | Italian |
| `nl` | Dutch |
| `ja` | Japanese |
| `ko` | Korean |
| `zh` | Chinese |
| `ar` | Arabic |
| `ru` | Russian |
| `tr` | Turkish |
| `hi` | Hindi |

### Input

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| `url` | string | *(required)* | Vimeo video URL |
| `language` | string | `"en"` | Preferred language ([ISO 639-1](https://en.wikipedia.org/wiki/List_of_ISO_639-1_codes)) |
| `format` | string | `"json"` | `"json"`, `"text"`, `"srt"`, or `"vtt"` |

#### Supported URLs

```
https://vimeo.com/123456789
https://player.vimeo.com/video/123456789
```

### Output example

When `format` is `json`, each dataset row looks like this:

```json
{
    "url": "https://vimeo.com/123456789",
    "platform": "vimeo",
    "language": "en",
    "duration_sec": 1842,
    "segments": [
        { "start": 0.0, "end": 5.3, "text": "Welcome to the advanced motion graphics workshop." },
        { "start": 5.3, "end": 10.8, "text": "By the end of this session you will be able to rig any character in After Effects." }
    ],
    "full_text": "Welcome to the advanced motion graphics workshop. By the end of this session you will be able to rig any character in After Effects."
}
```

When `format` is `text`, `srt`, or `vtt`, the formatted transcript is written to the actor's key-value store under the `OUTPUT` key.

When extraction fails, the dataset row contains a clear error:

```json
{
    "error": "NOT_FOUND",
    "message": "The video is private, removed, or has no extractable transcript."
}
```

### Error codes

| Code | Meaning |
|------|---------|
| `INVALID_FORMAT` | `format` was not one of json/text/srt/vtt |
| `BAD_REQUEST` | The URL was malformed or rejected by the transcript operation |
| `UNSUPPORTED_PLATFORM` | No transcript operation serves this URL's platform |
| `UNAUTHORIZED` | The actor's ScriptBase key is missing, invalid, or revoked |
| `INSUFFICIENT_CREDITS` | The ScriptBase account behind this actor is out of credits |
| `NOT_FOUND` | The video is private, removed, or has no extractable transcript |
| `UPSTREAM_FAILED` | Every transcript source failed -- retry shortly |
| `RATE_LIMITED` | Too many requests -- retry after a short delay |
| `TIMEOUT` | Extraction took longer than the actor's poll budget |
| `INTERNAL_ERROR` | Unexpected error during extraction |

### Use cases

- **Online course & e-learning** — convert lecture recordings and tutorial videos into course notes, searchable transcripts, or LMS-ready caption files without hiring a transcriptionist.
- **Subtitle generation** — export SRT or WebVTT directly from any public Vimeo video. Paste it into Premiere, DaVinci Resolve, or your video host's caption uploader.
- **Webinar repurposing** — turn recorded webinars into blog posts, email sequences, or LinkedIn articles that extend the life of the content.
- **Portfolio & film archiving** — make filmmaker reels and documentary excerpts searchable and indexable by extracting their narration or dialogue.
- **Translation pipelines** — get clean source text to feed into translation APIs or human translators for multilingual subtitle tracks.
- **Accessibility compliance** — organizations hosting training or marketing videos on Vimeo can generate accurate captions to meet WCAG and ADA requirements.

### Integrations

Use this actor through the [Apify API](https://docs.apify.com/api/v2) or connect it to your automation stack:

- **Python** — `apify_client.actor("your-actor-id").call(run_input={"url": "https://vimeo.com/123456789"})`
- **JavaScript** — `await client.actor("your-actor-id").call({url: "https://vimeo.com/123456789"})`
- **Zapier / Make / n8n** — watch a spreadsheet of Vimeo URLs and auto-generate transcripts whenever a new row is added.
- **Webhooks** — receive a payload with the full transcript the moment extraction completes, piping directly into your CMS or translation service.

### FAQ

**Does this require a Vimeo account?**
No. The actor extracts transcripts from any publicly accessible Vimeo video without credentials.

**What about password-protected videos?**
Password-protected or private Vimeo videos are not accessible. The actor only works with public content.

**My video is a long course (90+ minutes). Will it work?**
Yes. The actor handles longer videos, though extraction time scales with duration. For very long videos, set a generous actor timeout in your run configuration.

**The video already has captions attached — will it use those?**
Yes. The actor uses existing caption tracks first and only falls back to speech-to-text when no captions are present.

**Can I get WebVTT output for a video platform that requires it?**
Yes. Set `format` to `"vtt"` and retrieve the file from the key-value store under the `OUTPUT` key.

**Does it support Vimeo showcase or channel URLs?**
Pass the direct video URL (including the numeric ID) for best results. Channel or showcase listing pages are not supported.

**What does it cost?**
Pricing is per transcribed minute (1 minute = 1 charge unit, minimum 1), so you pay only for the audio actually processed — and failed extractions cost nothing. The exact per-minute price is shown on this actor's Apify Store page.

# Actor input Schema

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

URL of the Vimeo video.

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

Preferred transcript language as an ISO 639-1 code (e.g. en, es, fr, de, ja).

## `format` (type: `string`):

Choose how the transcript is returned. JSON includes timestamps per segment. Text returns the full transcript as a plain string. SRT and VTT are subtitle file formats.

## Actor input object example

```json
{
  "url": "https://vimeo.com/76979871",
  "language": "en",
  "format": "json"
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

## `segments` (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 = {
    "url": "https://vimeo.com/76979871",
    "language": "en",
    "format": "json"
};

// Run the Actor and wait for it to finish
const run = await client.actor("scriptbase/vimeo-transcript-extractor").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 = {
    "url": "https://vimeo.com/76979871",
    "language": "en",
    "format": "json",
}

# Run the Actor and wait for it to finish
run = client.actor("scriptbase/vimeo-transcript-extractor").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 '{
  "url": "https://vimeo.com/76979871",
  "language": "en",
  "format": "json"
}' |
apify call scriptbase/vimeo-transcript-extractor --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/DTQAgetBX1raJHRKn/builds/sVpdFyejZlqg4u5m1/openapi.json