Open source licences in a mobile app — what to check before an investor or a lawyer asks

A mobile app has hundreds of dependencies, each with a licence. Which licences are a problem in a closed-source app, where the risks hide (GPL, AGPL, unlicensed code, fonts), how to run a review and an SBOM, and what the Cyber Resilience Act changes.

Zespół Mobilesoft· Engineering team· 18 listopada 2026· 8 min czytania

A typical Flutter or React Native app has several hundred dependencies, counting the ones pulled in by other libraries. Each of them has a licence, and each licence has conditions. Usually nobody checks them until an investor, a company buyer, a large client's security questionnaire, or a lawyer taking over the project from another vendor asks about them.

That's when it turns out the app contains a GPL library, the licence information screen was never built, and someone copied a piece of code from a repository with no licence at all. Below we describe the licences you'll find in mobile apps, where problems most often hide, and how to run a review in a few days rather than in the middle of negotiations.

This article isn't legal advice. It helps you put the technical side in order and identify which cases need a lawyer.

Why it's the owner's problem, not the developer's

A developer adds a library because it solves a problem. But the licensing consequences fall on whoever distributes the app — the company whose account the app is published under. Problems usually surface at the least convenient moment:

  • when selling the company or raising a funding round — due diligence covers the code and its licences,
  • when taking over an app from another vendor — along with the code, you take over its licensing debt,
  • when working with a corporation or bidding in a tender — security questionnaires increasingly ask for a component list,
  • when a library's author or foundation reports an infringement.

We cover what else to check during a project handover in the checklist for taking over a project from another software house.

Licence types you'll find in an app

Type Examples What it means for a closed-source commercial app Permissive MIT, BSD, Apache 2.0 Can be used without releasing your own code. You must keep the copyright notice and licence text; Apache 2.0 also requires passing on the NOTICE file if the project has one Weak copyleft LGPL, MPL 2.0 Changes to the library itself must be released. LGPL also requires that users can replace the library with their own version — hard with static linking, which is typical on iOS Strong copyleft GPL v2, GPL v3 An app containing such code generally has to be distributed under the GPL, with source code. Usually incompatible with a closed product Network copyleft AGPL v3 Like the GPL, but the obligation to release code also arises when the program is offered over a network. Mainly relevant for the backend Source-available SSPL, BSL, RSAL The code is public, but the licence isn't open source and may restrict commercial use or hosting No licence Code from a repository with no LICENSE file Formally no permission to use it — the rights stay with the author

A separate case is the GPL on the App Store. The Free Software Foundation's position is that the App Store's terms of use are incompatible with the GPL — in 2011, for exactly this reason, the VLC player was pulled from Apple's store after a complaint from one of its authors. A GPL library in an iOS app is therefore a double risk.

Where problems hide in a mobile app

Transitive dependencies. You add an MIT-licensed library, and it pulls in three more — one under the LGPL. You won't see it in the project's configuration file.

Manually copied code. Snippets from GitHub, ready-made components pasted into the project, code from Stack Overflow answers (content published there is licensed under CC BY-SA, which requires attribution and is copyleft). Tools that analyse package managers won't detect such code.

Fonts, icons, graphics, and animations. They have their own licences — from permissive (SIL Open Font License) to commercial ones issued to a specific person or company. A font licence bought by your vendor doesn't necessarily cover your company.

Commercial SDKs. They aren't open source, but they have licence terms and sometimes keys tied to the vendor's account. It's a frequent finding in audits when a developer disappears.

Backend. Here the biggest risks are the AGPL and licence changes on upgrade. In recent years several popular server projects switched from open source to source-available licences — Elasticsearch in 2021, Terraform in 2023, Redis in 2024 — and Elasticsearch and Redis later added the AGPL as one of the options. Upgrading to a new version can therefore change the terms under which you use a component.

The notice obligation: a licences screen

Even if all dependencies have permissive licences, you usually have to meet one condition: include the copyright notice and licence text with the app. In a mobile app this is done with an "Open source licences" screen in the settings or the "About" section. In older apps we take over, it's the most frequently missing element.

Platform How to generate the licence list Android Google's oss-licenses-plugin with a ready-made screen, or a Gradle report iOS LicensePlist — generates a section in the system Settings or data for your own screen Flutter Built-in licences screen (showLicensePage), populated automatically from packages React Native Generators based on package.json on the JavaScript side, plus native libraries separately

It matters that the list is generated automatically with every release. A hand-written list goes stale with the first dependency update.

How to run a licence review

  1. Generate a list of dependencies with licences — separately for the Android app, the iOS app, and the backend, including transitive dependencies. A good format is an SBOM in a standard format (CycloneDX or SPDX); you can generate one with, among others, the CycloneDX Gradle plugin, the cdxgen tool, or an export from GitHub's dependency graph.
  2. Classify the licences into three groups: allowed (permissive), needing analysis (weak copyleft, unusual licences), and not allowed in your distribution model (GPL in a closed app, AGPL in a backend without releasing code, no licence).
  3. Review code outside package managers — directories with bundled libraries, copied files, comments with repository URLs.
  4. Check assets — fonts, icons, graphics, animations, sounds — and who the commercial licences were issued to.
  5. Decide on each problem: replace it with a library under a different licence, buy a commercial licence (many projects are dual-licensed), remove the feature, or rewrite the code.
  6. Add a check to CI. Tools such as licensee for Gradle can fail the build when a dependency with a licence outside the allowed list appears. If you don't have an automated release process yet, see our article on CI/CD and fastlane.

Store the result of the review — the list, the classification, and the decisions — in the repository alongside the rest of the technical documentation. The same dependency list is useful for tracking vulnerabilities, which we cover in the article on mobile app security.

SBOM and the Cyber Resilience Act

A component list is no longer just good practice. The EU Cyber Resilience Act (Regulation 2024/2847) covers products with digital elements, which generally includes software such as mobile apps made available on the market in the course of a commercial activity. Since 11 September 2026, manufacturers have had to report actively exploited vulnerabilities, and from 11 December 2027 the full requirements apply, including identifying and documenting the product's components, among other things in the form of an SBOM.

Whether and to what extent the CRA applies to your app depends on your business model — that's a question for a lawyer. Technically, though, the preparation is the same as for a licence review: an automatically generated, up-to-date component list.

How much does it cost

A licence review for a typical mobile app with a backend — generating the list, classification, asset review, a licences screen, and a CI check — usually takes 8–24 hours. At an example rate of PLN 180 net per hour, that's roughly PLN 1.4k–4.3k net. Fixing the problems found is a separate item: from an hour to swap a library for an equivalent to several days to rewrite a module. The rate and scope are indicative, and the legal analysis of unusual cases is a job for a lawyer.

Summary

Open source licences are rarely a day-to-day problem, but they can block a company sale, an investment, or a contract. The review isn't complicated: generate a list of dependencies with licences, catch copyleft and unlicensed code, check fonts and graphics, add a licences screen, and automate the check in CI. It's best done now, not during due diligence.

We review licences and dependencies as part of a source code audit and our audits and consulting service, and it's one of the first steps in a mobile app takeover. In the free app analysis we check how far behind the libraries and SDKs are — a good starting point for further decisions. We'll work out the details via contact.