# PyPI API — $0.0003 per package

> PyPI API: Python package metadata from PyPI — version, summary, license, Python. $0.0003 per delivered package, nothing delivered means nothing charged.

[Home](https://quanticdata.io/)/[Collectors](https://quanticdata.io/collectors/)/*PyPI API*

# 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](https://app.quanticdata.io/register) [See the request](/collectors/pypi-api/#integration)

$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 / package**6,666 packages on the free $2 every month

**Semantic input**packages, max_results — no URL lists

**Up to 50**packages per run, pagination handled for you

**No browser**read over HTTP/TLS — cheaper and faster than rendering

On this page: [What it is](/collectors/pypi-api/#what) [Output fields](/collectors/pypi-api/#output) [Inputs](/collectors/pypi-api/#input) [Pricing](/collectors/pypi-api/#pricing) [Integration](/collectors/pypi-api/#integration) [Use cases](/collectors/pypi-api/#use-cases) [Versus the alternatives](/collectors/pypi-api/#compare) [FAQ](/collectors/pypi-api/#faq)

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

Input is meaning, not a URL *packages* *max_results*

## 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.0003**per delivered package*$0.3 per 1,000 delivered packages*

**6,666 packages**on the free allowance*$2 every month, no card*

**Zero rows**zero charge*blocks, captchas and retries are on us*

**−30%**on volume tiers*the 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

Most popular

### 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](https://quanticdata.io/web-data-api-for-ai/). 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 →](mailto:hello@quanticdata.io)

### 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](https://app.quanticdata.io/register)

Related: [All 65 collectors](https://quanticdata.io/collectors/) [npm registry API](https://quanticdata.io/collectors/npm-registry-api/) [GitHub repository search API](https://quanticdata.io/collectors/github-repository-search-api/) [Stack Overflow API](https://quanticdata.io/collectors/stack-overflow-api/) [Documentation](https://quanticdata.io/docs/)

---

Source: https://quanticdata.io/collectors/pypi-api/ · Site index for AI: https://quanticdata.io/llms.txt