# PyPI Package Stats and New Releases Tracker (`transparent_meteorite/pypi-package-stats-releases`) Actor

Get PyPI package stats and new releases: latest version, release dates, release cadence, download counts and an activity score for every package you list. Uses the public PyPI and pypistats.org JSON APIs. No login, no proxy.

- **URL**: https://apify.com/transparent_meteorite/pypi-package-stats-releases.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.19 / 1,000 package or release 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

## PyPI Package Stats and New Releases Tracker: Versions, Cadence, Downloads

**PyPI package stats** for any list of Python packages: latest version, when it shipped, release cadence, recent download counts and an activity score, or switch to releases mode for one row per new release in the last N days, from the PyPI JSON API and pypistats.

**This Actor vs brunofin/pypi-package-stats:** that one adds package metadata such as author, license and dependencies. This one works out release cadence from real upload times, ranks packages by an activity score, and has a releases mode that returns a what-shipped feed for your time window.

Track any list of Python packages on PyPI. For every package you name, the actor returns the latest version, when it shipped, how often the project releases, recent download counts and a simple activity score. Switch to releases mode to get one row per new release published in the last N days.

### What does this Actor do?

It reads two public sources: the PyPI JSON API (`pypi.org/pypi/<name>/json`) for versions and upload dates, and the pypistats.org API for download counts. It works out release cadence from the real upload times of the release files, then writes one clean row per package or per release. No login, no proxy, no API key, and no personal data: only public package registry fields.

Two output modes:

- **packages**: one summary row per package, ranked by activity score.
- **releases**: one row per release published inside your time window, newest first. Good for a daily or weekly "what shipped" feed.

**Run in 30 seconds**

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

### Input

| Field | What it does |
|---|---|
| `packages` | PyPI package names, one per line, for example `requests` or `scikit-learn`. A `pypi.org/project/<name>` link also works. |
| `mode` | `packages` (default) or `releases`. |
| `releasesWithinDays` | Releases mode only. Keep releases from the last N days. Default 30. |
| `includePrereleases` | Keep alpha, beta, release candidate and dev versions. On by default. |
| `includeDownloads` | Add day, week and month download counts. On by default. |
| `maxItems` | Stop after this many rows. |

Sample input:

```json
{
  "packages": ["requests", "fastapi", "pydantic", "openai"],
  "mode": "releases",
  "releasesWithinDays": 14,
  "includePrereleases": false,
  "maxItems": 50
}
```

### Output

Packages mode, one row per package:

| Field | Meaning |
|---|---|
| `package`, `pypiUrl` | Package name and its PyPI page. |
| `latestVersion`, `latestReleaseAt` | Newest version and the date it was uploaded. |
| `daysSinceLatestRelease` | Age of the newest release in days. |
| `releasesLast30Days`, `releasesLast90Days`, `releasesLast365Days`, `totalReleases` | Release cadence counts. |
| `activityScore` | 0 to 100. 60 points for how recent the last release is, 40 points for releases in the last year. |
| `downloadsLastDay`, `downloadsLastWeek`, `downloadsLastMonth` | Download counts from pypistats.org. |
| `summary`, `license`, `requiresPython`, `developmentStatus`, `repositoryUrl` | Metadata the maintainers publish. |
| `firstReleaseAt`, `latestIsPrerelease`, `yanked`, `scrapedAt` | Extra context and run time. |

Releases mode, one row per release: `package`, `version`, `releasedAt`, `daysAgo`, `isLatest`, `isPrerelease`, `yanked`, `requiresPython`, `fileCount`, `sizeBytes`, `releaseUrl`, `packageUrl`, `summary`, `downloadsLastMonth`, `scrapedAt`.

### Sample output

```json
{
  "package": "fastapi",
  "pypiUrl": "https://pypi.org/project/fastapi/",
  "latestVersion": "0.118.0",
  "latestReleaseAt": "2026-09-29T10:14:52.000Z",
  "daysSinceLatestRelease": 22,
  "releasesLast90Days": 9,
  "releasesLast365Days": 31,
  "activityScore": 95,
  "downloadsLastDay": 4120000,
  "downloadsLastWeek": 28900000,
  "downloadsLastMonth": 121000000,
  "license": "MIT",
  "requiresPython": ">=3.8"
}
```

### Use cases

- Watch the dependencies you rely on and get a weekly list of new releases, including pre-releases, in a spreadsheet or Slack.
- Screen libraries before you adopt them: low activity score, long gap since the last release and falling downloads are warning signs.
- Build a "trending Python packages" report or newsletter section from release counts and download numbers.
- Feed release rows into an n8n, Make or Zapier workflow to open tickets when a pinned package ships a new major version.
- Research a niche for developer-tool content, sponsorship or outreach by ranking the packages in it.

### Why use it

- **Real dates.** Release dates come from the upload times of the files on PyPI, not from guesses.
- **Public data only.** The same JSON APIs that pip and the PyPI website use. No login, no proxy.
- **Repeatable.** The activity score is a fixed formula, so the same package gives the same score on the same day.
- **Two shapes.** A package summary for screening, or a release feed for monitoring.

