Licensing

Tangle editions and what each unlocks, activating and moving a license, offline use, free designer and demo modes, and expiry.

A license unlocks a Tangle edition on a computer that runs tangle-core. Without a license, core runs as the free designer or in demo mode. Licensing is offline first: each machine keeps a signed license file and trusts it with no network call, and a license problem never interrupts a running show.

#Editions

DMX universes are counted as the distinct universe numbers in device settings (Art-Net, sACN and DMX modules put the universe there).

"External API" means REST and MCP calls made with your own API tokens by other software. These always work on every edition:

• The built-in designer and dashboards served by core.
• The WebSocket client protocol.
• The tangle-core command line on the machine.

On Lite, an external REST or MCP call is refused with 403 not_licensed.

#License models

A license is one of these models. The model sets how long it runs and how it moves; the edition sets what it unlocks.

#Free designer and demo modes

Without a license, core runs in one of two modes. You choose when you start core.

tangle-core run --project show.json          # free designer
tangle-core run --project show.json --demo   # demo mode

At the end of each hour, core pauses playing timelines, disconnects devices and logs that the session hour is over. To continue for another hour, resume the session:

• REST: POST /api/v1/license/resume (scope control)
• MCP: resume_session
• WebSocket: license.resume

These session limits apply only to unlicensed starts. A licensed core never falls into them, even if its license lapses while it runs.

#Activate a license

Activation needs internet access on the machine, unless you use a license request by email or offline activation.

#In the designer

Open Settings > License. It shows what core runs as, the license (with Licensed to: the customer it was issued to), this computer's role, the limits, the features and the dates, and whether the license server can be reached. Then:

• License key: paste the key and click Activate.
• Sign in with email: sign in with the email and password of your Tangle license account, pick the license if you have several, and Tangle activates it. Neither the password nor the session is kept. Forgot password? emails a reset link.
• License by email / file…: for a computer that cannot reach the license server (see License by email).
• Refresh now, Deactivate, and Offline (never contact the license server).

These need a token with the admin scope; the desktop app's own token has it.

#On the command line

tangle-core license activate <key>
tangle-core license activate <key> --name "Lobby rack"

--name is the name shown on the license (default: the computer's name). The license applies from the next start of core: restart core or its service.

The first machine you activate creates the installation and becomes its main host. With redundancy, activate the same key on each other node: they join as redundant hosts, up to the number the license allows. If the license has no room left, activation fails and says how to free a place.

Note: License files live in the core data folder (see Operations). A core installed as a boot service on macOS or Linux uses the machine-wide folder, so run the license commands with sudo there, for example sudo tangle-core license activate <key>.

#Check the license

tangle-core license status
tangle-core license status --json

The status shows the state, edition, model, the last characters of the key, host role (main or redundant), device and redundant host limits, features, and the dates that matter: expires, updates until, and refresh before. --json also shows what the next start will run as (nextStart).

License states:

#Refresh a license

When online, core fetches a fresh license file a minute after it starts and then every 24 hours (and sends the heartbeats floating licenses need), retrying every hour after a failure. A failure never stops the show: the signed file on disk keeps working until it expires. To refresh by hand, for example after a renewal or an upgrade:

tangle-core license refresh

The new file takes effect at the next start.

How long a license file stays valid without going online:

Two days before the file expires, the state becomes expiring with the date to connect before.

#Move a license

To move a node-locked license to another computer, deactivate it on the old one, then activate it on the new one:

tangle-core license deactivate       # on the old computer
tangle-core license activate <key>   # on the new computer

deactivate removes this computer from its installation and deletes the local license file. The computer runs as the free designer (or --demo) from its next start.

To move a floating license, run this on the new computer:

tangle-core license move <key>

A floating license can move once every 7 days. A second move within a week is refused. The old installation keeps running its current project; it becomes unlicensed at its next start once its license file expires.

#With an email and password

tangle-core license sign-in owner@example.com              # password typed on standard input
tangle-core license sign-in owner@example.com --license <id>   # when the account has several licenses

The password can also come from TANGLE_LICENSE_PASSWORD.

#License by email

A computer that cannot reach the license server but can send email (from another machine) can ask for its license file by email:

1. In Settings > License, click License by email / file… and export a request, or on the command line:

   tangle-core license request --email owner@example.com --out lobby.request    # or --key <key>

2. Email the request file to licensing@tangle.systems from the address the license is registered to. The answer is a license file.

3. Install the file with License by email / file…, or tangle-core license import <file>.

#Offline mode

Tick Offline (never contact the license server) in Settings > License (REST PUT /api/v1/license/offline) for a computer that must never reach the internet. Core then keeps using its license file and is renewed with files, by email or by offline activation.

#Offline activation

For a computer with no internet access:

1. On the offline computer, print its id:

   tangle-core license fingerprint

2. On a computer with internet access, write a license file for that id:

   tangle-core license issue <key> --fingerprint <id> --out lobby.lic

   --name sets the name shown on the license (default "offline host").

3. Copy the file to the offline computer and install it:

   tangle-core license import lobby.lic

Core checks the file's signature with a key built into core, with no network call. A file edited after signing is rejected, and a file issued for another computer is rejected with fingerprint mismatch.

Floating, subscription and education licenses need a fresh file before their file validity runs out (see Refresh a license). Repeat these steps to bring one.

Warning: If the computer's clock is set more than 24 hours behind the last time Tangle ran, the license counts as invalid. Keep the clock correct.

#What happens when a license expires

What the license allows is decided once, when core starts and loads the project. A license that expires, is suspended, moves away, or cannot be validated while core runs does not stop, pause or limit the running show. Devices, timelines, automations and cues continue unchanged.

• Core publishes a license.status event when the license changes, and GET /api/v1/license reports pendingRestart: true.
• The change takes effect at the next start. An expired license then runs as the free designer, or in demo mode with --demo.
• Subscriptions and education licenses warn 14 days before they end, and keep working for 14 days of grace after the end date. A perpetual license never expires.

#Limits are checked when the project loads

Core checks the project against the edition when it starts:

• A project that goes over a limit (devices, DMX universes, timelines) or uses a feature the edition lacks (timecode, PTP) is refused, with a message naming the limit and the edition that includes it. For example: "Tangle Lite allows 2 timelines and cue lists in total; this project has 3 (upgrade for unlimited timelines)".
• A change made while core runs that would go over a limit is refused with 403 not_licensed.
• If the license does not allow redundancy, or the cluster lists more nodes than allowed, core runs standalone and says why.

These checks happen at load and on configuration changes, never on the cue path.

#License status in the API

GET /api/v1/license (scope read), MCP get_license, or WebSocket license.status returns: