open-index/open-pypi

PyPI - Complete Package Archive

Every Python package on PyPI with full metadata, release history, dependencies, and trove classifiers

What is it?

This dataset contains a comprehensive snapshot of PyPI (the Python Package Index), the official package repository for the Python programming language. PyPI is where pip install pulls from. Nearly every open source Python library, framework, and tool is published here, from one-off utilities to foundational projects like NumPy, Django, and TensorFlow.

The archive currently contains 712,894 packages with 7,950,017 releases and 17,214,044 distribution files, maintained by 802,704 package owners. For each package we store the full metadata from the PyPI JSON API: descriptions, authors, license information, version history, file checksums, trove classifiers, PEP 508 dependency specifications, project URLs, and ownership roles.

We built this dataset because PyPI metadata is spread across multiple endpoints (JSON API, Simple API, XML-RPC changelog) with different response formats and rate limits. Having everything in a single Parquet archive makes it straightforward to study the Python ecosystem at scale. No API keys, no rate limits, no pagination.

What is being released?

The dataset is organized as 7 tables, each stored as a Parquet file with Zstandard compression.

data/
  packages/0000.parquet      core metadata (30+ columns per package)
  releases/0000.parquet      every published version with file stats
  files/0000.parquet         every distribution file (wheel, sdist, egg)
  classifiers/0000.parquet   trove classifiers per package
  dependencies/0000.parquet  PEP 508 dependency specifications
  project_urls/0000.parquet  project URL labels (homepage, docs, source, etc.)
  owners/0000.parquet        package ownership roles

Dataset statistics

Table	Rows	Description
packages	712,894	One row per package: name, description, license, author, requires_python, version
releases	7,950,017	Every published version: upload time, file count, total size, wheel/sdist flags
files	17,214,044	Every distribution file: filename, size, SHA-256, package type, python version
classifiers	3,623,313	Trove classifiers (e.g. "Programming Language :: Python :: 3")
dependencies	3,049,127	PEP 508 dependency strings with parsed package name and extras
project_urls	990,303	Labeled URLs (Homepage, Documentation, Source, etc.)
owners	802,704	Package owners with roles (Owner, Maintainer)

Releases per package: median 3, p90 20, p99 121, max 9,475 (average 11.2). Most packages have only a handful of releases, but heavily maintained projects can have hundreds.

Wheel availability: 80.8% of releases include a wheel distribution. Wheels are the standard binary format and are what pip install prefers.

Source distributions: 88.3% of releases include an sdist (source tarball).

Packages with dependencies: 60.2% of packages declare at least one dependency.

Ecosystem snapshot

License distribution

The Python ecosystem leans heavily on permissive licenses. MIT leads, followed by BSD and Apache variants. A substantial number of packages ship without a machine-readable license field, partly because PyPI historically accepted free-text license strings rather than SPDX identifiers.

MIT                 ██████████████████████████████ 174,718
AGPL-3              ███ 16,590
UNKNOWN             ███ 15,792
Apache-2.0          ███ 15,657
BSD                 ███ 15,141
MIT License         ██ 12,443
Apache 2.0          █ 7,110
Apache License 2.0  █ 6,547
GPLv3               █ 6,207
GPL                 █ 5,804

Most common classifiers

Trove classifiers are the structured metadata tags that packages use to declare their intended audience, supported Python versions, and topic area. The distribution here tells you what the Python community is actually building.

Programming Language :: Pyt...  ██████████████████████████████ 362,286
License :: OSI Approved :: ...  █████████████████████ 250,428
Operating System :: OS Inde...  ███████████████████ 230,039
Intended Audience :: Develo...  ██████████████████ 211,873
Programming Language :: Pyt...  ████████████ 144,791
Programming Language :: Pyt...  ███████████ 138,653
Programming Language :: Python  ██████████ 122,038
Programming Language :: Pyt...  ██████████ 121,132
Programming Language :: Pyt...  ██████████ 115,963
Programming Language :: Pyt...  █████████ 104,815
Development Status :: 4 - Beta  ████████ 91,082
Programming Language :: Pyt...  ███████ 79,781
Development Status :: 3 - A...  ██████ 74,469
Programming Language :: Pyt...  ██████ 67,784
Topic :: Software Developme...  █████ 64,719

