Go to content
Startups

Open Source License Compliance for SaaS Products

Your SaaS product almost certainly runs on open source code you did not write. Your customers never receive that code as files. They use the service over the network while the code stays on your servers. That arrangement decides which license obligations you have, because most open source license rules attach when you distribute software, and a hosted service does not distribute it.

Copyleft is a license rule that requires modified or combined works to be released under the same license. The GNU General Public License (GPL), the best-known copyleft license, triggers when you convey the software, meaning you enable someone else to make or receive copies. Because a SaaS product does not convey code to customers, GPL-licensed libraries rarely force a hosted product to publish source.

The license that does reach into a hosted service is the GNU Affero General Public License (AGPL). Its network clause says that if you modify AGPL-licensed code and let users interact with it over the network, you must offer those users the corresponding source code. Separately, permissive licenses such as MIT and Apache 2.0 allow commercial use but require you to keep copyright notices and license text. Skipping that step is a common compliance failure in real products.

The practical obligations for a hosted product come down to three things: preserving attribution for permissive dependencies, deciding whether any AGPL code in your service is acceptable, and auditing your full dependency tree, including the libraries your direct dependencies pull in, before you ship.

Why the GPL rarely forces a hosted product to publish source

You trigger the GPL’s obligations at the moment you convey the software. Conveying is the license’s term for any action that enables another party to make or receive copies, such as handing over a binary, a Docker image, an SDK, or a compiled application. If you run GPL-licensed code only on your own servers and never distribute it to customers, you do not trigger the copyleft requirement. So a typical SaaS product can use GPL libraries internally without publishing anything.

The obligation changes the moment you distribute. If you give customers a Docker image of your product and that image contains GPL code, you have conveyed that code, and you must make the complete corresponding source available under the GPL, including any modifications you made. The same applies if you ship an SDK or a desktop companion app that links GPL libraries. For a pure hosted service with no customer-facing artifacts, the GPL has no effect.

One contested area is linking. The Free Software Foundation takes the position that dynamically linking a GPL library into your program creates a derivative work, meaning your code would inherit the GPL. Courts have not settled the question. It only becomes relevant if you distribute the combined program. A SaaS product that keeps the combined program on its own servers is not conveying it.

Attribution: the MIT and Apache notices you must keep

Permissive licenses let you use, modify, and sell software under your own proprietary terms, on condition that you preserve certain notices. The MIT License requires you to include the original copyright notice and the license text in all copies or substantial portions of the software. Apache 2.0 adds more: you must retain the copyright, patent, trademark, and attribution notices. You must also include the NOTICE file if the project ships one. A NOTICE file is a text file that lists attribution information for the project.

For a SaaS product, "all copies" includes the code you deploy and any artifact you hand to a customer. In practice, you need a third-party notices file or page that lists every permissive dependency with its copyright line and license text. Founders routinely skip this step, and the omission tends to surface when someone asks for a compliance review, such as a customer’s security questionnaire or an acquirer’s due diligence.

MIT and BSD licenses say nothing about patents. Kyle Mitchell’s critique of MIT and BSD explains that this silence leaves patent permission uncertain: the license grants you copyright rights, but a contributor who holds patents covering the code has not clearly licensed them to you. Apache 2.0 includes an explicit patent grant, which is one reason many companies prefer it for dependencies. The practical difference shows up in legal review of your dependency list, and engineers do not need to act on it day-to-day.

Attribution is not a cosmetic requirement. Most lawyers read a violation of the attribution rule as terminating the license, which means you could lose the right to use the code at all. The same analysis notes that a missed notice can turn a paperwork gap into a much larger problem.

AGPL: the copyleft that reaches into your service

The AGPL is a GPL variant written for network services. Section 13 of the AGPLv3 requires that if you modify an AGPL-licensed program, your modified version must offer all users who interact with it remotely over a computer network an opportunity to receive the corresponding source code. For SaaS, the GPL waits for distribution, while the AGPL triggers on network interaction.

The trigger has two parts: you modify the AGPL program, and users interact with the modified version over the network. An analysis of common AGPL misconceptions stresses that merely communicating with an AGPL-licensed API does not trigger the obligation. If you call a hosted service that happens to run AGPL software, you have not modified anything, so the obligation sits with the operator of that service, not with you. The obligation attaches when the AGPL code is inside your product and you have changed it.

