# npm Package Download Trends and New Versions (`transparent_meteorite/npm-package-download-trends`) Actor

Get npm package download trends and new versions: weekly and 30-day downloads, trend percent, latest version, publish date, deprecation, maintainers and a momentum score for every package you list. Uses the public npm registry and download APIs. No login, no proxy.

- **URL**: https://apify.com/transparent_meteorite/npm-package-download-trends.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.93 / 1,000 package or version 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

## npm Package Download Trends and New Versions: Downloads, Trend %, Latest Version

**npm download stats** for any list of packages, from the public npm registry and downloads API: weekly and 30-day downloads, trend versus the prior 30 days, latest version, deprecation, maintainers and a momentum score, or a feed of new versions.

**This Actor vs scrapemint/package-adoption-tracker:** that one also covers PyPI and searches npm by keyword ranked by growth. Choose this one for latest version, deprecation and maintainer fields, a momentum score, and a versions mode that lists every release in your window.

Track any list of JavaScript packages on npm. For every package you name, the actor returns weekly and 30-day download counts, how much downloads grew or shrank compared with the 30 days before, the latest version and when it was published, whether it is deprecated, how many maintainers it has, and a simple momentum score.

### What does this Actor do?

It reads two public sources: the npm registry (`registry.npmjs.org/<name>`) for versions, publish times, deprecation notices, maintainers and license, and the npm download counts API (`api.npmjs.org/downloads`) for daily downloads. It adds up the newest 30 days and the 30 days before them, so the trend percent is a real comparison of two windows.

Two output modes:

- **packages**: one summary row per package, ranked by momentum score.
- **versions**: one row per version 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 35 prefilled packages and press **Start**. A run takes about a minute.
3. Open the **Output** tab. Use the table view or download CSV, Excel or JSON.

### Input

| Field | What it does |
|---|---|
| `packages` | npm package names, one per line, for example `react` or `@angular/core`. An `npmjs.com/package/<name>` link also works. |
| `mode` | `packages` (default) or `versions`. |
| `versionsWithinDays` | Versions mode only. Keep versions published in the last N days. Default 30. |
| `includePrereleases` | Keep versions with a pre-release tag such as `-beta.1`. On by default. |
| `includeDownloads` | Add day, week and 30-day download counts and the trend. On by default. |
| `maxItems` | Stop after this many rows. |

Sample input:

```json
{
  "packages": ["react", "vite", "zod", "@angular/core"],
  "mode": "versions",
  "versionsWithinDays": 14,
  "includePrereleases": false,
  "maxItems": 50
}
```

### Output

Packages mode, one row per package:

| Field | Meaning |
|---|---|
| `package`, `npmUrl` | Package name and its npm page. |
| `latestVersion`, `latestPublishedAt` | The version tagged `latest` and the date it was published. |
| `daysSinceLatestPublish` | Age of that version in days. |
| `downloadsLastDay`, `downloadsLastWeek`, `downloadsLast30Days`, `downloadsPrior30Days` | Download counts from api.npmjs.org. |
| `trendPct30d`, `trendPct7d` | Percent change of the newest 30 (or 7) days against the window just before it. |
| `momentumScore` | 0 to 100. Up to 50 points for growth, 30 for how recent the latest version is, 20 for stable releases in the last year. |
| `releasesLast30Days`, `releasesLast365Days`, `totalVersions`, `firstPublishedAt` | Release cadence counts (stable versions) and history. |
| `deprecated`, `deprecationMessage`, `maintainersCount` | Deprecation status of the latest version and number of npm maintainers. |
| `dataThrough`, `license`, `description`, `repositoryUrl`, `dependenciesCount`, `hasTypes`, `scrapedAt` | Metadata the maintainers publish and the run time. |

Versions mode, one row per version: `package`, `version`, `publishedAt`, `daysAgo`, `isLatest`, `isPrerelease`, `deprecated`, `versionUrl`, `npmUrl`, `description`, `downloadsLastWeek`, `trendPct30d`, `scrapedAt`.

### Sample output

```json
{
  "package": "zod",
  "npmUrl": "https://www.npmjs.com/package/zod",
  "latestVersion": "4.1.12",
  "latestPublishedAt": "2026-10-08T14:02:11.000Z",
  "daysSinceLatestPublish": 13,
  "downloadsLastWeek": 52000000,
  "downloadsLast30Days": 215000000,
  "trendPct30d": 8.4,
  "momentumScore": 83,
  "deprecated": false,
  "maintainersCount": 2,
  "license": "MIT"
}
```

The numbers above are illustrative. Your run returns the live values at the time it runs.

### Use cases

- Watch the dependencies you rely on and get a weekly list of new versions, including pre-releases, in a spreadsheet or Slack.
- Screen libraries before you adopt them: a deprecation flag, a long gap since the last version and falling downloads are warning signs.
- Build a "rising JavaScript packages" report or newsletter section from the trend percent and download numbers.
- Feed version 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 or sponsorship by ranking the packages in it.

