# Vimeo Scraper (`goat255/vimeo-scraper`) Actor

Scrape Vimeo videos and channels without a login. Pull metadata for any video by URL or id, or a user's public uploads by username. Walks pagination up to your chosen limit.

- **URL**: https://apify.com/goat255/vimeo-scraper.md
- **Developed by:** [Goutam Soni](https://apify.com/goat255) (community)
- **Categories:** Social media, Videos, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.50 / 1,000 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 Scraper

Scrape Vimeo videos and channels without a login or API key. Extract video metadata by URL or id, and pull a user's public uploads by username, returned as clean structured rows ready for export to JSON, CSV, or Excel.

### What it does

- **Video metadata** from any Vimeo video URL or numeric id: title, description, owner, tags, thumbnail, duration, resolution, frame rate, upload date, and privacy.
- **Channel uploads** by username: a user's most recent public videos, each as its own structured row.
- **Profile details** (optional): one profile header row per user with display name, bio, location, portrait, and video, follower, and like counts.
- **Automatic pagination** across a user's public listing up to the limit you set.
- **Bulk input**: pass many video URLs and many usernames in a single run, processed in parallel.
- **No login, no password, no API key.** Give it links or usernames and it returns data.

### Use cases

- **Content research and curation**: collect titles, descriptions, durations, and thumbnails across creators to build a video catalog or content calendar.
- **Market and competitor research**: track which videos a channel publishes, how long they run, and how they are described.
- **Lead generation**: pull creator profiles with follower and upload counts to size and prioritize outreach lists.
- **Media monitoring**: snapshot a channel's public uploads on a schedule to detect new releases.
- **Dataset building**: assemble a normalized video dataset (owner, tags, dimensions, upload date) for analysis or machine learning.

### Input

| Field | Type | Description |
|---|---|---|
| `videoUrls` | array | Vimeo video links or numeric ids to fetch metadata for. Accepts `https://vimeo.com/76979871` or a bare `76979871`. |
| `users` | array | Vimeo usernames to pull public uploads from. Accepts a username or a full profile link (`example_user` or `https://vimeo.com/example_user`). |
| `maxVideosPerUser` | integer | Cap on videos returned per user (1 to 60). Pagination is walked across pages until this is reached or the user's public listing is exhausted. Default 60. |
| `includeProfile` | boolean | When on, each user also emits one profile header row (display name, bio, counts) before its videos. Default on. |
| `concurrency` | integer | How many sources to process in parallel (1 to 20). Default 5. |
| `proxyConfig` | object | Optional proxy. The public source does not require a proxy, so this is off by default. |

#### Example input

```json
{
  "videoUrls": ["https://vimeo.com/76979871"],
  "users": ["example_user"],
  "maxVideosPerUser": 60,
  "includeProfile": true,
  "concurrency": 5
}
````

### Output

Each video is one row. Example video row:

```json
{
  "type": "video",
  "id": "76979871",
  "url": "https://vimeo.com/76979871",
  "ownerName": "Example User",
  "ownerUrl": "https://vimeo.com/example_user",
  "ownerId": "152184",
  "title": "An example video",
  "description": "An example description.",
  "tags": ["example", "demo"],
  "thumbnail": "https://example.com/thumb.jpg",
  "duration": 62,
  "width": 1920,
  "height": 1080,
  "fps": 24,
  "uploadDate": "2026-06-01 12:00:00",
  "privacy": "anybody",
  "scrapedAt": "2026-06-18T00:00:00.000Z"
}
```

When `includeProfile` is on, each user also produces one profile row:

```json
{
  "type": "profile",
  "id": "152184",
  "url": "https://vimeo.com/example_user",
  "username": "example_user",
  "displayName": "Example User",
  "videosCount": 811,
  "followersCount": 113,
  "likesCount": 1298,
  "bio": "An example bio.",
  "location": "Anytown",
  "portrait": "https://example.com/portrait.jpg",
  "scrapedAt": "2026-06-18T00:00:00.000Z"
}
```

**Key fields:** `type` tells a `video` row from a `profile` row. `id` and `url` are the stable identity of each item. `ownerName` / `ownerUrl` identify the creator. `title`, `description`, and `tags` are the content. `duration` is in seconds, `width` / `height` are pixels. Fields that the source does not publish for a given item come back as `null` (or an empty array for `tags`).

### FAQ

**Is it free? How much does it cost?**
You pay only for the platform usage and the per-result charge shown on this listing. There is no separate subscription and no Vimeo account needed.

**Do I need a Vimeo login or API key?**
No. The actor reads public data only, so no account, password, or API key is required.

**How many videos can I get per user?**
The public listing exposes up to 60 of a user's most recent videos. `maxVideosPerUser` accepts 1 to 60; values above 60 return the same 60. You can scrape any number of users in one run.

**How fast is it?**
Sources are processed in parallel (`concurrency`, default 5). A single video resolves in one request, and a user's full listing in a few requests, so most runs finish in seconds to a minute depending on how many sources you pass.

**Why are some fields empty?**
Single videos looked up by URL or id and videos pulled from a channel listing expose slightly different data. For example, frame rate is available for a video looked up by URL, while description, tags, and upload date are available from a channel listing. Anything the source does not publish for a given item is returned as `null` rather than guessed.

**Can I export the results?**
Yes. Results are stored in a dataset you can download as JSON, CSV, Excel, or XML, or pull through the API.

# Actor input Schema

## `videoUrls` (type: `array`):

Vimeo video links or numeric ids to fetch metadata for. Example: https://vimeo.com/76979871, 76979871.

## `users` (type: `array`):

Vimeo usernames to pull public uploads from. A username or a full profile link. Example: staff, https://vimeo.com/staff.

## `maxVideosPerUser` (type: `integer`):

Cap on videos returned per user. Pagination is walked across multiple pages until this is reached or the user's public listing is exhausted. The public listing exposes up to 60 of a user's most recent videos, so values above 60 return the same 60.

## `includeProfile` (type: `boolean`):

When on, each user also emits one profile record (display name, bio, video and follower counts) before its videos.

## `concurrency` (type: `integer`):

How many sources to process in parallel.

## `proxyConfig` (type: `object`):

Optional proxy. The public read endpoints do not require a proxy, but you may route through one if you wish.

## Actor input object example

```json
{
  "videoUrls": [
    "https://vimeo.com/76979871"
  ],
  "users": [
    "staff"
  ],
  "maxVideosPerUser": 60,
  "includeProfile": true,
  "concurrency": 5,
  "proxyConfig": {
    "useApifyProxy": false
  }
}
```

# 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 = {
    "videoUrls": [
        "https://vimeo.com/76979871"
    ],
    "users": [
        "staff"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("goat255/vimeo-scraper").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 = {
    "videoUrls": ["https://vimeo.com/76979871"],
    "users": ["staff"],
}

# Run the Actor and wait for it to finish
run = client.actor("goat255/vimeo-scraper").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 '{
  "videoUrls": [
    "https://vimeo.com/76979871"
  ],
  "users": [
    "staff"
  ]
}' |
apify call goat255/vimeo-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Vimeo Scraper",
        "description": "Scrape Vimeo videos and channels without a login. Pull metadata for any video by URL or id, or a user's public uploads by username. Walks pagination up to your chosen limit.",
        "version": "0.1",
        "x-build-id": "XNPpmfc4pfBwFS8rV"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/goat255~vimeo-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-goat255-vimeo-scraper",
                "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/goat255~vimeo-scraper/runs": {
            "post": {
                "operationId": "runs-sync-goat255-vimeo-scraper",
                "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/goat255~vimeo-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-goat255-vimeo-scraper",
                "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",
                "properties": {
                    "videoUrls": {
                        "title": "Video URLs (video mode)",
                        "type": "array",
                        "description": "Vimeo video links or numeric ids to fetch metadata for. Example: https://vimeo.com/76979871, 76979871.",
                        "default": [
                            "https://vimeo.com/76979871"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "users": {
                        "title": "Users (channel mode)",
                        "type": "array",
                        "description": "Vimeo usernames to pull public uploads from. A username or a full profile link. Example: staff, https://vimeo.com/staff.",
                        "default": [
                            "staff"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxVideosPerUser": {
                        "title": "Max videos per user",
                        "minimum": 1,
                        "maximum": 60,
                        "type": "integer",
                        "description": "Cap on videos returned per user. Pagination is walked across multiple pages until this is reached or the user's public listing is exhausted. The public listing exposes up to 60 of a user's most recent videos, so values above 60 return the same 60.",
                        "default": 60
                    },
                    "includeProfile": {
                        "title": "Include a profile header row",
                        "type": "boolean",
                        "description": "When on, each user also emits one profile record (display name, bio, video and follower counts) before its videos.",
                        "default": true
                    },
                    "concurrency": {
                        "title": "Concurrency",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "How many sources to process in parallel.",
                        "default": 5
                    },
                    "proxyConfig": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional proxy. The public read endpoints do not require a proxy, but you may route through one if you wish.",
                        "default": {
                            "useApifyProxy": false
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