Python version requirements

The requires_python field tells pip which Python versions a package supports. This distribution shows how the ecosystem is migrating across Python versions.

>=3.6        ██████████████████████████████ 62,864
>=3.10       █████████████████████████████ 59,794
>=3.8        ███████████████████████████ 56,443
>=3.9        ████████████████████ 41,298
>=3.7        ███████████████████ 39,605
>=3.11       ███████████ 23,165
>=3.12       ███████ 15,558
>=3.5        █████ 10,991
<4.0,>=3.10  ███ 7,090
>=3.8,<4.0   ███ 6,151

Most depended-upon packages

These are the packages most frequently listed as dependencies across all of PyPI. They form the foundation of the Python ecosystem. Infrastructure libraries like type checkers, testing frameworks, and HTTP clients dominate because they sit in the dependency tree of thousands of projects.

numpy       ██████████████████████████████ 93,339
pytest      █████████████████████████████ 89,238
requests    ██████████████████████████ 79,792
pandas      ████████████████████ 61,207
pytest-cov  █████████████ 41,862
pydantic    █████████████ 41,173
matplotlib  █████████████ 41,025
scipy       ████████████ 36,206
click       ██████████ 30,162
black       █████████ 29,138
mypy        █████████ 28,341
tqdm        █████████ 27,173
ruff        █████████ 26,852
httpx       ████████ 25,560
pyyaml      ████████ 25,328

Project URL labels

Packages can declare labeled URLs pointing to their homepage, documentation, source code, and other resources. The labels used tell you how maintainers think about their project's public surface.

Homepage       ██████████████████████████████ 506,288
Repository     ██████ 92,853
Download       █████ 83,019
Documentation  ████ 70,441
Issues         ███ 51,747
Bug Tracker    ███ 43,162
Source         ██ 30,934
Changelog      █ 18,172
Source Code    █ 9,566
repository     █ 8,469

How to download and use this dataset

The dataset uses the standard Hugging Face Parquet layout with one config per table. You can query it remotely with DuckDB, stream it with the datasets library, or download files individually.

Using DuckDB

DuckDB can read Parquet files directly from Hugging Face without downloading anything first. This is the fastest way to explore the data.

-- Most popular packages (by number of releases)
SELECT name, version AS latest, release_count, requires_python, license
FROM read_parquet('hf://datasets/open-index/open-pypi/data/packages/*.parquet')
WHERE release_count > 0
ORDER BY release_count DESC
LIMIT 20;

-- Packages that require Python 3.8+
SELECT name, requires_python, version, release_count
FROM read_parquet('hf://datasets/open-index/open-pypi/data/packages/*.parquet')
WHERE requires_python LIKE '%3.8%'
ORDER BY release_count DESC
LIMIT 20;

-- Most depended-upon packages across the ecosystem
SELECT dep_name, count(DISTINCT name) AS dependents
FROM read_parquet('hf://datasets/open-index/open-pypi/data/dependencies/*.parquet')
GROUP BY dep_name
ORDER BY dependents DESC
LIMIT 20;

-- License distribution
SELECT license, count(*) AS packages,
       round(count(*) * 100.0 / sum(count(*)) OVER (), 1) AS pct
FROM read_parquet('hf://datasets/open-index/open-pypi/data/packages/*.parquet')
WHERE license IS NOT NULL AND license != '' AND length(license) < 100
GROUP BY license
ORDER BY packages DESC
LIMIT 15;

-- Largest distribution files (biggest wheels and sdists)
SELECT name, version, filename, packagetype,
       size / (1024*1024) AS size_mb
FROM read_parquet('hf://datasets/open-index/open-pypi/data/files/*.parquet')
WHERE size > 0
ORDER BY size DESC
LIMIT 20;

