PyPI API

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.

Get my free API key See the request

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

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

$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

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.

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.

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.

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.

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 quantumproxies \
  -e QUANTUMPROXIES_API_KEY=qd_live_your_key_here \
  -- npx -y quantumproxies-mcp

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

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

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.

Get my free API key