# JetBrains Marketplace Publisher Lead Extractor (`ayeeyee/jetbrains-marketplace-publisher-lead-extractor`) Actor

Verified dev-tool vendor leads from the JetBrains Marketplace: MX/DNS emails, phones, socials + tech stack scraped from the publisher's OWN declared website, an A-D lead score, plugin traction, a verified/trader trust signal, and a vendor-readiness grade. No API keys, no proxy. Per-result pricing.

- **URL**: https://apify.com/ayeeyee/jetbrains-marketplace-publisher-lead-extractor.md
- **Developed by:** [Virtual Footprint LLC](https://apify.com/ayeeyee) (community)
- **Categories:** Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 publisher lead with contacts

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
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 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

## JetBrains Marketplace Publisher Lead Extractor

Turn JetBrains Marketplace plugins (IntelliJ / PyCharm / WebStorm / GoLand / Rider / PhpStorm / CLion / Android Studio) into **verified dev-tool vendor sales leads** — MX/DNS-validated contact emails, phones, social profiles, tech stack and an A–D lead score, all scraped from the publisher's **OWN declared website**, plus the vendor's plugin traction (downloads / rating / newest publish), a verified/trader trust badge, a vendor-readiness grade, and a "freshly published within the window" signal.

> Per-result pricing. You're charged only when a vendor returns a real contact signal — not for empty lookups. No API keys, no proxy required (the JetBrains Marketplace APIs are public keyless endpoints).

### Why this exists

Every existing JetBrains Marketplace Apify actor is **metadata-only** — they export plugin names/downloads and stop there. **None ship vendor *contact* leads.** This actor is first-to-market on the vendor-CONTACT lead lane: it resolves the publisher behind each plugin, walks to the publisher's own declared website (`vendor.url`), and verifies a real business contact there (MX/DNS-checked email, phone, socials, tech stack) — the data a B2B sales team actually buys.

Incumbents (all metadata-only, ≤2 users, unrated): `benthepythondev/jetbrains-plugins-scraper`, `automation-lab/jetbrains-marketplace-scraper`, `parseforge/jetbrains-marketplace-plugins-scraper`, `crawlerbros/jetbrains-marketplace-scraper`, `jungle_synthesizer/jetbrains-plugin-marketplace-scraper`.

### What it does

For each publisher vendor:

1. **Discovers** plugins via JetBrains Marketplace's keyless `/api/searchPlugins?search=…` (and/or resolves explicit plugin-id/URL refs). The Marketplace owner (**JetBrains s.r.o.**) is dropped — not a sellable third-party target (same self-discipline as Docker Hub's official-image drop).
2. **Resolves the vendor** via `/api/plugins/{id}`, which returns the full `vendor` object — including the publisher's **OWN declared `vendor.url`** website + `isVerified`/`isTrader`/`country` trust signals + `cdate` (epoch ms).
3. **Filters** honestly: vendors **without a declared `vendor.url`** are dropped (no vendor website to enrich → not billed) — the data-driven equivalent of Docker's official-image drop. Verified-only is optional.
4. **Enriches the vendor's own website** with the shared enrichment layer — MX/DNS-verified emails, NANP phones, socials, tech stack, A–D lead score. The Marketplace `vendor.email` personal/support address is deliberately **not** surfaced — contact always comes from the publisher's own declared site (ToS-clean, identical to the App-Store `sellerUrl` / Steam `website` / Docker Hub `profile_url` pattern).
5. **Rolls up** all of a vendor's plugins into one lead (total downloads, avg rating, newest publish, top plugins) and emits a **vendor-readiness** grade (verified/trader badge + traction + catalog + reachability + recency → A–D) + a `newlyLaunched` flag.

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `plugins` | array | `[]` | Explicit JetBrains plugin ids or `plugins.jetbrains.com/plugin/<id>-<slug>` URLs. |
| `searchQueries` | array | `["github"]` | Keywords to discover plugins (and thus vendors) via the keyless search endpoint. |
| `maxPerQuery` | int | `25` | Cap on plugins per search query (1–100). |
| `vendorUrlOnly` | bool | `true` | Keep only vendors that declared their own `vendor.url` website (the clean hop). Vendors without one are dropped, not billed. |
| `verifiedVendorsOnly` | bool | `false` | Keep only `isVerified`/`isTrader` vendors. |
| `excludeMarketplaceOwner` | bool | `true` | Drop JetBrains s.r.o. (the Marketplace owner). |
| `publishedWithinDays` | int | `0` | Flag vendors whose newest plugin `cdate` is within the trailing N days as `newlyLaunched` (0 = off). `cdate` reflects the current Marketplace published version, so this is a *freshly published within the window* signal, not a *first-ever upload* claim. |
| `verifyEmails` | bool | `true` | MX/DNS-validate the best contact email's domain. |
| `concurrency` | int | `3` | Parallel vendors/plugins (1–8). |
| `proxyConfiguration` | object | `{}` | Optional — only if you hit rate limits. |

