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

Extract public WordPress.org plugin and theme review topics with reviewer, rating, title, body, date, and profile metadata.

- **URL**: https://apify.com/w3crawler/wordpress-plugin-reviews-scraper.md
- **Developed by:** [w3crawler](https://apify.com/w3crawler) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.99 / 1,000 plugin reviews

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

### What does WordPress Plugin Reviews Scraper do?

WordPress Plugin Reviews Scraper extracts public review topics from the [WordPress.org support reviews](https://wordpress.org/support/plugin/woocommerce/reviews/) pages. It supports plugin and theme review listings as well as individual public support-topic URLs, then follows selected topics to capture the original reviewer, rating, title, body, publication text, profile URL, and reply counts.

The Actor uses server-rendered HTTPS pages and a Cheerio crawler, so it is lightweight and predictable for public support content. Requests are bounded, delayed politely, restricted to official WordPress.org paths, and reported truthfully when a page is unavailable. On Apify, you can run it by API, schedule recurring review monitoring, export datasets, connect integrations, and inspect request and diagnostic summaries.

### Why use WordPress Plugin Reviews Scraper?

Use the output for public customer-feedback research, plugin comparison, product-quality monitoring, support-team analysis, sentiment preparation, and review-count inventories. Stable review IDs help deduplicate repeated runs. Dataset rows contain only source-backed review data and provenance; the key-value summary reports numeric counts without diagnostic messages or request URL lists.

### How to use WordPress Plugin Reviews Scraper

1. Open the Input tab and provide one or more public review listing or topic URLs.
2. Set `maxItems` and `maxPages` to bound the crawl.
3. Enable `followPagination` only when you need additional pages from the same product review scope.
4. Start the Actor and review the dataset and `OUTPUT_SUMMARY` record.

### Input

`startUrls` accepts plugin or theme review listings such as `/support/plugin/woocommerce/reviews/` and individual `/support/topic/.../` URLs. `maxItems` caps review records, `maxPages` bounds listing pagination, and `followPagination` follows only same-scope listing pages. `requestDelayMs`, `maxConcurrency`, and `userAgent` control polite public access. `proxyConfiguration` is optional and is used only when you have an approved Apify Proxy configuration.

```json
{
  "startUrls": [
    { "url": "https://wordpress.org/support/plugin/woocommerce/reviews/" }
  ],
  "maxItems": 25,
  "maxPages": 1,
  "followPagination": false,
  "requestDelayMs": 600,
  "maxConcurrency": 1
}
```

### Output

Dataset rows have stable IDs, product scope, review title/body, rating, reviewer metadata, source URLs, and extraction timestamps. Run status, request totals, and numeric diagnostic counts are kept in `OUTPUT_SUMMARY`. Saved review rows produce `status: "SUCCEEDED"`; later request or metadata issues use `dataStatus: "PARTIAL"`. A genuine empty search is `SUCCEEDED` with `dataStatus: "NO_RESULTS"`. A source failure before any review row is `FAILED` with `dataStatus: "FAILED"` and no diagnostic dataset row.

```json
{
  "recordId": "wordpress_review_<sha256-prefix>",
  "recordType": "wordpress-review",
  "source": "WordPress.org public support reviews",
  "provenance": "wordpress_org_support_reviews_html_v1",
  "contentType": "plugin",
  "productSlug": "woocommerce",
  "title": "Great support",
  "body": "This is a helpful plugin.",
  "rating": 5,
  "reviewerName": "A public reviewer",
  "sourceUrl": "https://wordpress.org/support/topic/example/",
  "scrapedAt": "2026-09-08T00:00:00.000Z"
}
```

You can download the dataset in various formats such as JSON, HTML, CSV, or Excel.

### Data table

| Field | Description |
| --- | --- |
| `recordId`, `reviewId`, `recordType` | Stable review identity and normalized row type. |
| `contentType`, `productSlug`, `productName` | Plugin or theme scope from the public listing. |
| `title`, `body`, `rating` | Review title, original topic body, and star rating. |
| `reviewerName`, `reviewerUsername`, `reviewerProfileUrl` | Public reviewer signals when exposed. |
| `publishedAt`, `replyCount`, `participantCount` | Public topic timing and conversation counts. |
| `sourceUrl`, `listingUrl`, `provenance` | Direct evidence and extraction lineage. |

### Pricing / Cost estimation

#### How much does it cost to scrape WordPress reviews?

The Actor makes one request for each listing page and at most one request per selected topic, subject to `maxItems`, `maxPages`, retries, and pagination. Keeping `maxConcurrency` at 1 and using the default delay makes resource use predictable and considerate. Your Apify plan determines the final cost; small runs may fit within the platform free tier.

### Tips or advanced options

Use an individual topic URL for a precise review lookup. Use a listing URL with a small `maxItems` for a quick sample, then increase `maxPages` and enable same-scope pagination for an inventory. Review counts and page markup change over time, and some topics may be deleted or protected. JavaScript-only or login-gated content is reported rather than bypassed.

### FAQ, disclaimers, and support

Only public WordPress.org support pages are in scope. The Actor does not log in, collect private forum content, bypass CAPTCHAs or access controls, or mutate source pages. You are responsible for complying with WordPress.org terms, applicable law, and any required permission. Use the Issues tab for feedback or request a custom parser when a different public forum needs support.

### Local verification

```bash
npm ci
npm test
npm run lint
apify validate-schema
apify run --purge --input-file test/inputs/default.json
npm run validate
```

# Actor input Schema

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

HTTPS wordpress.org plugin/theme review listings or individual public support topics.

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

Hard cap on emitted review records.

## `maxPages` (type: `integer`):

Maximum review-listing pages followed per supplied listing URL.

## `followPagination` (type: `boolean`):

Follow same-scope review listing pages up to maxPages.

## `requestDelayMs` (type: `integer`):

Polite delay before each public request.

## `maxConcurrency` (type: `integer`):

Bounded parallelism for public review pages.

## `userAgent` (type: `string`):

Optional descriptive user agent for public requests.

## `proxyConfiguration` (type: `object`):

Optional Apify Proxy configuration for responsible public access.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://wordpress.org/support/plugin/woocommerce/reviews/"
    }
  ],
  "maxItems": 25,
  "maxPages": 1,
  "followPagination": false,
  "requestDelayMs": 600,
  "maxConcurrency": 1,
  "userAgent": "WordPressPluginReviewsScraper/1.1 (public WordPress.org support reviews)",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `dataset` (type: `string`):

No description

## `summary` (type: `string`):

No description

## `sourceMetadata` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "startUrls": [
        {
            "url": "https://wordpress.org/support/plugin/woocommerce/reviews/"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("w3crawler/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 = { "startUrls": [{ "url": "https://wordpress.org/support/plugin/woocommerce/reviews/" }] }

# Run the Actor and wait for it to finish
run = client.actor("w3crawler/wordpress-plugin-reviews-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "startUrls": [
    {
      "url": "https://wordpress.org/support/plugin/woocommerce/reviews/"
    }
  ]
}' |
apify call w3crawler/wordpress-plugin-reviews-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,w3crawler/wordpress-plugin-reviews-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/EHr6mNwUdbSZDTvIv/builds/rBCh1wrGvF53rNd0z/openapi.json