# 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:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Social media
- **Stats:** 2 total users, 1 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 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

## 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 public VK pages such as `https://vk.com/durov` and `https://vk.com/telegram`.

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.

Examples:

```text
https://vk.com/durov
https://vk.com/telegram
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.

***

### 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/durov" },
    { "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.

***

### 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/durov' }],
  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/durov'}],
    '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/durov"}],"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/durov 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.

***

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

# Actor input Schema

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

Add public VK user or community pages, for example https://vk.com/durov. 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/durov"
    }
  ],
  "maxPostsPerUrl": 20,
  "includeAttachments": true
}
```

# Actor output Schema

## `overview` (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 = {
    "startUrls": [
        {
            "url": "https://vk.com/durov"
        }
    ],
    "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/durov" }],
    "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("💾 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 '{
  "startUrls": [
    {
      "url": "https://vk.com/durov"
    }
  ],
  "maxPostsPerUrl": 20,
  "includeAttachments": true
}' |
apify call automation-lab/vk-posts-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "VK Posts Scraper",
        "description": "Scrape public VK profile and community posts with text, post URLs, views, likes, reposts, and public attachment links. No login needed.",
        "version": "0.1",
        "x-build-id": "1XdSN5WT2aDtTZxJN"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~vk-posts-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-vk-posts-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/automation-lab~vk-posts-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-vk-posts-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/automation-lab~vk-posts-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-vk-posts-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",
                "required": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "Public VK profile or community URLs",
                        "type": "array",
                        "description": "Add public VK user or community pages, for example https://vk.com/durov. Private pages and login-only content are not supported.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxPostsPerUrl": {
                        "title": "Maximum posts per VK URL",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "How many wall posts to save from each supplied VK URL.",
                        "default": 20
                    },
                    "includeAttachments": {
                        "title": "Include attachment links and images",
                        "type": "boolean",
                        "description": "When enabled, the actor includes lightweight public attachment URLs visible in VK mobile HTML.",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
