Check every dependency's licence before you ship.

Paste a package.json, requirements.txt, go.mod or Cargo.toml — get a per-dependency verdict against your project licence, with conflicts flagged and a downloadable report. Checked entirely on your device.

  • Your file data never leaves the device
  • package.json · requirements.txt · go.mod · Cargo.toml
  • Per-dependency verdicts + downloadable report
  • Guidance, not legal advice

Paste a dependency list or add your files

One dependency per line for name@licence lists, or paste a whole manifest file. package-lock.json carries licences per package; package.json, requirements.txt, go.mod and Cargo.toml do not — those dependencies are matched against a small built-in snapshot of well-known packages, or flagged Unknown.

Try a sample:

Drag & drop manifest files here

or browse your files

Checked in your browser — every dependency is matched against your project licence with a plain-English reason. Nothing is uploaded.

The licence you ship your project under.
Copyleft triggers on distribution — not on internal use, and (for the GPL) not on network use.
    No text or files yet. Everything stays on this device. Reports download instantly.

    Privacy you can verify, not just trust

    Most online licence checkers either make you install a command-line tool and run it in CI, or send your dependency list to their server to look licences up in a registry. This one can't: your text and files are parsed entirely in your browser. Your file data never leaves the device — the only third-party requests are the site's own analytics, which count page views — and it uploads nothing, ever. There is no file fetched after load for the check itself. Don't take our word for it:

    New cross-origin requests during use: 0
    1. Press F12 to open developer tools, then the Network tab.
    2. Check a dependency list above. Watch: apart from the site's analytics, nothing new is requested — no uploads, and no file data ever leaves your device.
    3. Extra credit: disconnect your internet after this page loads — checking still works.

    How to check dependency licences without uploading them

    Every dependency you add is a licensing decision, whether it comes from npm, PyPI, crates.io or Go modules — and most of the time that decision is trivial. The trouble starts with the handful that are not: a GPL library in a closed-source product, an AGPL service in a SaaS, an Apache-2.0 library in a GPL-2.0 project. Those are the ones that turn into a relicensing scramble the week before launch, because nobody checked at the time the dependency was added.

    This tool checks the decision where the list already is: on your own device. When you paste a list or drop a manifest file here, your browser:

    1. Reads the licences your file actually declares — package-lock.json carries a licence per package, and name@licence lines state them directly. package.json, requirements.txt, go.mod and Cargo.toml carry no licences at all, so those dependencies are matched against a small built-in snapshot of well-known packages, and flagged Unknown when they are not in it.
    2. Checks each licence against your project licence — using the compatibility rules the FSF and OSI publish: permissive licences combine freely, weak copyleft (MPL, LGPL, EPL) comes with conditions, strong copyleft (GPL, AGPL) forces the combined work under the same licence. SPDX expressions are honoured: "MIT OR Apache-2.0" takes the best alternative, "MIT AND GPL-3.0" takes the worst part.
    3. Adjusts for how you ship — internal use does not trigger copyleft, the GPL does not trigger on network use alone, and the AGPL does. A GPL dependency that is Incompatible for a distributed product is Conditional for internal use, and the reason says so.

    What makes this checker different

    The pages that top the results for this search are mostly pair checkers — pick two licences, get one verdict — or command-line tools you install and run in CI. The dedicated browser tools that do read a manifest are npm-only, or they query a registry from a server, or they produce a licence inventory without ever judging it against your project licence. This page is the only free, fully client-side checker we found that takes a real manifest from five ecosystems, judges every dependency against the licence you actually ship under, explains each verdict in plain English, and hands you a downloadable report — with no install, no account, no upload, and a live network-request counter so you can verify the privacy claim yourself.

    When is checking the right choice — and when is it the wrong one?

    Checking is right before a release, before adding a new dependency to a commercial product, and before open-sourcing a project that grew in private. It is the wrong choice as a substitute for legal advice: if a verdict affects a shipping decision, a contract, or an acquisition, get a lawyer. It is also the wrong choice for transitive dependencies — this tool checks the list you paste, not the tree underneath it. For a full audit, use a dedicated compliance scanner that resolves the whole tree.

    Honest limitations

    Guidance, not legal advice

    Licence compatibility depends on jurisdiction, exact versions, and how the code is combined. This tool applies the widely accepted rules — it cannot settle an ambiguous case.

    Only direct dependencies

    The list you paste is what gets checked. A GPL package hiding two levels down in the dependency tree is not seen — resolve the full tree with a compliance scanner for that.

    Most manifests carry no licences

    package.json, requirements.txt, go.mod and Cargo.toml list names and versions only. Their dependencies are Unknown unless the snapshot knows them or you add name@licence lines.

    The snapshot can go stale

    Packages get relicensed. A licence marked "snapshot" is a starting point from a small curated list — verify it against the package's own page before relying on it.

    Expressions are simplified

    Nested SPDX expressions with mixed AND and OR are evaluated conservatively (worst part wins). WITH exceptions are noted, not fully evaluated — read the exception before relying on the verdict.

    It never changes your files

    This tool only reports and downloads a new report. Your manifest files are never modified — to fix a licence problem, change the dependency or the project licence yourself.

    Frequently asked questions

    Do my files upload anywhere?

    No. Your text and files are analysed entirely in your browser — your file data never leaves the device, and the only third-party requests are the site's own analytics, which count page views. You can verify it yourself with the network-request counter in the privacy section below the checker.

    Is this legal advice?

    No. This tool gives guidance based on widely accepted licence-compatibility analysis (FSF and OSI guidance): whether two licences can be combined and what each combination obliges you to do. It is not legal advice, and it cannot replace a lawyer for commercial use or ambiguous cases. If a verdict affects a shipping decision, consult a qualified attorney.

    Which dependency files can I paste?

    package.json, package-lock.json, requirements.txt, go.mod, Cargo.toml, a name,version,licence CSV, or plain name@licence lines such as react@MIT. The format is detected automatically, and you can also drop up to 10 files at once, up to 5 MB each. You can mix pasted text and files in one check.

    Why do some dependencies say licence not declared?

    Because the file you pasted does not carry per-dependency licences. package.json, requirements.txt, go.mod and Cargo.toml list names and versions only — they never say what licence each package uses. package-lock.json does carry a licence field per package, so its licences are read directly. For the others, add the licence yourself with a name@licence line, or check whether the package is in the built-in snapshot of well-known packages.

    What does snapshot mean next to a licence?

    It means the licence came from a small built-in list of well-known packages (for example react is MIT, requests is Apache-2.0) rather than from your file. The list is a snapshot and may be outdated — packages do get relicensed — so verify a snapshot licence against the package's own page before you rely on it. Anything not in the snapshot is flagged Unknown, never guessed.

    Why is a GPL dependency incompatible with my closed-source project?

    Because the GPL is strong copyleft: distributing a combined work that includes GPL code means distributing the whole work under the GPL, which a closed-source project cannot do. The fix is to remove or replace the dependency, find a permissively licensed alternative, or relicense the project. Note the distribution setting: internal use does not trigger copyleft, and the GPL does not trigger on network use alone — only the AGPL does.

    What does Conditional mean?

    It means the dependency can be used, but only if you meet a condition. Typical conditions: keep MPL-licensed files under the MPL, link an LGPL library dynamically rather than statically, or distribute the combined work under GPL-3.0 instead of GPL-2.0. The reason shown with each verdict names the exact condition, and the report lists it too.

    What is the difference between internal use, distributing, and SaaS?

    Copyleft obligations trigger on distribution, not on internal use: running GPL code on your own servers for your own team does not oblige you to share source. Distributing binaries or code does trigger them. SaaS sits in between: the GPL does not trigger on network use alone, so a GPL dependency in a service you never ship is Conditional, but the AGPL was written for exactly that case — offering AGPL code over a network counts as distribution, so an AGPL dependency in a closed-source service is Incompatible.

    What does this tool NOT do?

    It does not resolve transitive dependencies, it does not contact any package registry, it does not read licence text files, and it does not give legal advice. It checks only the licences declared in what you paste, plus the small built-in snapshot. A dependency whose licence is unknown here may still be perfectly fine — it just needs a human to check it. For a full audit, use a dedicated compliance scanner or a lawyer.