# WordPress Plugin Directory Stats and Health Score (`transparent_meteorite/wordpress-plugin-directory-stats`) Actor

Get WordPress plugin directory stats: active installs, rating, downloads, version, last updated, tested-up-to WordPress version, support thread resolution and a health score that flags abandoned plugins. Uses the public WordPress.org plugins API. No login, no proxy.

- **URL**: https://apify.com/transparent_meteorite/wordpress-plugin-directory-stats.md
- **Developed by:** [Detroit Web Agent - Open Data](https://apify.com/transparent_meteorite) (community)
- **Categories:** Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.84 / 1,000 plugin rows

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

## WordPress Plugin Directory Stats and Health Score: Installs, Updates, Abandonment Risk

**WordPress plugin scraper** for the official WordPress.org plugin directory API: active installs, rating, downloads, version, last update, tested-up-to and PHP requirements, support resolution and a 0-100 health score with abandonment risk.

**This Actor vs nexgendata/wordpress-plugin-scraper:** that one also covers themes and version history. Choose this one for a health score and abandonment risk per plugin, a tested-up-to lag count, and an at-risk-only filter for spotting neglected plugins.

Read the WordPress.org plugin directory and get one clean row per plugin: active installs, rating, total downloads, version, last updated date, the WordPress version it was tested up to, PHP requirement, support thread resolution and a health score that shows which plugins look neglected. Pick the popular, new, updated or top-rated lists, or name the plugins you care about.

### What does this Actor do?

It calls the free public WordPress.org plugins API (`api.wordpress.org/plugins/info/1.2/`), the same API the WordPress admin uses to browse plugins. No key and no login are needed. For each plugin it works out how many days have passed since the last update, how many WordPress releases behind its "tested up to" version is, and how many support threads were resolved, then combines them into a health score from 0 to 100.

By default it reads the popular, new and recently updated lists (25 plugins each, duplicates removed), so a default run returns roughly 60 to 75 rows.

**Run in 30 seconds**

1. Open the Actor and press **Try for free** (a free Apify account is enough).
2. Keep the prefilled lists and press **Start**. A run takes well under a minute.
3. Open the **Output** tab. Use the table view or download CSV, Excel or JSON.

### Input

| Field | What it does |
|---|---|
| `browse` | Directory lists to read: `popular`, `new`, `updated`, `top-rated`. Default: popular, new, updated. |
| `perList` | Plugins to read per list, 1 to 100. Default 25. |
| `slugs` | Optional extra plugins by slug, for example `akismet`. A wordpress.org/plugins link also works. |
| `search` | Optional directory search term, for example `seo`. |
| `minActiveInstalls` | Drop plugins below this many active installs. |
| `onlyAtRisk` | Keep only plugins with medium or high abandonment risk. |
| `sortBy` | `activeInstalls`, `healthScore` (lowest first), `lastUpdatedAt` or `downloadedTotal`. |
| `maxItems` | Stop after this many rows. |

Sample input:

```json
{
  "browse": ["popular", "updated"],
  "perList": 50,
  "slugs": ["akismet", "woocommerce"],
  "onlyAtRisk": false,
  "sortBy": "healthScore",
  "maxItems": 100
}
```

### Output

One row per plugin:

| Field | Meaning |
|---|---|
| `slug`, `name`, `pluginUrl` | Plugin identifier, display name and its wordpress.org page. |
| `activeInstalls` | Active installs as WordPress.org reports them (rounded steps such as 10,000 or 1,000,000). |
| `rating`, `numRatings` | Average rating from 0 to 5 stars and the number of ratings. |
| `downloadedTotal` | Total downloads over the plugin's life. |
| `version`, `lastUpdatedAt`, `addedAt` | Current version, last update time (UTC) and the date it joined the directory. |
| `testedUpToWp`, `requiresWp`, `requiresPhp` | Compatibility fields the plugin declares. |
| `supportThreadsResolved`, `supportThreadsTotal`, `supportResolvedPct` | Support forum threads resolved and total. |
| `daysSinceUpdate`, `testedLagReleases` | Days since the last update and how many WordPress releases behind the tested-up-to version is. |
| `healthScore`, `healthLabel`, `abandonmentRisk` | 0 to 100 score, a label (healthy, watch, at risk) and low, medium or high risk. |
| `scrapedAt` | When the row was read. |

Developer names, profiles and contact details are not output.

### Sample output

```json
{
  "slug": "elementor",
  "name": "Elementor Website Builder - more than just a page builder",
  "pluginUrl": "https://wordpress.org/plugins/elementor/",
  "activeInstalls": 10000000,
  "rating": 4.5,
  "numRatings": 7319,
  "downloadedTotal": 910268920,
  "version": "4.3.5",
  "lastUpdatedAt": "2026-10-13T12:48:00.000Z",
  "addedAt": "2016-05-30",
  "testedUpToWp": "7.1.3",
  "requiresPhp": "7.4",
  "supportThreadsResolved": 45,
  "supportThreadsTotal": 65,
  "daysSinceUpdate": 9,
  "testedLagReleases": 0,
  "healthScore": 94,
  "healthLabel": "healthy",
  "abandonmentRisk": "low"
}
```

### Use cases

- Vet a plugin before you install it on a client site: a long gap since the last update and an old tested-up-to version are warning signs.
- Audit the plugins on your sites every month: list their slugs, sort by `healthScore` and replace the weakest ones first.
- Spot new plugins that gain installs quickly, for newsletters, competitor research or product ideas.
- Feed rows into an n8n, Make or Zapier workflow that posts at-risk plugins to Slack or opens a ticket.
- Build a ranked "best maintained plugins in a niche" article using the search term and health score.

### Why use it

- **Official source.** Data comes from the WordPress.org plugins API, not from page scraping.
- **A score you can explain.** The health score is a fixed formula, so the same plugin gives the same score on the same day.
- **Ready for spreadsheets and workflows.** Flat rows, ISO dates and numbers, no HTML to clean up.

### Pricing

Pay per event. You pay a small fixed amount per plugin row delivered, listed on the Pricing tab, plus a tiny start fee per run. Slugs that are not found are never charged, and you can set a maximum cost per run in the run options.

### FAQ

**How is the health score calculated?**
Up to 50 points for how recently the plugin was updated (full marks at 30 days or less, zero at about two years), up to 30 points for the tested-up-to WordPress version (10 points lost for each WordPress release behind the current one), and up to 20 points for the share of support threads resolved (10 points when there are no threads). Risk is high when a plugin has not been updated for more than two years or scores under 35, medium under 60, otherwise low.

**Which WordPress version counts as current?**
The actor reads the current release from the WordPress.org version check at run time. If that is unavailable it uses the newest tested-up-to value in the run and says so in the OUTPUT record.

**Why are active installs round numbers?**
WordPress.org publishes active installs in steps, for example 100, 1,000, 10,000 and 1,000,000+. The actor passes them on unchanged.

**Why is the plugin rating a decimal like 4.5?**
The API gives a 0 to 100 value. The actor divides it by 20 to give 0 to 5 stars.

### Limits

- Only the public plugin directory is read. Premium plugins sold elsewhere are not included.
- The list endpoints return up to 100 plugins per list per run.
- Some very new plugins have no ratings, installs or support threads yet; those fields are empty or zero.
- Install counts and ratings are exactly as WordPress.org publishes them.

### Related Actors

- [Developer Signals](https://apify.com/transparent_meteorite/developer-signals) tracks public developer activity signals for companies.
- [Website Tech Stack](https://apify.com/transparent_meteorite/website-tech-stack) detects which technologies a website runs on.
- [Sitemap Link Inventory](https://apify.com/transparent_meteorite/sitemap-link-inventory) lists every URL a site publishes in its sitemaps.

Found a bug or need a field? Open an issue on the Issues tab with the run URL.

### More from DWA Open Data

Browse all 69 data Actors, with live prices and sample output, at [open-data-actors.pages.dev](https://open-data-actors.pages.dev).

***

**Feedback:** if this Actor was useful, or if it fell short, an honest review on the [Reviews tab](https://apify.com/transparent_meteorite/wordpress-plugin-directory-stats/reviews) helps other users decide. Problems or feature requests: please open an [Issue](https://apify.com/transparent_meteorite/wordpress-plugin-directory-stats/issues) and we usually reply within one business day.

# Actor input Schema

## `browse` (type: `array`):

Which WordPress.org plugin directory lists to read. Plugins that appear in more than one list are returned once.

## `perList` (type: `integer`):

How many plugins to read from each list (1 to 100).

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

Extra plugins to look up by slug, one per line, for example "akismet" or "woocommerce". A wordpress.org/plugins/<slug>/ link also works.

## `search` (type: `string`):

Also read plugins matching this search in the directory, for example "seo" or "contact form".

## `minActiveInstalls` (type: `integer`):

Drop plugins with fewer active installs than this. WordPress.org reports installs in steps (10, 100, 1000 and so on).

## `onlyAtRisk` (type: `boolean`):

Keep only plugins whose abandonment risk is medium or high.

## `sortBy` (type: `string`):

Order of the output rows.

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

Stop after this many rows. You pay only for rows delivered.

## Actor input object example

```json
{
  "browse": [
    "popular",
    "new",
    "updated"
  ],
  "perList": 25,
  "minActiveInstalls": 0,
  "onlyAtRisk": false,
  "sortBy": "activeInstalls",
  "maxItems": 100
}
```

# 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 = {
    "browse": [
        "popular",
        "new",
        "updated"
    ],
    "perList": 25,
    "maxItems": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("transparent_meteorite/wordpress-plugin-directory-stats").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 = {
    "browse": [
        "popular",
        "new",
        "updated",
    ],
    "perList": 25,
    "maxItems": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("transparent_meteorite/wordpress-plugin-directory-stats").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 '{
  "browse": [
    "popular",
    "new",
    "updated"
  ],
  "perList": 25,
  "maxItems": 100
}' |
apify call transparent_meteorite/wordpress-plugin-directory-stats --silent --output-dataset

```

## MCP server setup

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

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/Npa2X2lBExc36wgvr/builds/M3DnmtD8W7c8Iatzd/openapi.json