# PyPI Intel: Packages, Releases, Dependencies & Maintainer Leads (`obsidian937/pypi-intel`) Actor

Turn the Python Package Index into structured B2B data. Deep-dive and monitor releases of any package list, map a project's dependency tree (supply chain), or build developer lead lists from maintainer emails. Official public PyPI API, no proxy, no auth, no key. Delta mode for monitoring.

- **URL**: https://apify.com/obsidian937/pypi-intel.md
- **Developed by:** [Obsidian IT Consulting SRL](https://apify.com/obsidian937) (community)
- **Categories:** Developer tools, Lead generation, Jobs
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

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

## PyPI Intel: Packages, Releases, Dependencies & Maintainer Leads

Turn the Python Package Index (PyPI) into structured, B2B-ready data. This actor pulls package metadata, release history, dependency trees, and maintainer contacts straight from the official public PyPI API. No proxy, no auth, no API key.

Built for sales, dev-recruiting, competitive intelligence, VC sizing, and supply-chain / security teams who need clean Python ecosystem data they can act on.

### Three modes

#### 1. Package deep-dive / release monitor
Give it a list of package names and get a full structured record for each: latest version, summary, license, author and maintainer emails, repository, keywords, topics, dependency count, release history, and recent download counts (day / week / month).

Turn on **Delta mode** and it becomes a release monitor: it remembers each package's version and, on later runs, emits only the packages whose latest version changed. Pair it with a schedule and a webhook to get alerted the moment a dependency ships a new release.

#### 2. Maintainer leads
Give it a PyPI username and get every package that user maintains, each enriched with contact email, repository, and download reach. A maintainer of widely-installed packages is a high-intent technical lead for recruiting, dev-tool sales, or partnership outreach.

#### 3. Dependency graph (supply chain)
Give it one or more root packages and it walks the runtime dependency tree breadth-first (up to 3 levels deep), emitting every package in the chain. Each link carries its maintainer, license, and download weight. This is the SBOM / supply-chain / security angle: map exactly what a project pulls in and who is behind each piece.

### Example input

Monitor releases of your stack:

```json
{
  "mode": "package",
  "packages": ["requests", "flask", "numpy", "pydantic"],
  "deltaMode": true
}
````

Build a developer lead list:

```json
{
  "mode": "maintainer",
  "maintainer": "kennethreitz",
  "minDownloads": 10000
}
```

Map a project's supply chain:

```json
{
  "mode": "dependencies",
  "packages": ["flask"],
  "depth": 2
}
```

### Output fields

`name`, `version`, `summary`, `author`, `authorEmail`, `maintainer`, `maintainerEmail`, `license`, `keywords`, `topics`, `requiresPython`, `homepage`, `repository`, `dependencies`, `dependenciesCount`, `releasesCount`, `firstReleaseAt`, `lastReleaseAt`, `yanked`, `downloadsLastDay`, `downloadsLastWeek`, `downloadsLastMonth`, `pypiUrl`. Dependency and release-monitor records add `depth`, `dependencyOf`, `previousVersion`, and `versionChanged`.

### Pricing

Pay per result: you are billed per record saved to the dataset. No subscription, no minimum.

### Data source and limits

All data comes from the official public PyPI endpoints (`pypi.org/pypi/<package>/json`), the pypistats download API, and the PyPI XML-RPC `user_packages` method. PyPI retired its keyword search API years ago, so discovery here is dependency-graph and maintainer driven rather than free-text search. Everything is public and anonymous.

### Part of the B2B data suite

This actor pairs with the rest of the founder / VC / sales / dev-intel suite:

- **npm Registry Intel** for the JavaScript side of the same dependency and maintainer data
- **GitHub Intel** for repos, developer leads, and stargazers
- **Hacker News Intel** for hiring signals and launch tracking
- **Y Combinator Companies Scraper** and **IndieHackers Product Scraper** for startup data
- **BetaList Startup Scraper** for early launches
- **SEC EDGAR Intel** for filings and financials of public companies

# Actor input Schema

## `mode` (type: `string`):

What to extract: deep-dive / release-monitor a list of packages, list a maintainer's packages as developer leads, or map a package's dependency tree.

## `packages` (type: `array`):

Package names. In package mode: the list to deep-dive or monitor. In dependencies mode: the root package(s) whose dependency tree to walk. Example: \["requests", "flask"].

## `maintainer` (type: `string`):

PyPI username whose packages to list as developer leads (maintainer mode).

## `depth` (type: `integer`):

How many levels of the dependency tree to walk (dependencies mode). 1 = direct dependencies, 2 = include their dependencies, max 3.

## `includeExtras` (type: `boolean`):

Include optional / extra dependencies (those behind an `extra ==` marker) when walking the tree (dependencies mode). Off keeps only the real runtime supply chain.

## `includeDownloads` (type: `boolean`):

Fetch recent download counts (last day / week / month) from pypistats for each package. One extra request per package; gives market reach.

## `downloadsPeriod` (type: `string`):

Which window the minimum-downloads filter uses. All three counts are always returned.

## `minDownloads` (type: `integer`):

Only emit packages with at least this many downloads in the selected period (maintainer / dependencies modes; root packages are always kept).

## `deltaMode` (type: `boolean`):

Only emit changes since the previous run (per-account state). Package mode: only packages whose latest version changed (release monitor). Maintainer mode: only newly-published packages. Pair with a schedule + webhook for recurring alerts.

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

Cap on records to return.

## Actor input object example

```json
{
  "mode": "package",
  "packages": [],
  "maintainer": "",
  "depth": 1,
  "includeExtras": false,
  "includeDownloads": true,
  "downloadsPeriod": "last-week",
  "minDownloads": 0,
  "deltaMode": false,
  "maxItems": 50
}
```

# 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("obsidian937/pypi-intel").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("obsidian937/pypi-intel").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 '{}' |
apify call obsidian937/pypi-intel --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "PyPI Intel: Packages, Releases, Dependencies & Maintainer Leads",
        "description": "Turn the Python Package Index into structured B2B data. Deep-dive and monitor releases of any package list, map a project's dependency tree (supply chain), or build developer lead lists from maintainer emails. Official public PyPI API, no proxy, no auth, no key. Delta mode for monitoring.",
        "version": "1.0",
        "x-build-id": "55Ca7QisWVd8h8GAa"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/obsidian937~pypi-intel/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-obsidian937-pypi-intel",
                "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/obsidian937~pypi-intel/runs": {
            "post": {
                "operationId": "runs-sync-obsidian937-pypi-intel",
                "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/obsidian937~pypi-intel/run-sync": {
            "post": {
                "operationId": "run-sync-obsidian937-pypi-intel",
                "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": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "package",
                            "maintainer",
                            "dependencies"
                        ],
                        "type": "string",
                        "description": "What to extract: deep-dive / release-monitor a list of packages, list a maintainer's packages as developer leads, or map a package's dependency tree.",
                        "default": "package"
                    },
                    "packages": {
                        "title": "Packages",
                        "type": "array",
                        "description": "Package names. In package mode: the list to deep-dive or monitor. In dependencies mode: the root package(s) whose dependency tree to walk. Example: [\"requests\", \"flask\"].",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maintainer": {
                        "title": "Maintainer (PyPI username)",
                        "type": "string",
                        "description": "PyPI username whose packages to list as developer leads (maintainer mode).",
                        "default": ""
                    },
                    "depth": {
                        "title": "Dependency depth",
                        "type": "integer",
                        "description": "How many levels of the dependency tree to walk (dependencies mode). 1 = direct dependencies, 2 = include their dependencies, max 3.",
                        "default": 1
                    },
                    "includeExtras": {
                        "title": "Include optional dependencies",
                        "type": "boolean",
                        "description": "Include optional / extra dependencies (those behind an `extra ==` marker) when walking the tree (dependencies mode). Off keeps only the real runtime supply chain.",
                        "default": false
                    },
                    "includeDownloads": {
                        "title": "Include download counts",
                        "type": "boolean",
                        "description": "Fetch recent download counts (last day / week / month) from pypistats for each package. One extra request per package; gives market reach.",
                        "default": true
                    },
                    "downloadsPeriod": {
                        "title": "Downloads period (for filtering)",
                        "enum": [
                            "last-day",
                            "last-week",
                            "last-month"
                        ],
                        "type": "string",
                        "description": "Which window the minimum-downloads filter uses. All three counts are always returned.",
                        "default": "last-week"
                    },
                    "minDownloads": {
                        "title": "Minimum downloads",
                        "type": "integer",
                        "description": "Only emit packages with at least this many downloads in the selected period (maintainer / dependencies modes; root packages are always kept).",
                        "default": 0
                    },
                    "deltaMode": {
                        "title": "Delta / monitor mode",
                        "type": "boolean",
                        "description": "Only emit changes since the previous run (per-account state). Package mode: only packages whose latest version changed (release monitor). Maintainer mode: only newly-published packages. Pair with a schedule + webhook for recurring alerts.",
                        "default": false
                    },
                    "maxItems": {
                        "title": "Max items",
                        "type": "integer",
                        "description": "Cap on records to return.",
                        "default": 50
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