-- Packages using a specific classifier
SELECT p.name, p.version, p.summary
FROM read_parquet('hf://datasets/open-index/open-pypi/data/classifiers/*.parquet') c
JOIN read_parquet('hf://datasets/open-index/open-pypi/data/packages/*.parquet') p
  ON c.name = p.name
WHERE c.classifier = 'Framework :: Django'
ORDER BY p.release_count DESC
LIMIT 20;

-- How many packages have GitHub as their source?
SELECT
    count(*) FILTER (WHERE url LIKE '%github.com%') AS github,
    count(*) FILTER (WHERE url LIKE '%gitlab.com%') AS gitlab,
    count(*) FILTER (WHERE url LIKE '%bitbucket.org%') AS bitbucket,
    count(*) AS total
FROM read_parquet('hf://datasets/open-index/open-pypi/data/project_urls/*.parquet')
WHERE lower(label) IN ('source', 'source code', 'repository', 'github', 'code');

Using datasets

from datasets import load_dataset

# Load the packages table
ds = load_dataset("open-index/open-pypi", "packages", split="train")
print(f"{len(ds):,} packages")

# Stream all releases without downloading everything
ds = load_dataset("open-index/open-pypi", "releases", split="train", streaming=True)
for row in ds:
    print(row["name"], row["version"])

Using huggingface_hub

from huggingface_hub import snapshot_download

# Download everything
snapshot_download(
    "open-index/open-pypi",
    repo_type="dataset",
    local_dir="./pypi/",
)

# Download only the packages table
snapshot_download(
    "open-index/open-pypi",
    repo_type="dataset",
    local_dir="./pypi/",
    allow_patterns="data/packages/*.parquet",
)

For faster downloads, install pip install huggingface_hub[hf_transfer] and set HF_HUB_ENABLE_HF_TRANSFER=1.

Using the CLI

# Download just the packages table
huggingface-cli download open-index/open-pypi \
    --include "data/packages/*" \
    --repo-type dataset --local-dir ./pypi/

Using pandas + DuckDB

import duckdb

conn = duckdb.connect()

# What percentage of packages declare dependencies?
df = conn.sql("""
    SELECT
        count(DISTINCT d.name) AS with_deps,
        (SELECT count(*) FROM read_parquet('hf://datasets/open-index/open-pypi/data/packages/*.parquet')) AS total,
        round(count(DISTINCT d.name) * 100.0 /
            (SELECT count(*) FROM read_parquet('hf://datasets/open-index/open-pypi/data/packages/*.parquet')), 1) AS pct
    FROM read_parquet('hf://datasets/open-index/open-pypi/data/dependencies/*.parquet') d
""").df()
print(df)

Dataset card for PyPI - Complete Package Archive

Dataset summary

This dataset is a comprehensive snapshot of PyPI (the Python Package Index), the official package repository for the Python programming language. It covers every package currently published on PyPI, with full metadata, all historical releases, distribution files, trove classifiers, PEP 508 dependencies, project URLs, and ownership roles.

The dataset is built for research, analysis, and tooling. Some things you can do with it:

• Ecosystem analysis of the Python package landscape and its growth
• Dependency graph research for supply chain analysis and vulnerability propagation modeling
• Python version adoption studies using requires_python constraints across the ecosystem
• License compliance auditing across dependency trees
• Package discovery and recommendation systems
• Software engineering research on release practices, classifier usage, and metadata quality

Dataset structure

Data instances

Here is an example row from the packages table:

{
  "name": "requests",
  "summary": "Python HTTP for Humans.",
  "author": "Kenneth Reitz",
  "license": "Apache-2.0",
  "version": "2.32.3",
  "requires_python": ">=3.8",
  "release_count": 148,
  "home_page": "https://requests.readthedocs.io",
  "package_url": "https://pypi.org/project/requests/",
  "fetched_at": "2026-04-11T08:30:00Z"
}

And a row from the releases table:

{
  "name": "requests",
  "version": "2.32.3",
  "requires_python": ">=3.8",
  "upload_time": "2024-05-29T15:37:47Z",
  "file_count": 2,
  "total_size": 131105,
  "has_wheel": true,
  "has_sdist": true,
  "yanked": false
}

