Pricing

from $1.00 / 1,000 results

PyPI Package Lookup & Health

Look up Python packages on PyPI (or paste a requirements.txt) and get clean JSON: version, release date, dependencies, license, repo link, and a computed activity level.

Pricing

from $1.00 / 1,000 results

Rating

0.0

(0)

Developer

Nicolas van Arkens

Actor stats

Bookmarked

Total users

Monthly active users

5 days ago

Last modified

.dockerignore

.git
.venv
__pycache__
*.pyc
storage
test_*.py

requirements.txt

1apify < 3.0
2pydantic >= 2.8, < 2.12
3browserforge == 1.2.3
4httpx

.actor/actor.json

{
    "actorSpecification": 1,
    "name": "pypi-package-lookup",
    "title": "PyPI Package Lookup & Health",
    "description": "Look up Python packages on PyPI (or paste a requirements.txt) and get clean JSON: version, release date, dependencies, license, repo link, and a computed activity level.",
    "version": "0.1",
    "buildTag": "latest",
    "input": "./input_schema.json",
    "dockerfile": "./Dockerfile",
    "storages": { "dataset": "./dataset_schema.json" }
}

.actor/dataset_schema.json

{
    "actorSpecification": 1,
    "views": {
        "overview": {
            "title": "Overview",
            "transformation": { "fields": ["name","version","activityLevel","daysSinceRelease","dependencyCount","license","requiresPython","repository","url"] },
            "display": {
                "component": "table",
                "properties": {
                    "name": { "label": "Package", "format": "text" },
                    "version": { "label": "Version", "format": "text" },
                    "activityLevel": { "label": "Activity", "format": "text" },
                    "daysSinceRelease": { "label": "Days since release", "format": "number" },
                    "dependencyCount": { "label": "Deps", "format": "number" },
                    "license": { "label": "License", "format": "text" },
                    "requiresPython": { "label": "Python", "format": "text" },
                    "repository": { "label": "Repo", "format": "text" },
                    "url": { "label": "URL", "format": "link" }
                }
            }
        }
    }
}

.actor/Dockerfile

FROM apify/actor-python:3.12
COPY requirements.txt ./
RUN pip install --no-cache-dir -r requirements.txt
COPY . ./
CMD ["python", "-m", "src"]

.actor/input_schema.json

{
    "title": "PyPI Package Lookup & Health",
    "type": "object",
    "schemaVersion": 1,
    "properties": {
        "packages": {
            "title": "Package names",
            "type": "array",
            "description": "Python package names to look up on PyPI. Example: ['requests', 'flask', 'numpy'].",
            "editor": "stringList",
            "prefill": ["requests", "flask", "django"]
        },
        "requirementsText": {
            "title": "requirements.txt contents (optional)",
            "type": "string",
            "description": "Optionally paste the contents of a requirements.txt; package names are extracted and looked up alongside the list above.",
            "editor": "textarea"
        }
    },
    "required": []
}

.actor/README.md

1# PyPI Package Lookup & Health 🐍
2
3Look up Python packages on **PyPI** — or paste your **`requirements.txt`** — and get clean, structured JSON for each: version, last release date, dependency count, license, Python compatibility, repository link, and a computed **activity level** (active / slowing / stale / dormant) so you can spot unmaintained packages at a glance.
4
5Uses the official PyPI JSON API (reliable per-package data), not fragile HTML scraping.
6
7## Why use it
8
9- 📦 **Bulk lookup** — many packages in one run, or a whole requirements.txt
10- 🚦 **Activity level** — computed from release recency, not just a raw date
11- 🔢 **Dependency count & release history** at a glance
12- 📜 **License & Python compatibility** for each package
13- 🔗 **Repository, homepage, and docs links**
14
15## Use cases
16
17- **Dependency research** — compare candidate packages before adopting
18- **Maintenance audits** — find stale/dormant packages in your requirements
19- **Datasets** — structured metadata for Python ecosystem analysis
20- **Tooling & dashboards** — feed clean package data into your own systems
21
22## Input
23
24| Field | Description |
25|-------|-------------|
26| **Package names** | List of PyPI package names. |
27| **requirements.txt contents** (optional) | Paste a requirements.txt; names are extracted automatically. |
28
29## Output
30
31```json
32{
33  "name": "requests",
34  "summary": "Python HTTP for Humans.",
35  "version": "2.34.2",
36  "lastReleaseDate": "2026-05-14T19:25:26Z",
37  "activityLevel": "active",
38  "daysSinceRelease": 13,
39  "license": "Apache-2.0",
40  "requiresPython": ">=3.10",
41  "dependencyCount": 6,
42  "releaseCount": 163,
43  "repository": "https://github.com/psf/requests",
44  "documentation": "https://requests.readthedocs.io",
45  "url": "https://pypi.org/project/requests/"
46}
47```
48
49Export to JSON, CSV, or Excel, or pull via the Apify API.
50
51## Notes
52
53- Uses the official public PyPI JSON API. Independent tool, not affiliated with PyPI or the PSF.
54- The activity level is a simple heuristic from release recency, included for easy filtering — always verify directly for critical decisions.