Provide **either** `plugins` **or** `searchQueries` (or both).

### Output (per vendor lead)

```json
{
  "vendorId": "420",
  "vendorName": "GitHub",
  "vendorUrl": "https://github.com",
  "isVerified": true,
  "isTrader": true,
  "country": "United States",
  "countryCode": "US",
  "pluginCount": 1,
  "totalDownloads": 49706123,
  "avgRating": null,
  "newestPublish": "2026-07-…",
  "topPlugins": [{"name": "GitHub Copilot", "pluginId": "17718", "downloads": 49706123, "rating": null, "link": "/plugin/17718-github-copilot"}],
  "newlyLaunched": false,
  "emails": [],
  "emailVerified": false,
  "phones": [],
  "socials": {"linkedin": "https://www.linkedin.com/company/github", "twitter": "https://x.com/github"},
  "techStack": ["React"],
  "vendorReadiness": "B",
  "vendorLabel": "Strong prospect — real traction and contactable.",
  "leadScore": "C",
  "hasContact": true
}
```

When a vendor's own website yields no contact, the record is returned honestly with `hasContact: false`, `emails: []`, `socials: {}` — **not billed**.

### Real run sample

Verified live on Apify (2026-07-18). Input: `{"plugins": ["17718", "19347", "20705"]}` (GitHub Copilot, GitHub Actions Manager, GitHub Markdown Emojis). The three records below are copied verbatim from the actual run dataset — not fabricated or rounded:

```json
[
  {
    "vendorName": "D Software Inc",
    "vendorUrl": "http://www.moransoftware.ca",
    "isVerified": true, "isTrader": true, "country": "Canada",
    "pluginCount": 1, "totalDownloads": 749072, "avgRating": null,
    "emails": ["info@moransoftware.ca", "daniel@moransoftware.ca"],
    "emailVerified": true,
    "techStack": ["React"],
    "vendorReadiness": "B", "leadScore": "B", "hasContact": true
  },
  {
    "vendorName": "GitHub",
    "vendorUrl": "https://github.com",
    "isVerified": true, "isTrader": true, "country": "United States",
    "pluginCount": 1, "totalDownloads": 49706123, "avgRating": null,
    "emails": [], "emailVerified": false,
    "socials": {"linkedin": "https://www.linkedin.com/company/github", "instagram": "https://www.instagram.com/github", "youtube": "https://www.youtube.com/github", "twitter": "https://x.com/github", "tiktok": "https://www.tiktok.com/@github"},
    "techStack": ["React"],
    "vendorReadiness": "B", "leadScore": "C", "hasContact": true
  },
  {
    "vendorName": "4ch1m",
    "vendorUrl": "https://www.achimonline.de",
    "isVerified": false, "isTrader": false,
    "pluginCount": 1, "totalDownloads": 52589, "avgRating": null,
    "emails": [], "emailVerified": false, "socials": {},
    "techStack": ["Apache", "PHP"],
    "vendorReadiness": "D", "leadScore": "C", "hasContact": false
  }
]
```

The three records illustrate the full range: a **verified-email lead** (D Software Inc — two MX/DNS-validated emails off its own site, readiness B), a **high-traction socials-only lead** (GitHub — 49.7M downloads, verified/trader, five socials, no email exposed so not billed for `verified_email`), and an **honest no-contact record** (4ch1m — its site exposes no contact, so `hasContact: false` and it is **not billed** at all).

A `verifiedVendorsOnly` + `publishedWithinDays` run on `searchQueries: ["python"]` separately surfaced verified/trader vendors including **Windsurf (Cognition AI, windsurf.com, 9.5M downloads)** and **meanmail.dev (Armenia, 2-plugin catalog, socials)** — all cleanly typed and deduped.

### Cost

Pay-per-event, charged only on a successful result:

| Event | Price | When |
|---|---|---|
| `publisher_lead` (primary) | **$0.008** | per vendor returning at least one real contact signal + their plugin traction |
| `verified_email` | $0.003 | per vendor yielding an MX/DNS-validated email from their own site |
| `publisher_signal` | $0.001 | per vendor whose newest plugin `cdate` is within the chosen window |
| `apify-actor-start` | $0.0001 | one-time run start |

