# VK Clips Scraper (`automation-lab/vk-clips-scraper`) Actor

Extract public VK Clips, creator metadata, captions, engagement, thumbnails, and optional temporary media links for short-video trend monitoring.

- **URL**: https://apify.com/automation-lab/vk-clips-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Videos
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

## VK Clips Scraper

Collect public **VK Clips** for short-video trend monitoring without a VK login.
The Actor discovers clips from VK's public recommendation feed or refreshes
specific public clip URLs, then saves creator metadata, captions, engagement,
thumbnails, and optional temporary media links as structured dataset records.

Use it to replace manual clip checking with repeatable Apify runs that can be
scheduled, compared, exported, or connected to a data pipeline.

### What VK Clips Scraper does

The Actor supports two focused workflows:

1. **Recommended feed discovery** — collect current public clips from VK's
   recommendation surface and paginate until the requested limit or page cap.
2. **Specific clip refreshes** — submit known `vk.com/clip...` or
   `vk.com/video...` URLs and refresh their public metadata and engagement.

Both modes use VK's anonymous public video data surface. No VK username,
password, access token, or account cookie is required.

The Actor does not download video files. When enabled, it returns the temporary
public MP4 and HLS links supplied by VK so downstream systems can decide how to
use them responsibly.

### Who is it for

- Social media analysts comparing current short-video formats and creators
- Brand and agency teams tracking visible engagement on known clips
- Researchers archiving public metadata snapshots for longitudinal analysis
- Editors and trend scouts discovering high-engagement public clips
- Data engineers feeding VK short-video records into spreadsheets or warehouses
- Automation teams scheduling recurring runs and diffing datasets

