# WordPress Plugin Vendor Scraper — Developer B2B Leads (`w3crawler/wordpress-plugin-vendor-leads-scraper`) Actor

- **URL**: https://apify.com/w3crawler/wordpress-plugin-vendor-leads-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 vendor leads

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 Vendor Scraper do?

This Actor queries the official [WordPress.org Plugin Directory](https://wordpress.org/plugins/) information API and returns public plugin, developer, and vendor intelligence. It supports keyword discovery, an optional exact tag, minimum active-install and rating filters, bounded pagination, and optional detail enrichment through the public `api.wordpress.org` endpoints.

The Actor uses keyless HTTPS requests only. It does not log in, access private sites, use credentials or proxies, download premium products, or perform mutations. Public-source failures, blocked responses, malformed payloads, empty matches, and detail failures are represented explicitly instead of being silently treated as successful data.

### Why use WordPress Plugin Vendor Scraper?

Use the dataset for WordPress ecosystem research, plugin/vendor comparison, public market intelligence, compatibility inventories, support-health analysis, partnership research, and lead discovery. `vendorLeadEligible` is deliberately conservative: it is true only when a public HTTPS vendor homepage is available outside WordPress.org. It is not a claim that the vendor is for sale or that outreach is permitted. `businessModel` is an enum (`commercial`, `freemium`, `free`, `unknown`) sourced only from the WordPress.org API's explicit value; the API's boolean `false` and missing or unsupported values become `unknown`, never the string `"false"` or an inferred `free` claim.

### How to use WordPress Plugin Vendor Scraper

1. Search the public directory with a phrase such as `seo`, or leave `search` empty to browse.
2. Optionally set `tag`, `minActiveInstalls`, or `minRating` to narrow candidates.
3. Bound the run with `maxItems`, `maxPages`, and `perPage`.
4. Enable `includeDetails` when compatibility, support, download, or commercial-link enrichment is useful.
5. Keep `requestDelayMs` at or above the default for polite serial requests, and use `OUTPUT_SUMMARY` (also mirrored as `OUTPUT`) for run counts and diagnostics.

### Input

`search` is the public WordPress.org search phrase. `tag` is an exact normalized tag filter. `minActiveInstalls` and `minRating` apply public directory thresholds. `maxItems`, `maxPages`, and `perPage` bound discovery. `includeDetails` optionally calls the official `plugin_information` endpoint for matched slugs. `requestDelayMs` controls the minimum interval between source requests, `timeoutSecs` bounds each request, and `retries` allows up to three bounded retries for transient failures.

```json
{
  "search": "seo",
  "tag": "seo",
  "minActiveInstalls": 100000,
  "minRating": 80,
  "maxItems": 10,
  "maxPages": 1,
  "perPage": 20,
  "includeDetails": true,
  "requestDelayMs": 500,
  "timeoutSecs": 30,
  "retries": 2
}
```

### Output

Dataset rows have `recordType: "plugin_vendor"` and contain only public plugin/vendor business fields plus source lineage. `sourceUrl` is the canonical official API endpoint without search parameters. Run status, request URLs, filters, and optional detail-request outcomes are kept in `RUN_METADATA` and `OUTPUT_SUMMARY`; the summary is also mirrored under the compatibility key `OUTPUT`. Saved records produce `status: "SUCCEEDED"`; later optional detail or metadata issues use `dataStatus: "PARTIAL"`. A genuine empty search is `SUCCEEDED` with `dataStatus: "NO_RESULTS"`. A failed source request before any plugin record is `FAILED` with `dataStatus: "FAILED"` and no diagnostic dataset row.

```json
{
  "recordId": "wordpress_plugin_vendor_plugin_example-plugin_<digest>",
  "recordType": "plugin_vendor",
  "source": "WordPress.org Plugin Directory API",
  "provenance": "wordpress_org_plugin_directory_api_v2_business_model_contract",
  "pluginSlug": "example-plugin",
  "pluginName": "Example Plugin",
  "pluginUrl": "https://wordpress.org/plugins/example-plugin/",
  "vendorName": "Example Vendor",
  "vendorWebsite": "https://example.com/plugin",
  "vendorDomain": "example.com",
  "businessModel": "commercial",
  "businessModelEvidence": "wordpress-api-explicit",
  "activeInstalls": 12000,
  "rating": 92,
  "ratingsCount": 100,
  "tags": ["analytics", "seo"],
  "vendorLeadEligible": true,
  "sourceUrl": "https://api.wordpress.org/plugins/info/1.2/",
  "retrievedAt": "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`, `recordType` | Stable row identity and business-record type. |
| `pluginSlug`, `pluginName`, `pluginUrl` | Public WordPress.org plugin identity and directory page. |
| `vendorName`, `authorProfileUrl`, `vendorWebsite`, `vendorDomain` | Public authorship and vendor links after HTTPS/domain checks. |
| `activeInstalls`, `rating`, `ratingsCount`, `downloads` | Point-in-time popularity and rating measures. |
| `supportThreads`, `supportThreadsResolved` | Public support-volume signals when exposed. |
| `tags`, `version`, `requires`, `tested`, `requiresPhp` | Public taxonomy and compatibility fields. |
| `businessModel`, `businessModelEvidence` | Explicit WordPress.org business-model value and evidence classification; unknown is preserved when the source is non-committal. |
| `commercialSupportUrl`, `downloadUrl` | Public commercial or support links when present. |
| `vendorLeadEligible` | Conservative lead eligibility derived from public vendor evidence. |
| `source`, `provenance`, `sourceUrl`, `retrievedAt` | Source lineage and retrieval timestamp. |

`RUN_METADATA` and `OUTPUT_SUMMARY` contain serialized JSON with filters, request/page counts, candidate and match counts, source-backed record counts, duplicate metrics, numeric diagnostic/failure counts, request URLs, vendor domains, `businessModelCounts`, and generated-by metadata. Detailed issue messages stay in run logs. `OUTPUT` contains the same count-only summary as `OUTPUT_SUMMARY` for compatibility.

### Pricing / Cost estimation

The Actor performs one bounded search request per fetched page and, when `includeDetails` is enabled, up to one detail request per matched plugin. `maxItems`, `maxPages`, request delays, retries, timeouts, and response limits keep resource use predictable. Your Apify plan determines the final platform cost.

### Tips or advanced options

Use an exact tag and minimum thresholds for focused lead research. Keep `includeDetails` disabled when directory search data is sufficient. Use a nonzero `requestDelayMs` for repeated or larger runs. Public installs, ratings, support counts, versions, and vendor links are point-in-time source values and can change between runs.

### FAQ, disclaimers, and support

Only public, keyless WordPress.org Plugin Directory API data is in scope. The Actor does not infer private contact details, verify vendor intent, or authorize outreach. You are responsible for lawful use, terms compliance, and appropriate request rates. If the official response shape changes, the Actor emits a diagnostic rather than fabricating values. Use the Issues tab for feedback.

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

# Changelog

This Actor's version history is a separate document: https://apify.com/w3crawler/wordpress-plugin-vendor-leads-scraper/changelog.md

# Actor input Schema

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

WordPress.org plugin search phrase. Leave empty to browse the directory.

## `tag` (type: `string`):

Optional exact WordPress.org tag filter, such as e-commerce or analytics.

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

Keep plugins whose public active-install count is at least this value.

## `minRating` (type: `integer`):

Minimum WordPress.org rating percentage from 0 through 100.

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

Maximum matching plugin vendor records to emit.

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

Maximum public API query pages.

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

Public API page size.

## `includeDetails` (type: `boolean`):

Fetch the official plugin_information endpoint for each matched plugin.

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

Polite delay between official WordPress.org API requests.

## `timeoutSecs` (type: `integer`):

Timeout for each official WordPress.org API request.

## `retries` (type: `integer`):

Bounded retries for timeouts, rate limits, and transient 5xx responses.

## Actor input object example

```json
{
  "search": "seo",
  "minActiveInstalls": 0,
  "minRating": 0,
  "maxItems": 20,
  "maxPages": 1,
  "perPage": 20,
  "includeDetails": false,
  "requestDelayMs": 500,
  "timeoutSecs": 30,
  "retries": 2
}
```

# Actor output Schema

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

Dataset containing source-backed plugin vendor records only.

## `runMetadata` (type: `string`):

Serialized filters, request evidence, counts, and source metadata stored under RUN_METADATA.

## `outputSummary` (type: `string`):

Serialized output summary stored under OUTPUT_SUMMARY.

## `output` (type: `string`):

Compatibility alias of OUTPUT_SUMMARY stored under OUTPUT.

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("w3crawler/wordpress-plugin-vendor-leads-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("w3crawler/wordpress-plugin-vendor-leads-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 '{}' |
apify call w3crawler/wordpress-plugin-vendor-leads-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,w3crawler/wordpress-plugin-vendor-leads-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/nrIdiIJevgnI74FLj/builds/A6TAdn8vIyARP5DMk/openapi.json