Data fields

packages (30+ columns)

Column	Type	Description
name	VARCHAR	Package name (primary key)
summary	VARCHAR	One-line package summary
description	VARCHAR	Full package description (may be reStructuredText, Markdown, or plain text)
description_content_type	VARCHAR	MIME type of the description (e.g. text/markdown)
author	VARCHAR	Package author name
maintainer	VARCHAR	Package maintainer name
license	VARCHAR	License string (free-text, not always SPDX)
license_expression	VARCHAR	SPDX license expression (PEP 639, newer packages only)
home_page	VARCHAR	Project home page URL
download_url	VARCHAR	Direct download URL
package_url	VARCHAR	PyPI project page URL
project_url	VARCHAR	Project URL
requires_python	VARCHAR	Python version constraint (e.g. >=3.8)
keywords	VARCHAR	Comma-separated keyword tags
platform	VARCHAR	Target platform
version	VARCHAR	Latest version string
yanked	BOOLEAN	Whether the latest version is yanked
yanked_reason	VARCHAR	Reason for yanking
release_count	INTEGER	Total number of published releases
classifiers_json	VARCHAR	Trove classifiers as JSON array
project_urls_json	VARCHAR	Project URLs as JSON object
requires_dist_json	VARCHAR	PEP 508 dependency strings as JSON array
provides_extra_json	VARCHAR	Optional extras as JSON array
docs_url	VARCHAR	Documentation URL
bugtrack_url	VARCHAR	Bug tracker URL
organization	VARCHAR	PyPI organization name (if any)
last_serial	BIGINT	PyPI changelog serial number
fetched_at	TIMESTAMP	When this data was crawled

releases

Column	Type	Description
name	VARCHAR	Package name
version	VARCHAR	Version string
requires_python	VARCHAR	Python version constraint for this release
yanked	BOOLEAN	Whether this release is yanked
yanked_reason	VARCHAR	Reason for yanking
upload_time	TIMESTAMP	When the earliest file in this release was uploaded
file_count	INTEGER	Number of distribution files
total_size	BIGINT	Total size of all distribution files in bytes
has_sdist	BOOLEAN	Whether a source distribution is available
has_wheel	BOOLEAN	Whether a wheel distribution is available

files

Column	Type	Description
name	VARCHAR	Package name
version	VARCHAR	Version string
filename	VARCHAR	Distribution filename (e.g. requests-2.32.3-py3-none-any.whl)
packagetype	VARCHAR	Distribution type: bdist_wheel, sdist, bdist_egg, etc.
python_version	VARCHAR	Python version tag (e.g. py3, cp311)
size	BIGINT	File size in bytes
url	VARCHAR	Download URL
sha256	VARCHAR	SHA-256 hash of the file
md5	VARCHAR	MD5 hash of the file
requires_python	VARCHAR	Python version constraint
upload_time	TIMESTAMP	When this file was uploaded
yanked	BOOLEAN	Whether this file is yanked
yanked_reason	VARCHAR	Reason for yanking

classifiers

Column	Type	Description
name	VARCHAR	Package name
classifier	VARCHAR	Trove classifier string (e.g. Programming Language :: Python :: 3)

dependencies

Column	Type	Description
name	VARCHAR	Package name (the dependent)
dep_name	VARCHAR	Dependency package name
dep_spec	VARCHAR	Full PEP 508 specification string
extra	VARCHAR	Optional extra that activates this dependency (if conditional)

project_urls

Column	Type	Description
name	VARCHAR	Package name
label	VARCHAR	URL label (e.g. Homepage, Documentation, Source)
url	VARCHAR	URL

owners

Column	Type	Description
name	VARCHAR	Package name
username	VARCHAR	PyPI username
role	VARCHAR	Role: Owner or Maintainer

Data splits

Each table is a separate dataset configuration. Load them by name:

# Load the packages table
ds = load_dataset("open-index/open-pypi", "packages", split="train")

# Load the releases table
ds = load_dataset("open-index/open-pypi", "releases", split="train")

