# Open Source Maintainer Leads: npm & PyPI (`scrapemint/oss-maintainer-leads`) Actor

Search npm and PyPI by keyword and turn packages into B2B leads: the maintainer's public email, repository, homepage, monthly downloads, and last publish date. One lead per package. Keyless registries, no API key.

- **URL**: https://apify.com/scrapemint/oss-maintainer-leads.md
- **Developed by:** [Ken M](https://apify.com/scrapemint) (community)
- **Categories:** Business, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

## Open Source Maintainer Leads: npm & PyPI

Turn the npm and PyPI registries into a B2B lead list. Search by keyword and get, for every package, the maintainer or author's **public email**, the repository, homepage, **monthly downloads**, and the last publish date. One lead per package.

Open source maintainers are a captive, high-value market for developer tools, supply-chain security, and DevRel. Both registries publish maintainer contact info, so leads are reachable with no guessing and no API key.

### Who buys this

- **Developer-tool SaaS** (CI/CD, testing, monitoring) selling to package authors.
- **Supply-chain security vendors** (SCA, dependency scanning) whose top targets are maintainers.
- **DevRel and community teams** running outreach and partner programs.
- **Technical recruiters** sourcing active open-source contributors.

### How it works

1. For each keyword it searches npm (full keyword search) and name-matches the PyPI index, prioritising exact and prefix matches.
2. For each package it reads the registry record for the maintainer/author public email, repository, homepage, and downloads.
3. Each package is scored and tiered, then pushed as one lead.

### Output

One row per package:

```json
{
  "registry": "npm",
  "name": "express",
  "url": "https://www.npmjs.com/package/express",
  "description": "Fast, unopinionated, minimalist web framework",
  "author": "TJ Holowaychuk",
  "email": "tj@vision-media.ca",
  "emails": ["tj@vision-media.ca", "wes@wesleytodd.com"],
  "maintainers": ["wesleytodd", "jonchurch"],
  "repository": "https://github.com/expressjs/express",
  "homepage": "https://expressjs.com/",
  "monthlyDownloads": 456438953,
  "lastPublished": "2026-05-10T12:00:00.000Z",
  "tier": "qualified_lead",
  "leadScore": 94
}
````

### Tiers and pricing

Pay per lead. The first 10 `qualified_lead` per run are free so you can validate output.

| Tier | Meaning | Price |
| --- | --- | --- |
| `listing` | Package data, no public email or repository | $0.01 |
| `lead` | A public maintainer email or a repository link | $0.02 |
| `qualified_lead` | A public email and monthly downloads at or above the bar | $0.05 |

Both registries are keyless JSON APIs, so runs are fast and cheap, and a single run can return thousands of leads.

### Input

| Field | Default | Notes |
| --- | --- | --- |
| `keywords` | `[]` | Search terms, one query each. |
| `registries` | `both` | npm + PyPI, npm only, or PyPI only. |
| `maxLeads` | `200` | Cap total leads per run. |
| `maxPerKeyword` | `80` | Candidate packages per keyword per registry. |
| `minMonthlyDownloads` | `0` | Drop packages below this download count. |
| `qualifiedMinDownloads` | `1000` | Download bar for the qualified\_lead tier. |
| `requireEmail` | `false` | Only keep packages with a public email. |

### Notes

- npm publishes author and maintainer emails in the package record; some maintainers use a noreply address, which is filtered out.
- PyPI keyword search is not available programmatically, so PyPI is discovered by name-matching the official package index (exact and prefix matches first).
- Respect each registry's terms and applicable outreach laws when contacting maintainers.

# Actor input Schema

## `keywords` (type: `array`):

Terms to find packages for (e.g. testing, stripe, django, kubernetes).

## `registries` (type: `string`):

Which registries to pull from.

## `maxLeads` (type: `integer`):

Cap total leads scored per run.

## `maxPerKeyword` (type: `integer`):

Cap candidate packages taken from each keyword per registry.

## `minMonthlyDownloads` (type: `integer`):

Drop packages below this monthly download count. Zero keeps everything.

## `qualifiedMinDownloads` (type: `integer`):

Monthly downloads at or above this, with a public email, tier a lead as qualified\_lead.

## `requireEmail` (type: `boolean`):

Skip packages whose maintainer email is not public.

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

Package lookups in parallel.

## Actor input object example

```json
{
  "keywords": [
    "testing",
    "payments",
    "logging"
  ],
  "registries": "both",
  "maxLeads": 200,
  "maxPerKeyword": 80,
  "minMonthlyDownloads": 0,
  "qualifiedMinDownloads": 1000,
  "requireEmail": false,
  "concurrency": 8
}
```

# 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 = {
    "keywords": [
        "testing",
        "payments",
        "logging"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapemint/oss-maintainer-leads").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 = { "keywords": [
        "testing",
        "payments",
        "logging",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("scrapemint/oss-maintainer-leads").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 '{
  "keywords": [
    "testing",
    "payments",
    "logging"
  ]
}' |
apify call scrapemint/oss-maintainer-leads --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=scrapemint/oss-maintainer-leads",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Open Source Maintainer Leads: npm & PyPI",
        "description": "Search npm and PyPI by keyword and turn packages into B2B leads: the maintainer's public email, repository, homepage, monthly downloads, and last publish date. One lead per package. Keyless registries, no API key.",
        "version": "0.1",
        "x-build-id": "TFuxfQlxgcupfrRv4"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapemint~oss-maintainer-leads/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapemint-oss-maintainer-leads",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/scrapemint~oss-maintainer-leads/runs": {
            "post": {
                "operationId": "runs-sync-scrapemint-oss-maintainer-leads",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/scrapemint~oss-maintainer-leads/run-sync": {
            "post": {
                "operationId": "run-sync-scrapemint-oss-maintainer-leads",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "keywords": {
                        "title": "Search keywords",
                        "type": "array",
                        "description": "Terms to find packages for (e.g. testing, stripe, django, kubernetes).",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "registries": {
                        "title": "Registries",
                        "enum": [
                            "both",
                            "npm",
                            "pypi"
                        ],
                        "type": "string",
                        "description": "Which registries to pull from.",
                        "default": "both"
                    },
                    "maxLeads": {
                        "title": "Max leads",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Cap total leads scored per run.",
                        "default": 200
                    },
                    "maxPerKeyword": {
                        "title": "Max per keyword",
                        "minimum": 1,
                        "maximum": 250,
                        "type": "integer",
                        "description": "Cap candidate packages taken from each keyword per registry.",
                        "default": 80
                    },
                    "minMonthlyDownloads": {
                        "title": "Minimum monthly downloads",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Drop packages below this monthly download count. Zero keeps everything.",
                        "default": 0
                    },
                    "qualifiedMinDownloads": {
                        "title": "Qualified download bar",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Monthly downloads at or above this, with a public email, tier a lead as qualified_lead.",
                        "default": 1000
                    },
                    "requireEmail": {
                        "title": "Only packages with a public email",
                        "type": "boolean",
                        "description": "Skip packages whose maintainer email is not public.",
                        "default": false
                    },
                    "concurrency": {
                        "title": "Concurrency",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Package lookups in parallel.",
                        "default": 8
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