### Why use it

- **Real dates.** Publish times come from the registry's own `time` record for each version.
- **Public data only.** The same JSON APIs the npm website and the npm client use. No login, no proxy.
- **Repeatable.** The momentum score is a fixed formula, so the same inputs give the same score.
- **Two shapes.** A package summary for screening, or a version 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.

### FAQ

**Where do download counts come from?**
From api.npmjs.org. Days where the API returns 0 (npm has not processed them yet) are treated as missing: windows end at the last day with data, `dataThrough` shows which day that is, and a window total is the average of its days with data times the window length. Counts include CI, mirrors and bots, so use them to compare packages, not as a count of unique users. If the API is busy the download fields stay empty for that package and the run log says so.

**What is the trend percent?**
The downloads of the newest 30 days minus the downloads of the 30 days before them, divided by the earlier window. It is empty when the earlier window has no downloads or could not be read.

**What is the momentum score?**
A number from 0 to 100: up to 50 points for growth (minus 50 percent or worse scores zero, plus 50 percent or better scores full, unknown scores half), up to 30 points for how recent the latest version is (zero at one year old) and up to 20 points for stable releases in the last 365 days (12 or more is full).

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

### Limits

- Only the packages you list are read. The actor does not search npm.
- The registry document of a very large package can be several megabytes, so long lists take longer.
- Deprecation is read from the latest version only.
- Private registries are not supported, only the public npm registry.

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

# Actor input Schema

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

npm package names to read, one per line, for example "react" or "@angular/core". An npmjs.com/package/<name> link also works. Leave empty to use the 35 prefilled popular packages.

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

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

## `versionsWithinDays` (type: `integer`):

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

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

Keep versions with a pre-release tag such as -beta.1 or -rc.2 (versions mode). Turn off to see stable versions only.

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

Add day, week and 30-day download counts and the trend from api.npmjs.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": [
    "react",
    "vue",
    "express",
    "typescript",
    "lodash",
    "axios",
    "next",
    "webpack",
    "vite",
    "eslint",
    "prettier",
    "jest",
    "tailwindcss",
    "zod",
    "prisma",
    "svelte",
    "@angular/core",
    "@nestjs/core",
    "rxjs",
    "dayjs",
    "chalk",
    "commander",
    "dotenv",
    "uuid",
    "moment",
    "esbuild",
    "vitest",
    "openai",
    "@anthropic-ai/sdk",
    "langchain",
    "nodemon",
    "cors",
    "mongoose",
    "socket.io",
    "zustand"
  ],
  "mode": "packages",
  "versionsWithinDays": 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": [
        "react",
        "vue",
        "express",
        "typescript",
        "lodash",
        "axios",
        "next",
        "webpack",
        "vite",
        "eslint",
        "prettier",
        "jest",
        "tailwindcss",
        "zod",
        "prisma",
        "svelte",
        "@angular/core",
        "@nestjs/core",
        "rxjs",
        "dayjs",
        "chalk",
        "commander",
        "dotenv",
        "uuid",
        "moment",
        "esbuild",
        "vitest",
        "openai",
        "@anthropic-ai/sdk",
        "langchain",
        "nodemon",
        "cors",
        "mongoose",
        "socket.io",
        "zustand"
    ],
    "maxItems": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("transparent_meteorite/npm-package-download-trends").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": [
        "react",
        "vue",
        "express",
        "typescript",
        "lodash",
        "axios",
        "next",
        "webpack",
        "vite",
        "eslint",
        "prettier",
        "jest",
        "tailwindcss",
        "zod",
        "prisma",
        "svelte",
        "@angular/core",
        "@nestjs/core",
        "rxjs",
        "dayjs",
        "chalk",
        "commander",
        "dotenv",
        "uuid",
        "moment",
        "esbuild",
        "vitest",
        "openai",
        "@anthropic-ai/sdk",
        "langchain",
        "nodemon",
        "cors",
        "mongoose",
        "socket.io",
        "zustand",
    ],
    "maxItems": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("transparent_meteorite/npm-package-download-trends").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": [
    "react",
    "vue",
    "express",
    "typescript",
    "lodash",
    "axios",
    "next",
    "webpack",
    "vite",
    "eslint",
    "prettier",
    "jest",
    "tailwindcss",
    "zod",
    "prisma",
    "svelte",
    "@angular/core",
    "@nestjs/core",
    "rxjs",
    "dayjs",
    "chalk",
    "commander",
    "dotenv",
    "uuid",
    "moment",
    "esbuild",
    "vitest",
    "openai",
    "@anthropic-ai/sdk",
    "langchain",
    "nodemon",
    "cors",
    "mongoose",
    "socket.io",
    "zustand"
  ],
  "maxItems": 50
}' |
apify call transparent_meteorite/npm-package-download-trends --silent --output-dataset

```

## MCP server setup

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

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/R28wIpck6hJLMbT5N/builds/Bd4w8TX8iSqLRsfCk/openapi.json