# WordPress Plugin Directory Scraper (`fetch_cat/wordpress-plugin-directory-scraper`) Actor

Scrape WordPress.org plugin metadata, ratings, installs, authors, tags, versions, and update signals from public searches and slugs.

- **URL**: https://apify.com/fetch\_cat/wordpress-plugin-directory-scraper.md
- **Developed by:** [Hanna Nosova](https://apify.com/fetch_cat) (community)
- **Categories:** Developer tools, Lead generation, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.60 / 1,000 plugin records

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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 Directory Scraper

Scrape structured WordPress.org plugin directory data for market research, SEO analysis, security review, agency prospecting, and competitor monitoring.

The actor collects plugin names, slugs, authors, active installs, ratings, versions, compatibility data, tags, support stats, update dates, download counts, homepages, and WordPress.org plugin URLs.

Use it when you need a repeatable dataset instead of manually opening plugin pages one by one.

---

### What does WordPress Plugin Directory Scraper do?

WordPress Plugin Directory Scraper turns WordPress.org plugin searches and plugin slugs into clean dataset rows.

You can:

- 🔎 Search for plugins by keywords such as `seo`, `security`, `forms`, `cache`, or `ecommerce`
- 🔌 Fetch known plugins directly by slug, such as `woocommerce` or `contact-form-7`
- 📈 Compare active installs, ratings, downloads, support stats, and update freshness
- 🧩 Build lists of plugin vendors and plugin homepages
- 🛡️ Monitor compatibility signals such as tested WordPress version and required PHP version
- 📦 Export the results as JSON, CSV, Excel, XML, or through the Apify API

### Who is it for?

#### Plugin marketers

Find competitor plugins, track ratings, monitor install counts, and discover tags used by successful products.

#### WordPress agencies

Research the plugin ecosystem before recommending tools to clients or auditing a website stack.

#### SEO analysts

Build category-level datasets for keyword, SERP, and plugin positioning research.

#### Security analysts

Prioritize plugins by install count, update cadence, compatibility, and support signals.

#### Lead generation teams

Create lists of plugin authors, vendor websites, and WordPress.org profiles for outreach workflows.

#### Product teams

Track market size, category saturation, and competing plugin claims across WordPress.org.

### Why use this actor?

Manual plugin research is slow. WordPress.org has thousands of plugins across many categories, and the most useful signals are spread across plugin cards and plugin detail pages.

This actor helps you automate that work:

- ✅ Repeatable search inputs
- ✅ Direct slug lookups for known competitors
- ✅ Consistent field names
- ✅ Search rank captured per query
- ✅ Optional full description sections
- ✅ Low-cost HTTP-only execution
- ✅ No login needed for public directory data

### Typical use cases

- Build a list of top SEO plugins by active installs
- Compare plugin ratings in a category
- Find abandoned or stale plugins in a niche
- Discover plugin vendor websites for partnerships
- Monitor competitor versions and update dates
- Export plugin directory data into BI tools
- Create enrichment input for another workflow
- Track tags used by high-install plugins

### Output fields

| Field | Description |
| --- | --- |
| `sourceType` | Whether the row came from a search query or direct slug lookup |
| `query` | Search query that produced the plugin, when applicable |
| `rank` | Plugin rank within that query |
| `slug` | WordPress.org plugin slug |
| `name` | Plugin name |
| `version` | Current plugin version |
| `author` | Plugin author name or organization |
| `author_profile` | WordPress.org author profile URL |
| `homepage` | Vendor or project homepage when available |
| `requires` | Required WordPress version |
| `tested` | WordPress version tested up to |
| `requires_php` | Required PHP version |
| `rating` | Aggregate rating score |
| `ratings_count` | Number of ratings |
| `ratings_breakdown` | Optional 1-star through 5-star rating counts |
| `active_installs` | Active install estimate |
| `downloaded` | Total downloads |
| `last_updated` | Last updated timestamp from WordPress.org |
| `added` | Date the plugin was added |
| `tags` | Optional WordPress.org plugin tags |
| `short_description` | Short plugin summary |
| `description_html` | Optional full description HTML |
| `sections` | Optional full plugin sections |
| `screenshots` | Screenshot metadata when available |
| `support_threads` | Recent support thread count |
| `support_threads_resolved` | Recent resolved support thread count |
| `download_link` | Plugin ZIP download link |
| `plugin_url` | Public WordPress.org plugin URL |

### Pricing

This Actor uses Apify pay-per-event pricing. The prices below come from the current Actor pricing configuration. Apify public plans map to Store discount tiers, so the table shows both the user-facing plan context and the pricing tier name. The final price shown in Apify depends on the user account plan and any custom agreement.

| Event | What is charged | Price |
| --- | --- | ---: |
| `start` | One-time fee charged when a run starts. Covers fixed startup cost. | $0.005 |

| Event | What is charged | Free / no discount | Starter / Bronze | Scale / Silver | Business / Gold | Custom / Platinum | Custom / Diamond |
| --- | --- | ---: | ---: | ---: | ---: | ---: | ---: |
| `item` | Per WordPress plugin record saved to the dataset | $1.15 / 1,000 | $1 / 1,000 | $0.78 / 1,000 | $0.6 / 1,000 | $0.4 / 1,000 | $0.28 / 1,000 |

Apify may also charge platform usage for compute, storage, proxies, or data transfer outside this Actor pricing. Check the Actor run and the Apify Pricing tab for the exact cost shown to your account.

### Input settings

#### Search queries

Use `queries` to discover plugins by keyword.

Example queries:

- `seo`
- `security`
- `woocommerce`
- `forms`
- `analytics`
- `page builder`
- `backup`

#### Plugin slugs

Use `slugs` when you already know the plugin.

Examples:

- `woocommerce`
- `contact-form-7`
- `seo-by-rank-math`
- `wordpress-seo`
- `elementor`

You can also paste WordPress.org plugin URLs.

#### Maximum plugin records

Use `maxItems` to cap the number of dataset rows.

Start small, inspect the output, then increase the limit for larger research jobs.

#### Search page size

Use `perPage` to control how many plugins the WordPress.org search API returns per page. The maximum is 100; smaller values are useful for quick tests.

#### Optional fields

Enable optional fields when you need more detail:

- `includeTags` adds plugin tags
- `includeRatingsBreakdown` adds rating counts by star level
- `includeSections` adds larger full-text HTML sections
- `locale` requests a WordPress.org locale when supported

### Verified public examples

Ready-to-run Apify Store examples verified in post-publish QA:

- [Top WordPress SEO plugins](https://apify.com/fetch_cat/wordpress-plugin-directory-scraper/examples/top-wordpress-seo-plugins)
- [Monitor known WordPress plugin slugs](https://apify.com/fetch_cat/wordpress-plugin-directory-scraper/examples/monitor-known-wordpress-plugin-slugs)
- [Security plugin details with sections](https://apify.com/fetch_cat/wordpress-plugin-directory-scraper/examples/security-plugin-details-with-sections)

### Example input

```json
{
  "queries": ["seo", "security"],
  "slugs": ["woocommerce", "contact-form-7"],
  "maxItems": 50,
  "perPage": 50,
  "includeTags": true,
  "includeRatingsBreakdown": true,
  "includeSections": false,
  "locale": "en_US"
}
````

### Example output

```json
{
  "sourceType": "query",
  "query": "seo",
  "rank": 1,
  "slug": "seo-by-rank-math",
  "name": "Rank Math SEO – AI SEO Tools to Dominate SEO Rankings",
  "version": "1.0.273",
  "author": "Rank Math SEO",
  "author_profile": "https://profiles.wordpress.org/rankmath/",
  "homepage": "https://rankmath.com/",
  "requires": "6.7",
  "tested": "7.0",
  "requires_php": "7.4",
  "rating": 96,
  "ratings_count": 7453,
  "active_installs": 4000000,
  "downloaded": 185207621,
  "last_updated": "2026-06-30 11:48am GMT",
  "added": "2018-11-19",
  "plugin_url": "https://wordpress.org/plugins/seo-by-rank-math/"
}
```

### How to scrape WordPress plugins

1. Open the actor on Apify.
2. Add one or more search queries.
3. Add direct plugin slugs if you have known targets.
4. Set `maxItems` to the number of plugin records you need.
5. Keep optional full sections disabled for quick market scans.
6. Run the actor.
7. Download the dataset or connect it to your workflow.

### Tips for better results

- Use specific category terms for focused lists.
- Use broad terms such as `seo` or `security` for market mapping.
- Add known competitor slugs to guarantee they appear in the dataset.
- Keep `includeSections` disabled unless you need long descriptions or changelogs.
- Run the same query on a schedule to monitor changes over time.
- Combine `active_installs`, `rating`, and `last_updated` to prioritize plugins.

### Scheduling and monitoring

You can schedule this actor on Apify to monitor plugin categories daily, weekly, or monthly.

Useful scheduled workflows include:

- Weekly competitor install and rating snapshots
- Monthly plugin category exports
- Security watchlists for high-install plugins
- Agency reports on recommended plugin categories
- Vendor lead list refreshes

### Integrations

This actor works with common Apify integrations:

- Google Sheets for lightweight research tables
- Make or Zapier for lead workflows
- Webhooks for alerts when a run finishes
- Apify datasets API for BI pipelines
- Cloud storage exports for archives
- Other Apify actors for enrichment

### API usage

#### Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });

const run = await client.actor('fetch_cat/wordpress-plugin-directory-scraper').call({
  queries: ['seo'],
  slugs: ['woocommerce'],
  maxItems: 25,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])

run = client.actor('fetch_cat/wordpress-plugin-directory-scraper').call(run_input={
    'queries': ['security'],
    'maxItems': 25,
})

items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

#### cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/fetch_cat~wordpress-plugin-directory-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"queries":["seo"],"maxItems":25}'
```

### MCP integration

Use Apify MCP to make this actor available to AI assistants.

#### Claude Code

```bash
claude mcp add apify-wordpress-plugins "https://mcp.apify.com/?tools=fetch_cat/wordpress-plugin-directory-scraper"
```

#### Claude Desktop

Add an MCP server configuration that points to:

```text
https://mcp.apify.com/?tools=fetch_cat/wordpress-plugin-directory-scraper
```

Example JSON configuration:

```json
{
  "mcpServers": {
    "apify-wordpress-plugins": {
      "command": "npx",
      "args": [
        "-y",
        "mcp-remote",
        "https://mcp.apify.com/?tools=fetch_cat/wordpress-plugin-directory-scraper"
      ]
    }
  }
}
```

#### Example MCP prompts

Example prompts you can ask after connecting the MCP server:

- "Use the WordPress Plugin Directory Scraper tool to find the top WordPress SEO plugins and compare active installs and ratings."
- "Run the scraper for security plugins, then build a list with plugin authors and homepages."
- "Use the actor to check whether the slugs `woocommerce`, `wordpress-seo`, and `contact-form-7` are recently updated."
- "Create a CSV-ready dataset of WooCommerce extension competitors using the Apify WordPress plugin scraper."

### Export formats

After a run completes, Apify lets you export data as:

- JSON
- CSV
- Excel
- XML
- RSS
- HTML table

You can also read the dataset through the Apify API.

### Limits and caveats

- The actor returns public directory metadata.
- It does not log in to WordPress.org.
- It does not install, audit, or execute plugin code.
- Active install counts are directory estimates.
- Some plugin fields may be missing when WordPress.org does not provide them.
- Full sections can be large and may increase dataset size.

### Legality and responsible use

This actor extracts publicly available plugin directory metadata. You are responsible for using the data lawfully and respecting WordPress.org terms, privacy rules, and applicable regulations.

Do not use exported data for spam, abusive automation, or misleading outreach.

### Troubleshooting

#### Why did I get fewer records than `maxItems`?

The source may have fewer results for your query, or duplicate plugins may have been skipped across multiple queries and slugs.

#### Why is a field empty?

Some plugins do not provide every field. For example, a homepage, PHP requirement, screenshot list, or support statistic can be absent.

#### Should I enable full sections?

Enable `includeSections` only when you need long descriptions, changelogs, installation notes, or FAQ sections. For market scans, keep it disabled.

#### Can I scrape reviews?

This first version focuses on plugin metadata. Review scraping is a separate workflow and may be added later as a different dataset shape.

### Related scrapers

- [GitHub Repository Search Scraper](https://apify.com/fetch_cat/github-repository-search-scraper) for open-source repository discovery.
- [Hacker News Search Scraper](https://apify.com/fetch_cat/hacker-news-search-scraper) for developer conversation research.
- [Arxiv Paper Search Scraper](https://apify.com/fetch_cat/arxiv-paper-search-scraper) for research paper discovery.
- [Website Contact Finder](https://apify.com/fetch_cat/website-contact-finder) for contact enrichment workflows.

### Support

If a run fails or a plugin field looks incorrect, open an issue on Apify and include:

- **Input JSON**: the exact actor input you used.
- **Expected output**: the plugin records or fields you expected to receive.
- **Actual output**: the dataset rows, missing fields, error message, or run log excerpt you received.
- **Reproducible public URL**: a WordPress.org plugin page or search URL that demonstrates the issue, plus the Apify run URL or run ID.

### Summary

WordPress Plugin Directory Scraper gives marketers, agencies, analysts, and product teams a fast way to turn public WordPress.org plugin directory data into structured datasets.

### Changelog

- 2026-07-28 - Feature: Added ready-to-run Apify Store example tasks

- 2026-07-28 - Feature: Launched WordPress Plugin Directory Scraper on Apify Store
  - This actor is now publicly available in the Apify Store.

# Actor input Schema

## `queries` (type: `array`):

WordPress.org plugin directory search terms. Use plugin categories, buyer keywords, or competitor terms such as seo, security, ecommerce, forms, cache.

## `slugs` (type: `array`):

Optional direct plugin slugs or WordPress.org plugin URLs, e.g. woocommerce or https://wordpress.org/plugins/woocommerce/.

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

Maximum number of unique plugin records to save across all searches and direct slugs.

## `perPage` (type: `integer`):

Number of plugins requested per WordPress.org search API page. Higher values reduce requests; maximum is 100.

## `includeSections` (type: `boolean`):

Include full HTML sections such as description, installation, FAQ, changelog, and screenshots when available. This increases output size.

## `includeTags` (type: `boolean`):

Include WordPress.org plugin tags in each output record.

## `includeRatingsBreakdown` (type: `boolean`):

Include 1-star through 5-star rating counts when available.

## `locale` (type: `string`):

Optional WordPress.org locale code such as en\_US, de\_DE, fr\_FR. Leave empty for the default directory response.

## Actor input object example

```json
{
  "queries": [
    "seo",
    "security"
  ],
  "slugs": [
    "woocommerce",
    "seo-by-rank-math"
  ],
  "maxItems": 20,
  "perPage": 50,
  "includeSections": false,
  "includeTags": true,
  "includeRatingsBreakdown": true,
  "locale": "en_US"
}
```

# 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 = {
    "queries": [
        "seo",
        "security"
    ],
    "slugs": [
        "woocommerce",
        "seo-by-rank-math"
    ],
    "locale": "en_US"
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetch_cat/wordpress-plugin-directory-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 = {
    "queries": [
        "seo",
        "security",
    ],
    "slugs": [
        "woocommerce",
        "seo-by-rank-math",
    ],
    "locale": "en_US",
}

# Run the Actor and wait for it to finish
run = client.actor("fetch_cat/wordpress-plugin-directory-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 '{
  "queries": [
    "seo",
    "security"
  ],
  "slugs": [
    "woocommerce",
    "seo-by-rank-math"
  ],
  "locale": "en_US"
}' |
apify call fetch_cat/wordpress-plugin-directory-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "WordPress Plugin Directory Scraper",
        "description": "Scrape WordPress.org plugin metadata, ratings, installs, authors, tags, versions, and update signals from public searches and slugs.",
        "version": "0.1",
        "x-build-id": "d6fFeTuX9D6EKhgWm"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fetch_cat~wordpress-plugin-directory-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fetch_cat-wordpress-plugin-directory-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/fetch_cat~wordpress-plugin-directory-scraper/runs": {
            "post": {
                "operationId": "runs-sync-fetch_cat-wordpress-plugin-directory-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/fetch_cat~wordpress-plugin-directory-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-fetch_cat-wordpress-plugin-directory-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",
                "properties": {
                    "queries": {
                        "title": "Search queries",
                        "type": "array",
                        "description": "WordPress.org plugin directory search terms. Use plugin categories, buyer keywords, or competitor terms such as seo, security, ecommerce, forms, cache.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "slugs": {
                        "title": "Plugin slugs or URLs",
                        "type": "array",
                        "description": "Optional direct plugin slugs or WordPress.org plugin URLs, e.g. woocommerce or https://wordpress.org/plugins/woocommerce/.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Maximum plugin records",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of unique plugin records to save across all searches and direct slugs.",
                        "default": 20
                    },
                    "perPage": {
                        "title": "Search page size",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Number of plugins requested per WordPress.org search API page. Higher values reduce requests; maximum is 100.",
                        "default": 50
                    },
                    "includeSections": {
                        "title": "Include full section HTML",
                        "type": "boolean",
                        "description": "Include full HTML sections such as description, installation, FAQ, changelog, and screenshots when available. This increases output size.",
                        "default": false
                    },
                    "includeTags": {
                        "title": "Include plugin tags",
                        "type": "boolean",
                        "description": "Include WordPress.org plugin tags in each output record.",
                        "default": true
                    },
                    "includeRatingsBreakdown": {
                        "title": "Include ratings breakdown",
                        "type": "boolean",
                        "description": "Include 1-star through 5-star rating counts when available.",
                        "default": true
                    },
                    "locale": {
                        "title": "Locale",
                        "type": "string",
                        "description": "Optional WordPress.org locale code such as en_US, de_DE, fr_FR. Leave empty for the default directory response."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