Zero upstream compose cost (self-contained: keyless Marketplace APIs + the vendor's own public site). Primary event priced well above per-run compute — positive unit margin from day one.

### Performance & limits

- Pure keyless JSON (one `searchPlugins` + one `/api/plugins/{id}` per plugin, then one site fetch per vendor). No anti-bot, no proxy, no API key.
- Concurrency 3 is a safe default against the Marketplace's rate limits; the actor retries 429s with backoff.
- A `maxPerQuery=25` × 3-query run resolves ~75 plugins → typically 15–40 distinct sellable vendors after owner/no-URL filtering, in well under a minute plus per-vendor site enrichment.

### Troubleshooting

- **No results / "no sellable third-party vendors"** — the keywords resolved only to the Marketplace owner (JetBrains s.r.o.) or to vendors that didn't declare a website. Try broader keywords, or pass explicit plugin ids via `plugins`.
- **Fewer vendors than plugins** — expected: plugins roll up one-per-vendor (keyed by vendor id), and owner + no-website vendors are dropped.
- **A vendor you expected is missing** — it had no declared `vendor.url`; set `vendorUrlOnly: false` is **not** offered because there is then no clean, ToS-safe website to enrich (the only fallback would be the Marketplace personal/support email, which this actor deliberately does not mine).
- **`newlyLaunched` not set** — `cdate` is older than `publishedWithinDays`; widen the window or leave it `0`.

### Data sourcing & ToS

Discovery uses JetBrains Marketplace's public keyless `/api/searchPlugins` + `/api/plugins/{id}` endpoints. Contact data is scraped **only** from the publisher's OWN declared `vendor.url` website — the Marketplace `vendor.email` personal/support address is never mined for outreach. No login, no API key, no residential proxy.

# Actor input Schema

## `plugins` (type: `array`):

Explicit JetBrains Marketplace plugin ids (e.g. '17718'), or plugin URLs (https://plugins.jetbrains.com/plugin/17718-github-copilot). Resolved to the vendor that owns each plugin.

## `searchQueries` (type: `array`):

Keywords to discover plugins (and thus vendors) via JetBrains Marketplace's keyless search endpoint (e.g. 'docker', 'github'). Each query returns up to `maxPerQuery` plugins; plugins roll up to one lead per vendor.

## `maxPerQuery` (type: `integer`):

Cap on plugins returned per search query (1-100).

## `vendorUrlOnly` (type: `boolean`):

Keep only vendors that declared their OWN `vendor.url` website (the clean acquisition hop). Vendors without one are honestly dropped (not billed) — the data-driven equivalent of Docker's official-image drop. Default true.

## `verifiedVendorsOnly` (type: `boolean`):

Keep only vendors carrying the JetBrains `isVerified`/`isTrader` trust badge (a real trust signal — live-verified 2026-07-18).

## `excludeMarketplaceOwner` (type: `boolean`):

Drop JetBrains s.r.o. (the Marketplace owner, not a sellable third-party vendor). Default true.

## `publishedWithinDays` (type: `integer`):

Flag vendors whose newest plugin `cdate` falls within the trailing N days as `newlyLaunched` (rolling window, 0 = disabled). `cdate` reflects the current Marketplace published version, so this is a `freshly published within the window` signal, not a `first ever uploaded` claim.

## `verifyEmails` (type: `boolean`):

Validate the best contact email's domain against live MX/DNS records.

## `concurrency` (type: `integer`):

Vendors/plugins processed in parallel (1-8). The keyless Marketplace APIs tolerate moderate concurrency.

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

Optional. Only needed if you hit rate limits; the Actor works without a proxy (the keyless Marketplace APIs).

## Actor input object example

```json
{
  "plugins": [
    "17718",
    "https://plugins.jetbrains.com/plugin/19347-github-actions-manager"
  ],
  "searchQueries": [
    "docker",
    "github",
    "theme"
  ],
  "maxPerQuery": 25,
  "vendorUrlOnly": true,
  "verifiedVendorsOnly": false,
  "excludeMarketplaceOwner": true,
  "publishedWithinDays": 0,
  "verifyEmails": true,
  "concurrency": 3,
  "proxyConfiguration": {}
}
```

# Actor output Schema

## `results` (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 = {
    "plugins": [],
    "searchQueries": [
        "github"
    ],
    "proxyConfiguration": {}
};

// Run the Actor and wait for it to finish
const run = await client.actor("ayeeyee/jetbrains-marketplace-publisher-lead-extractor").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 = {
    "plugins": [],
    "searchQueries": ["github"],
    "proxyConfiguration": {},
}

# Run the Actor and wait for it to finish
run = client.actor("ayeeyee/jetbrains-marketplace-publisher-lead-extractor").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 '{
  "plugins": [],
  "searchQueries": [
    "github"
  ],
  "proxyConfiguration": {}
}' |
apify call ayeeyee/jetbrains-marketplace-publisher-lead-extractor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,ayeeyee/jetbrains-marketplace-publisher-lead-extractor"
        }
    }
}

```

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/jbOCYnBpbkwO82KR2/builds/8bFUCsQCey3arWv5g/openapi.json