### Pricing

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

### FAQ

**Where do download counts come from?**
From pypistats.org, which publishes download counts for PyPI. They include mirrors and CI traffic, so use them to compare packages, not as a count of unique users. If pypistats is busy the fields stay empty and the run log says so.

**What is the activity score?**
A number from 0 to 100. Up to 60 points for how recent the last release is (full marks for today, zero at two years old) and up to 40 points for releases in the last 365 days (12 or more is full marks). It is a quick filter, not a quality rating.

**Why is a package missing from the output?**
Its name is probably misspelled or it was removed. Not-found names are listed in the `OUTPUT` record and the run log.

**Does it list every version ever published?**
In releases mode it lists the releases inside your window. Set `releasesWithinDays` up to 3650 for a long history.

### Limits

- Only the packages you list are read. The actor does not search PyPI.
- Download counts depend on pypistats.org and cover roughly the last 180 days at most.
- Yanked releases are flagged, not hidden, in releases mode.
- Private indexes are not supported, only the public PyPI.

### 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/pypi-package-stats-releases/reviews) helps other users decide. Problems or feature requests: please open an [Issue](https://apify.com/transparent_meteorite/pypi-package-stats-releases/issues) and we usually reply within one business day.

# Actor input Schema

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

PyPI package names to read, one per line, for example "requests" or "scikit-learn". A pypi.org/project/<name> link also works. Leave empty to use the 30 prefilled popular packages.

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

packages = one summary row per package. releases = one row per release published within the number of days below, newest first.

## `releasesWithinDays` (type: `integer`):

Only used in releases mode. Keep releases published in the last N days.

## `includePrereleases` (type: `boolean`):

Keep alpha, beta, release candidate and dev versions. Turn off to see stable releases only.

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

Add last day, last week and last month download counts from pypistats.org. Turn off for a faster run.

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

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

## Actor input object example

```json
{
  "packages": [
    "requests",
    "numpy",
    "pandas",
    "fastapi",
    "django",
    "flask",
    "pydantic",
    "httpx",
    "scikit-learn",
    "matplotlib",
    "sqlalchemy",
    "pytest",
    "boto3",
    "openai",
    "anthropic",
    "langchain",
    "transformers",
    "torch",
    "scipy",
    "beautifulsoup4",
    "playwright",
    "uvicorn",
    "celery",
    "aiohttp",
    "polars",
    "ruff",
    "black",
    "rich",
    "typer",
    "streamlit"
  ],
  "mode": "packages",
  "releasesWithinDays": 30,
  "includePrereleases": true,
  "includeDownloads": true,
  "maxItems": 50
}
```

# 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 = {
    "packages": [
        "requests",
        "numpy",
        "pandas",
        "fastapi",
        "django",
        "flask",
        "pydantic",
        "httpx",
        "scikit-learn",
        "matplotlib",
        "sqlalchemy",
        "pytest",
        "boto3",
        "openai",
        "anthropic",
        "langchain",
        "transformers",
        "torch",
        "scipy",
        "beautifulsoup4",
        "playwright",
        "uvicorn",
        "celery",
        "aiohttp",
        "polars",
        "ruff",
        "black",
        "rich",
        "typer",
        "streamlit"
    ],
    "maxItems": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("transparent_meteorite/pypi-package-stats-releases").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 = {
    "packages": [
        "requests",
        "numpy",
        "pandas",
        "fastapi",
        "django",
        "flask",
        "pydantic",
        "httpx",
        "scikit-learn",
        "matplotlib",
        "sqlalchemy",
        "pytest",
        "boto3",
        "openai",
        "anthropic",
        "langchain",
        "transformers",
        "torch",
        "scipy",
        "beautifulsoup4",
        "playwright",
        "uvicorn",
        "celery",
        "aiohttp",
        "polars",
        "ruff",
        "black",
        "rich",
        "typer",
        "streamlit",
    ],
    "maxItems": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("transparent_meteorite/pypi-package-stats-releases").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 '{
  "packages": [
    "requests",
    "numpy",
    "pandas",
    "fastapi",
    "django",
    "flask",
    "pydantic",
    "httpx",
    "scikit-learn",
    "matplotlib",
    "sqlalchemy",
    "pytest",
    "boto3",
    "openai",
    "anthropic",
    "langchain",
    "transformers",
    "torch",
    "scipy",
    "beautifulsoup4",
    "playwright",
    "uvicorn",
    "celery",
    "aiohttp",
    "polars",
    "ruff",
    "black",
    "rich",
    "typer",
    "streamlit"
  ],
  "maxItems": 50
}' |
apify call transparent_meteorite/pypi-package-stats-releases --silent --output-dataset

```

## MCP server setup

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

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/Q0xQjBqZ3TPvHJk1m/builds/Iguor3zDzD9AndBrN/openapi.json