# Load dependencies
ds = load_dataset("open-index/open-pypi", "dependencies", split="train")

Dataset creation

Curation rationale

PyPI is the backbone of the Python ecosystem, but its metadata is fragmented across the JSON API (per-package), the Simple API (package listing), and the XML-RPC changelog (incremental updates). Researchers studying the Python ecosystem typically need to build their own crawlers and deal with these complexities from scratch.

By publishing a complete, pre-crawled snapshot in Parquet format on Hugging Face, we make the entire registry immediately queryable with DuckDB (via hf:// paths), streamable with the datasets library, and downloadable in bulk. No API keys, no rate limits, no pagination.

Source data

All data is sourced from the official PyPI APIs:

• JSON API (pypi.org/pypi/{project}/json): Full package metadata including all releases, files, classifiers, dependencies, project URLs, and ownership information
• Simple API (pypi.org/simple/, PEP 503/691): Complete package name enumeration
• XML-RPC API (pypi.org/pypi): Changelog-based incremental sync via changelog_since_serial

Data processing steps

The pipeline runs in three phases:

1. Enumerate. Fetch the complete package list from the Simple API (/simple/ endpoint). All package names are stored in a local queue with resume support.

2. Crawl. Pop package names from the queue and fetch full metadata from the JSON API (/pypi/{name}/json). Parse all releases (not just latest), all distribution files, classifiers, PEP 508 dependencies, project URLs, and ownership roles. The crawler uses concurrent workers with separate goroutines for state tracking and data persistence.

3. Export and publish. Export all 7 DuckDB tables to Parquet with Zstandard compression, generate this README with live statistics, and commit to Hugging Face.

No filtering or transformation is applied to the data beyond what the source APIs provide. Descriptions are truncated at 1MB to keep file sizes practical, but all other fields are preserved as-is.

Personal and sensitive information

This dataset contains PyPI usernames and user-generated text content (package descriptions, summaries) as they appear in the public PyPI registry. Email addresses from the author_email and maintainer_email fields are excluded from the published Parquet files. The data reflects what is publicly visible on pypi.org.

If you find content in this dataset that you believe should be removed, please open a discussion on the Community tab.

Considerations for using the data

Social impact

By providing a complete PyPI snapshot in an accessible format, we hope to enable research into software supply chain security, ecosystem health, and the dynamics of the Python open source community. The dataset can support tools for license compliance, vulnerability tracking, dependency management, and Python version migration planning.

Discussion of biases

The PyPI registry reflects the practices and preferences of the Python community. Download counts are not included in this dataset (PyPI provides them through a separate BigQuery dataset). Trove classifiers are self-reported by package maintainers and may be incomplete or inaccurate. The license field is free-text and varies widely in format, from SPDX identifiers to full license text.

Packages that have been removed from PyPI by their owners or by administrators are not included. Yanked releases are included but marked with the yanked flag.

Known limitations

• Snapshot, not live. This is a point-in-time snapshot. Packages published or updated after the crawl date are not included.
• License field is free-text. The license column contains whatever the maintainer typed, which ranges from "MIT" to the full text of the GPL. Filter with length(license) < 100 for usable license identifiers.
• Description is truncated. The description field is capped at 1MB. A small number of packages have longer descriptions that are truncated.
• JSON columns are strings. Fields like classifiers_json, project_urls_json, requires_dist_json are stored as VARCHAR containing JSON. Parse them with json_extract in DuckDB or json.loads in Python.
• No download counts. PyPI download statistics are available separately through Google BigQuery and are not included here.
• Ownership data may be incomplete. The ownership endpoint is not part of the standard JSON API and may not be available for all packages.

Additional information

Licensing

The dataset is released under the Open Data Commons Attribution License (ODC-By) v1.0. The original content is subject to the rights of its respective authors and package maintainers. PyPI is operated by the Python Software Foundation.

This is an independent community mirror. It is not affiliated with or endorsed by the Python Software Foundation or PyPI.

Contact

For questions, feedback, or issues, please open a discussion on the Community tab.

Last updated: 2026-04-11 16:24 UTC