# WordPress Plugin Monitor — Releases & Rating Changes (`xqfech/wordpress-plugin-monitor`) Actor

Watches the WordPress.org plugin directory between runs. Detects new plugins in any search/tag, version releases, rating and install-base movements for watched plugins. Outputs structured change events, not raw snapshots.

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

## Pricing

from $20.00 / 1,000 change events

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

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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 Monitor — Track New Plugins, Releases & Rating Changes

Snapshot scrapers tell you what the WordPress.org plugin directory looks like right now. This Actor tells you **what changed since your last run**: new plugins in your niche, version releases, rating and install-base movement, compatibility updates — as structured change events ready for Slack, sheets, or your pipeline.

Built on the official WordPress.org plugins API. No HTML parsing, no login, no proxies — which also makes it unusually stable and cheap to run.

### What it does

- **Watch a niche** — give it search terms (e.g. `woocommerce email`) or official plugin tags (`seo`, `backup`, `forms`). Every run diffs the result set against the previous run: `new_plugin`, `removed_plugin`, and `plugin_changed` events with field-level before/after.
- **Watch the global new-plugins feed** — every brand-new plugin published to wordpress.org, useful for ecosystem watchers and lead generation (new plugin authors are fresh leads).
- **Watch specific plugins** — track competitors by slug: version releases, `tested up to` bumps, required PHP/WP changes, rating trends, active-install growth, tag and homepage changes.

### Who uses this

- **Plugin developers** — know the day a competitor ships a release, changes requirements, or starts losing rating.
- **Agencies** — track the plugins your client sites depend on: releases and compatibility signals without reading changelogs.
- **Security & maintenance teams** — a version change event is your trigger to review and update.
- **Data & BD teams** — the new-plugins feed is a steady source of fresh WordPress-ecosystem leads.

### Output example

```json
{
  "type": "plugin_changed",
  "source": "watch",
  "slug": "contact-form-7",
  "name": "Contact Form 7",
  "url": "https://wordpress.org/plugins/contact-form-7/",
  "changes": [
    { "field": "version", "before": "6.1.5", "after": "6.1.6" },
    { "field": "tested", "before": "6.8", "after": "6.9" }
  ],
  "detectedAt": "2026-08-04T10:00:00.000Z"
}
```

### Input

| Field | Description |
| --- | --- |
| `searchTerms` | Search queries watched as result sets |
| `tags` | Official plugin tags watched as result sets |
| `watchNewPlugins` | Watch the global new-plugins feed |
| `pluginSlugs` | Specific plugins tracked with detailed field diffs |
| `maxPagesPerList` | Pagination depth (100 plugins per page) |
| `monitorId` | State namespace shared between runs |

### Reliability

Data comes from the official `api.wordpress.org` JSON API — the same one wp-admin uses — so there is no markup to break. Every item is validated against a strict schema and the run fails loudly rather than silently storing garbage. Noisy counters (review counts) are smoothed so you only see meaningful changes.

### Scheduling

Run it daily with an Apify Schedule and pipe change events to Slack, email, or Google Sheets via Apify integrations. Quiet days produce no change events and cost almost nothing.

### FAQ

**Does it need credentials?** No — the WordPress.org API is public.

**Can I watch several niches separately?** Yes, use different `monitorId` values per schedule.

**First run?** It stores a baseline (optionally emitted as `baseline` items); real change events start from run two.

# Actor input Schema

## `searchTerms` (type: `array`):

Each term is watched as a result set: new plugins entering the results, plugins leaving, and field changes (version, rating, installs) are reported.

## `tags` (type: `array`):

Official wordpress.org plugin tags, e.g. seo, backup, forms.

## `watchNewPlugins` (type: `boolean`):

Reports every brand-new plugin published to the directory.

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

Exact slugs (e.g. contact-form-7). Tracks version, tested-up-to, requirements, rating, installs, tags and homepage with field-level diffs.

## `maxPagesPerList` (type: `integer`):

100 plugins per page.

## `monitorId` (type: `string`):

State namespace. Runs with the same Monitor ID share the previous-run snapshot.

## `emitBaseline` (type: `boolean`):

On the very first run the full initial snapshot is pushed as baseline items so you still get data.

## Actor input object example

```json
{
  "searchTerms": [
    "woocommerce email"
  ],
  "watchNewPlugins": false,
  "pluginSlugs": [
    "contact-form-7"
  ],
  "maxPagesPerList": 1,
  "monitorId": "default",
  "emitBaseline": true
}
```

# 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 = {
    "searchTerms": [
        "woocommerce email"
    ],
    "pluginSlugs": [
        "contact-form-7"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("xqfech/wordpress-plugin-monitor").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 = {
    "searchTerms": ["woocommerce email"],
    "pluginSlugs": ["contact-form-7"],
}

# Run the Actor and wait for it to finish
run = client.actor("xqfech/wordpress-plugin-monitor").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 '{
  "searchTerms": [
    "woocommerce email"
  ],
  "pluginSlugs": [
    "contact-form-7"
  ]
}' |
apify call xqfech/wordpress-plugin-monitor --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

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