The most consequential change to installing Python packages this year is not in pip — it is a tab on a web page most people never open.
On November 6, 2026, the PyPI team announced that its redesigned project pages are live, and the centerpiece is a dedicated security tab that grades every release's provenance: a cryptographic answer to the question "where did this file actually come from?" The data behind it has existed since November 2024, when PyPI finalized support for PEP 740 digital attestations. What changed this month is that the information stopped being an API curiosity and became a label you cannot miss.
That matters because the classic supply-chain attack on PyPI is not a malicious package uploaded from scratch — it is a previously trustworthy package whose maintainer account or publishing pipeline gets taken over. Provenance states exist to catch exactly that scenario, and the new warnings are tuned to the specific ways a takeover shows up in release files. Here is what each state means, where the labels fall short, and how to check them without opening a browser.
The blind spot between pip and the package page
Since late 2024, PyPI has accepted signed attestations that bind each release file to an OIDC identity — typically a GitHub Actions workflow in a specific repository at a specific commit. Attestations are verified by PyPI at upload time, recorded in a transparency log, and exposed through an Integrity API. More than 20,000 attestations were published in the first weeks after launch, and the feature built directly on Trusted Publishing, which had already replaced long-lived API tokens with short-lived OIDC credentials for many projects.
The problem was visibility. Attestations lived one click deep on per-file pages, and nothing on a project's main page told you whether a release had them. Users reasonably treated pip install as a name lookup and never saw the difference between a wheel built by the project's own CI and a wheel uploaded by whoever happened to hold a token. PyPI's own announcement concedes the interface "did little to communicate their meaning, importance, or limitations."
The redesign, funded by the Open Source Security Foundation, implemented by Kabu Creative, and shaped by the OpenSSF Attestations Style Guide, closes that gap by promoting provenance to a first-class signal on the page.
What the new security tab shows
The security tab computes one provenance state per release by checking every file in it. Two states cover most of what you will see.
Full provenance means 100% of the release files carry attestations. Two attestation types count. A PyPI Publish attestation confirms the file was uploaded by a configured Trusted Publisher — an OIDC identity PyPI already trusts for that project. A SLSA Build Provenance attestation goes further and links the file back to its exact source commit, build platform, and build instructions. You can read the attestation metadata inline in the tab or follow the link into the transparency log entry.
No provenance means no file in the release has an attestation. PyPI is careful about the interpretation: this is normal for older releases and for projects that never configured Trusted Publishing, and it does not indicate malice. It means the file's origin cannot be cryptographically verified, so your trust has to come from surrounding signals — maintainer history, release cadence, repository activity. The label describes the absence of evidence, not the presence of a threat.
The four provenance warnings
The interesting states are the four warnings, because each maps to a recognizable failure mode.
Incomplete provenance fires when some files in a release carry attestations and others do not — the canonical example is wheels published through Trusted Publishing while the source tarball was uploaded with an API token. PyPI's advice is to check release notes or ask in the issue tracker before installing.
Inconsistent provenance means files within the same release trace back to different build systems or source repositories. The attestation metadata will show whether every file came from infrastructure the maintainers control.
Change of provenance fires when a release's files originate from a different repository or workflow than the previous release. This one is deliberately noisy, because legitimate causes are common — an organization rename or a repository migration will trip it. It is also precisely what a compromised pipeline looks like, so PyPI asks you to confirm a planned migration through official channels before trusting the release.
Loss of provenance means a project that previously published with attestations has stopped. Maybe the maintainers deliberately switched back to token uploads; maybe someone who took over the account could not reproduce the attested workflow. Until you know which, PyPI's guidance is to treat the release with skepticism.
Why mixed uploads now raise a red flag
There is an operational consequence buried in the incomplete-provenance rule that maintainers need to internalize: attestations are all-or-nothing per release. If your wheels go out through an attested Trusted Publisher workflow but your sdist still rides on a manual twine upload with an API token, the release is flagged with a prominent warning — PyPI treats the mixture as a possible compromise indicator rather than partial credit.
The fix is not to abandon attestations but to make the whole release flow through one attested path. In practice that means publishing with the official GitHub Action, which generates attestations by default when Trusted Publishing is configured, for every artifact of the release. If you inherit a project with a mixed history, expect warnings on the transition release and document the change in your release notes so users can tell the flag is expected.
What else changed on the project page
The redesign reaches beyond the security tab. Provenance warnings now render as banners at the top of the project page, in the same tier as yanked-release, archived-project, and pre-release notices — with one explicit precedence rule: if a project or release is quarantined, only the quarantine banner shows, because it outranks everything else. When a release has full provenance or an active warning, its state appears in the sidebar and links through to the security tab.
Metadata on the page is now ordered by utility and split into two honest labels: "PyPI data" for whatever the uploader asserted, and "Data verified by PyPI" for what the index actually checked. The release files tab gained search and filtering for long file lists, shows each file's provenance state inline, and marks "late files" — files uploaded more than 14 days after the release's initial timestamp — with an orange warning. The late-file badge only appears on releases predating July 2026, when PyPI began rejecting new files after that window outright. The release history tab now lists file count, provenance state, and release status per version, so a quarantined or yanked release is visible at a glance.
Checking provenance without a browser
Everything the tab displays is backed by the Integrity API that shipped with PEP 740, so you can wire the check into scripts and CI gates. The endpoint answers per file:
import json
import urllib.request
def get_provenance(project, version, filename):
url = f"https://pypi.org/integrity/{project}/{version}/{filename}/provenance"
with urllib.request.urlopen(url, timeout=15) as resp:
return json.loads(resp.read())
data = get_provenance("datasette", "0.65.5", "datasette-0.65.5-py3-none-any.whl")
print(data.keys()) # dict_keys(['attestation_bundles', 'version'])
A working check against a live response looks like this:
data = get_provenance("datasette", "0.65.5", "datasette-0.65.5-py3-none-any.whl")
bundles = data.get("attestation_bundles", [])
if not bundles:
print("no provenance: file origin is not cryptographically verified")
for bundle in bundles:
publisher = bundle.get("publisher", {})
print(publisher.get("kind"), publisher.get("repository"),
publisher.get("workflow"), publisher.get("environment"))
To audit every file of a release — the same sweep the security tab performs — combine it with the JSON metadata API:
def release_provenance(project, version):
with urllib.request.urlopen(f"https://pypi.org/pypi/{project}/{version}/json", timeout=15) as resp:
files = json.loads(resp.read())["urls"]
report = {}
for f in files:
try:
d = get_provenance(project, version, f["filename"])
report[f["filename"]] = len(d.get("attestation_bundles", []))
except Exception:
report[f["filename"]] = 0
attested = sum(1 for n in report.values() if n > 0)
state = "full" if attested == len(report) else ("none" if attested == 0 else "incomplete")
return state, report
The state this prints is the same full / none / incomplete classification the UI shows, so a dependency-review job can fail a build on the exact condition the web page would warn about.
Getting your own project to full provenance
If you maintain a package, the path to a green security tab runs through Trusted Publishing. Register your CI as a publisher in the project's PyPI settings, then publish with the official action:
publish:
runs-on: ubuntu-latest
environment: release
permissions:
id-token: write
steps:
- uses: actions/download-artifact@v4
with:
name: dist
path: dist
- uses: pypa/gh-action-pypi-publish@release/v1
With id-token: write and no stored API token, the action exchanges the workflow's OIDC identity for a short-lived upload credential and generates the PyPI Publish attestation automatically; SLSA build provenance follows when the build itself is attested. Two caveats are worth planning around. Trusted publishers are currently the major hosted CI providers, which is a real centralization trade-off for projects building on their own hardware. And remember the all-or-nothing rule: once any file in a release is attested, every file should be, or the release gets flagged as incomplete.
What these signals cannot tell you
Provenance answers "where did this file come from," not "is this file good." A brand-new package published through a perfectly attested workflow can still be malware; the system is designed to catch the takeover of a previously benign project's publishing path, and it does that well, but it says nothing about first-party malice. The labels also live on the website: pip does not surface provenance during install, so the check only helps people and tooling that actually consult it — which is an argument for the Integrity API pattern above rather than for eyeballing project pages. Finally, availability limits adoption: until more CI platforms can act as trusted publishers, full provenance will cluster on projects hosted by the largest providers, and a "no provenance" badge will often mean "small project on self-hosted CI" rather than anything suspicious.
None of that diminishes what shipped. PyPI took a verification system that already existed, made its states legible, and attached warnings calibrated to the real anatomy of account takeovers. The next time a dependency releases from an unexpected repository, the warning will be sitting at the top of the page — the remaining work is on the consumer side: look, or better, script the lookup so you cannot forget to look.
Originally published on Dispatch.
Top comments (0)