## Overview


Import an existing SBOM (CycloneDX or SPDX) so FOSSA can run license and security compliance checks against the components it lists, useful for analyzing software you don't build yourself.

## Import from the UI

{% steps %}
{% step title="Choose Import SBOM" %}
From the **Add Projects** page, select **Import SBOM (CycloneDX, SPDX)**.

{% img src="/images/project-setup/sbom-import-add-projects.png" alt="The Import SBOM option on the Add Projects page" /%}

{% callout type="info" %}
Imports must comply with:
- **CycloneDX** [1.2](https://cyclonedx.org/docs/1.2/json/), [1.3](https://cyclonedx.org/docs/1.3/json/), [1.4](https://cyclonedx.org/docs/1.4/json/), [1.5](https://cyclonedx.org/docs/1.5/json/), [1.6](https://cyclonedx.org/docs/1.6/json/), in JSON or XML.
- **SPDX** [2.2+](https://spdx.github.io/spdx-spec/v2.2.2/), [2.3](https://spdx.github.io/spdx-spec/v2.3/); requires a `DESCRIBES` relationship for the top-level project and `DEPENDS_ON` / `DEPENDENCY_OF` relationships, in JSON only. SPDX XML is not supported.
{% /callout %}
{% /step %}

{% step title="Add your files" %}
Select **Add Files** and choose the SBOM file (`.json` or `.xml`). Bulk import is supported. Select as many files as you need.

{% img src="/images/project-setup/sbom-import-upload-wizard.png" alt="SBOM Upload wizard showing the file drop zone" /%}
{% /step %}

{% step title="Name the project and set a version" %}
Add a unique name and a semantic version number.

{% img src="/images/project-setup/sbom-import-name-version.png" alt="SBOM Upload wizard with a file loaded, showing the Project Name and Revision fields" /%}
{% /step %}

{% step title="Review in your project list" %}
When upload and analysis finish, the SBOM appears in **Projects**, marked with the SBOM icon.

{% img src="/images/project-setup/sbom-import-projects-list.png" alt="SBOM projects in the Projects list with the SBOM import filter applied" /%}
{% /step %}
{% /steps %}

{% callout type="warning" %}
Importing under an **existing** SBOM project name adds the upload as the latest **revision** of that project rather than creating a new one.
{% /callout %}

## Import via the API

To automate imports, use the API instead of the UI. There are two steps: get a signed upload URL, then trigger a build.

{% steps %}
{% step title="Get a signed URL" %}
`GET /api/components/signed_url` returns a pre-signed cloud-storage URL. It is valid for **5 minutes**.

{% requestExamples %}
{% requestExample language="curl" %}
```bash
curl -X GET "https://app.fossa.com/api/components/signed_url" \
  --data-urlencode "packageSpec=<SBOM_package_or_file_name>" \
  --data-urlencode "revision=<SHA_hash_or_version>" \
  --data-urlencode "fileType=sbom" \
  -H "Authorization: Bearer $FOSSA_TOKEN"
```
{% /requestExample %}
{% requestExample language="python" %}
```python
import requests

resp = requests.get(
    "https://app.fossa.com/api/components/signed_url",
    params={"packageSpec": "<SBOM_package_or_file_name>", "revision": "<SHA_hash_or_version>", "fileType": "sbom"},
    headers={"Authorization": "Bearer <FOSSA_TOKEN>"},
)
signed_url = resp.json()["signedUrl"]
```
{% /requestExample %}
{% requestExample language="node" %}
```js
const params = new URLSearchParams({
  packageSpec: "<SBOM_package_or_file_name>",
  revision: "<SHA_hash_or_version>",
  fileType: "sbom",
});
const res = await fetch(`https://app.fossa.com/api/components/signed_url?${params}`, {
  headers: { Authorization: "Bearer <FOSSA_TOKEN>" },
});
const { signedUrl } = await res.json();
```
{% /requestExample %}
{% /requestExamples %}
{% /step %}

{% step title="Upload, then trigger a build" %}
`POST` your SBOM to the signed URL within 5 minutes, then call `POST /api/components/build?fileType=sbom` to start analysis. A successful build returns `201 Created`.

{% requestExamples %}
{% requestExample language="curl" %}
```bash
curl -X POST "https://app.fossa.com/api/components/build?fileType=sbom" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer <token>" \
  -d '{"selectedTeams":[],"archives":[{"packageSpec":"Distro cyclonedx","revision":"123456789","fileType":"sbom"}]}'
```
{% /requestExample %}
{% requestExample language="python" %}
```python
import requests

