# VK Posts Scraper (`automation-lab/vk-posts-scraper`) Actor

Scrape public VK profile and community posts with text, post URLs, views, likes, reposts, and public attachment links. No login needed.

- **URL**: https://apify.com/automation-lab/vk-posts-scraper.md
- **Developed by:** [Automation Lab](https://apify.com/automation-lab) (community)
- **Categories:** Social media
- **Features:** Limited permissions
- **Stats:** 151 total users, 47 monthly users, 24.8% runs succeeded, 0 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $0.02 / 1,000 result extracteds

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

## VK Posts Scraper

Extract public VK wall posts from user profiles and communities.

Use this actor when you need structured VK post feeds for monitoring, research, OSINT, media tracking, or recurring reports.

The actor works with anonymously accessible VK pages such as `https://vk.com/telegram` and direct posts such as `https://vk.com/wall1_2442097`. Public visibility in a browser does not guarantee that VK exposes an anonymous mobile wall feed.

It does not require login cookies.

It does not scrape private content.

It focuses on public posts and public engagement signals.

***

### What does VK Posts Scraper do?

VK Posts Scraper collects public wall posts from VK profiles and communities.

For each post, it can return:

- ✅ source VK URL
- ✅ VK profile or community name
- ✅ profile or owner ID when exposed
- ✅ post ID
- ✅ canonical VK post URL
- ✅ post text
- ✅ raw public date label
- ✅ likes count
- ✅ reposts count
- ✅ comments count when exposed by VK
- ✅ views count
- ✅ public attachment links and images when visible
- ✅ scrape timestamp

The output is saved as clean dataset rows.

You can export the data as JSON, CSV, Excel, XML, or RSS from Apify.

***

### Who is it for?

#### Social media monitoring teams

Track public VK pages for announcements, narratives, campaigns, and engagement trends.

#### OSINT and risk analysts

Collect public posts from watchlists of VK communities or public figures.

#### PR and reputation agencies

Monitor public VK channels for brand mentions, campaign updates, and viral posts.

#### Journalists and researchers

Create structured archives of public VK posts for investigation and citation.

#### Data teams

Feed VK post data into dashboards, alerting systems, BI tools, or enrichment pipelines.

***

### Why use this VK scraper?

VK pages are difficult to process manually at scale.

Copying posts by hand is slow.

Screenshots are hard to search.

Browser automation is expensive.

This actor uses a lightweight HTTP extraction strategy for public mobile VK pages.

That keeps runs faster and cheaper than a full browser workflow.

It also gives you repeatable structured output.

***

### What VK pages are supported?

The actor supports public VK profile and community URLs on `vk.com` or `vk.ru`.

Examples:

```text
https://vk.com/telegram
https://vk.com/wall1_2442097
https://vk.com/some_public_community
```

Private pages are not supported.

Login-only content is not supported.

Deleted, restricted, or region-blocked pages may return no posts. A valid wall that requires sign-in or yields no usable posts still fails when no other source produces results; login cookies are not supported.

#### Invalid or missing targets

The VK homepage (`https://vk.com/`) is not a profile, community, or post target. If no usable target remains (for example, only homepage URLs or an empty `startUrls` array), an API or scheduled run completes with zero dataset rows and an `invalid_input` status message. The default key-value store contains `INPUT_DIAGNOSTIC` with `status: "invalid_input"`, `reason: "missing_target"`, and a correction message. There is no diagnostic dataset row and no result charge; the normal start fee still applies. Correct the caller or schedule to supply a public wall URL. Schema-invalid requests can be rejected by Apify before a run starts.

In mixed lists, invalid targets are ignored and valid walls are still scraped. This empty outcome applies only to missing targets—not access, extraction, storage, or network failures.

***

### Data fields

| Field | Description |
|---|---|
| `sourceUrl` | VK URL used by the actor for extraction |
| `profileId` | VK owner ID when public metadata exposes it |
| `profileName` | Public profile or community name |
| `postId` | VK wall post ID |
| `postUrl` | Canonical URL for the post |
| `text` | Public post text |
| `publishedAt` | ISO date when VK exposes one |
| `publishedAtRaw` | Raw VK date label as displayed publicly |
| `attachments` | Public links/images discovered in the post body |
| `likesCount` | Number of likes when visible |
| `commentsCount` | Number of comments when visible |
| `repostsCount` | Number of reposts/shares when visible |
| `viewsCount` | Number of views when visible |
| `scrapedAt` | Timestamp when the actor saved the record |

***

### How much does it cost to scrape VK posts?

VK Posts Scraper uses pay-per-event pricing.

You pay a small start fee per run and a per-result fee for each VK post saved.

The default input is intentionally small so first runs stay inexpensive.

For larger monitoring jobs, set `maxPostsPerUrl` to the amount you need.

For recurring jobs, schedule the actor and keep limits focused on recent posts.

***

### How to scrape VK posts

1. Open the actor on Apify.
2. Add one or more public VK URLs to **Public VK profile or community URLs**.
3. Set **Maximum posts per VK URL**.
4. Choose whether to include attachment links.
5. Click **Start**.
6. Download the dataset or connect it to an integration.

***

### Input example

```json
{
  "startUrls": [
    { "url": "https://vk.com/telegram" }
  ],
  "maxPostsPerUrl": 25,
  "includeAttachments": true
}
```

***

### Input fields

#### `startUrls`

Public VK profile or community URLs.

Use URLs from `vk.com`.

The actor normalizes them to public mobile VK pages internally.

#### `maxPostsPerUrl`

Maximum number of posts to save from each VK URL.

Use a low number for tests.

Use a higher number for historical collection.

#### `includeAttachments`

When enabled, the actor saves lightweight public attachment links and image URLs visible in VK mobile HTML.

Disable this if you only need text and engagement counts.

***

### Output example

```json
{
  "sourceUrl": "https://m.vk.com/durov?al=1",
  "profileId": "1",
  "profileName": "Pavel Durov",
  "postId": "1_2442097",
  "postUrl": "https://vk.com/wall1_2442097",
  "text": "Post text...",
  "publishedAtRaw": "8 May 2018",
  "likesCount": 242000,
  "repostsCount": 14000,
  "viewsCount": 15600000,
  "attachments": [],
  "scrapedAt": "2026-07-10T00:00:00.000Z"
}
```

***

### Tips for better results

Use public VK URLs only.

Start with a small limit, then increase it after checking the output.

Use multiple start URLs for watchlists.

Schedule recurring runs for monitoring.

Deduplicate by `postId` in your downstream system if you run the same source repeatedly.

Keep `includeAttachments` enabled for research archives.

Disable `includeAttachments` when you only need engagement metrics.

#### Multi-source reliability

The actor retries transient network errors, HTTP 429 responses, and temporary VK server errors with bounded backoff. If one public source remains unavailable, the actor reports that source in the run log and continues processing the rest of your watchlist.

A run fails clearly when none of the supplied sources produces a usable public post. This prevents scheduled monitoring jobs from silently succeeding with an empty dataset.

***

### Integrations

You can connect VK Posts Scraper to common Apify integrations.

#### Google Sheets

Send new VK posts into a spreadsheet for review.

#### Slack

Notify a channel when a monitored VK page publishes new public posts.

#### Webhooks

Trigger your own API after each run finishes.

#### Make or Zapier

Build no-code workflows around VK monitoring.

#### BI dashboards

Export CSV or JSON into dashboards and reporting systems.

***

### API usage

#### Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/vk-posts-scraper').call({
  startUrls: [{ url: 'https://vk.com/telegram' }],
  maxPostsPerUrl: 25,
  includeAttachments: true,
});

