# WordPress Plugin Scraper (`maximedupre/wordpress-plugin-scraper`) Actor

Scrape public WordPress.org plugin data by search, tag, author, directory list, slug, or plugin URL. Export installs, ratings, compatibility, author links, support stats, media, changelog, and review facts.

- **URL**: https://apify.com/maximedupre/wordpress-plugin-scraper.md
- **Developed by:** [Maxime Dupré](https://apify.com/maximedupre) (community)
- **Categories:** Developer tools, Marketing
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$0.90 / 1,000 scraped plugins

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

### 🔌 WordPress plugin scraper

WordPress Plugin Scraper collects public plugin data from the [WordPress.org Plugin Directory](https://wordpress.org/plugins/). Use this WordPress plugin scraper to search the directory, browse common plugin lists, collect plugins by tag or author, or enrich exact plugin slugs and WordPress.org plugin URLs.

The Actor saves one dataset row per successfully scraped plugin. Rows include plugin names, slugs, WordPress.org URLs, active installs, ratings, version and compatibility data, author links, support stats, download links, media links, changelog entries, and raw review facts when WordPress.org exposes them.

You do not need WordPress credentials, cookies, a WordPress.org account, or a source API key. For a quick first run, keep `Browse directory`, leave `Directory list` on `Popular plugins`, and set a small `Maximum plugin rows` value to preview the output shape.

### 📦 What this Actor does

- Searches public WordPress.org plugins by keyword.
- Browses popular, featured, top-rated, new, and recently updated plugin lists.
- Collects plugins from public tag pages.
- Collects plugins by WordPress.org author username.
- Enriches exact plugin slugs or WordPress.org plugin URLs.
- Saves one clean row per plugin.
- Includes source-backed detail fields automatically when available.
- Runs without user-provided source credentials.

This Actor is built for WordPress ecosystem research, plugin market research, SEO and agency audits, developer portfolio checks, compatibility reviews, and repeatable WordPress.org plugin data exports.

### 🎯 Target options

Choose one target type per run.

`Browse directory` is the easiest first run. Pick a directory list such as popular, featured, top-rated, new, or recently updated plugins.

`Search plugins` collects plugins returned for one or more search queries, such as `seo`, `booking calendar`, or `membership`.

`Plugins by tag` collects plugins for public WordPress.org tag slugs, such as `ecommerce` or `security`.

`Plugins by author` collects plugins for public WordPress.org author usernames, such as `automattic` or `yoast`.

`Exact plugins` enriches known plugin slugs or plugin page URLs, such as `woocommerce`, `contact-form-7`, or `https://wordpress.org/plugins/elementor/`.

`Maximum plugin rows` caps the total number of plugin rows saved by the run. Start small when testing a new target, then raise the limit when the output looks right.

### 📊 Data you can extract

Each dataset row represents one public WordPress.org plugin. Fields can include:

- `target` - the query, tag, author, directory list, slug, or URL that produced the row.
- `pluginSlug`, `pluginName`, and `pluginUrl` - stable plugin identity and source URL.
- `shortDescription` and `description` - source descriptions when available.
- `activeInstalls`, `downloaded`, `rating`, `ratingCount`, and `ratingDistribution` - public adoption and rating signals.
- `authorName`, `authorProfileUrl`, `homepageUrl`, and `donateUrl` - source-visible author and project links.
- `version`, `requiresWpVersion`, `testedWpVersion`, and `requiresPhpVersion` - compatibility data.
- `addedDate` and `lastUpdated` - source dates when WordPress.org exposes them.
- `tags`, `supportThreads`, and `supportThreadsResolved` - directory and support signals.
- `downloadUrl`, `iconUrl`, and `media` - plugin ZIP, icon, banner, and screenshot links.
- `contributors` - public contributor profile facts.
- `changelog` - source-native version notes when available.
- `reviews` - raw review facts, including reviewer name, rating, title, text, date, and review URL when available.

The Actor does not add sentiment, review summaries, recommendations, or generated quality scores. It returns source-backed facts only.

### 🧾 Output example

```json
{
	"target": "popular",
	"pluginSlug": "woocommerce",
	"pluginName": "WooCommerce",
	"pluginUrl": "https://wordpress.org/plugins/woocommerce/",
	"shortDescription": "An ecommerce toolkit that helps you sell anything.",
	"activeInstalls": 7000000,
	"rating": 4.5,
	"ratingCount": 4802,
	"ratingDistribution": {
		"fiveStar": 4021,
		"fourStar": 391,
		"threeStar": 180,
		"twoStar": 94,
		"oneStar": 116
	},
	"authorName": "Automattic",
	"authorProfileUrl": "https://profiles.wordpress.org/automattic/",
	"version": "10.8.1",
	"requiresWpVersion": "6.7",
	"testedWpVersion": "6.8",
	"requiresPhpVersion": "7.4",
	"lastUpdated": "2026-05-27 5:54pm GMT",
	"tags": ["ecommerce", "online-store", "shopping-cart"],
	"supportThreads": 236,
	"supportThreadsResolved": 212,
	"downloadUrl": "https://downloads.wordpress.org/plugin/woocommerce.10.8.1.zip",
	"iconUrl": "https://ps.w.org/woocommerce/assets/icon.svg"
}
````

You can export the dataset from Apify as JSON, CSV, Excel, XML, RSS, or HTML. You can also run the Actor through the Apify API, schedules, webhooks, and integrations.

### 💰 Pricing

This Actor charges per successfully saved plugin. The current local pricing is `$0.0009` per scraped plugin, which is `$0.90` per 1,000 plugins.

Skipped, invalid, unavailable, or empty targets do not produce plugin rows. Runs still stop cleanly and log what happened.

### ⚠️ Limits

This Actor focuses on public WordPress.org plugin directory data. It does not scrape private WordPress dashboards, premium plugin customer areas, commercial marketplace accounts, paid plugin ZIP files, or private source code.

The Actor does not need user credentials, cookies, a WordPress.org login, or a source API key. It also does not expose proxy, timeout, retry, field toggle, or review-analysis settings in the public input form.

Some fields can be empty. WordPress.org does not expose every media link, changelog entry, review detail, support count, or compatibility value for every plugin.

### ❓ FAQ

#### Can I scrape a specific WordPress plugin?

Yes. Choose `Exact plugins` and add plugin slugs or WordPress.org plugin URLs.

#### Can I collect all plugins by an author?

Yes. Choose `Plugins by author` and add one or more WordPress.org author usernames.

#### Does this scrape WordPress plugin reviews?

It returns raw source-native review facts when WordPress.org exposes them for the plugin. It does not summarize reviews, score sentiment, or classify complaints.

#### Does this include premium plugin data?

No. It only returns public WordPress.org Plugin Directory data.

#### Do I need a WordPress.org account?

No. The Actor works from public WordPress.org data and does not ask for WordPress credentials.

### 📝 Changelog

- 0.1: Initial release.

### 🆘 Support

For issues, questions, or feature requests, [file a ticket](https://console.apify.com/actors/maximedupre~wordpress-plugin-scraper/issues) and I'll fix or implement it in less than 24h 🫡

### 🔗 Other actors

- [CodeCanyon Scraper ↗](https://apify.com/maximedupre/codecanyon-scraper) - Scrape public Envato Market item data for plugins, scripts, and code items.
- [Sitemap Sniffer ↗](https://apify.com/maximedupre/sitemap-sniffer) - Find sitemap files, URL counts, nested indexes, and optional URL inventory rows.
- [Website URL Crawler ↗](https://apify.com/maximedupre/website-url-crawler) - Crawl rendered websites and export discovered links for SEO and QA work.
- [Webpage Text Extractor ↗](https://apify.com/maximedupre/webpage-text-extractor) - Extract clean text, article text, or Markdown from public webpages.
- [Google Play Store Scraper ↗](https://apify.com/maximedupre/google-play-store-scraper) - Scrape public app, review, permission, and Data Safety data from Google Play.

**Made with ❤️ by Maxime Dupré**

# Actor input Schema

## `targetType` (type: `string`):

Choose the WordPress.org directory slice for this run.

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

Limit plugin rows across the whole run.

## `browseCategory` (type: `string`):

Use this when `What to collect` is `Browse directory`.

## `searchQueries` (type: `array`):

Use this when `What to collect` is `Search plugins`.

## `tagSlugs` (type: `array`):

Use this when `What to collect` is `Plugins by tag`.

## `authorUsernames` (type: `array`):

Use this when `What to collect` is `Plugins by author`.

## `pluginTargets` (type: `array`):

Use this when `What to collect` is `Exact plugins`.

## Actor input object example

```json
{
  "targetType": "search",
  "maxItems": 50,
  "browseCategory": "popular",
  "searchQueries": [
    "seo",
    "booking calendar"
  ],
  "tagSlugs": [
    "ecommerce",
    "security"
  ],
  "authorUsernames": [
    "automattic",
    "yoast"
  ],
  "pluginTargets": [
    "woocommerce",
    "contact-form-7",
    "https://wordpress.org/plugins/elementor/"
  ]
}
```

# Actor output Schema

## `results` (type: `string`):

Open the dataset with one row for each successfully scraped WordPress.org plugin.

# 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 = {
    "targetType": "search",
    "maxItems": 50,
    "browseCategory": "popular",
    "searchQueries": [
        "seo",
        "booking calendar"
    ],
    "tagSlugs": [
        "ecommerce",
        "security"
    ],
    "authorUsernames": [
        "automattic",
        "yoast"
    ],
    "pluginTargets": [
        "woocommerce",
        "contact-form-7",
        "https://wordpress.org/plugins/elementor/"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("maximedupre/wordpress-plugin-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 = {
    "targetType": "search",
    "maxItems": 50,
    "browseCategory": "popular",
    "searchQueries": [
        "seo",
        "booking calendar",
    ],
    "tagSlugs": [
        "ecommerce",
        "security",
    ],
    "authorUsernames": [
        "automattic",
        "yoast",
    ],
    "pluginTargets": [
        "woocommerce",
        "contact-form-7",
        "https://wordpress.org/plugins/elementor/",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("maximedupre/wordpress-plugin-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 '{
  "targetType": "search",
  "maxItems": 50,
  "browseCategory": "popular",
  "searchQueries": [
    "seo",
    "booking calendar"
  ],
  "tagSlugs": [
    "ecommerce",
    "security"
  ],
  "authorUsernames": [
    "automattic",
    "yoast"
  ],
  "pluginTargets": [
    "woocommerce",
    "contact-form-7",
    "https://wordpress.org/plugins/elementor/"
  ]
}' |
apify call maximedupre/wordpress-plugin-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "WordPress Plugin Scraper",
        "description": "Scrape public WordPress.org plugin data by search, tag, author, directory list, slug, or plugin URL. Export installs, ratings, compatibility, author links, support stats, media, changelog, and review facts.",
        "version": "0.1",
        "x-build-id": "4R9fTl1vdIgiWsauh"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/maximedupre~wordpress-plugin-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-maximedupre-wordpress-plugin-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/maximedupre~wordpress-plugin-scraper/runs": {
            "post": {
                "operationId": "runs-sync-maximedupre-wordpress-plugin-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/maximedupre~wordpress-plugin-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-maximedupre-wordpress-plugin-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": [
                    "targetType"
                ],
                "properties": {
                    "targetType": {
                        "title": "What to collect",
                        "enum": [
                            "browse",
                            "search",
                            "tag",
                            "author",
                            "plugins"
                        ],
                        "type": "string",
                        "description": "Choose the WordPress.org directory slice for this run.",
                        "default": "browse"
                    },
                    "maxItems": {
                        "title": "Maximum plugin rows",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Limit plugin rows across the whole run.",
                        "default": 50
                    },
                    "browseCategory": {
                        "title": "Directory list",
                        "enum": [
                            "popular",
                            "featured",
                            "top-rated",
                            "new",
                            "updated"
                        ],
                        "type": "string",
                        "description": "Use this when `What to collect` is `Browse directory`.",
                        "default": "popular"
                    },
                    "searchQueries": {
                        "title": "Search queries",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Use this when `What to collect` is `Search plugins`.",
                        "items": {
                            "type": "string",
                            "minLength": 1
                        }
                    },
                    "tagSlugs": {
                        "title": "Tag slugs",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Use this when `What to collect` is `Plugins by tag`.",
                        "items": {
                            "type": "string",
                            "minLength": 1
                        }
                    },
                    "authorUsernames": {
                        "title": "Author usernames",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Use this when `What to collect` is `Plugins by author`.",
                        "items": {
                            "type": "string",
                            "minLength": 1
                        }
                    },
                    "pluginTargets": {
                        "title": "Plugin slugs or URLs",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Use this when `What to collect` is `Exact plugins`.",
                        "items": {
                            "type": "string",
                            "minLength": 1
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
