Licensing and Entitlements

Overview#

Timebase components check a licence before they provision anything. An install that has never been linked in Portal is not refused outright: it runs on a default tier that grants a working set of entitlements for fourteen days from installation, so you can install, evaluate and register in whatever order suits you.

That window is grace, not a licence. /app/license reports the install as unlicensed throughout, and the Instance Info tab says so on screen. What the default tier buys you is time.

This article covers what the default tier grants, what refuses a request and how that refusal looks, and what changes when grace ends.

What an unlicensed install gets#

Two of those choices are deliberate and worth understanding.

Historian's counts are unlimited on purpose. An unlicensed Historian is allowed to hold whatever it already holds. Capping a store that is already populated would turn the end of grace into a data-loss event rather than a registration deadline. What bites at the end of grace is the deadline, not a count.

Atlas ships real ceilings because an ontology is authored during an evaluation rather than inherited from somewhere. A hundred types and a thousand instances is a shape you can genuinely model within, and a shape you will exceed the moment the deployment is real.

Collector, Connect and Explorer are covered by licensing without being limited by it. They carry the same grace window and report the same unlicensed state; they simply have nothing countable yet.

What a refusal looks like#

Every default-tier limit is soft: a narrow band above the limit warns before anything is refused.

The band is fixed at one percent and cannot be configured. It is room to keep working while a licence is arranged, not capacity to plan around.

A refused request returns 403 Forbidden, with the entitlement in the error code:

Error.LicenseInstancesLimitReached
The 'Instances' entitlement does not permit this operation. <reason>

Read the reason. It distinguishes three different situations that need three different responses:

The evaluator counts the proposed total, never the change you are making. An ontology already holding 5,000 types does not evaluate "one more against a limit of 100" and pass; it evaluates 5,001 and refuses.

Where the gates are#

Historian refuses nothing on licence grounds. Its Datasets and Tags entitlements are unlimited by design, and every write path stays open whatever the licence says: a Collector keeps writing, a dataset that does not exist is still created when data arrives for it, and tag metadata still lands. The reasoning is that a customer must not lose plant data because a licence lapsed; what a lapsed licence will take away, once that is wired in a later release, is reading data out, which an operator notices and can act on while nothing is lost. Earlier Beta builds refused dataset and tag creation past a count, and a Collector's background loop then retried that refusal forever while the values landed anyway. That gate was removed in September.

The Datasets and Tags counts are still measured and shown on the licence view, so you can see what the installation holds. They are tracked, not capped.

Atlas gates in one place: the compile you ask for. Authoring is never refused, so you can create types, properties and instance-map entries past a limit; the limit applies when you compile. A compile is weighed against both Types and Instances before its world is published, and one that would breach either ceiling is refused with 403, leaving the previously compiled world untouched. The recompile Atlas runs for itself at startup is never refused. See Compile and Query Workflow.

How Atlas counts Types and Instances#

Both entitlements are counted over compiled worlds, not over what is stored on disk. A world is one domain compiled on one branch, so the same domain compiled on main and on a working branch counts twice. Every compiled world on every branch counts, apart from draft sessions. A compile is weighed against the total the installation would be running afterwards: the world being compiled replaces its own earlier contribution, and every other compiled world is added to it.

The Instances rule surprises people, so here it is worked through. An entity whose type carries 12 properties, counting the ones it inherits, adds 13: itself and 12. It adds 13 whether its instance-map entry sets values for 2 of those properties or all 12. A relationship between two entities adds 1. A model of a few hundred assets can therefore reach a few thousand Instances, and the number grows with the size of the types far more than with the number of values you write.

What follows from that:

• To lower Types, import narrowly (see the note below) and drop properties no instance uses.
• To lower Instances, keep types lean: a property attached to a type is counted on every instance of it. Moving rarely used properties to a subtype that only some instances use helps more than leaving values out.
• To free room for a compile, unload a world you do not need: the same domain on an old working branch is the usual one. See Atlas API - Domains, "Unload a domain".
• To check before you compile, read a compiled domain's Overview: its Types and Instances Total cards are exactly that world's contribution. The Licensing tab shows the installation's totals, refreshed after each compile or unload and once a day.

An imported library's types count as yours. Importing a library copies its types into your model, and the evaluator counts them exactly as it counts types you authored by hand. This matters most on the default tier, where 100 types is the whole allowance and some of the standards libraries are large: isa88-procedural is around 48 types, isa95-personnel around 39, isa95-equipment around 36. Two of those together and you have spent the tier before modelling anything of your own.

The practical habit is to import narrowly. Take isa95-equipment on its own rather than adding isa95-material and isa95-personnel unless you genuinely model materials or people, add control-modules only when you model at device level, and read a library's scope note before importing it. Atlas Libraries describes what each one carries.

Bridge meters egress as a rate, 32 MB per hour. Rate windows are phased so they reset on a UTC clock boundary, which means "your quota resets at midnight" is literally true rather than approximately.

Seeing where you stand#

Every host has an Instance Info tab carrying its name, description, serial and licence state, and a shared licence view showing each entitlement with its limit and current consumption. Atlas adds a Licensing tab, opened from the Support menu.

Use it before you go looking for a bug. An unexpected 403 on a create is almost always a limit you can see there.

When grace ends#

Nothing is deleted, disabled or downgraded. What stops is provisioning: compiling in Atlas, and egress beyond the rate window in Bridge. Everything already configured keeps running. The Historian keeps ingesting and keeps creating the datasets and tags that ingest needs, because it refuses nothing on licence grounds in this release.

Linking the installation in Portal replaces the default tier with a real licence. An organization Admin copies the Instance ID from Pulse's Instance Info, pastes it into Portal, and a Free licence is issued on the spot for every component behind that Pulse; an installation that cannot reach Portal is registered by hand and its licence carried across as a file. Licensing Your Timebase Installation walks both routes. A real licence is never merged with the default tier - the fallback is whole-tier, so a licence that omits a metric does not quietly pick up the default's allowance for it.

Troubleshooting#

Related articles#

• Component Settings - where each component's configuration lives
• Configuration File Versions and Upgrades - what an upgrade changes
• Licensing Your Timebase Installation - the steps to license an installation
• Setting Up Your Organization in Portal - creating your organization