src/main.py

1"""PyPI Package Lookup & Health — Apify Actor.
2
3Give it a list of Python package names (or paste a requirements.txt), and it
4returns clean, structured data for each from the official PyPI JSON API, plus a
5computed activity signal (active / slowing / stale / dormant) from release
6recency. Reliable (pure JSON API, per-package) — unlike scraping PyPI's HTML
7search page.
8"""
9
10from __future__ import annotations
11
12import asyncio
13import re
14from datetime import datetime, timezone
15
16import httpx
17from apify import Actor
18
19PYPI = "https://pypi.org/pypi"
20
21_REQ_LINE = re.compile(r"^\s*([A-Za-z0-9][A-Za-z0-9._-]*)")
22
23
24def parse_requirements(text: str) -> list[str]:
25    """Extract package names from requirements.txt content."""
26    names: list[str] = []
27    for line in text.splitlines():
28        line = line.strip()
29        if not line or line.startswith("#") or line.startswith("-"):
30            continue
31        if line.startswith(("git+", "http://", "https://")):
32            continue
33        m = _REQ_LINE.match(line)
34        if m:
35            names.append(m.group(1))
36    return names
37
38
39def _parse_dt(value: str | None) -> datetime | None:
40    if not value:
41        return None
42    try:
43        return datetime.fromisoformat(value.replace("Z", "+00:00"))
44    except (ValueError, AttributeError):
45        return None
46
47
48def compute_activity(last_release_iso: str | None, now: datetime) -> tuple[str, int | None]:
49    dt = _parse_dt(last_release_iso)
50    if dt is None:
51        return "unknown", None
52    if dt.tzinfo is None:
53        dt = dt.replace(tzinfo=timezone.utc)
54    days = int((now - dt).total_seconds() / 86400)
55    if days <= 180:
56        level = "active"
57    elif days <= 365:
58        level = "slowing"
59    elif days <= 730:
60        level = "stale"
61    else:
62        level = "dormant"
63    return level, days
64
65
66def transform(data: dict, now: datetime) -> dict:
67    info = data.get("info", {})
68    version = info.get("version")
69    releases = data.get("releases", {})
70    files = releases.get(version) or []
71    last_upload = files[0].get("upload_time_iso_8601") if files else None
72    yanked = bool(files[0].get("yanked")) if files else False
73
74    urls = info.get("project_urls") or {}
75    repo = None
76    for k, v in urls.items():
77        if k.lower() in ("source", "repository", "code", "github") or "github.com" in (v or ""):
78            repo = v
79            break
80
81    activity, days = compute_activity(last_upload, now)
82    requires = info.get("requires_dist") or []
83
84    return {
85        "name": info.get("name"),
86        "summary": (info.get("summary") or "").strip() or None,
87        "version": version,
88        "lastReleaseDate": last_upload,
89        "activityLevel": activity,
90        "daysSinceRelease": days,
91        "yanked": yanked,
92        "license": info.get("license_expression") or info.get("license") or None,
93        "requiresPython": info.get("requires_python"),
94        "author": info.get("author") or info.get("author_email"),
95        "dependencyCount": len(requires),
96        "releaseCount": len(releases),
97        "homepage": info.get("home_page") or urls.get("Homepage"),
98        "documentation": urls.get("Documentation"),
99        "repository": repo,
100        "keywords": [k.strip() for k in (info.get("keywords") or "").replace(",", " ").split() if k.strip()][:20],
101        "url": f"https://pypi.org/project/{info.get('name')}/",
102    }
103
104
105async def fetch_package(client: httpx.AsyncClient, name: str, log) -> dict | None:
106    for attempt in range(1, 4):
107        try:
108            resp = await client.get(f"{PYPI}/{name}/json")
109            if resp.status_code == 404:
110                return None
111            resp.raise_for_status()
112            return resp.json()
113        except (httpx.HTTPError, ValueError) as exc:
114            log.warning(f"Fetch attempt {attempt} failed for {name}: {exc}")
115            if attempt < 3:
116                await asyncio.sleep(attempt * 2)
117    return None
118
119
120async def main() -> None:
121    async with Actor:
122        actor_input = await Actor.get_input() or {}
123
124        names: list[str] = list(actor_input.get("packages", []) or [])
125        manifest = actor_input.get("requirementsText", "") or ""
126        if manifest.strip():
127            names += parse_requirements(manifest)
128
129        # Normalize + dedupe (PyPI names are case-insensitive, - and _ equivalent).
130        seen, unique = set(), []
131        for n in names:
132            n = n.strip()
133            if not n:
134                continue
135            key = n.lower().replace("_", "-")
136            if key not in seen:
137                seen.add(key)
138                unique.append(n)
139        names = unique
140
141        if not names:
142            Actor.log.warning("No packages provided. Add 'packages' or paste a requirements.txt into 'requirementsText'.")
143            await Actor.push_data([])
144            return
145
146        Actor.log.info(f"Looking up {len(names)} PyPI package(s).")
147        now = datetime.now(timezone.utc)
148
149        async with httpx.AsyncClient(
150            timeout=30.0,
151            headers={"User-Agent": "scrapeworks-pypi-lookup/0.1", "Accept": "application/json"},
152        ) as client:
153            for name in names:
154                data = await fetch_package(client, name, Actor.log)
155                if data is None:
156                    await Actor.push_data([{"name": name, "found": False,
157                                            "error": "Package not found on PyPI"}])
158                    Actor.log.info(f"  {name}: not found")
159                    continue
160                rec = transform(data, now)
161                rec["found"] = True
162                await Actor.push_data([rec])
163                Actor.log.info(f"  {rec['name']} ({rec['version']}): {rec['activityLevel']}")
164
165        Actor.log.info("Done.")