Choose [VK Posts Scraper](https://apify.com/automation-lab/vk-posts-scraper)
when you need wall posts and attachments rather than the Clips surface.

### Why use this Actor

- **Clip-specific output:** only VK records identified as public short videos are saved.
- **Discovery and refresh:** use a feed for exploration or exact URLs for tracking.
- **Engagement filters:** filter on views, likes, comments, and reposts before saving.
- **Typed records:** stable IDs and normalized dates are ready for downstream use.
- **Low overhead:** HTTP API requests are used instead of launching a browser.
- **No media transfer:** thumbnails and video files are not downloaded by the Actor.
- **Apify-native:** run manually, on a schedule, by API, or through MCP.

### Data you can extract

| Field | Meaning |
| --- | --- |
| `clipId` | Stable VK identifier in `owner_id_clip_id` form |
| `clipUrl` | Canonical public `vk.com/clip...` URL |
| `ownerId` | VK owner ID; negative IDs represent communities |
| `authorName` | Public creator or community name |
| `authorHandle` | Public VK screen name when available |
| `authorUrl` | Public creator or community URL |
| `authorFollowers` | Public follower or member count when returned |
| `authorAvatarUrl` | Public profile image URL |
| `title` | VK's public clip title |
| `caption` | Public description or caption |
| `publishedAt` | ISO 8601 publication timestamp |
| `durationSeconds` | Clip duration |
| `width`, `height` | Source video dimensions |
| `views` | Public view count at scrape time |
| `likes` | Public like count at scrape time |
| `comments` | Public comment count at scrape time |
| `reposts` | Public repost count at scrape time |
| `thumbnailUrl` | Largest public preview returned by VK |
| `mediaUrls` | Optional temporary MP4/HLS URLs |
| `sourceMode` | `recommended` or `clips` |
| `scrapedAt` | ISO 8601 collection timestamp |

Some optional fields can be absent when VK does not expose them for a clip.

### Getting started

1. Open the Actor input page.
2. Select **Recommended feed** or **Specific clip URLs**.
3. Set `maxItems` to the number of accepted records you need.
4. For URL mode, add one or more public VK Clip URLs.
5. Optionally set minimum engagement thresholds.
6. Keep **Include public media URLs** enabled only when you need signed links.
7. Click **Start**.
8. Open the default dataset or export it as JSON, CSV, Excel, or XML.

A first discovery test with 10 items is usually enough to inspect the schema.

### Input parameters

| Input | Type | Default | Description |
| --- | --- | --- | --- |
| `mode` | string | `recommended` | Recommendation discovery or exact URL refresh |
| `clipUrls` | array | sample public clip | Required in `clips` mode; maximum 500 URLs |
| `maxItems` | integer | 25 | Maximum records saved after filters, 1–500 |
| `maxPages` | integer | 10 | Recommendation pages scanned, 1–50 |
| `minViews` | integer | 0 | Minimum public views |
| `minLikes` | integer | 0 | Minimum public likes |
| `minComments` | integer | 0 | Minimum public comments |
| `minReposts` | integer | 0 | Minimum public reposts |
| `includeMediaUrls` | boolean | true | Include temporary signed media links |
| `proxyConfiguration` | object | direct | Optional Apify Proxy configuration |

`maxPages` is a scan safety limit, not a promise of that many result pages.
Filters can produce fewer records than `maxItems` when the scanned feed does
not contain enough matching clips.

### Recommended feed example

```json
{
  "mode": "recommended",
  "maxItems": 10,
  "maxPages": 3,
  "includeMediaUrls": true
}
```

This input discovers up to 10 current public records and includes the signed
media links VK returns with each clip.

### Specific clip example

```json
{
  "mode": "clips",
  "clipUrls": [
    { "url": "https://vk.com/clip-234902882_456239861" }
  ],
  "maxItems": 1,
  "includeMediaUrls": true
}
```

Use this mode in a scheduled task to collect repeated engagement snapshots for
a stable list of public clip URLs.

### High-engagement monitoring example

```json
{
  "mode": "recommended",
  "maxItems": 20,
  "maxPages": 10,
  "minViews": 10000,
  "minLikes": 100,
  "includeMediaUrls": false
}
```

This workflow scans more recommendation pages while saving only clips that meet
both thresholds. Schedule it daily or weekly, then compare datasets by `clipId`.

### Output example

A current explicit-URL test produced a record shaped like this:

```json
{
  "clipId": "-234902882_456239861",
  "clipUrl": "https://vk.com/clip-234902882_456239861",
  "ownerId": -234902882,
  "authorName": "ФИЛЬМАБОЙСЫ",
  "authorHandle": "filmaboysi",
  "authorUrl": "https://vk.com/filmaboysi",
  "title": "Клип @filmaboysi",
  "durationSeconds": 72,
  "width": 720,
  "height": 960,
  "views": 544390,
  "likes": 47139,
  "comments": 141,
  "reposts": 2366,
  "thumbnailUrl": "https://i.mycdn.me/videoPreview?...",
  "sourceMode": "clips",
  "scrapedAt": "2026-07-30T07:50:00.000Z"
}
```

Counts naturally change over time. Signed URLs and token-like query parameters
in media links are omitted from this documentation example.

### How much does it cost to monitor VK Clips?

The Actor uses pay per event pricing:

- **Start:** $0.030 per run
- **VK Clip saved:** the BRONZE tier is $0.003192 per dataset record
- Higher-volume subscription tiers receive a lower per-record price
- Rejected, duplicate, filtered, unavailable, or failed records are not charged

Example BRONZE totals:

| Saved clips | Estimated Actor charge |
| ---: | ---: |
| 1 | $0.033192 |
| 10 | $0.061920 |
| 25 | $0.109800 |
| 100 | $0.349200 |

Apify platform usage and proxy usage can be billed separately according to your
Apify plan. Direct access is the default, so no proxy transfer is required for
the normal public API path.

### Scheduling trend monitoring

Create an Apify Schedule with the high-engagement input and a daily or weekly
interval. Keep each run's dataset, then join records by `clipId` to calculate:

- view growth since the previous run
- like, comment, and repost growth
- newly observed recommendation-feed clips
- creators appearing repeatedly in accepted results
- changes to captions or public metadata

Recommendation feeds are dynamic and can vary between runs. Treat them as
samples of the currently returned public feed, not as a complete historical
index of all VK Clips.

### Export and integration patterns

The default dataset works with Apify's built-in JSON, CSV, Excel, XML, RSS, and
JSONL exports. Common workflows include:

- send new records to Google Sheets after a scheduled run
- load snapshots into BigQuery, Snowflake, or PostgreSQL
- trigger a webhook when a run succeeds
- compare `views`, `likes`, `comments`, and `reposts` by stable `clipId`
- use `authorHandle` to group trends by public creator
- keep `includeMediaUrls` false when only analytics fields are needed

The Actor saves one primary entity type, so all clip records stay in the default
dataset for compatibility with integrations.

### Run with the Apify API

Replace `APIFY_TOKEN` with your Apify API token.

#### cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~vk-clips-scraper/runs?token=APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"mode":"recommended","maxItems":10,"maxPages":3}'
```

#### JavaScript

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/vk-clips-scraper').call({
  mode: 'recommended',
  maxItems: 10,
  maxPages: 3,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/vk-clips-scraper').call(run_input={
    'mode': 'clips',
    'clipUrls': [{'url': 'https://vk.com/clip-234902882_456239861'}],
    'maxItems': 1,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### Use with MCP and AI agents

Add the Apify MCP server to Claude Code:

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/vk-clips-scraper"
```

#### Claude Desktop, Cursor, and VS Code

Claude Desktop, Cursor, and VS Code can use this equivalent configuration:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/vk-clips-scraper"
    }
  }
}
```

#### Example prompts

Example prompts showing MCP usage include:

- "Collect 10 current VK Clips and rank them by public views."
- "Refresh this VK Clip URL and summarize its engagement counts."
- "Run a high-engagement VK Clips scan and export the dataset as CSV."

### Reliability and retries

The Actor retries transient HTTP failures twice. Token acquisition and data
calls share one network identity, including one sticky session when proxy use is
enabled. Deterministic invalid inputs fail immediately rather than wasting
requests.

If VK returns no clips for a valid filtered discovery input, the run succeeds
with an empty dataset. If token acquisition or the public API fails, the run
fails visibly so a schedule or webhook can react.

### Limitations

- Only public, anonymously accessible VK short-video records are supported.
- Private, deleted, restricted, or unavailable clips are not bypassed.
- Recommendation results are dynamic, personalized anonymously, and not exhaustive.
- Exact URL mode accepts URLs containing a VK owner ID and clip/video ID.
- Engagement counts are point-in-time values and can change after collection.
- Public signed MP4/HLS URLs expire and should be refreshed by rerunning.
- The Actor does not download, transcode, caption, or permanently host media.
- Author follower/member counts can be absent when VK omits them.
- `maxPages` bounds feed scanning; strict filters can return fewer than `maxItems`.

### Proxy guidance

Direct access is the tested default and has the lowest transfer cost. If your
network cannot reach VK, configure Apify Proxy in the input. The Actor keeps the
token and API requests on one sticky proxy identity.

Use residential proxy groups only when your use case requires them. A local
Russian residential-proxy validation returned a correct explicit clip record,
but residential transfer is paid infrastructure and is not enabled
automatically.

### Legality and responsible use

Collect only public information you are authorized to process. Follow VK's
terms, Apify's policies, applicable copyright rules, privacy law, and your own
organization's retention requirements.

A public media URL does not transfer ownership or grant redistribution rights.
Do not use this Actor to republish videos without permission, evade access
controls, profile sensitive individuals, or make solely automated decisions
about people.

### Troubleshooting

**The run says clip URLs are required.**

You selected `clips` mode without adding `clipUrls`. Add at least one public
`vk.com/clip...` or compatible `vk.com/video...` URL.

**A URL is rejected as invalid.**

Confirm it belongs to VK and contains both owner and clip IDs, for example
`clip-234902882_456239861`.

**The dataset has fewer records than `maxItems`.**

The feed may have ended, repeated clips may have been deduplicated, or your
engagement filters rejected records. Increase `maxPages` or relax filters.

**Media links no longer open.**

They are temporary signed links returned by VK. Rerun the Actor to obtain fresh
links, or disable `includeMediaUrls` for metadata-only workflows.

**A scheduled run fails upstream.**

Inspect the run log for a VK API or network error. Retry later, or enable an
appropriate Apify Proxy configuration if your execution network is restricted.

### FAQ

#### Does it require a VK account?

No. It uses VK's anonymous public video data flow and does not accept account
credentials.

#### Can it search by keyword?

No. This Actor covers the current recommendation feed and exact public clip URL
refreshes. It does not claim keyword search.

#### Does it scrape ordinary VK posts?

No. Use [VK Posts Scraper](https://apify.com/automation-lab/vk-posts-scraper)
for wall posts and their attachments.

#### Are video files included in the dataset?

No binary files are downloaded. Optional `mediaUrls` contains temporary public
links returned by VK.

#### Can I track growth over time?

Yes. Schedule repeat runs, retain each dataset, and compare records by `clipId`.
The Actor outputs snapshots; it does not maintain a private historical database.

#### Why did a known clip return no record?

It may be deleted, private, restricted, unavailable anonymously, or no longer
identified by VK as a short-video record. The Actor does not bypass restrictions.

### Related Automation Labs Actors

- [VK Posts Scraper](https://apify.com/automation-lab/vk-posts-scraper) — collect public VK wall posts and attachments
- [VK Video Search Scraper](https://apify.com/automation-lab/vk-video-search-scraper) — discover ordinary VK Video search results

Use VK Clips Scraper when the buyer job is specifically public short-video
discovery, clip-level engagement monitoring, or exact clip refreshes.

# Actor input Schema

## `mode` (type: `string`):

Use Recommended feed to discover current public clips, or Specific clip URLs to refresh known clips.

## `clipUrls` (type: `array`):

Public vk.com/clip... or vk.com/video... URLs. Required only in Specific clip URLs mode; maximum 500.

## `maxItems` (type: `integer`):

Maximum accepted clip records to save after filters are applied.

## `maxPages` (type: `integer`):

Safety limit for recommendation pages scanned while finding clips that pass filters. Each page contains up to 10 clips.

## `minViews` (type: `integer`):

Keep clips with at least this many public views.

## `minLikes` (type: `integer`):

Keep clips with at least this many public likes.

## `minComments` (type: `integer`):

Keep clips with at least this many public comments.

## `minReposts` (type: `integer`):

Keep clips with at least this many public reposts.

## `includeMediaUrls` (type: `boolean`):

Include temporary public MP4/HLS URLs returned by VK. These signed URLs expire; rerun the Actor to refresh them.

## `proxyConfiguration` (type: `object`):

Optional Apify Proxy settings. Direct access is the default; keep a sticky session when enabling a proxy.

## Actor input object example

```json
{
  "mode": "recommended",
  "clipUrls": [
    {
      "url": "https://vk.com/clip-234902882_456239861"
    }
  ],
  "maxItems": 10,
  "maxPages": 10,
  "minViews": 0,
  "minLikes": 0,
  "minComments": 0,
  "minReposts": 0,
  "includeMediaUrls": true,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

Open the default dataset in the VK Clips overview view.

# 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 = {
    "mode": "recommended",
    "clipUrls": [
        {
            "url": "https://vk.com/clip-234902882_456239861"
        }
    ],
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/vk-clips-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 = {
    "mode": "recommended",
    "clipUrls": [{ "url": "https://vk.com/clip-234902882_456239861" }],
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/vk-clips-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 '{
  "mode": "recommended",
  "clipUrls": [
    {
      "url": "https://vk.com/clip-234902882_456239861"
    }
  ],
  "maxItems": 10
}' |
apify call automation-lab/vk-clips-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/lQmyLfrobakYyCDzq/builds/JR5D3IwwjcACtG6yv/openapi.json