Interpretations diverge on how much integration counts as modification. The conservative reading, which Promise Legal recommends to startups, is that any meaningful integration of AGPL code into a SaaS product creates a source-disclosure obligation over the entire combined work. That would mean your proprietary code, not just the AGPL file, must be offered to your users. The risk is asymmetric: if you integrate an AGPL library and the conservative reading applies, you are required to open-source the core of your product.

The license defines what you must provide. Corresponding Source under AGPLv3 includes all the source needed to generate, install, and run the object code and to modify the work, excluding system libraries and general-purpose tools. You cannot satisfy the obligation by publishing a single file; you would need the buildable source of the combined work.

You do not have to keep a fork of an AGPL project public; the source obligation runs to the people you distribute to, or under the network clause, the users who interact with your service, not to the public at large. The same analysis also explains that a project cannot bolt extra restrictions onto AGPL code. AGPLv3’s Section 7 permits additional terms only in specific categories, so a "no SaaS" clause or a logo removal requirement is not a valid addition, and you can treat it as removable.

Auditing your dependency tree with SCA tools

The licenses that matter are not only the ones you chose. Transitive dependencies, the libraries that your direct dependencies pull in, carry their own licenses, and your package manager installs them without asking. Most applications contain open source components; FOSSA’s guide to open source licenses cites research from 2018 that over 90 percent of applications include open source code. A manual review of your direct dependencies misses the transitive ones.

Software composition analysis (SCA) tools close that gap. An SCA tool scans your codebase and matches the components it finds against license and vulnerability databases. It then produces a software bill of materials (SBOM), a structured list of every component in your product. SCA tools fall into three groups: open source scanners like ScanCode and FOSSology, commercial SCA products that add vulnerability data, and compliance workflow products that manage approvals and documentation.

Before you choose a tool, check how it handles the cases that actually break compliance. Safeguard’s seven-question guide recommends verifying that the tool tracks transitive dependencies and parses SPDX expressions such as "MIT OR Apache-2.0". You should also be able to configure allow, review, and deny policies, see how the tool reports unknown licenses, and confirm that it can produce an SBOM and attribution files. An SPDX expression is a standardized way to write a license identifier; it matters because a single package can offer a choice of licenses.

No tool reads a license the way a lawyer does. Detection goes wrong when a file carries modified license text or when package metadata says one thing and the license text says another. The obligations you have also depend on how you distribute software, which a tool cannot judge. Treat the scanner as a filter that finds candidates for human review.

You put this into practice by running the scanner in CI/CD and configuring it to fail the pipeline when a GPL or AGPL dependency appears without an approved exception. Keep an allowlist of accepted licenses, generate the attribution file from the scan output, and document each exception in the repository so a future contributor or an acquirer can see why a copyleft dependency is present. When you evaluate a new dependency, license terms should be considered alongside maintenance activity and security track record, as discussed in this guide to evaluating open source dependency risk.

What to verify before you ship

Before you release, run a concrete compliance pass over the whole dependency tree. The checks below catch the failures described above, and each one produces a record you can keep.

  • Run a full SCA scan of the codebase and review the license report, including transitive dependencies, for anything you did not explicitly approve.
  • Flag every GPL and AGPL dependency. For each one, decide explicitly whether to replace it, keep it under a documented exception, or accept the source-disclosure consequence.
  • Confirm that the attribution file exists and covers every MIT, BSD, and Apache component with its copyright line and license text.
  • Review model licenses separately if your product wraps an open-weight model, one whose trained weights are publicly released. Model licenses are often not approved by the Open Source Initiative (OSI) and can carry usage-based commercial terms, so they need their own review track.
  • Update developer onboarding so new dependencies go through the same review before they reach the main branch.

The scan report and the exception log are also the documents you hand over when someone asks for a compliance review. A customer’s security questionnaire, an investor’s due diligence, or an acquirer’s audit will ask for the same artifacts, so keeping them current is not busywork. The OpenChain standard, ISO/IEC 5230:2020, formalizes this kind of process and focuses it on SBOM management, giving you a concrete target if you want to certify your process.

Separately from licensing, assessing the maintenance risk of a dependency tells you whether the project is still active enough to trust in production. A dependency that stops being maintained also stops receiving security fixes, which matters as much as its license.

More in Startups Back to top ↑