src/main.py

1import asyncio
2from .main import main
3
4asyncio.run(main())

PyPI Package Metadata Scraper

klondikeking/pypi-package-scraper

Extract detailed metadata for Python packages from the PyPI public API. Get version, dependencies, classifiers, license, author info, and release history for any PyPI package.

Pierrick McD0nald

PyPI Package Stats Scraper — Downloads, Versions, Dependencies

seemuapps/pypi-package-stats-scraper

Get download counts, version history, dependencies, license, author, and classifiers for any Python package on PyPI. Bulk-process a list of packages in one run.

Andrew

PyPI Package Scraper

devilscrapes/pypi-package-scraper

Pull rich metadata for any PyPI package — current version, dependencies, classifiers, author, license, home page, download URLs, release history. Free PyPI JSON API, no key required.

DevilScrapes

PyPI Packages Scraper

parseforge/pypi-packages-scraper

Pull Python package data from PyPI. Returns name, version, summary, description, classifiers, license, author, project URLs (homepage, source, issues, docs), Python version requirement, dependencies, release history, last upload, and total release count. Direct lookup by package name.

ParseForge

PyPI Scraper

crawlerbros/pypi-scraper

Scrape Python package metadata from PyPI: exact-name lookup, newly-added packages, and recently-updated packages. Pulls version, license, classifiers, dependencies, project URLs, and maintainer info.

Crawler Bros

5.0

PyPI (Python) Packages Scraper

gio21/pypi-packages-scraper

Scrape PyPI Python packages by name-search or top-downloads. Returns full metadata: name, version, summary, author, license, downloads, dependencies, project URLs, classifiers. Pay per package returned.

Gio

PyPI Python Package Scraper

cloud9_ai/pypi-package-scraper

Search and extract Python package data from PyPI. Get versions, dependencies, download stats, and classifiers. No API key needed.

cloud9

PyPI Release Monitor API

automly/pypi-release-monitor-api

Monitor PyPI releases and package metadata from the public PyPI JSON API.

Automly

PyPI Package Metadata Monitor (Pythia)

apricot_blackberry/pythia-pypi

Fetch structured metadata for any PyPI package. Returns latest version, up to 10 most-recent releases with publish dates, total release count, author, license, and Python version requirement.

Creator Fusion

Pypi Package Scraper

openclawmara/pypi-package-scraper

Scrape PyPI the Python Package Index. Extract package metadata, download statistics, version history, dependencies, and maintainer info. Track new releases and popularity trends. Perfect for Python ecosystem analysis and package research.