# VK Content Scraper — Posts, Users, Communities (`endspec/vk-instant-content-scraper`) Actor

Scrape VK (VKontakte): search posts, users, communities. Russian-language social platform data.

- **URL**: https://apify.com/endspec/vk-instant-content-scraper.md
- **Developed by:** [EndSpec](https://apify.com/endspec) (community)
- **Categories:** Social media, Developer tools
- **Stats:** 75 total users, 14 monthly users, 100.0% runs succeeded, 2 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.50 / 1,000 result returneds

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?

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 Scraper — Search VK (VKontakte) Users and Communities

**Search VK (vk.com) by keyword and get back matching user and community profiles as structured JSON — instantly, one row per result.**

***

**Simple Input-Output Example**

Input:

```json
{
  "query": "технологии",
  "count": 20
}
```

Output (one dataset row per result):

```json
{
  "id": "123",
  "name": "Tech Community",
  "username": "techcomm",
  "owner_id": "techcomm:123",
  "is_verified": false,
  "image": "https://sun9-example.userapi.com/impg/techcomm_200.jpg",
  "_query": "{\"query\":\"технологии\",\"count\":20}"
}
```

**Important Notes:**

- Results are returned **instantly** — one search request per run, no browser, no crawling
- **Pay only per result returned** — `$0.0040` per result; failed queries and zero-result runs cost nothing
- This actor returns **VK user and community profiles** — it does **not** return post text, likes, comments, or media feeds
- Search matches VK's own search index — **Cyrillic queries generally return far more results** than transliterated ones
- All data comes from **public sources** only
- Contact: contact@endspec.net

***

### Full Actor Documentation

#### VK Scraper — Users and Communities

**Find VK (VKontakte) users and communities by keyword.** Run one search against [vk.com](https://vk.com), Russia's largest social network, and get every matching profile back as a clean dataset row — ID, display name, username, verification status, and avatar.

***

#### Overview

The VK Scraper is an Apify Actor that searches [VK (vk.com)](https://vk.com) and extracts publicly available **user and community profiles** matching your keyword. It is built for Russian-market research, social listening across CIS countries, lead discovery, and academic study of VK communities.

Give it a search term. It returns the profiles VK's public search surfaces for that term, normalized into one dataset row per profile, ready to export as JSON, CSV, or Excel.

##### What This Actor Does Not Do

Being direct about scope saves you a wasted run:

- **It does not return posts.** No post text, dates, like counts, repost counts, view counts, or attachments. The output is profiles only.
- **It does not return music, playlists, or video feeds.**
- **It does not scrape a specific profile's wall or follower list.** It searches; it does not enumerate a known account.
- **It does not access private, friends-only, or logged-in content.**
- **It does not paginate.** One run is one search request — see [Cost, Performance, and Limits](#cost-performance-and-limits).

##### What You Can Do

- **Find VK communities by topic**: Search any keyword and discover the public groups and pages organized around it
- **Find VK users by name or keyword**: Surface public accounts matching a term
- **Check verification status**: Every result carries an `is_verified` flag, so you can separate official pages from lookalikes
- **Build target lists**: Collect community IDs and usernames for market research or outreach shortlists
- **Feed downstream pipelines**: Export to CSV/JSON and push profile IDs into your own enrichment, CRM, or analysis workflow
- **Track a niche over time**: Re-run the same query on a schedule and watch which communities appear or disappear

##### Data Availability

**All data returned by this actor is publicly available information.** It surfaces only profiles that VK itself exposes through public search — the same records any logged-out visitor can see on vk.com. No private, restricted, or friends-only data is accessed, and no login is performed.

***

#### Actor Input Parameters

The actor accepts the following input parameters:

**query**
• Type: string
• Required: Optional (but see Important Notes — a run without it is not useful)
• Default: none (the input form is prefilled with `технологии`)
• Description: The keyword to search on VK
e.g., `технологии`, `programming`, `Москва`

**count**
• Type: integer
• Required: Optional
• Default: `20`
• Minimum: `1`
• Maximum: `100`
• Description: Maximum number of results to return from the search
e.g., `50`

**Important Notes:**

- **`query` is technically optional, but always provide it.** The input schema marks no field as required, so a run with an empty input will start and will not crash — it will simply search for nothing and return no useful results. Treat `query` as required in practice.
- **`count` is a cap, not a quota.** It is an upper bound applied to the result list. If the search matches fewer profiles than `count`, you get fewer rows — and you are only charged for the rows you actually receive.
- **`count` above the returned page size has no effect.** A single search returns a single page of results. Raising `count` to `100` does not make VK's search return more profiles than it has for that term; it only raises the ceiling.
- **Cyrillic beats transliteration.** VK's search index is Russian-language first. `технологии` returns substantially more than `tekhnologii`. If a query returns nothing, try it in Cyrillic before assuming there is no data.
- **Broad queries return broad results.** The actor does not filter users from communities — both come back in the same dataset, distinguished by the shape of their records.

***

#### Input Examples

##### Example 1: Basic Cyrillic Keyword Search

```json
{
  "query": "технологии",
  "count": 20
}
```

**When to use:** The standard case. A Russian-language keyword and a modest result cap. This is the recommended starting point for any new topic.

##### Example 2: Wider Sweep for Research

```json
{
  "query": "маркетинг",
  "count": 100
}
```

**When to use:** When you want the broadest view of a niche in one run and are willing to pay for every profile returned. `100` is the schema maximum.

##### Example 3: Narrow Probe / Cheap Test

```json
{
  "query": "Москва",
  "count": 1
}
```

**When to use:** Testing a new query cheaply before committing to a large run. `1` is the schema minimum — you get one row and are charged for one result.

##### Example 4: Latin-Script Query (Error-Prone — Expect Fewer Results)

```json
{
  "query": "programming",
  "count": 20
}
```

**Result:** This runs fine, but VK's search index is Russian-language first. A Latin-script query often returns far fewer profiles than its Cyrillic equivalent (`программирование`), and may return none at all. If you get an empty dataset here, that is the expected behavior — not a failure. Retry in Cyrillic.

***

#### Output Structure

The actor writes results to the Apify dataset — **one row per profile returned**. Results can be downloaded as JSON, CSV, Excel, XML, or RSS from the run's Storage tab, or pulled via the Apify API.

##### Successful Output Format

Each successful row follows this structure:

```json
{
  "id": "string",
  "name": "string",
  "username": "string",
  "owner_id": "string",
  "is_verified": false,
  "image": "string",
  "_query": "string"
}
```

**Field Descriptions:**

**id**
• Type: string
• Description: The numeric VK identifier for the user or community, as a string

**name**
• Type: string
• Description: The public display name of the user or community (e.g. `Tech Community`)

**username**
• Type: string
• Description: The VK screen name / vanity handle — the part that appears in `vk.com/<username>`

**owner\_id**
• Type: string
• Description: VK's owner reference for the record, combining the handle and the numeric ID

**is\_verified**
• Type: boolean
• Description: Whether VK marks this profile as verified (`true`) or not (`false`)

**image**
• Type: string
• Description: URL of the profile's or community's public avatar image

**\_query**
• Type: string
• Description: A JSON-encoded echo of the input you submitted (`query` and `count`), so rows remain traceable to their search after you merge datasets from multiple runs

**A note on field completeness:** The fields above are what VK's public search returns for a profile record. Individual records may omit fields VK does not publish for that profile — always null-check before consuming a field downstream. Do not assume every row carries every key.

##### Error Output Format

When a search fails, the actor writes a single error row instead of results, and **does not charge** for it:

```json
{
  "status": "error",
  "_query": "string",
  "error": "string"
}
```

**Field Descriptions:**

**status**
• Type: string
• Description: Always the literal `"error"` on a failed run. Note that **successful rows do not carry a `status` field** — presence of `status` is itself the error signal.

**\_query**
• Type: string
• Description: JSON-encoded echo of the input that failed

**error**
• Type: string
• Description: A human-readable description of what went wrong. When the service is rate-limited this is a fixed message (see Example 4 below); for other failures the text varies and may include an HTTP status code.

***

#### Output Examples

##### Example 1: Successful Search With Results

Input `{ "query": "технологии", "count": 20 }` — each matching profile arrives as its own row:

```json
{
  "id": "123",
  "name": "Tech Community",
  "username": "techcomm",
  "owner_id": "techcomm:123",
  "is_verified": false,
  "image": "https://sun9-example.userapi.com/impg/techcomm_200.jpg",
  "_query": "{\"query\":\"технологии\",\"count\":20}"
}
```

##### Example 2: A Verified Community

```json
{
  "id": "124",
  "name": "Tech News",
  "username": "technews",
  "owner_id": "technews:124",
  "is_verified": true,
  "image": "https://sun9-example.userapi.com/impg/technews_200.jpg",
  "_query": "{\"query\":\"технологии\",\"count\":20}"
}
```

**Interpretation:** `is_verified: true` marks this as a VK-verified page — useful for filtering official brand and media accounts out of a noisy result set.

##### Example 3: No Results Found (Successful Run, Empty Dataset)

When the search matches nothing, the run **succeeds and the dataset is empty** — zero rows, not a row containing an empty list:

```json
[]
```

The run log will read `Done. Returned 0 item(s).` This is the normal, non-error outcome for a query VK's index has nothing for. **You are not charged**, because charges are per returned result. If you expected results here, retry the query in Cyrillic (see Input Example 4).

##### Example 4: Rate-Limited (Service Busy)

When the service is temporarily rate-limited, a single row is written with this exact message:

```json
{
  "status": "error",
  "_query": "{\"query\":\"технологии\",\"count\":20}",
  "error": "Our servers are busy right now — please retry shortly. You were not charged."
}
```

**What to do:** Wait a few minutes and re-run. You were not charged for this row.

##### Example 5: Other Failure

Any other failure produces an error row whose `error` text describes the problem and may carry an HTTP status code:

```json
{
  "status": "error",
  "_query": "{\"query\":\"технологии\",\"count\":20}",
  "error": "Our servers returned HTTP 403: null"
}
```

**What to do:** These are almost always transient service-side conditions. Re-run a few minutes later. If the same failure persists across several runs, email contact@endspec.net with your run ID — see [Support](#contact--support). You were not charged for this row.

***

#### Use Cases

##### For Market Researchers and Analysts

**CIS Market Mapping:** Identify which VK communities own a topic in the Russian-speaking market — their size signals, verification status, and naming conventions tell you who the incumbents are before you spend on entry.

**Example Workflow:**

1. List the Cyrillic keywords that define your category
2. Run the actor once per keyword with `count: 100`
3. Export all datasets to CSV and merge on `_query` to keep terms separated
4. Filter on `is_verified` to separate official pages from fan and spam accounts
5. Rank the remaining communities and build your target map

##### For Social Listening and Brand Teams

**Brand Presence Audit:** Find every VK community using your brand name — official pages, fan groups, and impersonators alike.

**Example Workflow:**

1. Run the actor with your brand name as `query`, in both Cyrillic and Latin script
2. Pull `name`, `username`, and `is_verified` from the results
3. Flag unverified profiles using your brand name as review candidates
4. Re-run on a weekly schedule and diff `id` sets to catch new impersonators as they appear

##### For Lead Generation and Sales

**Community Prospecting:** Build a shortlist of VK communities whose audience matches your ICP, then approach the ones worth a partnership.

**Example Workflow:**

1. Search your niche keyword in Cyrillic
2. Export results and keep the `username` column — it gives you `vk.com/<username>` for each target
3. Manually qualify the shortlist by visiting the top candidates
4. Route qualified handles into your CRM as outreach targets

**Note:** This actor returns profiles, not contact details. Qualification and contact discovery are manual steps after the search.

##### For Academic Researchers

**Community Structure Studies:** Sample the VK community landscape for a topic reproducibly, with the query preserved alongside every record.

**Example Workflow:**

1. Define your keyword set and fix `count` across all runs so samples are comparable
2. Run the actor once per keyword
3. Use the `_query` field on every row to keep provenance attached through merges
4. Repeat the identical run at fixed intervals to build a longitudinal panel
5. Analyze verification rates, naming patterns, and turnover between waves

##### For Developers

**Pipeline Integration:** Call the actor from the Apify API and treat it as a VK search endpoint that returns clean JSON.

**Example Workflow:**

1. Trigger runs via the Apify API with your `query` and `count`
2. Read the default dataset when the run finishes
3. Branch on the `status` field — its presence means the row is an error, its absence means the row is a result
4. Retry rows carrying the busy message after a backoff
5. Store the results keyed on `id`

***

#### Best Practices

##### Query Construction

- **Search in Cyrillic first.** VK's index is Russian-language first; this single choice drives result volume more than anything else.
- **Test a term with `count: 1` before a wide run.** One row is the cheapest possible confirmation that a query returns anything at all.
- **Run one keyword per run.** The actor takes a single query string. Multiple terms means multiple runs — which also keeps `_query` meaningful as a provenance label.
- **Keep queries specific.** A term like `Москва` matches an enormous, low-signal set. Narrower topical terms return more usable profiles.

##### Cost Control

- **Set `count` to what you will actually use.** You are charged per result returned, so a `count` of `100` on a term you only need ten profiles from is money spent on rows you will discard.
- **Empty and failed runs are free.** Exploratory searching costs nothing when it comes back empty — there is no penalty for probing a term.

##### Error Handling

- **Branch on the presence of `status`.** Successful rows have no `status` field; error rows always do. Do not test for `status === "success"` — it never appears.
- **Retry the busy message.** `Our servers are busy right now — please retry shortly. You were not charged.` means rate-limited, not broken. Back off and retry.
- **Do not parse the `error` string.** Its wording varies for non-rate-limit failures. Treat any row with `status: "error"` as failed and retry; do not build logic on the message text.
- **Log run IDs.** When contacting support, the Apify run ID is the fastest path to an answer.

##### Data Usage

- **Verify before acting.** Profile records reflect VK's search index at the moment of the run and can change. Re-check anything time-sensitive.
- **Respect privacy.** Use profile data only for legitimate business and research purposes.
- **Follow applicable law.** GDPR and equivalent regimes apply to personal data regardless of whether it was public when you collected it.

***

#### Cost, Performance, and Limits

##### Pricing

- **Pay per result returned** — `$0.0040` per result row
- **Pay-as-you-go** — no monthly subscription, no minimum commitment
- **No charge for zero-result runs** — an empty dataset costs nothing
- **No charge for errors** — rate-limit and failure rows are never billed

The billed event is `result-returned`, charged once per profile row written to the dataset.

##### Performance

- **Single request per run.** No browser, no crawling, no page rendering — a run is one search and completes in seconds.
- **Lightweight.** Minimal memory and compute; safe to run at the smallest available memory setting.
- **Scales by running in parallel.** For many keywords, start many short runs rather than trying to widen one.

##### Limits

- **One query per run.** The input takes a single `query` string.
- **`count` range: 1–100.** Enforced by the input schema; the default is `20`.
- **No pagination.** A run returns a single page of search results. `count` caps that page — it cannot reach past it. If a term has more profiles on VK than one page holds, this actor will not retrieve them.
- **Profiles only.** No posts, comments, media, or feeds — see [What This Actor Does Not Do](#what-this-actor-does-not-do).
- **Rate limits are possible.** Under load the actor may return the busy message instead of results. Retry after a short wait; you are not charged.

***

#### Data Sources and Legality

**All data returned by this actor is publicly available information from [vk.com](https://vk.com).** The actor surfaces only user and community profiles that VK itself publishes through public search — records visible to any logged-out visitor. It does not log in, does not access private or friends-only content, and does not circumvent access controls.

**Your responsibilities:**

- You are responsible for complying with all applicable laws and regulations, including GDPR and other data-protection regimes, when collecting, storing, and using this data.
- You are responsible for complying with VK's terms of service.
- Personal data remains personal data even when it is public. Have a lawful basis before you process it.
- Use the results for legitimate business, research, or analytical purposes only.
- Honor removal and opt-out requests from individuals whose profiles appear in your results.

This section is factual guidance, not legal advice. If your use case involves personal data at scale, consult a qualified professional.

***

#### Frequently Asked Questions

**Q: Does this actor return VK posts?**
A: No. Despite what a keyword search might suggest, the output is **user and community profiles only** — no post text, dates, like counts, repost counts, view counts, or attachments. If you need post content, this is not the actor for you.

**Q: Why did my search return zero results?**
A: Most often because the query was in Latin script. VK's search index is Russian-language first — try the Cyrillic form (`технологии`, not `tekhnologii`). Otherwise, VK's public search may simply have nothing for that term. Either way, an empty run costs nothing.

**Q: How do I tell a user from a community in the results?**
A: The actor does not label them; both come back in one dataset. In practice, `name` and `username` are the tell — communities read as topics or brands, users as personal names. Visiting `vk.com/<username>` confirms it.

**Q: I set `count: 100` but got 12 rows. Is that a bug?**
A: No. `count` is a maximum, not a target. VK's search returned 12 matching profiles for that term, so you received 12 rows — and were charged for 12, not 100.

**Q: Can I get more results by paginating?**
A: Not with this actor. One run is one search request returning one page. There is no cursor or offset input. To cover a topic more broadly, run several narrower, related queries instead of one broad one.

**Q: Can I search several keywords in one run?**
A: No — one `query` per run. Run the actor once per keyword; the `_query` field on each row keeps the results attributable after you merge the datasets.

**Q: How do I detect an error in my code?**
A: Check whether the row has a `status` field. Successful result rows have none; error rows always carry `status: "error"`. Do not check for `status: "success"` — the actor never emits it.

**Q: I got "Our servers are busy right now" — what now?**
A: That is a rate-limit condition, not a failure of your input. Wait a few minutes and re-run. You were not charged.

**Q: Am I charged for failed or empty runs?**
A: No. Charging happens once per result row actually returned. Zero results, rate limits, and errors all cost nothing.

**Q: Can I use this actor commercially?**
A: Yes. The data is publicly available. You remain responsible for complying with applicable law and VK's terms of service — see [Data Sources and Legality](#data-sources-and-legality).

**Q: In what formats can I get the results?**
A: The Apify dataset exports to JSON, CSV, Excel, XML, and RSS from the run's Storage tab, and is available through the Apify API.

**Q: How often should I re-run the same query?**
A: VK communities appear, rename, and disappear over time. For monitoring use cases, weekly or monthly re-runs and diffing on `id` works well.

***

#### Contact & Support

**Questions? Need Help? We're Here for You!**

For any questions, technical support, feature requests, or general inquiries about the VK Scraper, please reach out:

**Email:** contact@endspec.net

**Response Time:** We guarantee a response within 24 hours during business days.

**What to Include in Your Inquiry:**

- Your question or issue description
- Actor run ID (if applicable)
- The exact input you used (`query` and `count`)
- Any error rows from the dataset, and the run log if relevant
- What you expected to get back

You can also report issues directly through the **Issues** tab on this actor's Apify page.

We're committed to helping you get the most out of this actor — whether you're integrating it into a pipeline, troubleshooting a query that returns nothing, or working out whether it fits your use case.

***

#### Related Actors

- [LinkedIn Instant Profile Search](https://apify.com/endspec/linkedin-instant-profile-search) — find LinkedIn profiles by name, job title, or company.
- [Instagram Instant Media Scraper](https://apify.com/endspec/instagram-instant-media-scraper) — pull public media data from Instagram profiles.
- [YouTube Instant Email Scraper](https://apify.com/endspec/youtube-instant-email-scraper) — extract public contact details from YouTube channels.

***

*Last Updated: July 2026*

# Actor input Schema

## `query` (type: `string`):

What to search on VK

## `count` (type: `integer`):

Max results

## Actor input object example

```json
{
  "query": "технологии",
  "count": 20
}
```

# 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 '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "query": "технологии"
};

// Run the Actor and wait for it to finish
const run = await client.actor("endspec/vk-instant-content-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 = { "query": "технологии" }

# Run the Actor and wait for it to finish
run = client.actor("endspec/vk-instant-content-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 '{
  "query": "технологии"
}' |
apify call endspec/vk-instant-content-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,endspec/vk-instant-content-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/j7lmnI7K9IQpewveN/builds/1LI4LRrB3t4f5mvEO/openapi.json