Skip to content

GitHub Security Advisory API Adds Better CVE Data and Server-Side Filters

GitHub's October 2 update adds five SecurityAdvisory fields and two server-side filters, giving vulnerability tools richer data with fewer API requests and less local filtering.

GitHub Security Advisory API Adds Better CVE Data and Server-Side Filters

On this page

GitHub updated its Security Advisory API on October 2 with five new fields and two server-side filters, giving software teams more advisory data without switching from GraphQL to the REST API. The change is small on paper, but it removes several pieces of glue code from tools that monitor vulnerabilities, build security dashboards, or track how advisories move between GitHub and the National Vulnerability Database (NVD).

GitHub Security Advisory API now exposes five more pieces of advisory data

The update adds five fields to GitHub's SecurityAdvisory object. They cover the Common Vulnerabilities and Exposures (CVE) identifier, the relevant source-code location, the time GitHub reviewed an advisory, the time the NVD published its record, and the repository security advisory associated with it when one exists. Before this change, an integration that needed some of that information could have to make additional requests or maintain a separate lookup path. The new fields put the information directly into the GraphQL response, which is particularly useful when an application already consumes advisory records through GraphQL.

The distinction matters because a security advisory is more than a severity label. A CVE identifier gives an advisory a widely used public reference, while review and publication timestamps provide a basic timeline for understanding when information entered each system. The source-code location can connect an advisory to the affected project code, and the repository advisory URL can connect a database entry back to the repository where the issue was reported. Together, those fields make a single API response more useful for software that has to turn raw advisory data into something developers can act on.

Two new filters change where the filtering work happens

The more practical part of the update is on the securityAdvisories query itself. GitHub added severities and isWithdrawn as server-side filters, so an application can ask GitHub for only the records it needs instead of retrieving a broader result set and filtering it locally. Severity filtering can be used to focus on categories such as critical or high-severity advisories, while the withdrawn filter lets an integration distinguish active records from advisories that have been withdrawn. GitHub says these filters work alongside existing options including classifications, identifiers, Exploit Prediction Scoring System (EPSS) values, and publication or update dates.

That changes the shape of a typical security-data pipeline. An application that previously downloaded a large advisory set and discarded irrelevant records on its own can now push part of that selection to GitHub before the data reaches its own infrastructure. For a small script, the difference may be barely noticeable, but a continuously running vulnerability service has more reason to care because fewer records mean less processing and less data that needs to be stored or passed between components. GitHub also says the additions are read-only and additive, so existing queries do not need to be rewritten simply because these fields and filters appeared.

GraphQL matters because the alternative was another API path

GraphQL is an API query system that lets a client request specific fields rather than receiving a fixed response shape. GitHub's documentation already exposes the Security Advisory Database through GraphQL, alongside its REST API, and the database contains both CVEs and GitHub-originated advisories affecting open-source software. The October update matters because the new advisory metadata is available directly through the GraphQL path instead of forcing an integration to change interfaces for those details. GitHub describes that as fewer round trips, one authentication path, and one rate-limit budget for integrations that consume advisory information.

There is a useful distinction here between fewer requests and faster security work. GitHub has not published a benchmark showing that every advisory integration will become a particular percentage faster, so claims of a universal performance improvement would go beyond the evidence. What is confirmed is architectural: the API can now perform more of the selection and return more of the metadata in the same GraphQL workflow. For developers maintaining security tooling, that can remove code rather than merely making an existing request execute faster.

The new fields also make advisory timelines easier to track

The two timestamps added for GitHub review and NVD publication are especially useful when an organization wants to understand the history of an advisory rather than simply its current severity. The NVD is the U.S. National Vulnerability Database, a public repository that publishes vulnerability records and associated information. With both timestamps available in the advisory object, a monitoring system can compare when NVD published a record with when GitHub reviewed the corresponding advisory. That creates a cleaner basis for reporting delays or building internal measurements without maintaining separate timestamp collection logic.

This does not mean the two timestamps describe the same event or that one system is necessarily ahead in every case. GitHub's fields represent distinct stages in the advisory lifecycle, and an integration still has to interpret them correctly. The useful part is that both values can now be collected alongside the advisory itself, rather than reconstructed later from separate data sources. That makes the resulting records easier to audit when a security team needs to explain how an advisory reached its current state.

Severity filtering is more useful when paired with existing advisory data

GitHub's advisory query already supports several ways to narrow results, including package ecosystem, identifier, publication date, update date, classification, and EPSS measurements. EPSS, or Exploit Prediction Scoring System, estimates the likelihood that a vulnerability will be exploited in the wild, so it provides a different signal from a vulnerability's severity classification. Adding server-side severity filtering means a tool can combine these dimensions instead of treating the advisory database as one large undifferentiated feed. For example, a triage system could request only high-severity records and then use EPSS information to decide which entries deserve closer attention.

That distinction is important because severity alone does not tell an organization which vulnerability should be handled first. A critical advisory can affect software that a particular company does not use, while a lower-severity issue in a heavily deployed package may deserve immediate investigation. GitHub's API does not make that decision for the developer; it provides more structured inputs for the application's own rules. The October changes therefore improve the data-access layer rather than replacing the security team's prioritization process.

What the update does not change for existing integrations

The update is not a replacement for the Security Advisory API, and it does not require existing GraphQL queries to start using the new fields. GitHub explicitly describes the changes as additive and read-only, which means an integration can continue requesting the fields it already uses. The new filters are optional as well, so an application does not have to adopt server-side severity or withdrawal filtering immediately. That makes the change relatively low-risk for existing tooling compared with an API migration that removes or renames fields.

There is also no reason to treat the update as a replacement for GitHub's broader advisory data sources. GitHub's documentation still describes both GraphQL and REST access, while the web interface remains available for people who want to browse advisories directly. The value of the October change is narrower: GraphQL integrations can now obtain more of the information they need and perform more of their filtering at the source.

Developers can use the change to simplify advisory pipelines

The most immediate work for developers is to inspect any integration that fetches GitHub security advisories and identify information it currently obtains through extra requests or local filtering. If the application separately resolves CVE identifiers, checks withdrawal status, or downloads a large result set just to discard unwanted severities, the new fields and filters provide opportunities to simplify those paths. The existing GraphQL schema also exposes vulnerability details such as affected package, vulnerable version range, first patched version, and severity, so the new advisory metadata can sit alongside the package-level information already available.

For a security dashboard, the practical next step is to add the new fields to a test query first, then compare the resulting data with the records the application already stores. After that, server-side filtering can be introduced for a narrowly defined use case, such as a high-severity triage feed or a withdrawn-advisory audit. That approach lets teams measure the reduction in returned records and processing work against their own workload rather than assuming the API change produces a particular performance gain. The October 2 update is therefore less about a dramatic new feature and more about giving software that already consumes GitHub's advisory data a cleaner path to the information it was probably collecting the hard way.

Copy this post

0 Comments

No comments yet. Be the first to share your thoughts.

Join the conversation

Log in or create a free account to leave a comment. You can edit or delete your own comments any time.