# sbomify Action: Generate Compliance-Grade SBOMs in Any CI Pipeline

> Complete documentation for the sbomify action - a CLI shipped as a container that generates, augments and enriches SBOMs in GitHub Actions, GitLab CI, Bitbucket, Jenkins, CircleCI and any other pipeline.

**TL;DR:** sbomify-action is a CLI shipped as a container image that turns a lockfile into a compliance-grade SBOM inside your pipeline. It picks the right generator for your ecosystem, adds your business metadata, and enriches every component from package registries. It runs anywhere containers run - GitHub Actions is one runtime among several.

## What this is

`sbomify-action` is a **command-line tool shipped as a container image**. Point it at a lockfile, a Docker image or an existing SBOM, and it produces a complete, standards-ready SBOM in CycloneDX or SPDX format.

It ships as a GitHub Action, a container image and a Python package - but those are just delivery vehicles. The tool, its configuration and its behaviour are **identical on every runtime**. On anything other than GitHub Actions you pull the same container image and set the same environment variables. Learn it once, run it anywhere.

You do not need a sbomify account to use it. Generation, augmentation and enrichment all work standalone.

## Why not just run Trivy?

Because a scanner and an SBOM pipeline are different things.

A generator's job is **detection**. Trivy, Syft and cdxgen are all good at answering "what packages are in here?" - and they answer it with a name, a version and a PURL. Almost everything else is left empty: no supplier, no license, no description, no hashes. That is not a criticism of those tools; it is what they are built to do.

