Why A License Server Matters

For many enterprise and industrial customers, direct internet access from production machines is simply not allowed. Think:

‍

• Factory floors and SCADA systems
  ‍
• Hospitals and labs
  ‍
• Government, defense, and finance networks
  ‍
• Customer data centers with strict firewall rules
  ‍

Those environments still need:

‍

1. Up-to-date license and entitlement data for compliance and monetization, and
   ‍
2. A safe, controlled way to sync with Devolens without opening the entire network to the internet.
   ‍

The Devolens License Server solves this by acting as a controlled gateway between your internal network and Devolens. One machine (the license server) is allowed to reach Devolens. All other machines talk to that server over the LAN; the license server then forwards or serves license info on their behalf.

In many setups, it can also cache license files and continue to function even if the internet is temporarily unavailable or intentionally disabled.

‍

Options: Manual Offline Handling vs. Devolens License Server

Manual offline activations
‍

• Export and distribute activation files per machine.
  ‍
• Track who has which file, when it expires, and which version it belongs to.
  ‍
• Repeat the whole process for renewals, suspensions, upgrades, and audits.
  ‍

This gives you control, but becomes painful to maintain at scale and easy to get out of sync with your central licensing data.

‍

Build your own licensing proxy
‍

• You design and host a custom service in the DMZ.
  ‍
• You implement caching, failover, security, logging, and update logic.
  ‍
• You maintain compatibility with changes in licensing APIs over time.
  ‍

This works, but you’re effectively building and maintaining a licensing product on the side.

‍

Devolens License Server (recommended)
‍

• Purpose-built gateway for air-gapped, on-prem, and restricted networks.
  ‍
• Centralized sync: only the license server needs outbound internet access; all other machines stay completely internal.
  ‍
• Built-in caching of license responses to reduce calls to Devolens and tolerate temporary connectivity issues.
  ‍‍
• Offline mode: pre-load license files so the server can operate purely from cache when you know it won’t have internet access.
  ‍
• Floating/offline licensing support for restricting concurrent machines/containers even when the environment is disconnected.
  ‍

Tip: keep your deployment and security standards as they are. Use the License Server as the single, auditable bridge between your secure network and Devolens.

Implementation: How It Fits Your Stack

‍

1. Deploy the license server close to your protected machines
   ‍
   • Run it as a Windows service or as a .NET process on Linux or macOS
     ‍
   • Choose the appropriate network segment/DMZ where outbound access to Devolens is allowed.
     ‍
2. Configure using your Devolens configuration string
   ‍
   • Generate a configuration in the Devolens dashboard / configuration page.
     ‍
   • Either:
     ‍
     • Use the official pre-built binaries and pass the configuration via environment variables or command-line, or
       ‍
     • Build the server from source and embed the configuration string in the project (for stricter environments or advanced scenarios).
       ‍
       ‍
3. Expose a single HTTP endpoint to your applications
   ‍The license server listens on a configurable port (for example, 8080). Once the port is allowed in the internal firewall, applications on the LAN call the license server instead of Devolens directly.
   
   In the .NET client SDK, for example, you simply provide a LicenseServerUrl parameter when activating a key:
   ‍‍

var result = Key.Activate(
    token: authToken,
    productId: 1234,
    key: "AAAAA-BBBBB-CCCCC-DDDDD",
    machineCode: machineId,
    floatingTimeInterval: 150,
    LicenseServerUrl: "http://licenseserver.internal:8080"
);

var license = LicenseKey.FromResponse(rsaPublicKey, result);

  The same pattern applies in other languages and SDKs that support the license server URL.
‍

   4. Tune caching and offline behaviour
‍

• Set how long license responses should be cached (e.g., 10 days).
  ‍
• Enable offline mode for environments that will run fully disconnected, and load activation (.skm) files from a folder on the license server.
  ‍

    7. Optional: enable offline floating licensing
‍

• Configure the license server with a special floating configuration and RSA key for offline scenarios.
  ‍
• Ship the compiled license server plus a folder of activation files to the customer.

Benefits You Get With Devolens License Server

‍

1. Enterprise-friendly network posture
   Keep strict firewall rules. Only the license server talks to Devolens; client machines never need outbound internet access.
   ‍
2. Continuous compliance, even offline
   Caching and offline mode allow you to keep enforcing license rules during outages or in fully disconnected environments, based on pre-loaded license files.
   ‍
3. Centralized control over entitlements
   Update or revoke licenses in Devolens, and have those changes propagate via the license server—without manually touching individual machines.
   ‍
4. Reduced operational overhead
   Avoid custom scripts, spreadsheets, and ad-hoc processes for managing activations and renewals across hundreds or thousands of machines.
   ‍
5. Cross-platform deployment
   Run the license server on Windows, Linux, or macOS using modern .NET runtimes, so you can deploy where it best fits your infrastructure.
   ‍
6. Support for modern licensing models
   Use the license server together with floating licensing, per-device licenses, and offline-limited trials, all backed by the same Devolens platform.
   ‍
7. Security and auditability
   One well-defined service to monitor, log, and harden. Easier audits and clearer story for IT and InfoSec.
   ‍
8. Backed by an experienced licensing team
   Devolens has over a decade of experience in software licensing and is trusted by hundreds of companies worldwide.

‍

FAQ - Air-Gapped & Enterprise Environments

How is this different from one-off offline activation files?
Offline files work, but they scale poorly. You must manually generate, send, install, and track them per machine, and repeat for renewals or changes. The license server centralizes this: machines use a stable LAN endpoint, and you manage licenses in one place.

Do client machines need internet access?
No. Only the license server needs outbound access to Devolens. Client applications call the license server over the local network.

What happens if the license server temporarily loses internet?
With caching enabled, the license server can continue to serve previously fetched licenses for a configurable time window (for example, 10 days). Once connectivity returns, it syncs again with Devolens.

Can we run the license server completely offline?
Yes. In offline mode, the license server always reads from cache. You pre-load activation files (.skm) into a folder on the server, and it serves those licenses without contacting Devolens at all. This is ideal for fully air-gapped environments where you only sync new license files occasionally via secure media.

Can we use floating licenses in an offline environment?
Yes. You can configure the license server for offline floating licensing (for example, to limit the number of concurrent containers or machines). You generate a special license server configuration and RSA public key in Devolens, embed it in or configure it for the license server, and ship the compiled server plus activation files to your customer.

Do we have to run this on Windows?
No. The license server can run on Windows or on Linux/macOS, as long as the appropriate .NET runtime (e.g., .NET 5 or later) is installed.

How intrusive is the app-side change?
Minimal. For most SDKs you change the base URL used for activation calls (for example, passing LicenseServerUrl in the .NET SDK) so calls go to the license server rather than Devolens directly. Your core licensing logic remains the same.

How long does it take to get the first environment running?
Teams often get a first license server running quickly by:

‍

1. Deploying the pre-built binary on a VM,
   ‍
2. Supplying the configuration string from the Devolens dashboard, and
   ‍
3. Pointing a test application to the license server URL.
   ‍

From there, you can harden, automate, and roll out to production at your own pace.