console.log(run.defaultDatasetId);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/vk-posts-scraper').call(run_input={
    'startUrls': [{'url': 'https://vk.com/telegram'}],
    'maxPostsPerUrl': 25,
    'includeAttachments': True,
})
print(run['defaultDatasetId'])
```

#### cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~vk-posts-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"startUrls":[{"url":"https://vk.com/telegram"}],"maxPostsPerUrl":25,"includeAttachments":true}'
```

***

### MCP usage

Use this actor from MCP-compatible clients through Apify MCP Server.

MCP tool URL:

```text
https://mcp.apify.com/?tools=automation-lab/vk-posts-scraper
```

Add the Apify MCP server in Claude Code with the required HTTP transport:

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

For Claude Desktop, Cursor, and VS Code, add the same Apify MCP Server URL in the app's MCP/server settings and choose HTTP transport if the client asks for a transport type.

Example MCP JSON configuration:

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

After setup, ask your MCP client to run the `automation-lab/vk-posts-scraper` tool with the input fields shown above.

#### Example prompt ideas for MCP

Use prompts like these after connecting the Apify MCP server.

```text
Use the automation-lab/vk-posts-scraper MCP tool to collect the latest 50 public posts from https://vk.com/telegram and summarize the main topics.
```

```text
Run the VK Posts Scraper MCP tool for these VK community URLs, export the dataset, and identify posts with the highest viewsCount.
```

