# NPM Package Version Monitor (`snappytools/npm-package-version-monitor`) Actor

NPM Package Version Monitor checks a list of public npm packages against the official public npm registry API (https://registry.npmjs.org/) and returns one structured record per package.

- **URL**: https://apify.com/snappytools/npm-package-version-monitor.md
- **Developed by:** [Snappy](https://apify.com/snappytools) (community)
- **Categories:** Developer tools
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$1.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/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 Version Monitor – npm package version and release data export

Give it a list of public npm package names, such as `express` or `@types/node`, and get back one row per package. Each row has the latest version, when it was published, how many days ago that was, the licence, whether the package is deprecated, and a short list of recent releases.

It reads the official public npm registry API (registry.npmjs.org), so you need no login or API key. Schedule it to run daily or weekly and compare `latestVersion` between runs to catch new releases of the libraries you depend on.

### Why this one

- **Official source.** Every record comes straight from the public npm registry, not from a third-party mirror.
- **One clean row per package.** You get version, release dates, licence, deprecation status, repository URL and dependency count in a flat structure that opens neatly in a spreadsheet.
- **Staleness at a glance.** `daysSinceLatestRelease` tells you how long it has been since the last release, so you don't need to do the date maths.
- **Scoped names work.** Names like `@types/node` are handled, duplicates are removed and invalid names are skipped.
- **No credentials needed.** Only public package metadata is collected.
- **Pay per result.** $1.00 per 1,000 results, with no start fee, and runs with no results cost nothing.

### Quick start

```json
{
  "packages": ["express", "lodash", "@types/node"],
  "maxPackages": 5,
  "maxVersionsPerPackage": 5
}
```

This returns one record for each of the three packages, including the five most recent versions of each with their publish timestamps.

### What you can use it for

| Who | What for |
| --- | --- |
| Engineering teams | Watch the libraries your product depends on and spot stale or deprecated packages early |
| DevOps and platform teams | Schedule a run and compare `latestVersion` between runs to detect new releases of key frameworks |
| Security and compliance | Check `license`, `isDeprecated` and release cadence for packages under review |
| Open-source evaluators | Compare release frequency, `versionsCount` and `maintainersCount` before choosing a package |
| Analysts and managers | Export a table of package health indicators to spreadsheets or dashboards |

### How to use it

1. Click **Try for free**.
2. In **Package names**, add the npm packages you want to check, for example `express`, `lodash` or `@types/node`. Invalid names are skipped and duplicates are removed.
3. Set **Maximum packages** (1 to 100, default 20). Names beyond this limit are ignored.
4. Set **Recent versions per package** (0 to 50, default 5) to choose how many releases appear in `recentVersions`. Use 0 if you only want the latest version.
5. Click **Start**.
6. To track new releases, create a schedule and compare `latestVersion` or `latestPublishedAt` between runs.

### What data you get

Each record describes one package. Example values are from a test run on 26 Oct 2026.

| Field | What it is | Example |
| --- | --- | --- |
| `id` | Stable ID for the package | `npm:express` |
| `packageName` | The npm package name | `express` |
| `url` | npmjs.com page for the package | `https://www.npmjs.com/package/express` |
| `registryUrl` | Registry API address the data came from | `https://registry.npmjs.org/express` |
| `latestVersion` | Version tagged as latest | `5.3.0` |
| `latestPublishedAt` | When the latest version was published | `2026-10-09T12:56:54.505Z` |
| `daysSinceLatestRelease` | Days since the latest release | `16` |
| `createdAt` | When the package was first created | `2010-12-29T19:38:25.450Z` |
| `modifiedAt` | When the registry record last changed | `2026-10-09T12:56:55.078Z` |
| `versionsCount` | Number of published versions | `290` |
| `distTags` | Dist-tags mapped to versions | `{"latest": "5.3.0", "latest-4": "4.22.3"}` |
| `isDeprecated` | Whether the latest version is deprecated | `false` |
| `deprecationMessage` | Deprecation notice, if any | `null` |
| `license` | Licence identifier | `MIT` |
| `description` | Short package description | `Fast, unopinionated, minimalist web framework` |
| `keywords` | Keywords listed by the package | `["express", "framework", "web"]` |
| `homepage` | Package homepage | `https://expressjs.com/` |
| `repositoryUrl` | Normalised repository URL | `https://github.com/expressjs/express` |
| `maintainersCount` | Number of maintainers (names are not exported) | `5` |
| `dependenciesCount` | Number of runtime dependencies | `28` |
| `nodeEngine` | Declared Node.js engine range | `>= 18` |
| `recentVersions` | Most recent versions with publish times | `[{"version": "5.3.0", "publishedAt": "2026-10-09T12:56:54.505Z"}]` |
| `fetchedAt` | When this record was fetched | `2026-10-26T10:17:51.960Z` |

### Pricing

| Event | Price |
| --- | --- |
| Result (one package record) | $0.001 |

| Run | Cost |
| --- | --- |
| 100 results | $0.10 |
| 1,000 results | $1.00 |
| 10,000 results | $10.00 |

There is no start fee. Runs with no results cost nothing.

### Good to know

- **Limits.** A run processes up to 100 packages, and `recentVersions` lists up to 50 versions per package.
- **Data source.** All data comes from the public npm registry at registry.npmjs.org. Only public package metadata is collected.
- **Missing packages.** Names that don't exist are skipped, so you are only charged for real results.
- **Privacy.** Maintainer names and email addresses are not exported, only the count.
- **Freshness.** Data reflects the registry at fetch time (see `fetchedAt`) and may lag briefly behind npm replication.
- **Large packages.** Packages with very large registry documents can take longer to fetch.
- **Not affiliated.** This tool isn't affiliated with or endorsed by npm or GitHub.

### FAQ

**Do I need an npm account or API key?** No. The tool reads public registry data only.

**Can I check scoped packages?** Yes. Enter names like `@types/node` in **Package names**.

**What happens if I enter a package that doesn't exist?** It is skipped and not charged.

**How do I find out when a package has a new release?** Schedule the tool and compare `latestVersion` or `latestPublishedAt` between runs.

### Getting the data out

Download results as Excel, CSV or JSON from the Output tab. Send them to Google Sheets, Slack, Zapier, Make or webhooks from the **Integrations** tab. Every run is also available through the Apify API, and you can schedule runs from **Schedules**.

### Questions or problems

Open an issue on the **Issues** tab and include the run link. I reply within one business day.

### Related tools

- [GitHub Public Issue Monitor](https://apify.com/snappytools/github-issue-monitor): track issues on public GitHub repositories
- [GitHub Public Release Monitor](https://apify.com/snappytools/github-release-monitor): watch releases on public GitHub repositories
- [PyPI Package Release Monitor](https://apify.com/snappytools/pypi-release-monitor): the same kind of version check for Python packages

# Actor input Schema

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

List of public npm package names to check, for example express or @types/node. Invalid names are skipped and duplicates are removed.

## `maxPackages` (type: `integer`):

Upper bound on how many packages are processed in a single run (1-100). Extra names beyond this limit are ignored.

## `maxVersionsPerPackage` (type: `integer`):

How many of the most recently published versions to include in the recentVersions field of each record (0-50).

## Actor input object example

```json
{
  "packages": [
    "express",
    "lodash",
    "@types/node"
  ],
  "maxPackages": 20,
  "maxVersionsPerPackage": 5
}
```

# 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 = {
    "packages": [
        "express",
        "lodash",
        "@types/node"
    ],
    "maxPackages": 20,
    "maxVersionsPerPackage": 5
};

// Run the Actor and wait for it to finish
const run = await client.actor("snappytools/npm-package-version-monitor").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": [
        "express",
        "lodash",
        "@types/node",
    ],
    "maxPackages": 20,
    "maxVersionsPerPackage": 5,
}

# Run the Actor and wait for it to finish
run = client.actor("snappytools/npm-package-version-monitor").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": [
    "express",
    "lodash",
    "@types/node"
  ],
  "maxPackages": 20,
  "maxVersionsPerPackage": 5
}' |
apify call snappytools/npm-package-version-monitor --silent --output-dataset

```

## MCP server setup

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

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/yuRhHW7ZWaihXRktP/builds/jrVZhiJfqUNmpoGAu/openapi.json