What is a floating license?
A floating license lets a team share a fixed pool of concurrent seats across its installed devices. In PermitCore, each active device session borrows a seat while the application is in use, then returns it for someone else. It fits shared workstations, lab machines and rotating teams whose members do not all need the software at once.
- Seat 1
Device A is working
- Seat 2
Device B is working
- Seat 3
Available for checkout
This is an example allocation. A fourth simultaneous device waits until a seat is returned or expires.
Node-locked doesn't fit every team
A per-machine (node-locked) license makes sense for a single-user desktop app. It breaks down for a design studio with 5 licenses and 12 workstations where nobody uses the tool constantly — node-locking forces them to either overbuy seats or manage licenses machine-by-machine. Floating licensing sells the actual constraint that matters: how many people are using it right now, not how many machines it's installed on.
How it works
Checkout asks the server for a seat using the license key and a stable device ID. Success
returns a secret sessionToken and an expiresAt deadline. An unsuccessful
result grants no access. The same license and device ID renew their existing session;
separate app processes on one device therefore need a coordinated lifecycle.
- Check out: start protected work only after a successful grant.
- Keep alive: send a heartbeat normally every four minutes and before the granted deadline. Each grant lasts up to fifteen minutes, capped at the license's access deadline, including applicable grace.
- Return: stop work and await checkin.
TryCheckinAsyncconfirms HTTP 204; a lost response does not confirm release.
The next heartbeat checks the current license and floating-plan entitlement. Stop protected work on denied renewal or an expired deadline. Revocation is not an immediate push notification, and offline validation tokens do not renew floating seats.
Configured post-expiry grace and eligible Store payment grace remain available. A revoked license is still denied; an active subscription snapshot alone does not extend an expired paid-through period.
A tested SDK lifecycle
All eight SDKs support checkout, heartbeat and confirmed checkin. The .NET methods are CheckoutAsync, HeartbeatAsync and TryCheckinAsync. This example is compiled against the SDK and tested for completion, cancellation and cleanup failures.
Show the .NET lifecycle
This helper manages a floating lease. Before calling it, validate the key for your application using expectedProductId and provide the application version when using version rules; see license validation. Checkout itself does not carry those validation fields.
using System;
using System.Threading;
using System.Threading.Tasks;
using PermitCore;
namespace PermitCore.Examples;
public static class FloatingLeaseLifecycle
{
public static async Task RunAsync(PermitCoreClient client, string licenseKey,
Func<CancellationToken, Task> protectedWork, CancellationToken stop = default,
TimeSpan? heartbeatInterval = null)
{
var interval = heartbeatInterval ?? TimeSpan.FromMinutes(4);
if (interval <= TimeSpan.Zero || interval > TimeSpan.FromMinutes(4))
throw new ArgumentOutOfRangeException(nameof(heartbeatInterval));
var seat = await client.CheckoutAsync(licenseKey, ct: stop);
if (!seat.Success || string.IsNullOrWhiteSpace(seat.SessionToken))
throw new InvalidOperationException("No floating seat was granted.");
var token = seat.SessionToken;
using var lease = CancellationTokenSource.CreateLinkedTokenSource(stop);
Task? work = null;
try
{
var remaining = Remaining(seat);
lease.CancelAfter(remaining);
work = protectedWork(lease.Token);
while (!work.IsCompleted)
{
var pause = Task.Delay(remaining / 2 < interval ? remaining / 2 : interval, lease.Token);
if (await Task.WhenAny(work, pause) == work) break;
await pause;
var renewed = await client.HeartbeatAsync(token, lease.Token);
remaining = Remaining(renewed);
lease.Token.ThrowIfCancellationRequested();
lease.CancelAfter(remaining);
}
await work;
}
finally
{
lease.Cancel();
try
{
if (work is not null) await work;
}
catch (OperationCanceledException) when (lease.IsCancellationRequested) { }
finally
{
using var cleanup = new CancellationTokenSource(TimeSpan.FromSeconds(5));
if (!await client.TryCheckinAsync(token, cleanup.Token))
Console.Error.WriteLine("Seat return unconfirmed; the last granted deadline still applies.");
}
}
}
private static TimeSpan Remaining(FloatingSession session)
{
if (!session.Success || !session.ExpiresAt.HasValue)
throw new InvalidOperationException("Floating access could not be renewed.");
var remaining = session.ExpiresAt.Value.ToUniversalTime() - DateTime.UtcNow;
if (remaining <= TimeSpan.Zero)
throw new InvalidOperationException("The floating session deadline has passed.");
return remaining;
}
}Pass your application's work as protectedWork and use its cancellation token in every protected operation. Cancellation is cooperative: the helper cannot stop code that ignores that token. It waits for work to stop before returning the seat. A failed checkin is reported as unconfirmed.
Built for the shape floating licensing actually needs
Floating license questions
What is a floating license?
A floating license lets a team share a limited pool of concurrent seats across its installed devices. PermitCore tracks active device sessions rather than permanently assigning every installation a seat.
Is a floating licence the same as a concurrent licence?
These names usually describe the same shared-seat model. In PermitCore, MaxConcurrentSessions limits active device sessions; MaxActivations belongs to activation-based licensing.
What happens when every seat is in use?
Checkout returns an unsuccessful result without a session token. Show the message and let the user try again after another device returns its seat or its session expires.
Can a floating session work offline?
Checkout and heartbeat require the server. Offline validation tokens do not renew a floating seat. Stop protected work if renewal fails or the last granted expiresAt deadline passes.
What happens after a crash or license revocation?
A crashed device stops renewing and its lease expires at the last granted deadline. Grants last up to fifteen minutes and cannot exceed the license access deadline, including applicable grace. The next heartbeat checks the current license and floating-plan entitlement; revocation is not a push notification to the app.
Sell seats, not installs
Floating licensing is included from Starter. Free registration lets you explore the platform; the Free plan does not include floating seats. Read the model comparison before choosing.