# npm & PyPI Outdated Package Checker — MCP for AI Agents (`peppy_weekend/dependency-freshness-mcp`) Actor

Check any npm or PyPI package in seconds: latest version, release dates, deprecation status, and a dated, cited 'what changed since your version' breaking-change diff. Built for time-blind AI coding agents that emit stale, deprecated code. MCP-native — callable as a tool, no scraping.

- **URL**: https://apify.com/peppy\_weekend/dependency-freshness-mcp.md
- **Developed by:** [Eren Kahveci](https://apify.com/peppy_weekend) (community)
- **Categories:** Developer tools, AI
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event + usage

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## Dependency Freshness Checker — is your npm or PyPI dependency outdated? Latest version, deprecation & breaking-change MCP for AI agents

**Dependency Freshness Checker** tells any AI coding agent whether an npm or PyPI package is
**outdated (out of date)** — and gives the cited facts to prove it: the latest version, release
dates, deprecation status, how many versions behind you are, and a dated **"what changed
since your version"** breaking-change diff. It is MCP-native, reads only public registries and
GitHub releases (no scraping, no ToS risk), and is priced Pay-Per-Event for pay-as-you-go agent use.

### Add it to your agent in 30 seconds

[![Add to Cursor](https://img.shields.io/badge/Add%20to-Cursor-0098FF?logo=cursor)](cursor://anysphere.cursor-deeplink/mcp/install?name=dependency-freshness\&config=eyJkZXBlbmRlbmN5LWZyZXNobmVzcyI6eyJ1cmwiOiJodHRwczovL3BlcHB5X3dlZWtlbmQtLWRlcGVuZGVuY3ktZnJlc2huZXNzLW1jcC5hcGlmeS5hY3Rvci9tY3AifX0=)
[![Install in VS Code](https://img.shields.io/badge/VS_Code-Install_Server-0098FF?logo=visualstudiocode)](https://insiders.vscode.dev/redirect?url=vscode%3Amcp%2Finstall%3F%257B%2522name%2522%253A%2522dependency-freshness%2522%252C%2522type%2522%253A%2522http%2522%252C%2522url%2522%253A%2522https%253A%252F%252Fpeppy-weekend--dependency-freshness-mcp.apify.actor%252Fmcp%2522%257D)
[![Install in VS Code Insiders](https://img.shields.io/badge/VS_Code_Insiders-Install_Server-24bfa5?logo=visualstudiocode)](https://insiders.vscode.dev/redirect?url=vscode-insiders%3Amcp%2Finstall%3F%257B%2522name%2522%253A%2522dependency-freshness%2522%252C%2522type%2522%253A%2522http%2522%252C%2522url%2522%253A%2522https%253A%252F%252Fpeppy-weekend--dependency-freshness-mcp.apify.actor%252Fmcp%2522%257D)

Already speak MCP? Paste this into your client (Claude Desktop, Cline, Continue, Windsurf —
any stdio MCP client), add your free [Apify token](https://console.apify.com/account/integrations),
and restart:

```json
{
  "mcpServers": {
    "dependency-freshness": {
      "command": "npx",
      "args": ["-y", "dependency-freshness-mcp"],
      "env": { "APIFY_TOKEN": "apify_api_..." }
    }
  }
}
```

Then just ask your agent to **"check dependency freshness"** before any upgrade.

Per-framework copy-paste configs and one-click badges (Cursor, VS Code, Claude Desktop,
Cline, Continue, Windsurf, Goose) are in **[`docs/integrations.md`](docs/integrations.md)**.
Want the agent to wire itself? It reads **[`llms-install.md`](llms-install.md)**.

> The hosted Actor is a *paid* MCP server, so it's auth-gated — every path needs your Apify
> token (free to get). One click installs it; you paste the token once. For a fully
> auth-clean path, add the Apify hub at [`mcp.apify.com`](https://mcp.apify.com) and call the
> Actor by name (details in [`docs/integrations.md`](docs/integrations.md)).

### What does Dependency Freshness Checker do?

Give it any npm or PyPI package — optionally with the version your agent is assuming — and the
Dependency Freshness Checker returns, **citations-first**:

- the **latest published version** and its release date;
- whether the package (or your assumed version) is **deprecated**;
- **how many versions behind** you are; and
- a **dated, cited `changeSummary[]`** of what changed between your version and latest.

Every field carries a source URL and access date, so an agent can trust — and quote — the result.

### Why check npm & PyPI dependency freshness?

LLM coding agents are **time-blind**: their training is frozen, so they emit 70–90% deprecated
package code. Coding agents are the largest agent population, and they all share this blind spot.
The Dependency Freshness Checker fixes the frozen-training-cutoff problem at call time. It lives
in the proven-demand "freshness for agents" lane but stays **narrow and legally clean** — it reads
only public [npm](https://registry.npmjs.org), [PyPI](https://pypi.org), and
[GitHub releases](https://docs.github.com/en/rest/releases) — so it does not fight first-party RAG
browsers or funded incumbents.

### How to use the Dependency Freshness Checker

Pass a small list of packages. Defaults are kept low so a first run is cheap, fast, and succeeds:

```json
{
  "packages": [
    { "ecosystem": "npm", "name": "zod", "currentVersion": "3.22.0" },
    { "ecosystem": "pypi", "name": "fastapi" }
  ]
}
```

`currentVersion` is optional — omit it to just ask "what's latest?". See
`.actor/input_schema.json` for the full schema.

### Output — dated, cited freshness results

Each result includes `isOutdated`, `versionsBehind`, `latest` + `latestPublishedAt`, a dated
`changeSummary[]`, and field-level `citations[]`. The same shape is returned by a batch run and by
the MCP tool, so agents and dashboards consume one format.

### Using Dependency Freshness Checker as an MCP tool for AI agents

This Actor exposes one MCP tool, **`check_dependency_freshness(packages)`**. Three ways to reach it
(mechanics cited in `docs/research/50-mcp.md`):

- **A — Hosted, no setup.** Every public Apify Actor is callable through Apify's hosted MCP server
  at [`https://mcp.apify.com`](https://mcp.apify.com) — no extra wiring.

- **B — The Actor as its own MCP server (Standby).** The deployed Actor serves a Streamable-HTTP
  MCP endpoint at `/mcp` on its own stable URL:

  ```json
  {
    "mcpServers": {
      "dependency-freshness": {
        "url": "https://<user>--dependency-freshness-mcp.apify.actor/mcp",
        "headers": { "Authorization": "Bearer <APIFY_TOKEN>" }
      }
    }
  }
  ```

- **C — Local stdio (dev / MCP Inspector).** Build, then point any
  [MCP](https://modelcontextprotocol.io) client at the compiled entrypoint:

  ```json
  {
    "mcpServers": {
      "dependency-freshness": {
        "command": "node",
        "args": ["/abs/path/dependency-freshness-mcp/dist/mcp/stdio.js"],
        "env": { "GITHUB_TOKEN": "ghp_… (optional, raises GitHub rate limit)" }
      }
    }
  }
  ```

  Inspect locally with `npx @modelcontextprotocol/inspector node dist/mcp/stdio.js`.

### Pricing

The Dependency Freshness Checker uses **Pay-Per-Event** pricing, built for pay-as-you-go agent
use: a small flat fee per run start plus **$0.005 per package checked ($5 / 1,000)** — inside
Apify's recommended $1–10 / 1,000-results band. You only pay for packages actually checked.

### FAQ

**Does it scrape websites?** No. It reads only public registry APIs and GitHub releases — no
scraping, no terms-of-service risk.

**Which ecosystems are supported?** npm and PyPI today.

**Do I need a GitHub token?** No — it is optional and only raises the GitHub rate limit for
heavier batches.

**Can an agent call it directly?** Yes — that is the point. Use the `check_dependency_freshness`
MCP tool (option A or B above).

### Other Actors

More agent-native data Actors are on the way on the
[Apify Store](https://apify.com/store?category=AI). Follow the author profile to see new
freshness-for-agents tools as they ship.

# Actor input Schema

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

List of packages to check. Each item is an object: { "ecosystem": "npm" | "pypi", "name": "<package name>", "currentVersion": "\<the version you are assuming, optional>" }. Keep the list small — you are charged per package checked.

## Actor input object example

```json
{
  "packages": [
    {
      "ecosystem": "npm",
      "name": "zod",
      "currentVersion": "3.22.0"
    }
  ]
}
```

# Actor output Schema

## `freshnessResults` (type: `string`):

The freshness table — view 'overview' presents the dataset as a sortable table (see dataset\_schema.json).

# 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": [
        {
            "ecosystem": "npm",
            "name": "zod",
            "currentVersion": "3.22.0"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("peppy_weekend/dependency-freshness-mcp").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": [{
            "ecosystem": "npm",
            "name": "zod",
            "currentVersion": "3.22.0",
        }] }

# Run the Actor and wait for it to finish
run = client.actor("peppy_weekend/dependency-freshness-mcp").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 '{
  "packages": [
    {
      "ecosystem": "npm",
      "name": "zod",
      "currentVersion": "3.22.0"
    }
  ]
}' |
apify call peppy_weekend/dependency-freshness-mcp --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/vX0KFM75hkrcyqdo0/builds/62omQM9HhITibv3BT/openapi.json