# Vimeo Video Downloader (`maximedupre/vimeo-video-downloader`) Actor

Get direct media links and metadata from public Vimeo video URLs. Export video IDs, titles, creators, thumbnails, formats, audio links, and expiry hints.

- **URL**: https://apify.com/maximedupre/vimeo-video-downloader.md
- **Developed by:** [Maxime Dupré](https://apify.com/maximedupre) (community)
- **Categories:** Social media, Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.65 / 1,000 resolved videos

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/platform/actors/running/actors-in-store#pay-per-event

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

### 📥 Vimeo video downloader for public URLs

Vimeo Video Downloader turns public [Vimeo](https://vimeo.com/) video URLs into direct source-hosted media links and clean metadata. Paste one or more Vimeo video links and get a structured Apify dataset with video IDs, submitted URLs, titles, descriptions, creators, thumbnails, durations, available video and audio formats, content types, dimensions, and link expiry hints when Vimeo exposes them.

Use this Vimeo video downloader when you already have Vimeo URLs and need repeatable exports for content review, media archiving, research, moderation queues, reporting, or an API workflow. The Actor works with public and share-accessible Vimeo videos only. It does not ask for Vimeo cookies, a Vimeo login, a Vimeo API key, or your own proxy settings.

For a small first run, keep the prefilled public Vimeo URLs and start the Actor. Once the output shape fits your workflow, paste your own list of public Vimeo video URLs or call the Actor through the Apify API.

### ✅ What this Actor does

- Accepts public Vimeo video URLs such as `https://vimeo.com/76979871`.
- Accepts Vimeo player URLs such as `https://player.vimeo.com/video/76979871`.
- Processes batches of submitted URLs.
- Deduplicates repeated URLs that point to the same Vimeo video.
- Saves one dataset row per successfully resolved public video.
- Returns direct source-hosted media links in `availableFormats`.
- Includes progressive MP4 links, HLS playlist links, DASH playlist links, and audio playlist links when Vimeo exposes them.
- Adds source-backed title, description, creator, duration, upload date, thumbnail, view count, and like count when available.
- Adds `fetchedAt` and `expiresAt` values so you know when temporary media links were collected and when they may expire.
- Skips invalid, private, password-protected, login-only, deleted, access-denied, or temporarily unavailable videos without saving failure rows.

This Actor is focused on known Vimeo video URLs. It does not crawl Vimeo channels, search Vimeo, download comments, bypass privacy settings, convert audio, merge separate streams, or copy media files into Apify storage.

### 📦 Data you can export

Each output row represents one successful public Vimeo video. Core fields include:

- `videoId` - the compact Vimeo video ID.
- `submittedUrl` - the URL you submitted that produced the row.
- `title` and `description` - source-backed Vimeo text when available.
- `creatorName` and `creatorUrl` - Vimeo creator or channel details when exposed.
- `durationSeconds` and `uploadDate` - video timing metadata when exposed.
- `thumbnailUrl` - the best source-backed thumbnail URL found for the video.
- `viewCount` and `likeCount` - engagement counts when Vimeo exposes them.
- `fetchedAt` - when the media links were resolved.
- `availableFormats` - all useful detected video and audio media variants.

Inside `availableFormats`, each item can include `mediaType`, `quality`, `width`, `height`, `contentType`, `codec`, `bitrateKbps`, `mediaUrl`, and `expiresAt`.

You can open the dataset in Apify, export it as JSON, CSV, Excel, XML, RSS, or HTML, call it through the Apify API, schedule recurring runs, or connect the results to webhooks and integrations.

### 🚀 How to run

1. Add one or more public Vimeo video URLs in **Vimeo video URLs**.
2. Start the Actor.
3. Open the dataset when the run finishes.
4. Use `availableFormats[].mediaUrl` for the direct video or audio links Vimeo exposed during the run.

Direct Vimeo media links can be temporary. For best results, use exported media URLs soon after the run or rerun the Actor when you need fresh links.

### 🔎 Input

| Field | What to enter |
| ----- | ------------- |
| `startUrls` | Public Vimeo video URLs or Vimeo player URLs. |

The public form stays intentionally small. There are no quality, proxy, cookie, password, storage, conversion, or debug controls. The Actor returns the useful media variants Vimeo exposes so you can choose the format after the run.

### 🧾 Output example

```json
{
  "videoId": "76979871",
  "submittedUrl": "https://vimeo.com/76979871",
  "title": "The New Vimeo Player (You Know, For Videos)",
  "description": "A source-backed Vimeo description.",
  "creatorName": "Vimeo",
  "creatorUrl": "https://vimeo.com/staff",
  "durationSeconds": 62,
  "uploadDate": null,
  "thumbnailUrl": "https://i.vimeocdn.com/video/example",
  "viewCount": null,
  "likeCount": null,
  "fetchedAt": "2026-06-22T18:23:44.012Z",
  "availableFormats": [
    {
      "mediaType": "video",
      "quality": "720p",
      "width": 1280,
      "height": 720,
      "contentType": "video/mp4",
      "codec": null,
      "bitrateKbps": null,
      "mediaUrl": "https://vod-progressive-ak.vimeocdn.com/example.mp4",
      "expiresAt": "2026-06-22T19:23:37.000Z"
    }
  ]
}
````

### 💳 Pricing

This Actor uses pay-per-event pricing. You are charged for each public Vimeo video that is successfully resolved with at least one direct media link and saved to the dataset.

You are not charged for invalid, private, deleted, password-required, login-only, or unavailable Vimeo URLs that do not produce an output row.

### ⚠️ Limits and caveats

- Vimeo can expose different media formats for different videos, creators, regions, and run times.
- Some public-looking Vimeo pages do not expose downloadable media links. Those targets are skipped without a dataset row.
- Direct media links may expire. Use them soon after the run or rerun the Actor when you need fresh links.
- Audio-only links are returned when Vimeo exposes separate audio playlists or streams.
- The Actor does not save MP4, MP3, ZIP, or archive files to Apify storage.
- The Actor does not bypass private videos, passwords, login requirements, paywalls, DRM, geo restrictions, or creator download restrictions.

### ❓ FAQ

#### 🔒 Can I download private or password-protected Vimeo videos?

No. This Actor is for public and share-accessible Vimeo videos only. It does not use your Vimeo account, cookies, passwords, or any bypass method.

#### 💾 Does it save MP4 files to Apify storage?

No. It returns direct source-hosted media links that Vimeo exposes during the run. This keeps the output fast and avoids creating mirrored media copies.

#### 🔎 Why did a public Vimeo URL produce no row?

Some Vimeo pages are public to watch but do not expose downloadable media links through the public player data available to this Actor. In that case, the Actor logs the skipped URL and continues with the rest of your batch.

#### 🧩 Can I use this as a Vimeo API?

Yes. You can run the Actor through the Apify API and export the dataset in common formats. The output is designed for programmatic use, with stable field names and one successful video per row.

### 📝 Changelog

- 0.1: Initial release.

### 🆘 Support

For issues, questions, or feature requests, [file a ticket](https://console.apify.com/actors/maximedupre~vimeo-video-downloader/issues) and I'll fix or implement it in less than 24h 🫡

### 🔗 Other actors

- [YouTube Shorts Downloader ↗](https://apify.com/maximedupre/youtube-shorts-downloader) - Get media links and metadata from public YouTube Shorts URLs.
- [TikTok Video Downloader ↗](https://apify.com/maximedupre/tiktok-video-downloader) - Save public TikTok video or audio files with source metadata.
- [Loom Video Downloader ↗](https://apify.com/maximedupre/loom-video-downloader) - Export public Loom video links, metadata, transcripts, and captions.
- [Rumble Video Downloader ↗](https://apify.com/maximedupre/rumble-video-downloader) - Extract Rumble video media variants and metadata from public URLs.
- [Facebook Media Downloader ↗](https://apify.com/maximedupre/facebook-media-downloader) - Get direct media links from public Facebook videos and reels.

**Made with ❤️ by Maxime Dupré**

# Actor input Schema

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

Add public Vimeo video or player URLs. Results include direct media links and source-backed video details when Vimeo exposes them.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://vimeo.com/1202208321"
    },
    {
      "url": "https://vimeo.com/1146062919"
    },
    {
      "url": "https://vimeo.com/1145693535"
    },
    {
      "url": "https://vimeo.com/1134664351"
    },
    {
      "url": "https://vimeo.com/1133654544"
    }
  ]
}
```

# Actor output Schema

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

Open successful Vimeo video rows with metadata, available formats, and direct media links.

# 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://vimeo.com/1202208321"
        },
        {
            "url": "https://vimeo.com/1146062919"
        },
        {
            "url": "https://vimeo.com/1145693535"
        },
        {
            "url": "https://vimeo.com/1134664351"
        },
        {
            "url": "https://vimeo.com/1133654544"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("maximedupre/vimeo-video-downloader").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://vimeo.com/1202208321" },
        { "url": "https://vimeo.com/1146062919" },
        { "url": "https://vimeo.com/1145693535" },
        { "url": "https://vimeo.com/1134664351" },
        { "url": "https://vimeo.com/1133654544" },
    ] }

