PyPI API

Developers & tech · v1.2.0 · pypi_packages

$0.0003 / package

$0.30 / 1K · pay per delivered package

A PyPI API looks up Python packages by name and returns one row each: the latest version, the summary, the author, the license, the Python version required, the supported Python versions from the classifiers, the homepage and repository links, the declared keywords and the release count. It is keyless, and it takes a list of names in a single call.

By Aldo Morese, founder of QuanticData · Published Aug 21, 2026 · Updated Sep 3, 2026

Run in dashboard See the request

$0.0003 per delivered package · $2 free every month · Failed runs never billed

What it does

What a PyPI API does

PyPI has no clean JSON search endpoint, so this is a lookup by exact package name rather than a keyword search. Hand it the names you already have — from a requirements file, a dependency graph, a shortlist — and any name that does not resolve comes back under failed rather than being silently dropped from the result.

The metadata that decides whether a package is safe to adopt is buried in PyPI's classifiers and JSON, formatted for a project page. This lifts the latest version, the requires-python spec and the supported Python versions out as their own fields, so a dependency table carries the compatibility columns without you parsing "Programming Language :: Python :: 3.11" strings by hand.

Inputs

The whole request. Anything you leave out falls back to the default shown in the catalog.

Input	Type	Required	What it does
`packages`	array	yes	PyPI package names, e.g. requests, numpy.
`max_results`	integer	no	How many packages to deliver at most (1–50). You pay only for delivered packages.

Outputs — 24 fields, one row per package

What one package looks like

Every delivered package carries these fields. Nullable means the source did not publish it — the field stays empty instead of being guessed.

Field	Type	What it holds
`rank`	integer	1-based position.
`name`	string	Package name.
`version`	string · nullable	Latest version.
`summary`	string · nullable	Short summary.
`author`	string · nullable	Author.
`license`	string · nullable	License.
`requires_python`	string · nullable	Required Python version spec.
`homepage`	string · nullable	Homepage URL.
`repository`	string · nullable	Source repository URL.
`keywords`	string[]	Declared keywords.
`python_versions`	string[]	Supported Python versions (classifiers).
`release_count`	integer · nullable	Number of releases.
`url`	string	PyPI project URL.
`maintainer`	string · nullable	Maintainer.
`documentation`	string · nullable	Documentation URL.
`changelog`	string · nullable	Changelog URL.
`dependencies`	string[]	Runtime dependencies (requires_dist without extras).
`optional_dependencies_count`	integer	Dependencies that belong to an extra.
`extras`	string[]	Extras the package provides.
`development_status`	string · nullable	Development status classifier.
`released_at`	string · nullable	Upload time of the current version.
`first_release_at`	string · nullable	Upload time of the first release.
`yanked`	boolean	Whether the current version is yanked.
`known_vulnerabilities`	integer · nullable	Known vulnerabilities PyPI lists for the current version.

Integration

One POST, typed rows

Base URL https://api.quanticdata.io/v1, Bearer auth, the same key as every other Data API. Endpoint: POST /v1/scraper/collectors/pypi_packages/run.

curl -X POST https://api.quanticdata.io/v1/scraper/collectors/pypi_packages/run \
  -H "Authorization: Bearer $QD_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"packages":["requests","numpy","fastapi"],"max_results":3}'

import requests

r = requests.post(
    "https://api.quanticdata.io/v1/scraper/collectors/pypi_packages/run",
    headers={"Authorization": f"Bearer {QD_API_KEY}"},
    json={
        "packages": [
            "requests",
            "numpy",
            "fastapi"
        ],
        "max_results": 3
    },
    timeout=120,
)
for row in r.json()["payload"]["results"]:
    print(row)