```text
Use MCP to run VK Posts Scraper for my public VK watchlist and show posts that received more than 10,000 views.
```

***

### Public-only policy

This actor is designed for public VK pages.

It does not log in.

It does not bypass private access controls.

It does not accept cookies.

It does not scrape private messages.

It does not scrape closed community member-only content.

***

### Data handling and dependencies

The actor uses deterministic HTTP extraction and local HTML parsing. It does not use AI, send data to an AI provider, call a paid third-party API, or use a proxy.

Only user-supplied public VK URLs and publicly visible post data are processed. Results are written to the run's Apify dataset, and operational logs contain source URLs, statuses, and counts but no credentials. The actor keeps no separate cache or external copy of collected posts; datasets, key-value stores, and logs follow your Apify account retention settings and can be deleted with Apify storage controls.

Failed operations send sanitized diagnostic input, exceptions, a summary of the VK page type returned (no page text), and Actor/build/run IDs to our private GlitchTip service for repair. Secret fields and URL query strings are removed; diagnostic reports are retained for 30 days.

VK is named only to identify the public data source. This actor is independent and is not affiliated with or endorsed by VK.

***

### Legality

You are responsible for using scraped data lawfully.

Only scrape public pages you are allowed to access.

Respect applicable privacy, platform, and data protection laws.

Do not use the actor for harassment, spam, credential collection, or unauthorized surveillance.

For compliance-sensitive use cases, consult your legal team.

***

### FAQ and troubleshooting

#### Why did a VK URL return zero posts?

The page may be private, deleted, restricted, empty, or not exposing posts in public mobile HTML.

Try opening the URL in an incognito browser without logging in.

If VK asks you to log in, the actor cannot access that content.

#### Why is `commentsCount` missing?

VK does not expose every engagement metric for every post in the public mobile HTML.

The actor saves counts only when the public page exposes them.

#### Why is the date in `publishedAtRaw`?

VK localizes date labels.

The raw label preserves what VK exposed publicly.

Use `scrapedAt` and `postUrl` for audit trails.

***

### Related scrapers

Explore related actors from Automation Lab:

- https://apify.com/automation-lab/youtube-scraper
- https://apify.com/automation-lab/tiktok-comments-scraper
- https://apify.com/automation-lab/threads-replies-scraper
- https://apify.com/automation-lab/bluesky-scraper
- https://apify.com/automation-lab/facebook-comments-scraper

***

### Limitations

VK can change its public HTML at any time.

Some metrics may be hidden or localized.

Some content may require login.

Attachment extraction is best-effort and lightweight.

The actor is optimized for public post monitoring, not account takeover, scraping private data, or downloading media libraries.

***

### Changelog

See `.actor/CHANGELOG.md` for release notes.

***

### Support

If a public VK page is accessible without login but this actor cannot extract it, open an Apify issue with:

- the VK URL
- your input JSON
- run ID
- expected result
- actual output

This helps reproduce and fix extraction changes quickly.

# Changelog

This Actor's version history is a separate document: https://apify.com/automation-lab/vk-posts-scraper/changelog.md

# Actor input Schema

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

Add public VK user or community pages, for example https://vk.com/telegram. Private pages and login-only content are not supported.

## `maxPostsPerUrl` (type: `integer`):

How many wall posts to save from each supplied VK URL.

## `includeAttachments` (type: `boolean`):

When enabled, the actor includes lightweight public attachment URLs visible in VK mobile HTML.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://vk.com/telegram"
    }
  ],
  "maxPostsPerUrl": 20,
  "includeAttachments": true
}
```

# Actor output Schema

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

Structured public VK post rows with source, content, publication, engagement, and attachment fields.

# 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://vk.com/telegram"
        }
    ],
    "maxPostsPerUrl": 20,
    "includeAttachments": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/vk-posts-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 = {
    "startUrls": [{ "url": "https://vk.com/telegram" }],
    "maxPostsPerUrl": 20,
    "includeAttachments": True,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/vk-posts-scraper").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://vk.com/telegram"
    }
  ],
  "maxPostsPerUrl": 20,
  "includeAttachments": true
}' |
apify call automation-lab/vk-posts-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/vk-posts-scraper"
        }
    }
}
```

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 <APIFY_API_TOKEN>` 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/qM0eDdKEZDgqmdm7N/builds/iPaI2hnWSSFf2Pbsf/openapi.json