# Run the Actor and wait for it to finish
run = client.actor("maximedupre/vimeo-video-downloader").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://vimeo.com/1202208321"
    },
    {
      "url": "https://vimeo.com/1146062919"
    },
    {
      "url": "https://vimeo.com/1145693535"
    },
    {
      "url": "https://vimeo.com/1134664351"
    },
    {
      "url": "https://vimeo.com/1133654544"
    }
  ]
}' |
apify call maximedupre/vimeo-video-downloader --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Vimeo Video Downloader",
        "description": "Get direct media links and metadata from public Vimeo video URLs. Export video IDs, titles, creators, thumbnails, formats, audio links, and expiry hints.",
        "version": "0.1",
        "x-build-id": "p8kxq958dynbPufz4"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/maximedupre~vimeo-video-downloader/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-maximedupre-vimeo-video-downloader",
                "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/maximedupre~vimeo-video-downloader/runs": {
            "post": {
                "operationId": "runs-sync-maximedupre-vimeo-video-downloader",
                "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/maximedupre~vimeo-video-downloader/run-sync": {
            "post": {
                "operationId": "run-sync-maximedupre-vimeo-video-downloader",
                "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": "Vimeo video URLs",
                        "minItems": 1,
                        "maxItems": 100,
                        "type": "array",
                        "description": "Add public Vimeo video or player URLs. Results include direct media links and source-backed video details when Vimeo exposes them.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```