const res = await fetch(
  "https://api.quanticdata.io/v1/scraper/collectors/pypi_packages/run",
  {
    method: "POST",
    headers: {
      Authorization: `Bearer ${process.env.QD_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({"packages":["requests","numpy","fastapi"],"max_results":3}),
  },
);
const { payload } = await res.json();
console.table(payload.results);

claude mcp add quanticdata \
  -e QUANTICDATA_API_KEY=qd_live_your_key_here \
  -- npx -y quanticdata-mcp

# then, in the chat:
> run the pypi_packages collector with packages=["requests","numpy","fastapi"] and max_results=3

Example response

POST /v1/scraper/collectors/pypi_packages/run

$ curl $QD/pypi_packages/run \
    -H "Authorization: Bearer $QD_API_KEY" \
    -d '{"packages": ["requests", "numpy", "fastapi"], "max_results": 3}'
{ "status": "done", "count": 3,
  "results": [
    {
      "name": "…",
      "version": "…",
      "summary": "…",
      "author": "…" } ],
  "cost": 0.0009 }
# 3 packages × $0.0003 · nothing delivered, nothing charged

Try it

PyPI package data, running now

Change the input and run it against the live collector — nothing to install, no sign-up.

Run it from your own code, on your own inputs

Same collector, same rows — $2 of free API credit every month, no card.

Get my free API key

PyPI API: from packages, QuanticData reads the PyPI package pages and returns one row per package with name, version and summary, at $0.0003 per delivered package. — You send packages and max_results; the run reads the source and comes back as packages with rank, name and version — 24 fields on every row — and you are billed $0.0003 for each package actually delivered, nothing for a run that delivers none.

$0.0003 / package6,666 packages on the free $2 every month

Semantic inputpackages, max_results — no URL lists

Up to 50packages per run, pagination handled for you

No browserread over HTTP/TLS — cheaper and faster than rendering

Pricing

PyPI API pricing

$0.0003 per delivered package. A run that delivers nothing costs nothing: blocked pages, challenges and retries are on us, and the $2 monthly allowance covers about 6,666 packages before you spend anything.

$0.0003per delivered package$0.3 per 1,000 delivered packages

6,666 packageson the free allowance$2 every month, no card

Zero rowszero chargeblocks, captchas and retries are on us

−30%on volume tiersthe catalog returns your key's price

Pay as you go

$0/mo

$2 free credit / month
60 requests / min
List unit prices

Starter

$19/mo

$15 free credit / month
300 requests / min
10% off unit prices

Growth

$79/mo

$50 free credit / month
600 requests / min
20% off unit prices

Scale

$299/mo

$250 free credit / month
1,200 requests / min
30% off unit prices

Same wallet, same key and same $2 monthly allowance as every other Data API. Prices are launch pricing read live from the billing config — GET /v1/scraper/collectors returns the price your key actually pays.

What people build with the PyPI API

Three shapes of work this endpoint was designed around.

Dependency audits

Feed a requirements list in and get the latest version, license and Python support for each package as a row — the table an upgrade or compliance review starts from.

License inventories

The license field across a package list turns a dependency tree into a license column, so a review can flag the ones that need a closer look.

Version monitoring

Look up the packages you ship on a schedule and the latest version on each row tells you which dependencies have moved since the last check.

PyPI API versus rolling your own

The differences that actually cost time when you build this in-house.

	DIY scraper	This collector
Query	Hope for a keyword search PyPI does not offer	A lookup by exact name, a whole list at a time
Compatibility	Parse Python support out of classifier strings	requires-python and versions as their own fields
Missing names	A silent gap in the results	Reported under failed, never dropped quietly

What people search for

Live autocomplete demand around PyPI package data, pulled with our own Keyword ideas collector.

PyPI API: the POST to the pypi_packages collector, 3 packages delivered and the bill, 3 × $0.0003 = $0.0009 in usage.cost_usd; zero packages would cost $0. — The same call you would paste into a terminal: a Bearer key, packages in the body, and back the envelope every QuanticData endpoint returns — type, message, payload — where count is how many packages arrived and usage.cost_usd is $0.0009, which is 3 × $0.0003. A run that delivers nothing costs nothing. The key is good for 60 req/min on the free tier.

Sources and standards

The platform documentation and standards this collector is built against — check any claim on this page against the primary source:

FAQ

Questions we get about the PyPI API.

Something else? Ask us

Can I search PyPI by keyword?

No — PyPI exposes no clean JSON search endpoint, so this is a lookup by package name. You pass the names you already have and each resolves to a row of metadata; it does not discover packages from a topic word.

How do I get the latest version of a package?

Pass the package name and the version field on the returned row is its latest release, alongside release_count so you can see how many versions preceded it.

What happens if a package name does not exist?

It is reported under failed rather than dropped, so a lookup over a list tells you exactly which names resolved and which did not.

Is there a free PyPI API?

Every account gets $2 of credit every month with no card, which is about 6,666 delivered packages on this endpoint at $0.0003 each. It renews monthly, and a run that delivers nothing is never billed — so a failed or blocked attempt does not eat the allowance.

How much does one run cost?

Multiply the rows you actually receive by $0.0003. A run capped at 50 packages — the maximum for this collector — costs $0.015 if every row comes back, and less when the source has fewer. Volume tiers take up to 30% off, and GET /v1/scraper/collectors returns the price your key actually pays.

Run the PyPI API now

$2 of free credit every month, no card. Your key returns its own prices from GET /v1/scraper/collectors.

Run in dashboard

Illustration: three coloured zones of the page that is read (PyPI package pages) turn into clean JSON with the fields name, version and summary; 24 fields on every row.