requests.post(
    "https://app.fossa.com/api/components/build",
    params={"fileType": "sbom"},
    headers={"Authorization": "Bearer <token>"},
    json={
        "selectedTeams": [],
        "archives": [{"packageSpec": "Distro cyclonedx", "revision": "123456789", "fileType": "sbom"}],
    },
)
```
{% /requestExample %}
{% requestExample language="node" %}
```js
await fetch("https://app.fossa.com/api/components/build?fileType=sbom", {
  method: "POST",
  headers: { Authorization: "Bearer <token>", "Content-Type": "application/json" },
  body: JSON.stringify({
    selectedTeams: [],
    archives: [{ packageSpec: "Distro cyclonedx", revision: "123456789", fileType: "sbom" }],
  }),
});
```
{% /requestExample %}
{% /requestExamples %}
{% /step %}
{% /steps %}

Import a CycloneDX or SPDX SBOM to run license and security compliance checks against its listed components.

SBOM Import

Scan Frequency

Quick Import

Project Setup

Step-by-step onboarding paths for developers, security teams, and legal & compliance.

Install the CLI, analyze your first project, and wire FOSSA into CI so every pull request is checked automatically — no manual scans.

For Developers

Detect CVEs across your dependencies, set severity policies that gate builds, and focus on vulnerabilities that are actually reachable in your code.

For Security Teams

Surface license obligations per dependency, enforce policies that flag or block disallowed licenses, and produce audit-ready attribution reports automatically.

For Legal & Compliance

User Guides

Explore FOSSA products — compliance, security, quality, SBOM, and more.

License obligations, attribution, and policy enforcement for the open source in your code.

Compliance

Find, prioritize, and fix vulnerabilities across your dependencies.

Security

Code quality signals and dependency health monitoring.

Quality

Generate, aggregate, import, and share software bills of materials across the full SBOM lifecycle.

SBOM Management

The FOSSA AI agent for dependency upgrades, SAST security review, and AI code guardrails.

fossabot

Product Guides

New to FOSSA? Import your first project, run a scan, and see results in minutes.

Create an account, import your first project, read the results, and automate future scans.

Your First Scan

Choose between Quick Import and the FOSSA CLI based on your build environment and accuracy needs.

CLI vs Quick Import

Get Started

Get your code into FOSSA — import projects from source hosts, the CLI, or CI, then configure how they're scanned and organized.

Analyze your code locally with the FOSSA CLI and upload the results, the most accurate and secure way to integrate.

Provide dependency data from your existing CI/CD environment for faster, more accurate FOSSA scans.

CI/CD Scanning

Block PRs that introduce new license compliance or security violations using FOSSA GitHub status checks.

Pull Request Checks

Automatically add a FOSSA license-scan status badge to your GitHub README when you import a project.

Badge Pull Requests

Scan Docker and OCI container images for open source license and vulnerability issues.

Containers

Find open source code copied into your codebase without being declared as a dependency.

Snippets

Connect GitHub, GitLab, Bitbucket, or Azure Repos and scan hundreds of repositories in one click.

Import internal and firewalled projects into FOSSA with Broker, without sharing source-code access.

Broker

Decompose pre-compiled binaries and archives to identify open source components without source-code access.

Binaries

Inspect every dependency FOSSA detected, metadata, license status, filter options, custom licenses, and notice files.

Dependencies

Search, filter, and manage every package detected across all of your organization's projects from one place.

Package Inventory

Configure the title, branches, ignored dependencies, labels, VCS host, and visibility for an individual FOSSA project.

Project Settings

Exclude a specific package from your project's issue tracking and reporting.

Ignore a Dependency

Create and apply labels to organize projects and filter the dashboard by business context.

Project Labels

Keep FOSSA projects continuously scanned, re-analyze on every new revision and surface new license and security issues automatically.

Automatic Updates

How to upload an archive directly to FOSSA and how it's analyzed, for code that isn't pulled from a package registry.

Archive Upload

requirements.txt, alongside setup.py, is the most common -yet imprecise -- approach to dependency management in python projects.

Setuptools (requirements.txt/setup.py)

Quick reference: setuptools

Poetry is a tool for dependency management and packaging in Python.

Poetry

This is a modern approach to defining python project dependencies, providing very precise, complete dependency graphs for a python project.

Pipenv/Pipfile

Quick reference: pipenv

While originally created for Python programs, Conda can package and distribute software for any language. It provides a full list of all dependencies install…

Conda Analysis

PDM is a tool for dependency management and packaging in Python.

uv is a package and project manager for Python.

Python

A package.json file is required to be present all types of npm analysis.

Quick reference: npm

Yarn is a spiritual successor to the npm cli. Yarn automatically updates the yarn.lock file when the yarn CLI is used to modify the dependencies present in t…

Yarn

Pnpm is a fast, disk space-efficient package manager. Unlike npm and yarn, pnpm uses symbolic links to create a nested structure of dependencies.

Pnpm

package.json is a common build manifest used by both yarn and npmcli.

package.json

The package-lock.json file is generated when npm modifies node_modules or package.json and describes the exact dependency tree generated. One example of this…

Npm Lockfile

Quick reference: yarn

JavaScript

Go 1.11 has first-class support for "modules", which is now the preferred way to do dependency management.

Go Modules

Dep is an alternative toolchain for golang dependency management. Though go modules are the blessed form of dependency management, dep is exploring alternati…

Glide is very commonly encountered as a buildtool for older Go projects. Though deprecated, it's prevalent enough among existing projects that it warrants su…

Glide

Quick reference: gomodules

Quick reference: godep

Quick reference: glide

The V3 Go resolver is a new dynamic strategy to find dependences in go modules projects. It was first released in v3.8.5 on 2023-06-10.

What is the new package-based Go modules analysis strategy?

Maven projects are notoriously difficult to resolve into final dependency graphs. While many dependencies are declared as XML, these dependency declarations …

Maven plugin

This maven tactic uses native, mvn dependency:tree command to retrieve dependency information.

Maven - Tree Command

Maven projects use pom.xml files to declare dependencies and multi-project relationships.

Maven pom.xml

Quick reference: maven

Maven

How FOSSA's Gradle plugin tactic resolves dependencies via a Gradle init script, plus debugging steps.

Gradle build plugin

Gradle

While the other analysis strategies for gradle and maven offer some scala project coverage, scala projects overwhelmingly use the build tool sbt.

sbt Analysis

Quick reference: sbt

Scala

Quick reference: bundler

Ruby

When developing in PHP, composer is commonly used to manage dependencies.

Composer Analysis

NuGet analysis follows these strategies in sequence: 1. project.assets.json 2. PackageReference

NuGet Analysis

A .nuspec file is an XML manifest that contains package metadata for Nuget packages. This manifest is used both to build the package and to provide informati…

nuspec

Package references, using the PackageReference node, manage NuGet dependencies directly within project files (as opposed to a separate packages.config file)

PackageReference

The packages.config XML file is used in some project types to maintain the list of packages referenced by the project.

packages.config

The project.json file maintains a list of packages used in a project, known as a package management format. It supersedes packages.config but is in turn supe…

project.json

The project.assets.json file is used in .NET Core projects to manage dependencies and other resources

project.assets.json

Paket is a dependency manager for .NET projects. Paket enables precise and predictable control over your dependencies

Paket

Quick reference: Paket

.NET (C#, F#, VB)

Quick reference: cargo

Rust

Ideal/Minimum dart installed locally pubspec.yaml file present in your project pubspec.lock file present in your project, with dependencies already retrieved…

Quick reference: pub

Dart

podfile: Find all directories containing a Podfile file.

Cocoapods Analysis

Quick reference: cocoapods

Find any folder which contains a file named Cartfile.resolved.  Skip all subdirectories if one is found.

Carthage Analysis

Ideal/Minimum Cartfile.resolved file present in your project

Quick reference: carthage

Find all files named: Package.swift or find Xcode's project file named: project.pbxproj. We will not scan .build directory if the Package.swift or Xcode proj…

Swift Package Manager

iOS (Objective-C, Swift)

C/C++

Find all directories with a cabal.project file or a file with a .cabal extension.  When one is found, skip all subdirectories.

Cabal

Quick reference: cabal

Find all directories with a stack.yaml file.  When one is found, skip all subdirectories.

Stack

Ideal/Minimum stack buildtool install stack.yaml file present in your project

Quick reference: stack

Haskell

Ideal/Minimum mix installed locally mix.exs and mix.lock file present in your project

Quick reference: mix

Elixir

Ideal/Minimum rebar3 installed locally rebar.config file present in your project

Quick reference: rebar3

Erlang

Quick reference: leiningen

Clojure

Perl

Fortran

When developing in nim, nimble is used to manage dependencies.

Nimble Analysis

Currently, we only support analysis of r project which are using renv package manager.

R Analysis (renv)

dpkg

System

Supported Languages

Schedule recurring scans so FOSSA picks up newly disclosed vulnerabilities and license changes even when your code hasn't changed.

Configure who gets notified and through which channels when FOSSA detects new issues in your projects.

Notifications

Configure which issue scanners are enabled for your projects and how they gate CI/CD builds.

Issue Scanners

Control whether a FOSSA project is publicly accessible to anyone with the link or restricted to authenticated members.

Privacy Settings

View past scans for a project and trigger a rebuild or policy scan from the UI.

Build History and Rebuilding

How FOSSA handles transitive dependencies whose version is resolved by the package manager when multiple constraints conflict.

Mediated Dependencies

Bundle related projects into a single unit for shared reporting, policy enforcement, and release tracking.

Create a release group, add projects, and configure your first release.

Creating a Release Group

Clone, edit, and manage releases within a release group to track compliance at specific points in time.

Managing Releases

Review licensing, security, and quality issues aggregated across all projects in a release group.

Issues

Browse the unified dependency inventory and license breakdown across all projects in a release group.

Inventory & Licenses

Generate licensing, vulnerability, SBOM, and remediation guidance reports across all projects in a release group.

Reports

Configure policies, report defaults, and portal visibility for a release group.

Release Group Settings

Understand the permission model for release groups; who can create, edit, scan, set policies, and generate reports.