# Vimeo Video Downloader (`alpha-scraper/vimeo-video-downloader`) Actor Vimeo Video Downloader extracts public Vimeo video metadata and downloadable video links from one or multiple Vimeo URLs. Collect titles, creators, descriptions, thumbnails, upload dates, resolutions, durations, and more in a structured Apify dataset. - **URL**: https://apify.com/alpha-scraper/vimeo-video-downloader.md - **Developed by:** [Alpha Scraper](https://apify.com/alpha-scraper) (community) - **Categories:** Videos, Social media, Other - **Stats:** 4 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks - **User rating**: No ratings yet ## Pricing from $1.50 / 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. Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have. Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event ## What's an Apify Actor? An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes. In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours, and optionally produces a well-defined JSON output, datasets with results, or files in key-value store. In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server. Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md. ## How to integrate an Actor? If asked about integration, you help developers integrate Actors into their projects. You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready. Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run. For examples already wired to this Actor's own input schema, see the [API](#api) section below. Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`). # README ### Vimeo Video Downloader The **Vimeo Video Downloader** is an Apify Actor for extracting public Vimeo video information and a direct downloadable video URL from one or multiple Vimeo video pages. It is designed for users who need structured video metadata and a video-only stream link for research, content analysis, data collection, or automated workflows. Provide one or more Vimeo video URLs through the `startUrls` input, optionally configure the available Apify or custom proxy settings, and run the Actor. Each successfully processed URL produces a structured dataset record containing the original page URL, video title, uploader/channel, duration, resolution, thumbnail, upload date, likes, description, and a downloadable video link when one is available. The Actor focuses on **public Vimeo video data** and uses the URL supplied by the user as the starting point. Results are written individually to the Apify dataset, making them convenient to inspect and use in downstream data workflows. ### What Is a Vimeo Video Downloader? A **Vimeo Video Downloader** is a data extraction tool that processes public Vimeo video URLs and returns useful video metadata together with a direct downloadable video stream URL when the source provides a suitable video-only format. Instead of manually opening every Vimeo page and recording information one by one, users can submit multiple URLs to the Actor and receive structured records in the dataset. This makes the workflow useful for repetitive video research, catalog creation, metadata collection, and automated processing. The Actor does not document a separate audio-download result. Its current output specifically provides a `downloadable_video_link`, and that field is intended for the best available video-only format identified from the processed Vimeo page. ### Key Features | **Feature** | **Description** | **User Benefit** | | --------------------------- | -------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------- | | Public Vimeo URL processing | Accepts one or multiple Vimeo video URLs through `startUrls`. | Process several video pages in one run. | | Video metadata extraction | Returns title, uploader, duration, resolution, thumbnail, upload date, likes, and description where available. | Keep important Vimeo information in structured records. | | Downloadable video URL | Extracts a suitable video-only stream URL when available. | Provides a direct link that can be used in supported downstream workflows. | | Structured dataset output | Each processed video is pushed as an individual result. | Makes collected data easier to inspect and analyze. | | Proxy configuration | Supports the configured Apify/custom proxy input through `proxyConfiguration`. | Gives users configuration flexibility for supported network environments. | | Automatic date formatting | Upload dates in `YYYYMMDD` form are returned as `YYYY-MM-DD`. | Provides a more readable date representation. | ### What Data Can You Extract? The Vimeo Video Downloader returns a practical set of fields for each successfully processed video. The available information is based on the data exposed for the supplied public Vimeo URL. Typical result categories include: - **Video identity:** original Vimeo URL and video title. - **Creator information:** uploader or channel name. - **Playback information:** duration and provided resolution. - **Visual metadata:** thumbnail URL. - **Publication information:** upload date when supplied by the source. - **Engagement information:** like count when available. - **Content information:** video description. - **Download information:** a downloadable video URL for the selected video-only format when available. Some fields may be `null` when the source does not provide the corresponding information. ### Why Use the Vimeo Video Downloader? Manual Vimeo research can become repetitive when a project involves many public video pages. This Actor converts the process into a structured, repeatable workflow where URLs are provided as input and records are collected into an Apify dataset. The main practical advantages are automation and organization. Instead of manually copying metadata from page after page, users can submit multiple Vimeo links and receive consistent fields for each successful result. The Actor can also be useful when the immediate goal is not simply metadata collection. A downloadable video URL can be valuable for workflows that need to identify and process an available video stream after collecting the associated metadata. ### Benefits Using this Vimeo video extraction workflow can support several practical tasks: - **Automated collection:** Reduce repetitive manual copying from Vimeo pages. - **Structured research:** Keep video metadata in predictable dataset fields. - **Batch processing:** Submit multiple video URLs in one run. - **Content analysis:** Combine descriptions, titles, dates, and creator information for analysis. - **Dataset creation:** Build organized collections of public Vimeo video records. - **Workflow preparation:** Pass collected metadata and available video URLs into later processing steps. - **Quality review:** Compare metadata and source URLs before using results downstream. The Actor is most useful when the same collection process needs to be repeated across multiple public Vimeo videos. ### How to Use the Vimeo Video Downloader The workflow is straightforward: 1. Add one or more Vimeo video URLs to the `startUrls` field. 2. Review the optional proxy configuration if your environment requires it. 3. Start the Actor. 4. Let the Actor process each supplied URL. 5. Review the resulting records in the Apify dataset. 6. Use the extracted metadata and available `downloadable_video_link` values in your research or automation workflow. For initial testing, use a small number of public Vimeo URLs so you can confirm that the returned fields match your intended workflow before processing a larger set. ### Input The Actor requires the `startUrls` field. A `proxyConfiguration` object is also supported as an optional configuration input. | **Field** | **Type** | **Required** | **Default** | **Description** | | -------------------- | -------- | ------------ | -------------------------------------------------------------- | ------------------------------------------------- | | `startUrls` | Array | Yes | None | One or more Vimeo video URL objects to process. | | `proxyConfiguration` | Object | No | Apify proxy configuration when provided by the Actor interface | Proxy settings used by the Actor when configured. | Each item in `startUrls` is expected to contain a `url` value representing a Vimeo video page. ### Input Example ```json { "startUrls": [ { "url": "https://vimeo.com/1150530803" }, { "url": "https://vimeo.com/929824958" } ], "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": [] } } ``` Only supported Vimeo video URLs should be supplied. URLs that do not contain a usable `url` value are skipped by the Actor. ### Output Each successfully processed Vimeo video is stored as a separate dataset item. The result contains metadata associated with the processed page and the best available video-only stream selected by the Actor. The output is designed to be easy to read and reuse in data analysis or automation workflows. | **Field** | **Description** | | ------------------------- | ---------------------------------------------------------------------------- | | `original_url` | The Vimeo URL supplied for processing. | | `title` | The video title when available. | | `channel` | The uploader or channel name returned by the source. | | `duration` | Video duration formatted in seconds, such as `64s`. | | `provided_resolution` | Video height expressed as a resolution such as `1080p`, when available. | | `thumbnail` | Thumbnail URL returned for the video. | | `upload_date` | Upload date formatted as `YYYY-MM-DD` when available. | | `like_count` | Like count returned by the source, when available. | | `description` | Video description when available. | | `downloadable_video_link` | URL for the selected video-only stream, when a suitable format is available. | A field can contain `null` when information is not available for a particular video. ### Output Example ```json { "original_url": "https://vimeo.com/1150530803", "title": "Example Vimeo Video", "channel": "Example Creator", "duration": "64s", "provided_resolution": "1080p", "thumbnail": "https://i.vimeocdn.com/video/example-thumbnail.jpg", "upload_date": "2026-03-15", "like_count": 125, "description": "Example description for a public Vimeo video.", "downloadable_video_link": "https://example.com/video-stream" } ``` The example values are illustrative. Actual metadata and stream URLs depend on the supplied Vimeo video and the information available for that source. ### Use Cases The Vimeo Video Downloader can support several user-facing workflows involving public Vimeo video pages: - **Video research:** Collect titles, descriptions, creators, dates, and other metadata for research projects. - **Content cataloging:** Build a structured Vimeo video inventory with source URLs and thumbnails. - **Competitive or market research:** Organize publicly available video content for analysis. - **Dataset creation:** Create repeatable collections of Vimeo metadata in an Apify dataset. - **Content analysis:** Study video topics, descriptions, upload timing, or creator information. - **Media workflows:** Collect available video-only stream URLs for later processing where appropriate. - **Automation:** Integrate repeated Vimeo URL processing into a broader data collection workflow. Use cases should remain consistent with applicable laws, website terms, copyright requirements, and the rights associated with the content being processed. ### Advantages The Actor combines metadata collection and downloadable video-link extraction in one structured workflow. This can be useful when a project needs both descriptive information and a usable video stream reference for each public Vimeo URL. Because each result is stored separately, users can review records individually and work with a consistent schema instead of maintaining their own manually formatted notes. The input design also keeps the basic workflow simple: provide Vimeo URLs, configure optional proxy settings where appropriate, and start the run. ### Pros and Cons | **Pros** | **Cons** | | ------------------------------------------------------------------------ | ----------------------------------------------------------------------------------- | | Supports one or multiple Vimeo video URLs. | Only publicly accessible video pages are within the documented scope. | | Returns useful video metadata in structured fields. | Some fields may be unavailable or `null` for specific videos. | | Provides a video-only downloadable link when a suitable format is found. | The Actor does not expose a separate audio-download field. | | Stores results directly in an Apify dataset. | A supplied URL can fail to produce a result if it cannot be processed successfully. | | Supports configurable proxy input. | Returned stream URLs may depend on the source format available at processing time. | ### Comparison With Alternative Approaches | **Capability** | **This Actor** | **Manual / Typical Alternative** | | ----------------------- | ----------------------------------------------------- | ------------------------------------------------------------- | | Multiple URL processing | Supported through `startUrls`. | Often requires opening and recording pages individually. | | Structured metadata | Returns defined dataset fields. | May require manual copying and formatting. | | Downloadable video link | Attempts to provide a suitable video-only stream URL. | Usually requires additional manual inspection or tooling. | | Repeatable workflow | Can be run again with new input URLs. | Repetitive manual collection is harder to standardize. | | Dataset-ready results | Each result is pushed as a separate dataset item. | Manual work may need additional organization before analysis. | This comparison describes workflow differences rather than claiming universal superiority over every alternative. ### Limitations The Actor is intended for public Vimeo video pages and does not document support for private, restricted, or otherwise inaccessible content. A result may contain missing values when the source does not expose particular metadata. For example, `like_count`, `description`, thumbnail information, or resolution may not be available for every page. The `downloadable_video_link` field can also be `null` when a suitable video-only format is not found. The output therefore should not be treated as a guarantee that every Vimeo URL will produce a downloadable stream. The Actor logs processing errors for individual URLs rather than documenting a guaranteed successful result for every supplied input. ### Best Practices For reliable user workflows: - Start with a small number of public Vimeo URLs and inspect the dataset before scaling up. - Use complete, valid Vimeo video URLs in `startUrls`. - Review optional proxy configuration before processing a larger group of URLs. - Treat missing fields as expected possibilities rather than assuming every video exposes identical metadata. - Validate important metadata before using it in business, research, or publishing workflows. - Store or process downloadable stream URLs according to the applicable rights and permissions for the video content. ### Troubleshooting **Invalid Input** Check that `startUrls` is an array and that each item contains a valid `url` value. Remove empty objects or malformed entries before running the Actor. **Empty Results** Verify that the supplied pages are public Vimeo video URLs and can be accessed in the intended environment. Testing with a known public video can help isolate an input-specific issue. **Partial Results** Different Vimeo pages can expose different metadata. A successful record may therefore contain some fields while others are `null`. **Missing Downloadable Video Link** The `downloadable_video_link` field is populated only when a suitable video-only format is identified. A missing value does not necessarily mean the metadata extraction failed. **Temporary Processing Failure** Review the Actor run logs and retry with the affected URL. Confirm that the URL is still valid and publicly accessible before repeating larger jobs. ### Frequently Asked Questions **What does the Vimeo Video Downloader do?** It processes public Vimeo video URLs and returns structured metadata plus a downloadable video-only stream URL when a suitable format is available. **What input does the Vimeo Video Downloader accept?** The required input is `startUrls`, an array containing one or more Vimeo video URL objects. An optional `proxyConfiguration` object is also supported. **Can I process multiple Vimeo videos in one run?** Yes. `startUrls` is an array, so you can provide multiple Vimeo video URLs for processing in the same Actor run. **What data does the Vimeo Video Downloader return?** Results can include the original URL, title, uploader/channel, duration, resolution, thumbnail, upload date, like count, description, and downloadable video link. **Does it download audio separately?** The documented output does not include a separate audio-download field. The Actor specifically returns a `downloadable_video_link` for a video-only format when available. **What happens when metadata is unavailable?** Fields that are not available for a specific Vimeo page can be returned as `null`. Metadata availability can vary between videos. **Does every Vimeo URL produce a downloadable video link?** No. The Actor attempts to identify a suitable video-only format, but the `downloadable_video_link` can be `null` when no appropriate format is available. **Can the Actor be used for automation?** Yes. Its structured input and dataset output make it suitable for repeatable Vimeo data collection workflows and downstream processing. **How should I test the Actor?** Begin with one or a few public Vimeo video URLs, run the Actor, and inspect the returned dataset records before expanding the input. **Should I verify the extracted data?** Yes. Important business or research datasets should be reviewed and validated, particularly when fields are important for decisions or downstream processing. ### NLP Keywords - Vimeo video extraction - Vimeo video metadata - Vimeo public video data - Vimeo video URL extraction - Vimeo video information - Vimeo creator data - Vimeo uploader information - Vimeo video resolution - Vimeo video duration - Vimeo thumbnail extraction - Vimeo upload date - Vimeo like count - Vimeo video description - Vimeo downloadable video link - Vimeo video stream URL - public Vimeo scraper - Vimeo data collection - Vimeo dataset - structured Vimeo data - Vimeo video research ### Related Keywords - Vimeo video downloader online workflow - download video from Vimeo URL - Vimeo video metadata scraper - extract Vimeo video details - Vimeo public video scraper - Vimeo video URL scraper - Vimeo video information extractor - Vimeo content data extraction - Vimeo video dataset creator - Vimeo video research tool - scrape public Vimeo videos - Vimeo video stream extractor - extract Vimeo thumbnail URL - Vimeo uploader data extraction - Vimeo video description scraper - Vimeo upload date extractor - Vimeo resolution data extractor - Vimeo video link extractor - automated Vimeo data collection - structured Vimeo video data ### Final Overview The **Vimeo Video Downloader** provides a structured way to process public Vimeo video URLs and collect useful video information in an Apify dataset. It supports one or multiple input URLs, returns practical metadata, and attempts to provide a downloadable video-only stream URL when a suitable format is available. For best results, begin with a small set of valid public Vimeo URLs, review the returned records, and then incorporate the Actor into larger research, media-processing, or automated data-collection workflows as appropriate. **Contact me:** # Actor input Schema ## `startUrls` (type: `array`): List of one or more Vimeo video URLs ## `proxyConfiguration` (type: `object`): Apify proxy / custom proxy configuration used by the actor. ## Actor input object example ```json { "startUrls": [ { "url": "https://vimeo.com/1150530803?fl=pl&fe=sh" }, { "url": "https://vimeo.com/929824958?autoplay=1&muted=1&stream_id=Y2hhbm5lbHw5Mjd8aWQ6ZGVzY3x7InJlbW92ZV92b2RfdGl0bGVzIjpmYWxzZX0%3D" } ], "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": [] } } ``` # Actor output Schema ## `dataset` (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 '' with your token const client = new ApifyClient({ token: '', }); // Prepare Actor input const input = { "startUrls": [ { "url": "https://vimeo.com/1150530803?fl=pl&fe=sh" }, { "url": "https://vimeo.com/929824958?autoplay=1&muted=1&stream_id=Y2hhbm5lbHw5Mjd8aWQ6ZGVzY3x7InJlbW92ZV92b2RfdGl0bGVzIjpmYWxzZX0%3D" } ], "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": [] } }; // Run the Actor and wait for it to finish const run = await client.actor("alpha-scraper/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 '' with your token. client = ApifyClient("") # Prepare the Actor input run_input = { "startUrls": [ { "url": "https://vimeo.com/1150530803?fl=pl&fe=sh" }, { "url": "https://vimeo.com/929824958?autoplay=1&muted=1&stream_id=Y2hhbm5lbHw5Mjd8aWQ6ZGVzY3x7InJlbW92ZV92b2RfdGl0bGVzIjpmYWxzZX0%3D" }, ], "proxyConfiguration": { "useApifyProxy": True, "apifyProxyGroups": [], }, } # Run the Actor and wait for it to finish run = client.actor("alpha-scraper/vimeo-video-downloader").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 '{ "startUrls": [ { "url": "https://vimeo.com/1150530803?fl=pl&fe=sh" }, { "url": "https://vimeo.com/929824958?autoplay=1&muted=1&stream_id=Y2hhbm5lbHw5Mjd8aWQ6ZGVzY3x7InJlbW92ZV92b2RfdGl0bGVzIjpmYWxzZX0%3D" } ], "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": [] } }' | apify call alpha-scraper/vimeo-video-downloader --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "type": "http", "url": "https://mcp.apify.com/?tools=fetch-actor-details,alpha-scraper/vimeo-video-downloader" } } } ``` 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 ` 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/L3JNk0g1zf3kTmubr/builds/HXUer7WXjWFX7cViq/openapi.json