# AI/ML PyPI Package Tracker — Transformers, LangChain, Torch (`parsing_machine/ai-ml-python-package-tracker`) Actor

Extract PyPI metadata — version, author, license, homepage, download counts — for the core AI/ML Python stack: transformers, torch, langchain, openai, anthropic. Official PyPI JSON API pipeline. $1.00/1K, no auth required.

- **URL**: https://apify.com/parsing\_machine/ai-ml-python-package-tracker.md
- **Developed by:** [Iakov Iudin](https://apify.com/parsing_machine) (community)
- **Categories:** Developer tools, MCP servers, AI
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

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

## AI/ML PyPI Package Tracker — Transformers, LangChain, Torch | $1/1K No Auth

Used by MLOps teams and AI-infrastructure/dev-tooling analysts tracking release cadence and dependency health across the model-serving and LLM-orchestration ecosystem, data scientists exploring the Python AI tooling landscape, and AI agents that need package metadata for tool selection mid-conversation.

**Pricing:** $1.00 per 1,000 packages. Download stats from pypistats.org are included at no extra cost.

Scrape Python package metadata and download statistics from **PyPI** — the official Python package index. Fetches version, author, license, homepage, project URLs, required Python version, and monthly download counts via the **official PyPI JSON API**. No proxy, no authentication, no HTML parsing. Pay per result.

**Python is the language of AI** — every ML framework, data tool, and model serving library lives on PyPI. Use this actor to track the core AI/ML Python stack. Note that `packageNames` still accepts an arbitrary list of packages; the AI/ML packages are a curated prefill, not hardcoded scraping logic.

### What you get per package

| Field | Example |
|---|---|
| `package_name` | `transformers` |
| `version_latest` | `4.41.2` |
| `summary` | `State-of-the-art Machine Learning for JAX, PyTorch and TensorFlow` |
| `author` | `The Hugging Face team` |
| `license` | `Apache-2.0` |
| `home_page` | `https://github.com/huggingface/transformers` |
| `project_urls` | `{"Documentation": "...", "Source": "..."}` |
| `requires_python` | `>=3.8.0` |
| `keywords` | `language model, transformers, huggingface` |
| `downloads_last_month` | `1563278363` |
| `release_date` | `2026-05-14T19:25:26.443000Z` |
| `parse_confidence` | `1.0` |
| `warnings` | `[]` |
| `scraped_at` | `2026-05-31T12:00:00Z` |

### AI/ML PyPI Package Tracker vs competitors

| | **This actor** | epctex/pypi-scraper | trudax/pypi-packages |
|---|---|---|---|
| Data source | Official PyPI JSON API | HTML scraping | Unknown |
| Proxy required | No — $0 | Yes (external proxy) | Unknown |
| Download stats | Yes (pypistats.org) | No | No |
| `parse_confidence` | Yes | No | No |
| Batch lookup | Yes | No | No |
| License field | SPDX + expression | Partial | No |

### How to use AI/ML PyPI Package Tracker

#### Package name lookup

Add package names to `packageNames`. Each name fetches full metadata from `pypi.org/pypi/<name>/json`.

**Works with:**

- AI/ML packages: `transformers`, `torch`, `langchain`, `sentence-transformers`, `openai`, `anthropic`
- Scoped/prefixed packages: any valid PyPI name

Note: `transformers` (https://pypi.org/project/transformers), `sentence-transformers` (https://pypi.org/project/sentence-transformers), `anthropic` (https://pypi.org/project/anthropic), `torch`, `langchain`, and `openai` are verified real, official, actively maintained AI/ML packages, checked 2026-07-15 via pypi.org.

#### A note on search

PyPI **does not have an official search JSON API**. The XML-RPC search endpoint was deprecated in 2023. This actor supports only direct name lookup — which is the most reliable and fastest approach. If you need to discover package names, use [pypi.org/search](https://pypi.org/search) first, then feed the names to this actor.

#### Download statistics

With `includeDownloads=true` (default), the actor fetches last-month download counts from [pypistats.org](https://pypistats.org) — the official PyPI download statistics service. A 1.5-second delay is added between calls to respect the rate limit. Set `includeDownloads=false` to skip this step and speed up large batches.

### Input configuration

```json
{
  "packageNames": [
    "transformers",
    "torch",
    "langchain",
    "sentence-transformers",
    "openai",
    "anthropic"
  ],
  "maxItems": 50,
  "includeDownloads": true
}
```

| Field | Type | Default | Description |
|---|---|---|---|
| `packageNames` | array | `[]` | PyPI package names to look up (curated AI/ML preset prefilled, but accepts any arbitrary list) |
| `maxItems` | integer | `50` | Max total records (0 = no limit) |
| `includeDownloads` | boolean | `true` | Fetch download stats from pypistats.org |

### How AI/ML PyPI Package Tracker works

1. For each package name, fetches `https://pypi.org/pypi/<name>/json` — the official PyPI JSON API.
2. Extracts and normalizes all metadata fields to a flat schema.
3. If `includeDownloads=true`, fetches `https://pypistats.org/api/packages/<name>/recent` for download counts.
4. Emits one record per package with a `parse_confidence` score (1.0 = all key fields present).

### `parse_confidence` explained

Every record includes a `parse_confidence` score (0.0–1.0):

- **1.0** — all key fields (name, version, summary, release\_date) are present.
- **< 1.0** — one or more fields were missing; check `warnings` for details.

This field lets you filter out incomplete records and detect API changes before they silently corrupt your pipeline.

### Pricing examples

| Run | Items | Cost |
|---|---|---|
| 10 packages (with download stats) | 10 | ~$0.01 |
| 100 packages | 100 | ~$0.10 |
| 1,000 packages | 1,000 | ~$1.00 |
| Daily requirements.txt audit (50 pkgs × 30 days) | 1,500/mo | ~$1.50/mo |

Download stats from pypistats.org are included at no extra cost.

### Frequently asked questions

#### Does this require a proxy?

No. PyPI and pypistats.org are fully public APIs with no access restrictions. Zero proxy cost for the buyer.

#### How fast does it run?

Without download stats: ~2–5 packages/second. With `includeDownloads=true`: ~0.5 packages/second (1.5s delay per pypistats call to avoid rate limiting).

#### What is `license_expression`?

Modern PyPI packages use SPDX expressions like `BSD-3-Clause AND MIT` instead of a single license name. This actor normalizes both: if `license` is null, it falls back to `license_expression`. The `license` output field contains whichever is available.

#### What happens if a package isn't found?

The actor logs a warning, skips the package, and continues. Missing packages are reported in the `OUTPUT` key-value store (`failedDetails` list).

### Version monitoring

Schedule daily runs on your `requirements.txt` package list to catch upstream version changes before they break your environment. Especially valuable for MLOps teams tracking release cadence and dependency health across the model-serving and LLM-orchestration ecosystem — `torch`, `transformers`, and other foundational packages update frequently.

### Use with AI agents (MCP)

This actor is callable as a **tool by AI agents** (Claude Desktop, Cursor, VS Code, n8n, LangGraph, CrewAI, or any MCP-compatible client) via Apify's hosted Model Context Protocol server. An agent uses it to **look up PyPI package metadata mid-conversation** — e.g. "what's the latest version of transformers and does it support Python 3.12?" or "compare the license of torch vs langchain".

Point your MCP client at this single tool:

```json
{
  "mcpServers": {
    "apify": {
      "command": "npx",
      "args": [
        "mcp-remote",
        "https://mcp.apify.com/?tools=bovi/ai-ml-python-package-tracker",
        "--header",
        "Authorization: Bearer <YOUR_APIFY_TOKEN>"
      ]
    }
  }
}
```

Minimal call an agent can make:

```json
{ "packageNames": ["torch", "langchain", "transformers"] }
```

Reliability for agents: data comes from the **official PyPI JSON API** (no HTML scraping), so rows don't break on site redesigns. Every record includes a `parse_confidence` score and a `warnings` array for machine-readable quality signals. No API key needed inside the tool — auth is your Apify token in the client config above.

### Integrations

Built for MLOps teams, dev-tooling analysts, and AI-infrastructure buyers auditing dependencies and tracking the AI tooling ecosystem — the JSON/dataset output drops into the tools you already run, no glue code:

- **n8n / Make / Zapier** — trigger a run or pipe every new dataset item into 500+ apps (Google Sheets, Airtable, Slack, HubSpot, your database) with no code: [n8n](https://docs.apify.com/platform/integrations/n8n), [Make](https://docs.apify.com/platform/integrations/make), [Zapier](https://docs.apify.com/platform/integrations/zapier).
- **Webhooks** — fire your own endpoint the moment a run finishes, to push results straight into your pipeline ([docs](https://docs.apify.com/platform/integrations/webhooks)).
- **MCP server** — expose this actor as a tool to Claude, Cursor, or any [MCP client](https://mcp.apify.com) so an AI agent can pull this data mid-conversation ([guide](https://blog.apify.com/how-to-use-mcp/)).
- **API & SDKs** — fetch the dataset as JSON, CSV, or Excel through the Apify REST API or the Python / JS SDKs.

See all [Apify integrations](https://apify.com/integrations).

### Legal disclaimer

This actor uses only **official, public APIs** provided by the Python Software Foundation (pypi.org) and pypistats.org. It does not scrape HTML or access any authentication-gated or access-controlled data. All data accessed is publicly available without login. Not affiliated with the Python Software Foundation or pypistats.org.

# Actor input Schema

## `packageNames` (type: `array`):

PyPI package names to look up (e.g. requests, numpy, flask). Each name fetches full metadata from the official PyPI JSON API. Note: PyPI has no official search JSON API — only direct name lookup is supported.

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

Maximum total package records to return. 0 = no limit. Default 50.

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

Fetch last-month download count from pypistats.org (one extra HTTP call per package, ~1.5 s delay to respect rate limits). Default true. Set to false to speed up large batches.

## Actor input object example

```json
{
  "packageNames": [
    "transformers",
    "torch",
    "langchain",
    "sentence-transformers",
    "openai",
    "anthropic"
  ],
  "maxItems": 50,
  "includeDownloads": true
}
```

# Actor output Schema

## `results` (type: `string`):

Dataset containing Pypi Scraper records (package\_name, version\_latest, summary, author, license, downloads\_last\_month, requires\_python, keywords, home\_page, release\_date, parse\_confidence).

# 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 = {
    "packageNames": [
        "transformers",
        "torch",
        "langchain",
        "sentence-transformers",
        "openai",
        "anthropic"
    ],
    "maxItems": 50,
    "includeDownloads": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("parsing_machine/ai-ml-python-package-tracker").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 = {
    "packageNames": [
        "transformers",
        "torch",
        "langchain",
        "sentence-transformers",
        "openai",
        "anthropic",
    ],
    "maxItems": 50,
    "includeDownloads": True,
}

# Run the Actor and wait for it to finish
run = client.actor("parsing_machine/ai-ml-python-package-tracker").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 '{
  "packageNames": [
    "transformers",
    "torch",
    "langchain",
    "sentence-transformers",
    "openai",
    "anthropic"
  ],
  "maxItems": 50,
  "includeDownloads": true
}' |
apify call parsing_machine/ai-ml-python-package-tracker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,parsing_machine/ai-ml-python-package-tracker"
        }
    }
}

```

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/l7nDtf7UY5twlpmin/builds/d1mdDoZtqXOGIktYJ/openapi.json