The problem is that the fields they leave empty are exactly the fields [NTIA](https://sbomify.com/compliance/ntia-minimum-elements/), [CISA](https://sbomify.com/compliance/cisa-minimum-elements/) and the [EU CRA](https://sbomify.com/compliance/eu-cra/) actually ask for. A raw scan is a dependency list. Compliance needs an SBOM.

`sbomify-action` wraps generation in three more steps:

- **Generate**: Routes to the best generator for your ecosystem and falls back automatically if one fails. cyclonedx-py is the most accurate for Python, cargo-cyclonedx for Rust, cdxgen for Java and Gradle, Syft for container images. You never have to pick.
- **Inject**: Adds packages no lockfile knows about - vendored code, system libraries, binaries copied in during a Docker build.
- **Augment**: Adds your organisational metadata: supplier, authors, licenses, lifecycle phase, security contact, support dates. This is the information only you have.
- **Enrich**: Fills in per-component metadata from PyPI, crates.io, pub.dev, deps.dev, ecosyste.ms, Linux distro license databases and more - plus integrity hashes pulled straight from your lockfile.

The difference is measurable. On the seven fields the NTIA Minimum Elements require, a bare scanner typically populates a small fraction; the same SBOM after augmentation and enrichment populates all of them. See [how it works](https://sbomify.com/sbomify-action/how-it-works/) for the full pipeline, or our [comparison of SBOM generation tools](https://sbomify.com/2026/01/26/sbom-generation-tools-comparison/) for a look at the generators themselves.

## Generated in CI. Never touched again.

This is the part that matters most, and it is worth being precise about.

Everything `sbomify-action` does happens **inside your pipeline, at build time** - the one moment when the full build context actually exists. Every modification it makes is written to an [audit trail](https://sbomify.com/sbomify-action/advanced/#audit-trail) with UTC timestamps, so you can see exactly what was added and where it came from. You can then sign or attest the result **at origin**, before it goes anywhere.

**sbomify never modifies an artifact you upload.** The bytes that arrive are the bytes that are stored and later served. No server-side enrichment, no normalisation, no "improvement".

That is a deliberate design decision, and it exists to close a specific gap. If a platform rewrites your SBOM after ingestion, you have no way to audit what changed. Removing a vulnerable component and tidying up metadata are the same operation from the outside: a write you cannot inspect. At that point "this SBOM has no known vulnerabilities" stops being something you can verify and becomes something you have to take on faith - and an inconvenient CVE disappearing looks exactly like housekeeping.

Signing at origin collapses that ambiguity. Either the bytes still match what your pipeline produced and signed, or they do not. Anyone can check, including an auditor who does not trust either of us.

It also has a practical consequence: because the artifact is never altered, **the signature stays valid**. Platforms that modify after ingestion either invalidate your signature or re-sign with their own key - which breaks the chain of custody and moves the trust anchor from you to them.

> **One clarification, so this is not overstated.** This guarantee covers artifacts you _upload_. sbomify does create genuinely new artifacts on your behalf - aggregate product-level SBOMs, VEX and VDR documents, derived compliance reports. Those are new creations, clearly distinguished from your uploads, not edits to them. If you distribute them with the same guarantees, sign them yourself.

Related: [how to sign an SBOM](https://sbomify.com/faq/how-do-i-sign-an-sbom/) and [OIDC trusted publishing](https://sbomify.com/faq/how-do-i-set-up-oidc-trusted-publishing/).

## Runtime support

The core tool behaves identically everywhere. What differs is how you invoke it, how you authenticate, and how much the runtime tells it about your build.

| Runtime                                                    | Integration     | Auth          | VCS auto-detect | Wizard             | Attestation |
| ---------------------------------------------------------- | --------------- | ------------- | --------------- | ------------------ | ----------- |
| [GitHub Actions](https://sbomify.com/sbomify-action/runtimes/github-actions/) | Native action   | OIDC or token | Yes             | Generates workflow | Yes         |
| [GitLab CI](https://sbomify.com/sbomify-action/runtimes/gitlab-ci/)           | Container image | Token         | Yes             | No                 | No          |
| [Bitbucket](https://sbomify.com/sbomify-action/runtimes/bitbucket/)           | Container image | Token         | Yes             | No                 | No          |
| [Jenkins](https://sbomify.com/sbomify-action/runtimes/jenkins/)               | Container image | Token         | Yes             | No                 | No          |
| [CircleCI](https://sbomify.com/sbomify-action/runtimes/circleci/)             | Container image | Token         | Yes             | No                 | No          |
| [Travis CI](https://sbomify.com/sbomify-action/runtimes/travis/)              | Container image | Token         | Vendor + git    | No                 | No          |
| [Azure DevOps](https://sbomify.com/sbomify-action/runtimes/azure-devops/)     | Container image | Token         | From git        | No                 | No          |
| [Any container runner](https://sbomify.com/sbomify-action/runtimes/docker/)   | Container image | Token         | From git        | No                 | No          |
| [TeamCity](https://sbomify.com/sbomify-action/runtimes/teamcity/)             | Container image | Token         | Git roots       | No                 | No          |
| [Local machine](https://sbomify.com/sbomify-action/runtimes/local/)           | `uvx` or `pipx` | Token         | Opt-in          | Yes                | No          |

**Yes** means the runtime publishes repository URL, commit SHA and ref as environment variables and they are read from there. **From git** means it does not, so the action reads the checkout it is running in - no configuration either way, as long as the `.git` directory is present and the repository has a remote. Jenkins and CircleCI do both: the vendor's variables first, the checkout when a job publishes none, which is a job on [Subversion or Perforce](https://sbomify.com/sbomify-action/runtimes/jenkins/#falling-back-to-the-checkout) or one that [never ran `checkout`](https://sbomify.com/sbomify-action/runtimes/circleci/#falling-back-to-the-checkout).

**Vendor + git** means Travis CI, which publishes the commit and the branch a build was triggered for but no repository URL - only an `owner/repo` slug with no host attached, and Travis serves several forges. The commit and ref come from the job, the URL from the checkout, and no URL is guessed from the slug. See [Travis CI](https://sbomify.com/sbomify-action/runtimes/travis/#vcs-information).

**Git roots** means TeamCity, which is VCS-agnostic: detection runs only when the repository URL positively identifies Git, and stays silent otherwise rather than recording a Subversion revision as if it were a commit. See [TeamCity](https://sbomify.com/sbomify-action/runtimes/teamcity/#vcs-information).

**Opt-in** means a local run reads the checkout only when you set `SBOMIFY_LOCAL_VCS=true`, so an internal remote does not end up in a document by accident. `vcs_url`, `vcs_commit_sha` and `vcs_ref` in [`sbomify.json`](https://sbomify.com/sbomify-action/augmentation/) override whatever is detected, on every runtime.

OIDC trusted publishing and build provenance attestation are GitHub-only today because they depend on GitHub-issued identity tokens. Support for other runtimes will follow as those platforms expose equivalent primitives.

## Documentation

**Start here**

- [Quick start](https://sbomify.com/sbomify-action/quickstart/) - the setup wizard, and your first pipeline run
- [Why SBOM quality matters](https://sbomify.com/sbomify-action/why/) - the long-form case, and how the output maps to NTIA, CISA and CRA
- [How it works](https://sbomify.com/sbomify-action/how-it-works/) - the full pipeline, step by step

**Reference**

- [Configuration](https://sbomify.com/sbomify-action/configuration/) - every input, environment variable and CLI flag
- [Input sources](https://sbomify.com/sbomify-action/sources/) - lockfiles, container images, Yocto, additional packages
- [Augmentation](https://sbomify.com/sbomify-action/augmentation/) - your business metadata via `sbomify.json`
- [Enrichment](https://sbomify.com/sbomify-action/enrichment/) - registry metadata, license databases, lifecycle data, hashes
- [Publishing](https://sbomify.com/sbomify-action/publishing/) - uploading, releases, Dependency Track
- [Advanced](https://sbomify.com/sbomify-action/advanced/) - attestation, audit trail, caching, telemetry, troubleshooting

**Per-runtime guides**

- [All runtimes](https://sbomify.com/sbomify-action/runtimes/) - pick your CI platform

## Where the code lives

| Channel                  | Location                                                              |
| ------------------------ | --------------------------------------------------------------------- |
| Source and GitHub Action | [`sbomify/sbomify-action`](https://github.com/sbomify/sbomify-action) |
| Container image          | `ghcr.io/sbomify/sbomify-action`                                      |
| Python package           | [`sbomify-action`](https://pypi.org/project/sbomify-action/)          |

There is one source repository and one image. Every runtime other than GitHub Actions pulls that image directly - there is no separate integration to install or keep in sync.

The project is Apache-2.0 licensed. Security issues go to <security@sbomify.com>.

## Pages

- [Advanced Usage: Attestation, Audit Trail, Caching and Troubleshooting](https://sbomify.com/sbomify-action/advanced/): Attestation and signing, the SBOM audit trail, cache configuration, monorepo layouts, telemetry, version pinning and troubleshooting for the sbomify action.
- [Augmentation: Adding Your Business Metadata to an SBOM](https://sbomify.com/sbomify-action/augmentation/): How to add supplier, author, license, lifecycle and security contact information to your SBOM with sbomify.json, plus automatic VCS detection from your CI environment.
- [Enrichment: Filling In Component Metadata](https://sbomify.com/sbomify-action/enrichment/): How the sbomify action enriches every component with licenses, suppliers, descriptions and hashes from package registries, distro license databases and lifecycle data.
- [How the sbomify Action Works](https://sbomify.com/sbomify-action/how-it-works/): The full sbomify-action pipeline, step by step: generation, package injection, transitive discovery, hash enrichment, augmentation, enrichment, validation and upload.
- [Input Sources: Lockfiles, Containers, Directories and Yocto](https://sbomify.com/sbomify-action/sources/): Every input the sbomify action accepts - 18 lockfile ecosystems, container images, directory scans, Chainguard SBOM reuse, Yocto builds, git submodules and manually declared packages.
- [Publishing SBOMs: Uploading, Releases and Dependency Track](https://sbomify.com/sbomify-action/publishing/): How to upload SBOMs from CI to sbomify using OIDC trusted publishing or an API token, tag them against product releases, and send them to Dependency Track.
- [sbomify Action Configuration Reference](https://sbomify.com/sbomify-action/configuration/): Every input, environment variable and CLI flag for the sbomify action, including precedence rules and deprecated aliases.
- [sbomify Action Quick Start](https://sbomify.com/sbomify-action/quickstart/): Get your first SBOM generated in minutes with the interactive setup wizard, or by writing the configuration by hand.
- [sbomify Action Runtimes](https://sbomify.com/sbomify-action/runtimes/): Platform-specific setup for the sbomify action: GitHub Actions, GitLab CI, Bitbucket, Jenkins, CircleCI, Travis CI, Azure DevOps, plain Docker and local machines.
- [Why SBOM Quality Matters: Scanners vs. Pipelines](https://sbomify.com/sbomify-action/why/): Why a raw scanner output is not a compliance-grade SBOM, and why generating and signing in CI - with no server-side modification afterwards - is what makes an SBOM verifiable.

---

From sbomify: https://sbomify.com/sbomify-action/
