# WordPress Plugin Reviews Scraper (`crawlerbros/wordpress-plugin-reviews-scraper`) Actor

Scrape user reviews from WordPress.org plugin and theme listings. Extracts reviewer name, star rating (1-5), review title, review body, date, and profile URL. Works for plugins and themes. No login or API key required

- **URL**: https://apify.com/crawlerbros/wordpress-plugin-reviews-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Developer tools, Automation, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 7 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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

## WordPress Plugin Reviews Scraper

Scrape user reviews from [WordPress.org](https://wordpress.org/) plugin and theme listings. Extracts star ratings, reviewer names, review text, dates, and profile URLs — no login, API key, or proxy required.

### What It Does

For each plugin or theme you specify, this actor:
- Fetches reviews via the public WordPress.org RSS feed
- Extracts star rating (1–5), reviewer name and profile link, review title, full review body, and publication date
- Supports pagination to retrieve hundreds of reviews per plugin
- Supports filtering by star rating (e.g., only 1-star or only 5-star reviews)

### Input

| Field | Type | Description |
|-------|------|-------------|
| `mode` | `select` | **Required.** `bySlug` (default), `byUrl`, or `search` |
| `contentType` | `select` | `plugins` (default), `themes`, or `both` |
| `pluginSlugs` | `string[]` | Plugin slugs for `bySlug` mode (e.g. `woocommerce`, `contact-form-7`) |
| `themeSlugs` | `string[]` | Theme slugs for `bySlug` mode (e.g. `astra`, `neve`) |
| `startUrls` | `string[]` | WordPress.org URLs for `byUrl` mode |
| `searchQuery` | `string` | Keyword for `search` mode |
| `filterRating` | `select` | Only return reviews with this rating (1–5), empty = all |
| `maxReviewsPerItem` | `integer` | Max reviews per plugin/theme (1–500, default: 30) |
| `maxItems` | `integer` | Max total reviews (1–5000, default: 100) |

#### Example: Fetch reviews for WooCommerce

```json
{
  "mode": "bySlug",
  "pluginSlugs": ["woocommerce"],
  "maxReviewsPerItem": 50,
  "maxItems": 50
}
````

#### Example: Fetch only 1-star reviews (for negative feedback analysis)

```json
{
  "mode": "bySlug",
  "pluginSlugs": ["woocommerce", "contact-form-7"],
  "filterRating": "1",
  "maxReviewsPerItem": 100,
  "maxItems": 200
}
```

#### Example: Search and scrape reviews

```json
{
  "mode": "search",
  "searchQuery": "page builder",
  "contentType": "plugins",
  "maxReviewsPerItem": 30
}
```

#### Finding Plugin Slugs

Navigate to any plugin page on [wordpress.org/plugins](https://wordpress.org/plugins/). The URL will be:

```
https://wordpress.org/plugins/woocommerce/
                              ^^^^^^^^^^^
                              This is the slug
```

### Output

Each record contains:

| Field | Type | Description |
|-------|------|-------------|
| `reviewId` | `string` | Unique review identifier (topic slug) |
| `pluginSlug` | `string` | WordPress.org plugin or theme slug |
| `pluginName` | `string` | Plugin/theme display name |
| `contentType` | `string` | `plugins` or `themes` |
| `pluginUrl` | `string` | WordPress.org listing URL |
| `reviewerName` | `string` | Reviewer's WordPress.org username |
| `reviewerProfileUrl` | `string` | Link to reviewer's WordPress.org profile |
| `rating` | `integer` | Star rating (1–5) |
| `reviewTitle` | `string` | Review title/headline |
| `reviewText` | `string` | Full review body text |
| `reviewDate` | `string` | ISO-8601 publication date |
| `reviewUrl` | `string` | Direct link to the review |
| `scrapedAt` | `string` | ISO-8601 timestamp of extraction |

#### Example Output

```json
{
  "reviewId": "perfect-for-our-needs-29",
  "pluginSlug": "woocommerce",
  "pluginName": "WooCommerce",
  "contentType": "plugins",
  "pluginUrl": "https://wordpress.org/plugins/woocommerce/",
  "reviewerName": "ninjabeaver",
  "reviewerProfileUrl": "https://profiles.wordpress.org/ninjabeaver/",
  "rating": 5,
  "reviewTitle": "Perfect for our needs",
  "reviewText": "I've been running Woocommerce for a few years on a charity website and it never lets me down.",
  "reviewDate": "2026-05-19T19:18:16+00:00",
  "reviewUrl": "https://wordpress.org/support/topic/perfect-for-our-needs-29/",
  "scrapedAt": "2026-05-20T10:00:00+00:00"
}
```

### Use Cases

- **Plugin comparison**: Compare ratings and sentiment between competing WordPress plugins
- **Market research**: Understand what users love or hate about popular plugins
- **Competitive analysis**: Identify pain points with competitor plugins
- **Quality monitoring**: Track review trends over time for your own plugin
- **NLP training**: Collect labeled review data (1–5 stars) for sentiment models

### Supported Plugins & Themes

Works with any plugin or theme listed on WordPress.org with at least one review. Popular examples:

- Plugins: `woocommerce`, `contact-form-7`, `jetpack`, `elementor`, `yoast-seo`, `akismet`
- Themes: `astra`, `neve`, `oceanwp`, `hello-elementor`, `storefront`

### FAQ

**Do I need a WordPress.org account?**
No. All review data is publicly accessible without authentication.

**How many reviews can I fetch?**
Up to 500 reviews per plugin per run. Each RSS page returns 30 reviews; the actor paginates automatically.

**Can I filter by star rating?**
Yes. Use the `filterRating` field to fetch only 1-star, 2-star, 3-star, 4-star, or 5-star reviews.

**Does this also work for themes?**
Yes. Set `contentType` to `themes` and provide `themeSlugs`.

**How recent is the data?**
The RSS feed always returns the most recent reviews first. All dates are in ISO-8601 format.

### Data Source

WordPress.org is the official plugin and theme repository for WordPress, hosting 50,000+ plugins and 10,000+ themes. Review data is publicly available via RSS feeds at `wordpress.org/support/{plugins|themes}/{slug}/reviews/?feed=rss2`.

### Limitations

- Reviews only available for plugins/themes listed on wordpress.org (not premium-only plugins)
- Review text limited to the content visible in the public RSS feed
- WordPress.org rate limits aggressive scraping — the actor uses polite 300ms delays between pages

# Actor input Schema

## `mode` (type: `string`):

How to select what to scrape.

## `contentType` (type: `string`):

Whether to scrape plugin reviews, theme reviews, or both (used in search and bySlug modes).

## `pluginSlugs` (type: `array`):

Plugin slug identifiers for bySlug mode (e.g. woocommerce, contact-form-7, jetpack). Find the slug in the WordPress.org URL: wordpress.org/plugins/{slug}/

## `themeSlugs` (type: `array`):

Theme slug identifiers for bySlug mode (e.g. astra, hello-elementor, neve). Find the slug in the WordPress.org URL: wordpress.org/themes/{slug}/

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

Direct WordPress.org plugin or theme URLs for byUrl mode, e.g. https://wordpress.org/plugins/woocommerce/ or https://wordpress.org/themes/astra/

## `searchQuery` (type: `string`):

Keyword to search plugins/themes (mode=search). Reviews will be scraped for the top results.

## `filterRating` (type: `string`):

Only return reviews with this star rating. Leave empty for all ratings.

## `maxReviewsPerItem` (type: `integer`):

Maximum number of reviews to fetch per plugin or theme (1–500).

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

Maximum total review records to return across all plugins/themes (1–5000).

## Actor input object example

```json
{
  "mode": "bySlug",
  "contentType": "plugins",
  "pluginSlugs": [
    "woocommerce"
  ],
  "themeSlugs": [],
  "startUrls": [],
  "filterRating": "",
  "maxReviewsPerItem": 30,
  "maxItems": 100
}
```

# Actor output Schema

## `reviews` (type: `string`):

Dataset containing all scraped WordPress.org plugin and theme reviews.

# 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 = {
    "mode": "bySlug",
    "contentType": "plugins",
    "pluginSlugs": [
        "woocommerce"
    ],
    "themeSlugs": [],
    "startUrls": [],
    "searchQuery": "",
    "filterRating": "",
    "maxReviewsPerItem": 30,
    "maxItems": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/wordpress-plugin-reviews-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 = {
    "mode": "bySlug",
    "contentType": "plugins",
    "pluginSlugs": ["woocommerce"],
    "themeSlugs": [],
    "startUrls": [],
    "searchQuery": "",
    "filterRating": "",
    "maxReviewsPerItem": 30,
    "maxItems": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/wordpress-plugin-reviews-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 '{
  "mode": "bySlug",
  "contentType": "plugins",
  "pluginSlugs": [
    "woocommerce"
  ],
  "themeSlugs": [],
  "startUrls": [],
  "searchQuery": "",
  "filterRating": "",
  "maxReviewsPerItem": 30,
  "maxItems": 100
}' |
apify call crawlerbros/wordpress-plugin-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "WordPress Plugin Reviews Scraper",
        "description": "Scrape user reviews from WordPress.org plugin and theme listings. Extracts reviewer name, star rating (1-5), review title, review body, date, and profile URL. Works for plugins and themes. No login or API key required",
        "version": "1.0",
        "x-build-id": "FVePzzNfR6F8dlX3o"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~wordpress-plugin-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-wordpress-plugin-reviews-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/crawlerbros~wordpress-plugin-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-wordpress-plugin-reviews-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/crawlerbros~wordpress-plugin-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-wordpress-plugin-reviews-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": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "bySlug",
                            "search",
                            "byUrl"
                        ],
                        "type": "string",
                        "description": "How to select what to scrape.",
                        "default": "bySlug"
                    },
                    "contentType": {
                        "title": "Content type",
                        "enum": [
                            "plugins",
                            "themes",
                            "both"
                        ],
                        "type": "string",
                        "description": "Whether to scrape plugin reviews, theme reviews, or both (used in search and bySlug modes).",
                        "default": "plugins"
                    },
                    "pluginSlugs": {
                        "title": "Plugin slugs",
                        "type": "array",
                        "description": "Plugin slug identifiers for bySlug mode (e.g. woocommerce, contact-form-7, jetpack). Find the slug in the WordPress.org URL: wordpress.org/plugins/{slug}/",
                        "items": {
                            "type": "string"
                        }
                    },
                    "themeSlugs": {
                        "title": "Theme slugs",
                        "type": "array",
                        "description": "Theme slug identifiers for bySlug mode (e.g. astra, hello-elementor, neve). Find the slug in the WordPress.org URL: wordpress.org/themes/{slug}/",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "WordPress.org URLs",
                        "type": "array",
                        "description": "Direct WordPress.org plugin or theme URLs for byUrl mode, e.g. https://wordpress.org/plugins/woocommerce/ or https://wordpress.org/themes/astra/",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchQuery": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Keyword to search plugins/themes (mode=search). Reviews will be scraped for the top results."
                    },
                    "filterRating": {
                        "title": "Filter by rating",
                        "enum": [
                            "",
                            "5",
                            "4",
                            "3",
                            "2",
                            "1"
                        ],
                        "type": "string",
                        "description": "Only return reviews with this star rating. Leave empty for all ratings.",
                        "default": ""
                    },
                    "maxReviewsPerItem": {
                        "title": "Max reviews per plugin/theme",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of reviews to fetch per plugin or theme (1–500).",
                        "default": 30
                    },
                    "maxItems": {
                        "title": "Max total items",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum total review records to return across all plugins/themes (1–5000).",
                        "default": 100
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
