The PyPI API here looks up Python packages by name and returns one typed row each — latest version, summary, author, license, the required Python version spec, the supported Python versions parsed from the classifiers, homepage and repository links, declared keywords and the total release count, plus the PyPI project URL.
PyPI is keyless, but it has no clean JSON search endpoint — so this is a lookup by package name, not a keyword search. You hand it a list of names; each is fetched from PyPI's JSON metadata and flattened, and any name that does not exist is returned under failed rather than as an empty row. For a single package the PyPI JSON URL is enough on its own; the collector is for resolving a whole requirements file into one clean table.
$0.0003 per delivered package, up to 50 packages per run. Nothing delivered means nothing charged.
You pass a packages array of names. Each one becomes a JSON metadata fetch, parsed into a flat row with the version, license and Python-support fields already extracted.
failed, unbilled, instead of polluting your table with nulls.python_versions comes from the trove classifiers and requires_python from the version spec — two different answers to "what Python does this need", both surfaced.packages is required — an array of PyPI names such as requests or numpy. max_results caps delivery at 50 packages. You pay only for packages that resolve; names that do not exist return under failed at no charge.
One row per package. version is the latest release and release_count the total number of releases; requires_python is the declared spec while python_versions lists the classifier-declared versions; license, author, homepage and repository come from the metadata; keywords is an array; and url is the PyPI project page.
$0.0003 per delivered package ($0.30 per 1,000). Nothing delivered means nothing charged, and the $2 monthly free credit covers roughly 6,666 packages here. Volume tiers take up to 30% off.
$0.0003 per delivered package — $0.30 per 1,000 — no subscription. The $2/month free allowance is roughly 6,600 packages with no card, and unresolved names are never billed.
It shares a key and schema with the npm API, so a polyglot project's Python and JavaScript dependencies can be audited side by side in one table.
PyPI's per-project JSON API is public and keyless, and for one package the URL pypi.org/pypi/<name>/json is genuinely all you need — no collector required. We will not pretend otherwise.
The collector earns its price across a list: it fetches many names concurrently through rotating exits, parses the classifiers and version spec into tidy columns, and separates the misses into failed so a hundred-line requirements file becomes one clean table instead of a hundred requests and a parsing loop you maintain.
Doing it yourself is a loop over names hitting the JSON endpoint, plus the classifier parsing, the requires-python handling and error branches for names that 404. It is a small script — and then it is a small script you own, extend and debug when a package has an unusual metadata shape.
Prefer to keep the script? Run it over our residential proxies so a large audit gets stable exits without touching PyPI's limits.
Resolve every name in a requirements or lock file to get version, license and requires_python in one table — the fast way to spot an unmaintained or incompatibly licensed dependency.
Read python_versions and requires_python across your dependency set before a Python upgrade to find the packages that will block it.
Feed a curated list and get summary, repository, keywords and release_count to populate an internal catalogue of approved libraries.
One run resolves up to 50 packages. Because PyPI offers no clean JSON search, discovery by keyword is out of scope — you bring the names. Nonexistent names return in failed, unbilled. Runs parallelise up to your plan's rate limit (60–1,200 requests/minute by tier).
PyPI metadata is public and each package's license governs its code, not the metadata; downstream use is your responsibility. This is not legal advice.
PyPI's JSON metadata API is free and keyless — ideal for one package. This collector adds concurrent lookup across a list, parsed Python-support fields and a failed bucket, plus a $2/month free allowance of about 6,600 packages with no card.
No, and neither can the underlying API reliably — PyPI has no clean JSON search endpoint. This is a lookup by exact package name; you supply the names and get one flat row per package that resolves.
Every resolved row includes version, the latest published release, alongside release_count for the total number of releases. Send just the names you care about and read the column.
They come back under failed and are not billed. Real packages return as clean rows, so a typo or a private name never shows up as a misleading row of nulls in your results.