Comparison
11 best open source license scanning tools in 2026
A license scanner tells you which open source licenses are in your software, and whether any of them break your policy. Tools differ most in how deep they look: package metadata, license text in files, copied snippets or compiled binaries. Here are six commercial tools and five free ones, and where CRACI fits next to them.
Updated
Who this is for
This page is for engineering, security and legal teams choosing a license scanner, or checking whether the one they have still fits. We build CRACI, so weigh that in. Every claim about another product comes from that vendor's or project's own documentation. For how open source licenses work and what copyleft asks of you, start with open source license compliance. This page is general information, not legal advice.
What license scanning is
License scanning finds the open source components in your software and works out which license applies to each one. A license scanner then compares what it found with your policy, flags what needs review, and in many tools helps you produce the notices the licenses ask for. It is usually part of software composition analysis, next to vulnerability scanning.
Why it matters
- Copyleft obligations. Strong copyleft licenses such as the GPL ask that software you distribute with the component is offered under the same terms, with source. A copyleft package deep in your transitive dependencies counts as much as one you added yourself.
- The AGPL and SaaS. The AGPL extends copyleft to users who interact with the software over a network, so a hosted product is not out of scope just because you never ship a binary.
- License changes. A project can relicense in a new version, sometimes from an open source license to a source-available one. An ordinary upgrade can change your terms, so a check at the time a dependency was added is not enough.
- Attribution and notices. Even permissive licenses such as MIT, BSD and Apache-2.0 ask you to keep copyright and license notices. A missing notices file is the most common failure.
- SBOM license fields. Customers and auditors increasingly ask for an SBOM, and both formats carry licenses. SPDX has separate declared and concluded license fields and allows NOASSERTION when nothing is known. CycloneDX marks a license as declared or concluded and takes SPDX license expressions. See CycloneDX vs SPDX.
How license scanning works: four levels of detection
Every license scanner first decides what is in your software, then decides which license applies. The second step happens at one of four levels, and each level finds things the one before it misses.
| Level | What it reads | What it catches | What it misses |
|---|---|---|---|
| Declared license metadata | The license field in a package's manifest or registry entry | The common case, quickly, for every dependency a package manager knows about | Wrong or missing metadata, and code that never went through a package manager |
| File-level license text | LICENSE files, license headers and notices in each file | Licenses the metadata gets wrong, files under a different license, copyright holders | Code copied in without its license header |
| Snippet matching | Fragments of your own source compared with a database of open source code | Open source code pasted or modified inside your files | Compiled components you have no source for |
| Binary scanning | Executables, libraries, containers and firmware | Open source inside third-party binaries and supplier deliveries | Usually less precise about versions and files than a source scan |
Deeper levels cost more: they are slower, produce more findings to review, and in commercial tools often sit in a higher tier or an add-on. Most teams need declared licenses on every build and a deeper scan where code has a long history of copying, or where you ship code you did not write.
How to choose
- How deep do you need to look? If your code comes from package managers, declared licenses cover most of it. If developers have copied code in for years, or you redistribute supplier binaries, you need file text, snippet or binary scanning.
- Who reviews the findings? Deep scanners produce findings that someone has to clear. Legal teams usually want a review workflow, not just a report.
- Where does the policy run? On pull requests, in the build, at the package repository, or in a periodic audit. The earlier the check, the cheaper the fix.
- Do you need notices? If you distribute software, check that the tool generates attribution or notice files, and in which formats.
- What do customers ask for? If they want an SBOM per release with licenses, check the formats and whether the license fields say declared or concluded.
- Which CI do you run? Most tools here fit many CI systems. CRACI supports Linux jobs on GitHub Actions only today, with GitLab CI and Jenkins on the roadmap.
At a glance
Twelve products do not fit one table, so they are split in three, each with CRACI first and the same rows. "Not stated" means the vendor or project pages we cite do not say either way. Prices were checked between September and November 2026.
License compliance specialists and SCA suites
| Capability | CRACI | FOSSA | Black Duck | Sonatype | Mend.io |
|---|---|---|---|---|---|
| Source of license data | Declared license of each package the build fetched | Dependencies plus full license text | Package managers, file signatures, snippets and binaries | Binary fingerprints of the build output, then manifests | Direct and transitive dependencies |
| License detection from file text | Declared licenses only | Full-text detection and copyright extraction | Declared and undeclared licenses, full text (Enterprise) | Declared and observed licenses | Not stated |
| Snippet matching | Add-on, with binary scanning | Enterprise tier | Not stated | Not stated | |
| Policy that fails a build or pull request | License policy can block a build | Compliance gates in CI | Policies enforced in CI; failing builds not stated | Repository Firewall blocks at download | Builds can be gated on policy |
| SBOM export | CycloneDX or SPDX, with each component's declared license | SPDX and CycloneDX | SPDX and CycloneDX | CycloneDX or SPDX | SPDX and CycloneDX |
| Attribution or notice reports | Attribution notices | Notices reports | Not stated | Not stated | |
| Pricing | $0.002 per vCPU-minute ($0.004 for 2 vCPU), metered per second; no monthly fee | Free plan; Business $20 per project per month, billed annually | Quote | Guide Pro from $1,200 per year; Firewall Pro from $4,800 per year | Up to $1,000 per developer per year |
- Included
- Partly
- Not included
Developer platforms
| Capability | CRACI | Snyk | Aikido | GitHub dependency review |
|---|---|---|---|---|
| Source of license data | Declared license of each package the build fetched | Manifests and lockfiles | Manifests and lockfiles | ClearlyDefined data for the dependencies a pull request changes |
| License detection from file text | Declared licenses only | Not stated | Not stated | Not stated |
| Snippet matching | Not stated | Not stated | Not stated | |
| Policy that fails a build or pull request | License policy can block a build | License policies on Enterprise plans only | Policy enforcement; build gating not stated | Fails pull requests outside allow-licenses |
| SBOM export | CycloneDX or SPDX, with each component's declared license | Enterprise plans only | CycloneDX, SPDX or CSV | SPDX from the dependency graph |
| Attribution or notice reports | Not stated | Not stated | Not stated | |
| Pricing | $0.002 per vCPU-minute ($0.004 for 2 vCPU), metered per second; no monthly fee | Free tier; Team from $25 per month; license compliance on Enterprise | Free plan; paid from $350 per month | Free on public repositories; private ones need Code Security, $30 per committer per month |
- Included
- Partly
- Not included
Free and open source scanners
| Capability | CRACI | ScanCode Toolkit | ORT | FOSSology | Trivy |
|---|---|---|---|---|---|
| Source of license data | Declared license of each package the build fetched | File texts, notices and package manifests | Package metadata, plus a scan of downloaded source | Uploaded source files | Package metadata; file texts with --license-full |
| License detection from file text | Declared licenses only | Full comparison with license texts | Through ScanCode or another scanner | License, copyright and export control scans | With --license-full, which is slow |
| Snippet matching | Not stated | Through FossID or SCANOSS | Not stated | Not stated | |
| Policy that fails a build or pull request | License policy can block a build | Not stated | Evaluator reports policy violations | Not stated | Licenses get a severity by category |
| SBOM export | CycloneDX or SPDX, with each component's declared license | CycloneDX or SPDX output | CycloneDX and SPDX | SPDX files | CycloneDX or SPDX |
| Attribution or notice reports | Not stated | NOTICE files from templates | ReadMe with copyright notices | Not stated | |
| Pricing | $0.002 per vCPU-minute ($0.004 for 2 vCPU), metered per second; no monthly fee | Free, Apache-2.0 | Free, Apache-2.0 | Free, GPL-2.0; you host the server | Free, Apache-2.0 |
- Included
- Partly
- Not included
Commercial license scanning tools
CRACI
CRACI is a recorder, not a scanner. Your GitHub Actions jobs run on CRACI runners, and a package-aware proxy records every package each job fetches, including packages restored from CI caches. Each recorded package carries its declared license, so copyleft licenses are caught before they end up in the product, and license policy rules can block a build on a license. The CycloneDX or SPDX export carries each component's declared license. Best for teams that want license policy enforced on what the build actually pulled in, at every depth of the dependency tree. Watch out: CRACI records the declared license of each package it fetched and does no snippet or binary scanning, and it runs Linux jobs on GitHub Actions only today. Build-time SBOM generation
FOSSA
FOSSA started as a license compliance tool, and it shows. It detects licenses from their full text, including modified ones, extracts copyright information, applies policies and generates attribution notices that update from your CI/CD pipeline. Snippet scanning and binary scanning are available as add-ons, and it manages SBOMs from suppliers too. Best for teams whose first concern is license compliance. Watch out: snippet and binary scanning cost extra, and pricing is per project. CRACI vs FOSSA
Black Duck
Black Duck goes deepest. It finds open source through package managers, file signatures, snippet matching and binary analysis, and identifies declared and undeclared licenses with full license text from a KnowledgeBase of more than 2,750 licenses. Both tiers include notices reports. Best for code with a long history of copied or vendored open source, and for checking third-party binaries before you redistribute them. Watch out: undeclared licenses, full license text and snippet detection are in the Enterprise tier, and pricing is by quote. CRACI vs Black Duck
Sonatype
Sonatype Lifecycle applies license policies across more than 2,000 licenses, sorted into License Threat Groups with a threat level each, and records whether a license was declared or observed. It identifies components with Advanced Binary Fingerprinting on what the build produced, and Repository Firewall enforces license policy at the point of download. Best for large organizations that want a gate at the package repository. Watch out: packaging is changing, and new customers now buy Sonatype Guide. CRACI vs Sonatype
Mend.io
Mend SCA detects the licenses on direct and transitive dependencies and enforces rules such as blocking AGPL in commercial products, in pull requests and by gating the build. It produces SPDX and CycloneDX SBOMs. Best for teams that want license policy and vulnerability prioritization in one SCA product. Watch out: Mend's pages do not say whether it detects licenses from file text or generates attribution reports. CRACI vs Mend.io
Snyk
Snyk Open Source identifies license issues in direct and transitive dependencies, applies license policies with a
severity per rule, and lists every component and its license across an organization's projects. It reads
dependencies from manifests and lockfiles. Best for teams already using Snyk for vulnerabilities. Watch out: Snyk
License Compliance Management and the snyk sbom command are available only on Enterprise plans.
CRACI vs Snyk
Aikido
Aikido puts license scanning next to SCA, SAST, secrets, IaC, containers and cloud posture in one dashboard. It flags license risks with compliance checks and policy enforcement, and exports SBOMs as CycloneDX, SPDX or CSV. Best for smaller teams that want license checks as part of a broad AppSec platform. Watch out: dependencies come from manifests and lockfiles, and its pages do not say how deep license detection goes. CRACI vs Aikido
Free and open source license scanners
If budget is the constraint, these free tools cover a lot of ground. You run them yourself, so the policy, review workflow and history are yours to build and keep.
ScanCode Toolkit
ScanCode Toolkit, an AboutCode project, detects licenses, copyrights, package manifests and direct dependencies in source and binary files. Rather than relying on approximate patterns, it does a full comparison between your code and a database of license texts. It writes JSON, YAML, HTML, CycloneDX or SPDX. Best for file-level license detection you can script. Watch out: it reports what it finds; policy and review are up to you. Free under Apache-2.0.
ORT (OSS Review Toolkit)
ORT, a Linux Foundation project, is a whole pipeline. The Analyzer works out a project's dependencies, the Downloader fetches their source, the Scanner runs a license scanner such as ScanCode (or the FossID and SCANOSS snippet scanners), the Evaluator checks the results against policy rules written as code, and the Reporter writes CycloneDX and SPDX SBOMs and NOTICE files. Best for teams that want a complete, self-hosted compliance pipeline. Watch out: it takes real effort to configure and run. Free under Apache-2.0.
FOSSology
FOSSology is a license compliance system with a web interface and a database for a review workflow. It runs license, copyright and export control scans, rescans only the files that changed in a new version, and generates an SPDX file or a ReadMe with all the copyright notices. Best for compliance teams that review and clear findings by hand. Watch out: you host the server (Apache httpd and PostgreSQL). Free under GPL-2.0.
Trivy
Trivy, from Aqua Security, reads package licenses from metadata by default, and with --license-full also
detects licenses in source files, Markdown, text files and LICENSE documents, which its docs note is slow. It sorts
licenses into categories from forbidden to unencumbered and gives each a severity. Best for teams already running
Trivy for vulnerabilities in images and repositories. Watch out: full scanning does not work on SBOM input. Free
under Apache-2.0. CRACI vs Trivy
GitHub dependency review
GitHub's dependency review action checks the dependencies a pull request changes. With allow-licenses
it fails pull requests that add a dependency whose license is not on your list, using license data from
ClearlyDefined. Best for teams on GitHub who want a license check on every pull request at no extra cost on public
repositories. Watch out: if it cannot detect a license, it tells you but does not fail, license checks are not
supported on GitHub Enterprise Server, and private repositories need GitHub Code Security.
CRACI vs GitHub Advanced Security
How CRACI fits
Every other tool above is a scanner. It reads manifests, files or binaries and works out what is inside. CRACI is a
recorder. Your GitHub Actions jobs run on CRACI runners (change runs-on to craci), and a
package-aware proxy records what each job fetches from npm, PyPI, RubyGems, Composer, Cargo, Go, Nix, OCI, apt, apk
and Git sources. Each recorded package carries its declared license, at every depth of the dependency tree,
including packages restored from CI caches.
That makes CRACI's license check a check on what was actually built, not on what a manifest says. Copyleft licenses show up before they end up in the product, license policy can block a build on a license, and every build's SBOM exports as CycloneDX or SPDX with each component's declared license and a completeness state for the job.
CRACI is not the right choice when:
- you need licenses detected from file text, snippet matching or binary scanning (CRACI records the declared license of each package it fetched),
- you need attribution or notice files, or a legal review workflow,
- your pipelines run on GitLab, Jenkins or CircleCI, or need Windows or macOS runners (CRACI runs Linux jobs on GitHub Actions today; other CI systems, Windows and macOS are on the roadmap).
In those cases pick from the tools above, or run CRACI as the runner and keep a specialist for deep scans and notices. For the wider tool landscape, see the best SCA tools and SBOM tools compared, read about pricing, or book a demo.
CRACI compared with each tool
- CRACI vs Snyk What your manifests declare vs what your build did.
- CRACI vs Aikido A broad AppSec suite vs deterministic build evidence.
- CRACI vs Sonatype Repository gatekeeping and SCA vs build evidence.
- CRACI vs Black Duck Code, snippet and binary scanning vs build evidence.
- CRACI vs Mend.io Dependency scanning vs dependency observation.
- CRACI vs Checkmarx AppSec testing platform vs build-time evidence.
- CRACI vs Endor Labs Reachability analysis vs build observation.
- CRACI vs JFrog Artifact management vs per-build evidence.
- CRACI vs GitHub Advanced Security Code, secret and dependency scanning vs build evidence.
- CRACI vs Dependabot Version updates vs knowing what your builds used.
Side by side
Several tools on one page, for when you are choosing a category, not one product.
License scanning tools FAQ
Short answers to common questions about open source license scanning
What is license scanning?
License scanning finds the open source components in your software and works out which license each one is under, so you can check them against your policy and meet their conditions. A license scanner reads package metadata, license files, the text of source files or compiled binaries, depending on the tool.
What is the difference between declared and detected licenses?
A declared license is what a package says about itself in its manifest or registry entry, such as the license field in package.json. A detected license is what a scanner finds in the files, such as a LICENSE file or a license header. They can differ, because metadata can be wrong or missing and vendored code can carry its own license. SPDX keeps both apart with its declared and concluded license fields, and CycloneDX marks a license as declared or concluded.
What are the best free license scanning tools?
ScanCode Toolkit detects licenses from file text and writes CycloneDX or SPDX. ORT, the OSS Review Toolkit, runs a full pipeline from dependency analysis to policy checks and NOTICE files. FOSSology adds a web server and a review workflow. Trivy reports package licenses and can scan file text with --license-full, and GitHub's dependency review action fails pull requests that add a license outside your allow list. All are free; you run and maintain them yourself.
What is snippet matching in license scanning?
Snippet matching compares fragments of your own source files with a database of open source code, to find code that was copied in rather than added as a dependency. Copied code keeps its license even when no manifest mentions it. Black Duck offers it in its Enterprise tier, FOSSA as an add-on, and ORT through the FossID or SCANOSS scanners.
Can a license scanner fail a build?
Many can. GitHub's dependency review action fails a pull request that adds a license outside its allow list, Mend can gate a build on license policy, and CRACI's license policy can block a build on a license. Check whether a tool fails the pull request, the build or only reports the violation, and what it does with packages whose license it cannot find.
Do I need a license scanner if my SBOM lists licenses?
An SBOM records licenses, but it does not judge them. You still need a policy and something that checks every new dependency against it, and you still need to produce the notices your licenses ask for. Check also where the SBOM's license data came from: declared metadata, detected file text or a reviewed conclusion.
Is CRACI a license scanner?
Not in the classic sense. CRACI runs your GitHub Actions jobs and records every package each job fetched, with its declared license. Copyleft licenses show up before you ship, license policy can block a build on a license, and the CycloneDX or SPDX export carries each component's declared license. It does not match snippets or analyze binaries, so teams that need that pair it with a specialist tool.
See the license of every package your build fetched
Book a demo to see the declared license of each package a GitHub Actions job pulled in, and a build blocked on your license policy.
Book a demo